[clangd] Handle InitializeParams and store rootUri

[malaperle]

Summary

The root Uri is the workspace location and will be useful in the context of
indexing. We could also add more things to InitializeParams in order to
configure Clangd for C/C++ sepecific extensions.

[ilya-biryukov]

clangd/ClangdServer.cpp

168

NIT: remove {} around single-statement conditional branches.

clangd/ClangdServer.h

214

NIT: missing full stop at the end of the comment.

285

Why do we need to store it with a trailing /?

clangd/ProtocolHandlers.cpp

26

I would probably still call Callbacks.onInitialize in that case.
We don't do that in other methods, but onInitialize feels somewhat special. No client would probably gracefully handle missing response from onInitialize.

test/clangd/protocol.test

10

Maybe create a separate test for rootUri and leave this to test rootPath?
The value of rootUri is also not a well-formed URI, that seems weird.

[malaperle]

test/clangd/protocol.test

10

A separate test file? I don't think it's possible to add another initialize request in the same test file.

[ilya-biryukov]

test/clangd/protocol.test

10

Sure, in a separate file.

[malaperle]

clangd/ClangdServer.h

285

For appending filenames to it. I thought it would be better to make it explicitly clear that it was always trailing with a / instead of checking everywhere when appending whether or not to add the /.

[ilya-biryukov]

clangd/ClangdServer.h

285

I had an opposite use-case in mind: you need to recursively iterate over all files in that directory, and for that you'd probably need to have the directory name without trailing /.

[malaperle]

clangd/ClangdServer.h

285

it works with fs::directory_iterator with the trailing /. But I don't mind either way. I'll specify it never has it then and add it where necessary.

[ilya-biryukov]

clangd/ClangdServer.h

285

Sounds good, thanks.
I don't have a strong preference here either, just seems to me that it would make the code a bit easier to read. But again, should not make a big difference.

[ilya-biryukov]

clangd/ClangdLSPServer.cpp

95

NIT: remove {} around single-statement branches.

[malaperle]

Add test file, address comments.

[malaperle]

clangd/ClangdServer.h

285

Actually, I think using llvm::sys::path::append is the best, it takes care of whether or not it / is trailing

clangd/ProtocolHandlers.cpp

26

very good point!

[ilya-biryukov]

clangd/ProtocolHandlers.cpp

28

Dereferencing *IP will now fail if IP does not have a value.
Maybe also add a test for that?

[malaperle]

Add a test, fix bad dereference.

[ilya-biryukov]

LGTM.

[malaperle]

Thanks!

clangd/ClangdLSPServer.cpp

void ClangdLSPServer::LSPDiagnosticsConsumer::onDiagnosticsReady(
     PathRef File, Tagged<std::vector<DiagWithFixIts>> Diagnostics) {
   Server.consumeDiagnostics(File, Diagnostics.Value);
 }
 
 class ClangdLSPServer::LSPProtocolCallbacks : public ProtocolCallbacks {
 public:
   LSPProtocolCallbacks(ClangdLSPServer &LangServer) : LangServer(LangServer) {}
 
-  void onInitialize(StringRef ID, JSONOutput &Out) override;
+  void onInitialize(StringRef ID, InitializeParams IP,
+                    JSONOutput &Out) override;
   void onShutdown(JSONOutput &Out) override;
   void onDocumentDidOpen(DidOpenTextDocumentParams Params,
                          JSONOutput &Out) override;
   void onDocumentDidChange(DidChangeTextDocumentParams Params,
                            JSONOutput &Out) override;
   void onDocumentDidClose(DidCloseTextDocumentParams Params,
                           JSONOutput &Out) override;
   void onDocumentOnTypeFormatting(DocumentOnTypeFormattingParams Params,
public:
   void onGoToDefinition(TextDocumentPositionParams Params, StringRef ID,
                         JSONOutput &Out) override;
 
 private:
   ClangdLSPServer &LangServer;
 };
 
 void ClangdLSPServer::LSPProtocolCallbacks::onInitialize(StringRef ID,
+                                                         InitializeParams IP,
                                                          JSONOutput &Out) {
   Out.writeMessage(
       R"({"jsonrpc":"2.0","id":)" + ID +
       R"(,"result":{"capabilities":{
           "textDocumentSync": 1,
           "documentFormattingProvider": true,
           "documentRangeFormattingProvider": true,
           "documentOnTypeFormattingProvider": {"firstTriggerCharacter":"}","moreTriggerCharacter":[]},
           "codeActionProvider": true,
           "completionProvider": {"resolveProvider": false, "triggerCharacters": [".",">",":"]},
           "definitionProvider": true
         }}})");
+  if (IP.rootUri && !IP.rootUri->file.empty()) {
+    LangServer.Server.setRootPath(IP.rootUri->file);
+  } else if (IP.rootPath && !IP.rootPath->empty()) {
+    LangServer.Server.setRootPath(*IP.rootPath);
+  }
 }
 
 void ClangdLSPServer::LSPProtocolCallbacks::onShutdown(JSONOutput &Out) {
   LangServer.IsDone = true;
 }
 
 void ClangdLSPServer::LSPProtocolCallbacks::onDocumentDidOpen(
     DidOpenTextDocumentParams Params, JSONOutput &Out) {

clangd/ClangdServer.h

public:
   ///
   /// Various messages are logged using \p Logger.
   ClangdServer(GlobalCompilationDatabase &CDB,
                DiagnosticsConsumer &DiagConsumer,
                FileSystemProvider &FSProvider, unsigned AsyncThreadsCount,
                bool SnippetCompletions, clangd::Logger &Logger,
                llvm::Optional<StringRef> ResourceDir = llvm::None);
 
+  /// Set the root path of the workspace
+  void setRootPath(PathRef RootPath);
+
   /// Add a \p File to the list of tracked C++ files or update the contents if
   /// \p File is already tracked. Also schedules parsing of the AST for it on a
   /// separate thread. When the parsing is complete, DiagConsumer passed in
   /// constructor will receive onDiagnosticsReady callback.
   /// \return A future that will become ready when the rebuild (including
   /// diagnostics) is finished.
   std::future<void> addDocument(PathRef File, StringRef Contents);
   /// Remove \p File from list of tracked files, schedule a request to free
private:
 
   clangd::Logger &Logger;
   GlobalCompilationDatabase &CDB;
   DiagnosticsConsumer &DiagConsumer;
   FileSystemProvider &FSProvider;
   DraftStore DraftMgr;
   CppFileCollection Units;
   std::string ResourceDir;
+  // If set, this represents the workspace path, always with a trailing /
+  llvm::Optional<std::string> RootPath;
   std::shared_ptr<PCHContainerOperations> PCHs;
   // WorkScheduler has to be the last member, because its destructor has to be
   // called before all other members to stop the worker thread that references
   // ClangdServer
   ClangdScheduler WorkScheduler;
   bool SnippetCompletions;
 
   /// Used to serialize diagnostic callbacks.

clangd/ClangdServer.cpp

 #include "ClangdServer.h"
 #include "clang/Format/Format.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 #include <future>
 
 using namespace clang;
 using namespace clang::clangd;
 
 namespace {
 
ClangdServer::ClangdServer(GlobalCompilationDatabase &CDB,
                            llvm::Optional<StringRef> ResourceDir)
     : Logger(Logger), CDB(CDB), DiagConsumer(DiagConsumer),
       FSProvider(FSProvider),
       ResourceDir(ResourceDir ? ResourceDir->str() : getStandardResourceDir()),
       PCHs(std::make_shared<PCHContainerOperations>()),
       WorkScheduler(AsyncThreadsCount), SnippetCompletions(SnippetCompletions) {
 }
 
+void ClangdServer::setRootPath(PathRef RootPath) {
+  std::string NewRootPath = llvm::sys::path::convert_to_slash(
+      RootPath, llvm::sys::path::Style::posix);
+  if (NewRootPath.back() != '/') {
+    // Try appending a / in case the user has passed a directory with no
+    // trailing /
+    NewRootPath += '/';
+  }
+
+  if (llvm::sys::fs::is_directory(NewRootPath)) {
+    this->RootPath = NewRootPath;
+  }
+}
+
 std::future<void> ClangdServer::addDocument(PathRef File, StringRef Contents) {
   DocVersion Version = DraftMgr.updateDraft(File, Contents);
 
   auto TaggedFS = FSProvider.getTaggedFileSystem(File);
-  std::shared_ptr<CppFile> Resources =
-      Units.getOrCreateFile(File, ResourceDir, CDB, PCHs, TaggedFS.Value, Logger);
+  std::shared_ptr<CppFile> Resources = Units.getOrCreateFile(
+      File, ResourceDir, CDB, PCHs, TaggedFS.Value, Logger);
   return scheduleReparseAndDiags(File, VersionedDraft{Version, Contents.str()},
                                  std::move(Resources), std::move(TaggedFS));
 }
 
 std::future<void> ClangdServer::removeDocument(PathRef File) {
   DraftMgr.removeDraft(File);
   std::shared_ptr<CppFile> Resources = Units.removeIfPresent(File);
   return scheduleCancelRebuild(std::move(Resources));

clangd/Protocol.h

struct TextDocumentItem {
 
   /// The content of the opened text document.
   std::string text;
 
   static llvm::Optional<TextDocumentItem> parse(llvm::yaml::MappingNode *Params,
                                                 clangd::Logger &Logger);
 };
 
+enum class TraceLevel {
+  Off = 0,
+  Messages = 1,
+  Verbose = 2,
+};
+
+struct InitializeParams {
+  /// The process Id of the parent process that started
+  /// the server. Is null if the process has not been started by another
+  /// process. If the parent process is not alive then the server should exit
+  /// (see exit notification) its process.
+  llvm::Optional<int> processId;
+
+  /// The rootPath of the workspace. Is null
+  /// if no folder is open.
+  ///
+  /// @deprecated in favour of rootUri.
+  llvm::Optional<std::string> rootPath;
+
+  /// The rootUri of the workspace. Is null if no
+  /// folder is open. If both `rootPath` and `rootUri` are set
+  /// `rootUri` wins.
+  llvm::Optional<URI> rootUri;
+
+  // User provided initialization options.
+  // initializationOptions?: any;
+
+  /// The capabilities provided by the client (editor or tool)
+  /// Note: Not currently used by clangd
+  // ClientCapabilities capabilities;
+
+  /// The initial trace setting. If omitted trace is disabled ('off').
+  llvm::Optional<TraceLevel> trace;
+  static llvm::Optional<InitializeParams> parse(llvm::yaml::MappingNode *Params,
+                                                clangd::Logger &Logger);
+};
+
 struct DidOpenTextDocumentParams {
   /// The document that was opened.
   TextDocumentItem textDocument;
 
   /// Extension storing per-file metadata, such as compilation flags.
   llvm::Optional<Metadata> metadata;
 
   static llvm::Optional<DidOpenTextDocumentParams>

clangd/Protocol.cpp

 std::string TextEdit::unparse(const TextEdit &P) {
   std::string Result;
   llvm::raw_string_ostream(Result) << llvm::format(
       R"({"range": %s, "newText": "%s"})", Range::unparse(P.range).c_str(),
       llvm::yaml::escape(P.newText).c_str());
   return Result;
 }
 
+namespace {
+TraceLevel getTraceLevel(llvm::StringRef TraceLevelStr,
+                         clangd::Logger &Logger) {
+  if (TraceLevelStr == "off")
+    return TraceLevel::Off;
+  else if (TraceLevelStr == "messages")
+    return TraceLevel::Messages;
+  else if (TraceLevelStr == "verbose")
+    return TraceLevel::Verbose;
+
+  Logger.log(llvm::formatv("Unknown trace level \"{0}\"\n", TraceLevelStr));
+  return TraceLevel::Off;
+}
+} // namespace
+
+llvm::Optional<InitializeParams>
+InitializeParams::parse(llvm::yaml::MappingNode *Params,
+                        clangd::Logger &Logger) {
+  InitializeParams Result;
+  for (auto &NextKeyValue : *Params) {
+    auto *KeyString = dyn_cast<llvm::yaml::ScalarNode>(NextKeyValue.getKey());
+    if (!KeyString)
+      return llvm::None;
+
+    llvm::SmallString<10> KeyStorage;
+    StringRef KeyValue = KeyString->getValue(KeyStorage);
+    auto *Value =
+        dyn_cast_or_null<llvm::yaml::ScalarNode>(NextKeyValue.getValue());
+    if (!Value)
+      continue;
+
+    if (KeyValue == "processId") {
+      auto *Value =
+          dyn_cast_or_null<llvm::yaml::ScalarNode>(NextKeyValue.getValue());
+      if (!Value)
+        return llvm::None;
+      long long Val;
+      if (llvm::getAsSignedInteger(Value->getValue(KeyStorage), 0, Val))
+        return llvm::None;
+      Result.processId = Val;
+    } else if (KeyValue == "rootPath") {
+      Result.rootPath = Value->getValue(KeyStorage);
+    } else if (KeyValue == "rootUri") {
+      Result.rootUri = URI::parse(Value);
+    } else if (KeyValue == "initializationOptions") {
+      // Not used
+    } else if (KeyValue == "capabilities") {
+      // Not used
+    } else if (KeyValue == "trace") {
+      Result.trace = getTraceLevel(Value->getValue(KeyStorage), Logger);
+    } else {
+      logIgnoredField(KeyValue, Logger);
+    }
+  }
+  return Result;
+}
+
 llvm::Optional<DidOpenTextDocumentParams>
 DidOpenTextDocumentParams::parse(llvm::yaml::MappingNode *Params,
                                  clangd::Logger &Logger) {
   DidOpenTextDocumentParams Result;
   for (auto &NextKeyValue : *Params) {
     auto *KeyString = dyn_cast<llvm::yaml::ScalarNode>(NextKeyValue.getKey());
     if (!KeyString)
       return llvm::None;

clangd/ProtocolHandlers.h

 
 namespace clang {
 namespace clangd {
 
 class ProtocolCallbacks {
 public:
   virtual ~ProtocolCallbacks() = default;
 
-  virtual void onInitialize(StringRef ID, JSONOutput &Out) = 0;
+  virtual void onInitialize(StringRef ID, InitializeParams IP,
+                            JSONOutput &Out) = 0;
   virtual void onShutdown(JSONOutput &Out) = 0;
   virtual void onDocumentDidOpen(DidOpenTextDocumentParams Params,
                                  JSONOutput &Out) = 0;
   virtual void onDocumentDidChange(DidChangeTextDocumentParams Params,
                                    JSONOutput &Out) = 0;
 
   virtual void onDocumentDidClose(DidCloseTextDocumentParams Params,
                                   JSONOutput &Out) = 0;

clangd/ProtocolHandlers.cpp

 
 namespace {
 
 struct InitializeHandler : Handler {
   InitializeHandler(JSONOutput &Output, ProtocolCallbacks &Callbacks)
       : Handler(Output), Callbacks(Callbacks) {}
 
   void handleMethod(llvm::yaml::MappingNode *Params, StringRef ID) override {
-    Callbacks.onInitialize(ID, Output);
+    auto IP = InitializeParams::parse(Params, Output);
+    if (!IP) {
+      Output.log("Failed to decode InitializeParams!\n");
+      return;
+    }
+    Callbacks.onInitialize(ID, *IP, Output);
   }
 
 private:
   ProtocolCallbacks &Callbacks;
 };
 
 struct ShutdownHandler : Handler {
   ShutdownHandler(JSONOutput &Output, ProtocolCallbacks &Callbacks)

test/clangd/protocol.test

 # RUN: clangd -run-synchronously < %s | FileCheck %s
 # RUN: clangd -run-synchronously < %s 2>&1 | FileCheck -check-prefix=STDERR %s
 # vim: fileformat=dos
 # It is absolutely vital that this file has CRLF line endings.
 #
 # Test protocol parsing
-Content-Length: 125
+Content-Length: 124
 Content-Type: application/vscode-jsonrpc; charset-utf-8
 
-{"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":123,"rootPath":"clangd","capabilities":{},"trace":"off"}}
+{"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":123,"rootUri":"clangd","capabilities":{},"trace":"off"}}
 # Test message with Content-Type after Content-Length
 #
 # CHECK: "jsonrpc":"2.0","id":0,"result":{"capabilities":{
 # CHECK-DAG: "textDocumentSync": 1,
 # CHECK-DAG: "documentFormattingProvider": true,
 # CHECK-DAG: "documentRangeFormattingProvider": true,
 # CHECK-DAG: "documentOnTypeFormattingProvider": {"firstTriggerCharacter":"}","moreTriggerCharacter":[]},
 # CHECK-DAG: "codeActionProvider": true,