[WIP] clangd Transport layer

clangd/CMakeLists.txt

add_clang_library(clangDaemon
   FindSymbols.cpp
   FileDistance.cpp
   FuzzyMatch.cpp
   GlobalCompilationDatabase.cpp
   Headers.cpp
   JSONRPCDispatcher.cpp
   Logger.cpp
   Protocol.cpp
-  ProtocolHandlers.cpp
   Quality.cpp
   RIFF.cpp
   SourceCode.cpp
   Threading.cpp
   Trace.cpp
+  Transport.cpp
   TUScheduler.cpp
   URI.cpp
   XRefs.cpp
 
   index/CanonicalIncludes.cpp
   index/FileIndex.cpp
   index/Index.cpp
   index/IndexAction.cpp

clangd/ClangdLSPServer.h

 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_CLANGDLSPSERVER_H
 
 #include "ClangdServer.h"
 #include "DraftStore.h"
 #include "FindSymbols.h"
 #include "GlobalCompilationDatabase.h"
 #include "Path.h"
 #include "Protocol.h"
-#include "ProtocolHandlers.h"
+#include "Transport.h"
 #include "clang/Tooling/Core/Replacement.h"
 #include "llvm/ADT/Optional.h"
 #include <memory>
 
 namespace clang {
 namespace clangd {
 
-class JSONOutput;
 class SymbolIndex;
 
 /// This class exposes ClangdServer's capabilities via Language Server Protocol.
 ///
 /// JSONRPCDispatcher binds the implemented ProtocolCallbacks methods
 /// (e.g. onInitialize) to corresponding JSON-RPC methods ("initialize").
 /// The server also supports $/cancelRequest (JSONRPCDispatcher provides this).
-class ClangdLSPServer : private DiagnosticsConsumer, private ProtocolCallbacks {
+class ClangdLSPServer : private DiagnosticsConsumer, private Transport::MessageHandler {
 public:
   /// If \p CompileCommandsDir has a value, compile_commands.json will be
   /// loaded only from \p CompileCommandsDir. Otherwise, clangd will look
   /// for compile_commands.json in all parent directories of each file.
-  ClangdLSPServer(JSONOutput &Out, const clangd::CodeCompleteOptions &CCOpts,
+  ClangdLSPServer(Transport &TransportLayer,
+                  const clangd::CodeCompleteOptions &CCOpts,
                   llvm::Optional<Path> CompileCommandsDir,
                   bool ShouldUseInMemoryCDB, const ClangdServer::Options &Opts);
 
-  /// Run LSP server loop, receiving input for it from \p In. \p In must be
+  /// Run LSP server loop, receiving input from the TransportLater \p In must be
   /// opened in binary mode. Output will be written using Out variable passed to
   /// class constructor. This method must not be executed more than once for
   /// each instance of ClangdLSPServer.
   ///
   /// \return Whether we received a 'shutdown' request before an 'exit' request.
-  bool run(std::FILE *In,
-           JSONStreamStyle InputStyle = JSONStreamStyle::Standard);
+  bool run();
+
+  bool notifyServer(llvm::StringRef Method, llvm::json::Value ) override;
+  bool callServer(llvm::StringRef Method, llvm::json::Value Params,
+                    llvm::json::Value ID) override;
+  bool replyToServer(llvm::json::Value ID,
+                      llvm::Expected<llvm::json::Value> Result) override;
 
 private:
   // Implement DiagnosticsConsumer.
   void onDiagnosticsReady(PathRef File, std::vector<Diag> Diagnostics) override;
 
-  // Implement ProtocolCallbacks.
-  void onInitialize(InitializeParams &Params) override;
-  void onShutdown(ShutdownParams &Params) override;
-  void onExit(ExitParams &Params) override;
-  void onDocumentDidOpen(DidOpenTextDocumentParams &Params) override;
-  void onDocumentDidChange(DidChangeTextDocumentParams &Params) override;
-  void onDocumentDidClose(DidCloseTextDocumentParams &Params) override;
-  void
-  onDocumentOnTypeFormatting(DocumentOnTypeFormattingParams &Params) override;
-  void
-  onDocumentRangeFormatting(DocumentRangeFormattingParams &Params) override;
-  void onDocumentFormatting(DocumentFormattingParams &Params) override;
-  void onDocumentSymbol(DocumentSymbolParams &Params) override;
-  void onCodeAction(CodeActionParams &Params) override;
-  void onCompletion(TextDocumentPositionParams &Params) override;
-  void onSignatureHelp(TextDocumentPositionParams &Params) override;
-  void onGoToDefinition(TextDocumentPositionParams &Params) override;
-  void onReference(ReferenceParams &Params) override;
-  void onSwitchSourceHeader(TextDocumentIdentifier &Params) override;
-  void onDocumentHighlight(TextDocumentPositionParams &Params) override;
-  void onFileEvent(DidChangeWatchedFilesParams &Params) override;
-  void onCommand(ExecuteCommandParams &Params) override;
-  void onWorkspaceSymbol(WorkspaceSymbolParams &Params) override;
-  void onRename(RenameParams &Parames) override;
-  void onHover(TextDocumentPositionParams &Params) override;
-  void onChangeConfiguration(DidChangeConfigurationParams &Params) override;
+  // Implement LSP methods.
+  void onInitialize(InitializeParams &Params);
+  void onShutdown(ShutdownParams &Params);
+  void onExit(ExitParams &Params);
+  void onDocumentDidOpen(DidOpenTextDocumentParams &Params);
+  void onDocumentDidChange(DidChangeTextDocumentParams &Params);
+  void onDocumentDidClose(DidCloseTextDocumentParams &Params);
+  void onDocumentOnTypeFormatting(DocumentOnTypeFormattingParams &Params);
+  void onDocumentRangeFormatting(DocumentRangeFormattingParams &Params);
+  void onDocumentFormatting(DocumentFormattingParams &Params);
+  void onDocumentSymbol(DocumentSymbolParams &Params);
+  void onCodeAction(CodeActionParams &Params);
+  void onCompletion(TextDocumentPositionParams &Params);
+  void onSignatureHelp(TextDocumentPositionParams &Params);
+  void onGoToDefinition(TextDocumentPositionParams &Params);
+  void onReference(ReferenceParams &Params);
+  void onSwitchSourceHeader(TextDocumentIdentifier &Params);
+  void onDocumentHighlight(TextDocumentPositionParams &Params);
+  void onFileEvent(DidChangeWatchedFilesParams &Params);
+  void onCommand(ExecuteCommandParams &Params);
+  void onWorkspaceSymbol(WorkspaceSymbolParams &Params);
+  void onRename(RenameParams &Parames);
+  void onHover(TextDocumentPositionParams &Params);
+  void onChangeConfiguration(DidChangeConfigurationParams &Params);
+  void onCancelRequest(CancelRequestParams &Params);
 
   std::vector<Fix> getFixes(StringRef File, const clangd::Diagnostic &D);
 
   /// Forces a reparse of all currently opened files.  As a result, this method
   /// may be very expensive.  This method is normally called when the
   /// compilation database is changed.
   void reparseOpenedFiles();
   void applyConfiguration(const ClangdConfigurationParamsChange &Settings);
 
-  JSONOutput &Out;
+  Transport &TransportLayer;
   /// Used to indicate that the 'shutdown' request was received from the
   /// Language Server client.
   bool ShutdownRequestReceived = false;
 
   /// Used to indicate that the 'exit' notification was received from the
   /// Language Server client.
   /// It's used to break out of the LSP parsing loop.
   bool IsDone = false;
private:
   DraftStore DraftMgr;
 
   // Server must be the last member of the class to allow its destructor to exit
   // the worker thread that may otherwise run an async callback on partially
   // destructed instance of ClangdLSPServer.
   // Set in construtor and destroyed when run() finishes. To ensure all worker
   // threads exit before run() returns.
   std::unique_ptr<ClangdServer> Server;
+
+  // Tracking cancellations needs a mutex: handlers may finish on a different
+  // thread, and that's when we clean up entries in the map.
+  mutable std::mutex RequestCancelersMutex;
+  llvm::StringMap<std::pair<Canceler, unsigned>> RequestCancelers;
+  unsigned NextRequestCookie = 0;
+  Context cancelableRequestContext(const llvm::json::Value &ID);
+  void cancelRequest(const llvm::json::Value &ID);
+
+  using Handler = std::function<void(const llvm::json::Value &)>;
+  llvm::StringMap<Handler> Handlers;
+  Handler UnknownHandler;
 };
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_CLANGDLSPSERVER_H

clangd/ClangdLSPServer.cpp

 #include "ClangdLSPServer.h"
 #include "Diagnostics.h"
 #include "JSONRPCDispatcher.h"
 #include "SourceCode.h"
 #include "URI.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/JSON.h"
 #include "llvm/Support/Path.h"
 
+// TODO looking for llvm::to_string()
+#include "llvm/ADT/ScopeExit.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/Chrono.h"
+#include "llvm/Support/Errno.h"
+#include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/JSON.h"
+#include "llvm/Support/ScopedPrinter.h"
+#include "llvm/Support/SourceMgr.h"
+
 using namespace clang::clangd;
 using namespace clang;
 using namespace llvm;
 
 namespace {
 
 /// \brief Supports a test URI scheme with relaxed constraints for lit tests.
 /// The path in a test URI will be combined with a platform-specific fake

 CompletionItemKindBitset defaultCompletionItemKinds() {
   CompletionItemKindBitset Defaults;
   for (size_t I = CompletionItemKindMin;
        I <= static_cast<size_t>(CompletionItemKind::Reference); ++I)
     Defaults.set(I);
   return Defaults;
 }
 
+// When tracing, we trace a request and attach the response in reply().
+// Because the Span isn't available, we find the current request using Context.
+class RequestSpan {
+  RequestSpan(llvm::json::Object *Args) : Args(Args) {}
+  std::mutex Mu;
+  llvm::json::Object *Args;
+  static Key<std::unique_ptr<RequestSpan>> RSKey;
+
+public:
+  // Return a context that's aware of the enclosing request, identified by Span.
+  static Context stash(const trace::Span &Span) {
+    return Context::current().derive(
+        RSKey, std::unique_ptr<RequestSpan>(new RequestSpan(Span.Args)));
+  }
+
+  // If there's an enclosing request and the tracer is interested, calls \p F
+  // with a json::Object where request info can be added.
+  template <typename Func> static void attach(Func &&F) {
+    auto *RequestArgs = Context::current().get(RSKey);
+    if (!RequestArgs || !*RequestArgs || !(*RequestArgs)->Args)
+      return;
+    std::lock_guard<std::mutex> Lock((*RequestArgs)->Mu);
+    F(*(*RequestArgs)->Args);
+  }
+};
+Key<std::unique_ptr<RequestSpan>> RequestSpan::RSKey;
+
+static Key<Transport *> CurrentTransportLayer;
+static Key<json::Value> RequestID;
+
+const json::Value *getRequestId() {
+  return Context::current().get(RequestID);
+}
+
+void reply(json::Value &&Result) {
+  auto ID = getRequestId();
+  if (!ID) {
+    elog("Attempted to reply to a notification!");
+    return;
+  }
+  RequestSpan::attach([&](json::Object &Args) { Args["Reply"] = Result; });
+  log("--> reply({0})", *ID);
+  Context::current()
+      .getExisting(CurrentTransportLayer)
+      ->replyToClient(*ID, std::move(Result));
+}
+
+void replyError(ErrorCode Code, const llvm::StringRef &Message) {
+  elog("Error {0}: {1}", static_cast<int>(Code), Message);
+  RequestSpan::attach([&](json::Object &Args) {
+    Args["Error"] = json::Object{{"code", static_cast<int>(Code)},
+                                 {"message", Message.str()}};
+  });
+/*
+        ->writeMessage(json::Object{
+            {"jsonrpc", "2.0"},
+            {"id", *ID},
+            {"error", json::Object{{"code", static_cast<int>(Code)},
+                                   {"message", Message}}},
+        });
+*/
+  LSPError Error;
+  Error.Code = Code;
+  Error.Message = Message;
+  // TODO ID?
+
+  if (auto ID = getRequestId()) {
+    log("--> reply({0}) error: {1}", *ID, Message);
+    Context::current()
+        .getExisting(CurrentTransportLayer)
+        ->replyToClient(
+            *ID, make_error<LSPError>(Error)
+        );
+  }
+}
+
+void replyError(Error E) {
+  handleAllErrors(std::move(E),
+                  [](const CancelledError &TCE) {
+                    replyError(ErrorCode::RequestCancelled, TCE.message());
+                  },
+                  [](const ErrorInfoBase &EIB) {
+                    replyError(ErrorCode::InvalidParams, EIB.message());
+                  });
+}
+
+void call(StringRef Method, json::Value &&Params) {
+  RequestSpan::attach([&](json::Object &Args) {
+    Args["Call"] = json::Object{{"method", Method.str()}, {"params", Params}};
+  });
+  // FIXME: Generate/Increment IDs for every request so that we can get proper
+  // replies once we need to.
+  auto ID = 1;
+  log("--> {0}({1})", Method, ID);
+  Context::current()
+      .getExisting(CurrentTransportLayer)
+      ->callClient(Method, std::move(Params), ID);
+}
+
 } // namespace
 
+bool ClangdLSPServer::callServer(llvm::StringRef Method, llvm::json::Value Params,
+                      llvm::json::Value ID) {
+  auto I = Handlers.find(Method);
+  auto &Handler = I != Handlers.end() ? I->second : UnknownHandler;
+
+  // Create a Context that contains request information.
+  WithContextValue WithTransportLayer(CurrentTransportLayer, &TransportLayer);
+  WithContextValue WithID(RequestID, ID);
+
+  // Create a tracing Span covering the whole request lifetime.
+  trace::Span Tracer(Method);
+  SPAN_ATTACH(Tracer, "ID", ID);
+  SPAN_ATTACH(Tracer, "Params", Params);
+
+  // Requests with IDs can be canceled by the client. Add cancellation context.
+  WithContext WithCancel(cancelableRequestContext(ID));
+
+  // Stash a reference to the span args, so later calls can add metadata.
+  WithContext WithRequestSpan(RequestSpan::stash(Tracer));
+  Handler(std::move(Params));
+  return true;
+}
+
+bool ClangdLSPServer::notifyServer(llvm::StringRef Method, llvm::json::Value Params) {
+  auto I = Handlers.find(Method);
+  auto &Handler = I != Handlers.end() ? I->second : UnknownHandler;
+
+  // Create a tracing Span covering the whole request lifetime.
+  trace::Span Tracer(Method);
+  SPAN_ATTACH(Tracer, "Params", Params);
+
+  // Stash a reference to the span args, so later calls can add metadata.
+  WithContext WithRequestSpan(RequestSpan::stash(Tracer));
+  Handler(std::move(Params));
+  return true;
+}
+
+bool ClangdLSPServer::replyToServer(llvm::json::Value ID, llvm::Expected<llvm::json::Value> Result) {
+  // TODO
+  llvm_unreachable("Unimplemented");
+}
+
 void ClangdLSPServer::onInitialize(InitializeParams &Params) {
   if (Params.initializationOptions)
     applyConfiguration(*Params.initializationOptions);
 
   if (Params.rootUri && *Params.rootUri)
     Server->setRootPath(Params.rootUri->file());
   else if (Params.rootPath && !Params.rootPath->empty())
     Server->setRootPath(*Params.rootPath);
reply(json::Object{
                  {"commands", {ExecuteCommandParams::CLANGD_APPLY_FIX_COMMAND}},
              }},
         }}}});
 }
 
 void ClangdLSPServer::onShutdown(ShutdownParams &Params) {
   // Do essentially nothing, just say we're ready to exit.
   ShutdownRequestReceived = true;
-  reply(nullptr);
+  ::reply(nullptr);
+  TransportLayer.shouldTerminateLoop = true;
 }
 
 void ClangdLSPServer::onExit(ExitParams &Params) { IsDone = true; }
 
 void ClangdLSPServer::onDocumentDidOpen(DidOpenTextDocumentParams &Params) {
   PathRef File = Params.textDocument.uri.file();
   if (Params.metadata && !Params.metadata->extraFlags.empty())
     CDB.setExtraFlagsForFile(File, std::move(Params.metadata->extraFlags));

 
 void ClangdLSPServer::onCommand(ExecuteCommandParams &Params) {
   auto ApplyEdit = [](WorkspaceEdit WE) {
     ApplyWorkspaceEditParams Edit;
     Edit.edit = std::move(WE);
     // We don't need the response so id == 1 is OK.
     // Ideally, we would wait for the response and if there is no error, we
     // would reply success/failure to the original RPC.
-    call("workspace/applyEdit", Edit);
+    ::call("workspace/applyEdit", Edit);
   };
   if (Params.command == ExecuteCommandParams::CLANGD_APPLY_FIX_COMMAND &&
       Params.workspaceEdit) {
     // The flow for "apply-fix" :
     // 1. We publish a diagnostic, including fixits
     // 2. The user clicks on the diagnostic, the editor asks us for code actions
     // 3. We send code actions, with the fixit embedded as context
     // 4. The user selects the fixit, the editor asks us to apply it
     // 5. We unwrap the changes and send them back to the editor
     // 6. The editor applies the changes (applyEdit), and sends us a reply (but
     // we ignore it)
 
-    reply("Fix applied.");
+    ::reply("Fix applied.");
     ApplyEdit(*Params.workspaceEdit);
   } else {
     // We should not get here because ExecuteCommandParams would not have
     // parsed in the first place and this handler should not be called. But if
     // more commands are added, this will be here has a safe guard.
-    replyError(
+    ::replyError(
         ErrorCode::InvalidParams,
         llvm::formatv("Unsupported command \"{0}\".", Params.command).str());
   }
 }
 
 void ClangdLSPServer::onWorkspaceSymbol(WorkspaceSymbolParams &Params) {
   Server->workspaceSymbols(
       Params.query, CCOpts.Limit,
       [this](llvm::Expected<std::vector<SymbolInformation>> Items) {
         if (!Items)
-          return replyError(ErrorCode::InternalError,
+          return ::replyError(ErrorCode::InternalError,
                             llvm::toString(Items.takeError()));
         for (auto &Sym : *Items)
           Sym.kind = adjustKindToCapability(Sym.kind, SupportedSymbolKinds);
 
-        reply(json::Array(*Items));
+        ::reply(json::Array(*Items));
       });
 }
 
 void ClangdLSPServer::onRename(RenameParams &Params) {
   Path File = Params.textDocument.uri.file();
   llvm::Optional<std::string> Code = DraftMgr.getDraft(File);
   if (!Code)
-    return replyError(ErrorCode::InvalidParams,
+    return ::replyError(ErrorCode::InvalidParams,
                       "onRename called for non-added file");
 
   Server->rename(
       File, Params.position, Params.newName,
       [File, Code,
        Params](llvm::Expected<std::vector<tooling::Replacement>> Replacements) {
         if (!Replacements)
-          return replyError(ErrorCode::InternalError,
+          return ::replyError(ErrorCode::InternalError,
                             llvm::toString(Replacements.takeError()));
 
         // Turn the replacements into the format specified by the Language
         // Server Protocol. Fuse them into one big JSON array.
         std::vector<TextEdit> Edits;
         for (const auto &R : *Replacements)
           Edits.push_back(replacementToEdit(*Code, R));
         WorkspaceEdit WE;
         WE.changes = {{Params.textDocument.uri.uri(), Edits}};
-        reply(WE);
+        ::reply(WE);
       });
 }
 
 void ClangdLSPServer::onDocumentDidClose(DidCloseTextDocumentParams &Params) {
   PathRef File = Params.textDocument.uri.file();
   DraftMgr.removeDraft(File);
   Server->removeDocument(File);
   CDB.invalidate(File);
 }
 
 void ClangdLSPServer::onDocumentOnTypeFormatting(
     DocumentOnTypeFormattingParams &Params) {
   auto File = Params.textDocument.uri.file();
   auto Code = DraftMgr.getDraft(File);
   if (!Code)
-    return replyError(ErrorCode::InvalidParams,
+    return ::replyError(ErrorCode::InvalidParams,
                       "onDocumentOnTypeFormatting called for non-added file");
 
   auto ReplacementsOrError = Server->formatOnType(*Code, File, Params.position);
   if (ReplacementsOrError)
-    reply(json::Array(replacementsToEdits(*Code, ReplacementsOrError.get())));
+    ::reply(json::Array(replacementsToEdits(*Code, ReplacementsOrError.get())));
   else
-    replyError(ErrorCode::UnknownErrorCode,
+    ::replyError(ErrorCode::UnknownErrorCode,
                llvm::toString(ReplacementsOrError.takeError()));
 }
 
 void ClangdLSPServer::onDocumentRangeFormatting(
     DocumentRangeFormattingParams &Params) {
   auto File = Params.textDocument.uri.file();
   auto Code = DraftMgr.getDraft(File);
   if (!Code)
-    return replyError(ErrorCode::InvalidParams,
+    return ::replyError(ErrorCode::InvalidParams,
                       "onDocumentRangeFormatting called for non-added file");
 
   auto ReplacementsOrError = Server->formatRange(*Code, File, Params.range);
   if (ReplacementsOrError)
-    reply(json::Array(replacementsToEdits(*Code, ReplacementsOrError.get())));
+    ::reply(json::Array(replacementsToEdits(*Code, ReplacementsOrError.get())));
   else
-    replyError(ErrorCode::UnknownErrorCode,
+    ::replyError(ErrorCode::UnknownErrorCode,
                llvm::toString(ReplacementsOrError.takeError()));
 }
 
 void ClangdLSPServer::onDocumentFormatting(DocumentFormattingParams &Params) {
   auto File = Params.textDocument.uri.file();
   auto Code = DraftMgr.getDraft(File);
   if (!Code)
-    return replyError(ErrorCode::InvalidParams,
+    return ::replyError(ErrorCode::InvalidParams,
                       "onDocumentFormatting called for non-added file");
 
   auto ReplacementsOrError = Server->formatFile(*Code, File);
   if (ReplacementsOrError)
-    reply(json::Array(replacementsToEdits(*Code, ReplacementsOrError.get())));
+    ::reply(json::Array(replacementsToEdits(*Code, ReplacementsOrError.get())));
   else
-    replyError(ErrorCode::UnknownErrorCode,
+    ::replyError(ErrorCode::UnknownErrorCode,
                llvm::toString(ReplacementsOrError.takeError()));
 }
 
 void ClangdLSPServer::onDocumentSymbol(DocumentSymbolParams &Params) {
   Server->documentSymbols(
       Params.textDocument.uri.file(),
       [this](llvm::Expected<std::vector<SymbolInformation>> Items) {
         if (!Items)
-          return replyError(ErrorCode::InvalidParams,
+          return ::replyError(ErrorCode::InvalidParams,
                             llvm::toString(Items.takeError()));
         for (auto &Sym : *Items)
           Sym.kind = adjustKindToCapability(Sym.kind, SupportedSymbolKinds);
-        reply(json::Array(*Items));
+        ::reply(json::Array(*Items));
       });
 }
 
 void ClangdLSPServer::onCodeAction(CodeActionParams &Params) {
   // We provide a code action for each diagnostic at the requested location
   // which has FixIts available.
   auto Code = DraftMgr.getDraft(Params.textDocument.uri.file());
   if (!Code)
     return replyError(ErrorCode::InvalidParams,
                       "onCodeAction called for non-added file");
 
   json::Array Commands;
   for (Diagnostic &D : Params.context.diagnostics) {
     for (auto &F : getFixes(Params.textDocument.uri.file(), D)) {
       WorkspaceEdit WE;
       std::vector<TextEdit> Edits(F.Edits.begin(), F.Edits.end());
       WE.changes = {{Params.textDocument.uri.uri(), std::move(Edits)}};
       Commands.push_back(json::Object{
           {"title", llvm::formatv("Apply fix: {0}", F.Message)},
           {"command", ExecuteCommandParams::CLANGD_APPLY_FIX_COMMAND},
           {"arguments", {WE}},
       });
     }
   }
-  reply(std::move(Commands));
+  ::reply(std::move(Commands));
 }
 
 void ClangdLSPServer::onCompletion(TextDocumentPositionParams &Params) {
   Server->codeComplete(Params.textDocument.uri.file(), Params.position, CCOpts,
                        [this](llvm::Expected<CodeCompleteResult> List) {
                          if (!List)
                            return replyError(List.takeError());
                          CompletionList LSPList;
                          LSPList.isIncomplete = List->HasMore;
                          for (const auto &R : List->Completions) {
                            CompletionItem C = R.render(CCOpts);
                            C.kind = adjustKindToCapability(
                                C.kind, SupportedCompletionItemKinds);
                            LSPList.items.push_back(std::move(C));
                          }
-                         return reply(std::move(LSPList));
+                         return ::reply(std::move(LSPList));
                        });
 }
 
 void ClangdLSPServer::onSignatureHelp(TextDocumentPositionParams &Params) {
   Server->signatureHelp(Params.textDocument.uri.file(), Params.position,
                         [](llvm::Expected<SignatureHelp> SignatureHelp) {
                           if (!SignatureHelp)
                             return replyError(
                                 ErrorCode::InvalidParams,
                                 llvm::toString(SignatureHelp.takeError()));
-                          reply(*SignatureHelp);
+                          ::reply(*SignatureHelp);
                         });
 }
 
 void ClangdLSPServer::onGoToDefinition(TextDocumentPositionParams &Params) {
   Server->findDefinitions(Params.textDocument.uri.file(), Params.position,
                           [](llvm::Expected<std::vector<Location>> Items) {
                             if (!Items)
                               return replyError(
                                   ErrorCode::InvalidParams,
                                   llvm::toString(Items.takeError()));
-                            reply(json::Array(*Items));
+                            ::reply(json::Array(*Items));
                           });
 }
 
 void ClangdLSPServer::onSwitchSourceHeader(TextDocumentIdentifier &Params) {
   llvm::Optional<Path> Result = Server->switchSourceHeader(Params.uri.file());
-  reply(Result ? URI::createFile(*Result).toString() : "");
+  ::reply(Result ? URI::createFile(*Result).toString() : "");
 }
 
 void ClangdLSPServer::onDocumentHighlight(TextDocumentPositionParams &Params) {
   Server->findDocumentHighlights(
       Params.textDocument.uri.file(), Params.position,
       [](llvm::Expected<std::vector<DocumentHighlight>> Highlights) {
         if (!Highlights)
           return replyError(ErrorCode::InternalError,
                             llvm::toString(Highlights.takeError()));
-        reply(json::Array(*Highlights));
+        ::reply(json::Array(*Highlights));
       });
 }
 
 void ClangdLSPServer::onHover(TextDocumentPositionParams &Params) {
   Server->findHover(Params.textDocument.uri.file(), Params.position,
                     [](llvm::Expected<llvm::Optional<Hover>> H) {
                       if (!H) {
                         replyError(ErrorCode::InternalError,
                                    llvm::toString(H.takeError()));
                         return;
                       }
 
-                      reply(*H);
+                      ::reply(*H);
                     });
 }
 
 void ClangdLSPServer::applyConfiguration(
     const ClangdConfigurationParamsChange &Settings) {
   // Compilation database change.
   if (Settings.compilationDatabasePath.hasValue()) {
     CDB.setCompileCommandsDir(Settings.compilationDatabasePath.getValue());
void ClangdLSPServer::onChangeConfiguration(
     DidChangeConfigurationParams &Params) {
   applyConfiguration(Params.settings);
 }
 
 void ClangdLSPServer::onReference(ReferenceParams &Params) {
   Server->findReferences(Params.textDocument.uri.file(), Params.position,
                          [](llvm::Expected<std::vector<Location>> Locations) {
                            if (!Locations)
-                             return replyError(
+                             return ::replyError(
                                  ErrorCode::InternalError,
                                  llvm::toString(Locations.takeError()));
-                           reply(llvm::json::Array(*Locations));
+                           ::reply(llvm::json::Array(*Locations));
                          });
 }
 
-ClangdLSPServer::ClangdLSPServer(JSONOutput &Out,
+// TODO refactor
+typedef std::function<void(const llvm::json::Value &)> Handler;
+template <typename Param> 
+  void Register(
+    ClangdLSPServer& LSPServer,
+    llvm::StringMap<Handler>& Handlers,
+    StringRef Method,
+    void (ClangdLSPServer::*Handler)(Param)
+  ) {
+    // Capture pointers by value, as the lambda will outlive this object.
+    assert(!Handlers.count(Method) && "Handler already registered!");
+    Handlers[Method] = std::move(
+      [=, &LSPServer](const json::Value &RawParams) {
+        typename std::remove_reference<Param>::type P;
+        if (fromJSON(RawParams, P)) {
+          (LSPServer.*Handler)(P);
+        } else {
+          elog("Failed to decode {0} request.", Method);
+        }
+      }
+    );
+  }
+
+ClangdLSPServer::ClangdLSPServer(Transport &TransportLayer,
                                  const clangd::CodeCompleteOptions &CCOpts,
                                  llvm::Optional<Path> CompileCommandsDir,
                                  bool ShouldUseInMemoryCDB,
                                  const ClangdServer::Options &Opts)
-    : Out(Out), CDB(ShouldUseInMemoryCDB ? CompilationDB::makeInMemory()
+    : TransportLayer(TransportLayer), CDB(ShouldUseInMemoryCDB ? CompilationDB::makeInMemory()
                                          : CompilationDB::makeDirectoryBased(
                                                std::move(CompileCommandsDir))),
       CCOpts(CCOpts), SupportedSymbolKinds(defaultSymbolKinds()),
       SupportedCompletionItemKinds(defaultCompletionItemKinds()),
       Server(new ClangdServer(CDB.getCDB(), FSProvider, /*DiagConsumer=*/*this,
-                              Opts)) {}
+                              Opts)),
+      UnknownHandler([](const json::Value &Params) {
+        ::replyError(ErrorCode::MethodNotFound, "method not found");
+      }) 
+{
+  Register(*this, Handlers, "initialize", &ClangdLSPServer::onInitialize);
+  Register(*this, Handlers, "shutdown", &ClangdLSPServer::onShutdown);
+  Register(*this, Handlers, "exit", &ClangdLSPServer::onExit);
+  Register(*this, Handlers, "textDocument/didOpen", &ClangdLSPServer::onDocumentDidOpen);
+  Register(*this, Handlers, "textDocument/didClose", &ClangdLSPServer::onDocumentDidClose);
+  Register(*this, Handlers, "textDocument/didChange", &ClangdLSPServer::onDocumentDidChange);
+  Register(*this, Handlers, "textDocument/rangeFormatting",
+          &ClangdLSPServer::onDocumentRangeFormatting);
+  Register(*this, Handlers, "textDocument/onTypeFormatting",
+          &ClangdLSPServer::onDocumentOnTypeFormatting);
+  Register(*this, Handlers, "textDocument/formatting", &ClangdLSPServer::onDocumentFormatting);
+  Register(*this, Handlers, "textDocument/codeAction", &ClangdLSPServer::onCodeAction);
+  Register(*this, Handlers, "textDocument/completion", &ClangdLSPServer::onCompletion);
+  Register(*this, Handlers, "textDocument/signatureHelp", &ClangdLSPServer::onSignatureHelp);
+  Register(*this, Handlers, "textDocument/definition", &ClangdLSPServer::onGoToDefinition);
+  Register(*this, Handlers, "textDocument/references", &ClangdLSPServer::onReference);
+  Register(*this, Handlers, "textDocument/switchSourceHeader",
+          &ClangdLSPServer::onSwitchSourceHeader);
+  Register(*this, Handlers, "textDocument/rename", &ClangdLSPServer::onRename);
+  Register(*this, Handlers, "textDocument/hover", &ClangdLSPServer::onHover);
+  Register(*this, Handlers, "textDocument/documentSymbol", &ClangdLSPServer::onDocumentSymbol);
+  Register(*this, Handlers, "workspace/didChangeWatchedFiles", &ClangdLSPServer::onFileEvent);
+  Register(*this, Handlers, "workspace/executeCommand", &ClangdLSPServer::onCommand);
+  Register(*this, Handlers, "textDocument/documentHighlight",
+          &ClangdLSPServer::onDocumentHighlight);
+  Register(*this, Handlers, "workspace/didChangeConfiguration",
+          &ClangdLSPServer::onChangeConfiguration);
+  Register(*this, Handlers, "workspace/symbol", &ClangdLSPServer::onWorkspaceSymbol);
+  Register(*this, Handlers, "$/cancelRequest", &ClangdLSPServer::onCancelRequest);
+}
 
-bool ClangdLSPServer::run(std::FILE *In, JSONStreamStyle InputStyle) {
+bool ClangdLSPServer::run() {
   assert(!IsDone && "Run was called before");
   assert(Server);
 
-  // Set up JSONRPCDispatcher.
-  JSONRPCDispatcher Dispatcher([](const json::Value &Params) {
-    replyError(ErrorCode::MethodNotFound, "method not found");
-  });
-  registerCallbackHandlers(Dispatcher, /*Callbacks=*/*this);
+  bool Error = !TransportLayer.loop(*this);
 
-  // Run the Language Server loop.
-  runLanguageServerLoop(In, Out, InputStyle, Dispatcher, IsDone);
+  if (Error) {
+    // TODO XXX
+    elog("Transport error.");
+  }
 
   // Make sure IsDone is set to true after this method exits to ensure assertion
   // at the start of the method fires if it's ever executed again.
   IsDone = true;
   // Destroy ClangdServer to ensure all worker threads finish.
   Server.reset();
 
-  return ShutdownRequestReceived;
+  return ShutdownRequestReceived && Error;
 }
 
 std::vector<Fix> ClangdLSPServer::getFixes(StringRef File,
                                            const clangd::Diagnostic &D) {
   std::lock_guard<std::mutex> Lock(FixItsMutex);
   auto DiagToFixItsIter = FixItsMap.find(File);
   if (DiagToFixItsIter == FixItsMap.end())
     return {};
 
   const auto &DiagToFixItsMap = DiagToFixItsIter->second;
   auto FixItsIter = DiagToFixItsMap.find(D);
   if (FixItsIter == DiagToFixItsMap.end())
     return {};
 
   return FixItsIter->second;
 }
 
+void ClangdLSPServer::onCancelRequest(CancelRequestParams &Params) {
+  // TODO
+  /*
+  JSONRPCDispatcher::JSONRPCDispatcher(Handler UnknownHandler)
+    : UnknownHandler(std::move(UnknownHandler)) {
+    registerHandler("$/cancelRequest", [this](const json::Value &Params) {
+      if (auto *O = Params.getAsObject())
+        if (auto *ID = O->get("id"))
+          return cancelRequest(*ID);
+      log("Bad cancellation request: {0}", Params);
+    });
+  }
+
+  void JSONRPCDispatcher::cancelRequest(const json::Value &ID) {
+    auto StrID = llvm::to_string(ID);
+    std::lock_guard<std::mutex> Lock(RequestCancelersMutex);
+    auto It = RequestCancelers.find(StrID);
+    if (It != RequestCancelers.end())
+      It->second.first(); // Invoke the canceler.
+  }
+  */
+}
 void ClangdLSPServer::onDiagnosticsReady(PathRef File,
                                          std::vector<Diag> Diagnostics) {
   json::Array DiagnosticsJSON;
 
   DiagnosticToReplacementMap LocalFixIts; // Temporary storage
   for (auto &Diag : Diagnostics) {
     toLSPDiags(Diag, [&](clangd::Diagnostic Diag, llvm::ArrayRef<Fix> Fixes) {
       json::Object LSPDiag({
void ClangdLSPServer::onDiagnosticsReady(PathRef File,
   // Cache FixIts
   {
     // FIXME(ibiryukov): should be deleted when documents are removed
     std::lock_guard<std::mutex> Lock(FixItsMutex);
     FixItsMap[File] = LocalFixIts;
   }
 
   // Publish diagnostics.
-  Out.writeMessage(json::Object{
-      {"jsonrpc", "2.0"},
-      {"method", "textDocument/publishDiagnostics"},
-      {"params",
-       json::Object{
-           {"uri", URIForFile{File}},
-           {"diagnostics", std::move(DiagnosticsJSON)},
-       }},
+  TransportLayer.notifyClient(
+    "textDocument/publishDiagnostics",
     });
 }
 
 void ClangdLSPServer::reparseOpenedFiles() {
   for (const Path &FilePath : DraftMgr.getActiveFiles())
     Server->addDocument(FilePath, *DraftMgr.getDraft(FilePath),
                         WantDiagnostics::Auto);
 }
 
void ClangdLSPServer::CompilationDB::setCompileCommandsDir(Path P) {
   CachingCDB->clear();
 }
 
 GlobalCompilationDatabase &ClangdLSPServer::CompilationDB::getCDB() {
   if (CachingCDB)
     return *CachingCDB;
   return *CDB;
 }
+
+Context ClangdLSPServer::cancelableRequestContext(const json::Value &ID) {
+  auto Task = cancelableTask();
+  auto StrID = llvm::to_string(ID);  // JSON-serialize ID for map key.
+  auto Cookie = NextRequestCookie++; // No lock, only called on main thread.
+  {
+    std::lock_guard<std::mutex> Lock(RequestCancelersMutex);
+    RequestCancelers[StrID] = {std::move(Task.second), Cookie};
+  }
+  // When the request ends, we can clean up the entry we just added.
+  // The cookie lets us check that it hasn't been overwritten due to ID reuse.
+  return Task.first.derive(make_scope_exit([this, StrID, Cookie] {
+    std::lock_guard<std::mutex> Lock(RequestCancelersMutex);
+    auto It = RequestCancelers.find(StrID);
+    if (It != RequestCancelers.end() && It->second.second == Cookie)
+      RequestCancelers.erase(It);
+  }));
+}
 No newline at end of file

clangd/JSONRPCDispatcher.h

private:
   Logger::Level MinLevel;
   llvm::raw_ostream &Outs;
   llvm::raw_ostream &Logs;
   llvm::raw_ostream *InputMirror;
 
   std::mutex StreamMutex;
 };
 
+/*
 /// Sends a successful reply.
 /// Current context must derive from JSONRPCDispatcher::Handler.
 void reply(llvm::json::Value &&Result);
 /// Sends an error response to the client, and logs it.
 /// Current context must derive from JSONRPCDispatcher::Handler.
 void replyError(ErrorCode Code, const llvm::StringRef &Message);
 /// Implements ErrorCode and message extraction from a given llvm::Error. It
 /// fetches the related message from error's message method. If error doesn't
 /// match any known errors, uses ErrorCode::InvalidParams for the error.
 void replyError(llvm::Error E);
 /// Returns the request-id of the current request. Should not be used directly
 /// for replying to requests, use the above mentioned methods for that case.
 const llvm::json::Value *getRequestId();
 /// Sends a request to the client.
 /// Current context must derive from JSONRPCDispatcher::Handler.
 void call(llvm::StringRef Method, llvm::json::Value &&Params);
+*/
 
 /// Main JSONRPC entry point. This parses the JSONRPC "header" and calls the
 /// registered Handler for the method received.
 ///
 /// The `$/cancelRequest` notification is handled by the dispatcher itself.
 /// It marks the matching request as cancelled, if it's still running.
 class JSONRPCDispatcher {
 public:
private:
   llvm::StringMap<std::pair<Canceler, unsigned>> RequestCancelers;
   unsigned NextRequestCookie = 0;
   Context cancelableRequestContext(const llvm::json::Value &ID);
   void cancelRequest(const llvm::json::Value &ID);
 
   llvm::StringMap<Handler> Handlers;
   Handler UnknownHandler;
 };
-
-/// Controls the way JSON-RPC messages are encoded (both input and output).
-enum JSONStreamStyle {
-  /// Encoding per the LSP specification, with mandatory Content-Length header.
-  Standard,
-  /// Messages are delimited by a '---' line. Comment lines start with #.
-  Delimited
-};
-
-/// Parses input queries from LSP client (coming from \p In) and runs call
-/// method of \p Dispatcher for each query.
-/// After handling each query checks if \p IsDone is set true and exits the loop
-/// if it is.
-/// Input stream(\p In) must be opened in binary mode to avoid preliminary
-/// replacements of \r\n with \n.
-/// We use C-style FILE* for reading as std::istream has unclear interaction
-/// with signals, which are sent by debuggers on some OSs.
-void runLanguageServerLoop(std::FILE *In, JSONOutput &Out,
-                           JSONStreamStyle InputStyle,
-                           JSONRPCDispatcher &Dispatcher, bool &IsDone);
 } // namespace clangd
 } // namespace clang
 
 #endif

clangd/JSONRPCDispatcher.cpp

 //===--- JSONRPCDispatcher.cpp - Main JSON parser entry point -------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "JSONRPCDispatcher.h"
 #include "Cancellation.h"
-#include "ProtocolHandlers.h"
 #include "Trace.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/Chrono.h"
 #include "llvm/Support/Errno.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/JSON.h"

 void JSONOutput::mirrorInput(const Twine &Message) {
   if (!InputMirror)
     return;
 
   *InputMirror << Message;
   InputMirror->flush();
 }
 
-void clangd::reply(json::Value &&Result) {
-  auto ID = getRequestId();
-  if (!ID) {
-    elog("Attempted to reply to a notification!");
-    return;
-  }
-  RequestSpan::attach([&](json::Object &Args) { Args["Reply"] = Result; });
-  log("--> reply({0})", *ID);
-  Context::current()
-      .getExisting(RequestOut)
-      ->writeMessage(json::Object{
-          {"jsonrpc", "2.0"},
-          {"id", *ID},
-          {"result", std::move(Result)},
-      });
-}
-
-void clangd::replyError(ErrorCode Code, const llvm::StringRef &Message) {
-  elog("Error {0}: {1}", static_cast<int>(Code), Message);
-  RequestSpan::attach([&](json::Object &Args) {
-    Args["Error"] = json::Object{{"code", static_cast<int>(Code)},
-                                 {"message", Message.str()}};
-  });
-
-  if (auto ID = getRequestId()) {
-    log("--> reply({0}) error: {1}", *ID, Message);
-    Context::current()
-        .getExisting(RequestOut)
-        ->writeMessage(json::Object{
-            {"jsonrpc", "2.0"},
-            {"id", *ID},
-            {"error", json::Object{{"code", static_cast<int>(Code)},
-                                   {"message", Message}}},
-        });
-  }
-}
-
-void clangd::replyError(Error E) {
-  handleAllErrors(std::move(E),
-                  [](const CancelledError &TCE) {
-                    replyError(ErrorCode::RequestCancelled, TCE.message());
-                  },
-                  [](const ErrorInfoBase &EIB) {
-                    replyError(ErrorCode::InvalidParams, EIB.message());
-                  });
-}
-
-void clangd::call(StringRef Method, json::Value &&Params) {
-  RequestSpan::attach([&](json::Object &Args) {
-    Args["Call"] = json::Object{{"method", Method.str()}, {"params", Params}};
-  });
-  // FIXME: Generate/Increment IDs for every request so that we can get proper
-  // replies once we need to.
-  auto ID = 1;
-  log("--> {0}({1})", Method, ID);
-  Context::current()
-      .getExisting(RequestOut)
-      ->writeMessage(json::Object{
-          {"jsonrpc", "2.0"},
-          {"id", ID},
-          {"method", Method},
-          {"params", std::move(Params)},
-      });
-}
-
 JSONRPCDispatcher::JSONRPCDispatcher(Handler UnknownHandler)
     : UnknownHandler(std::move(UnknownHandler)) {
   registerHandler("$/cancelRequest", [this](const json::Value &Params) {
     if (auto *O = Params.getAsObject())
       if (auto *ID = O->get("id"))
         return cancelRequest(*ID);
     log("Bad cancellation request: {0}", Params);
   });
static llvm::Optional<std::string> readDelimitedMessage(std::FILE *In,
   if (ferror(In)) {
     elog("Input error while reading message!");
     return llvm::None;
   } else { // Including EOF
     Out.mirrorInput(
         llvm::formatv("Content-Length: {0}\r\n\r\n{1}", JSON.size(), JSON));
     return std::move(JSON);
   }
-}
-
-// The use of C-style std::FILE* IO deserves some explanation.
-// Previously, std::istream was used. When a debugger attached on MacOS, the
-// process received EINTR, the stream went bad, and clangd exited.
-// A retry-on-EINTR loop around reads solved this problem, but caused clangd to
-// sometimes hang rather than exit on other OSes. The interaction between
-// istreams and signals isn't well-specified, so it's hard to get this right.
-// The C APIs seem to be clearer in this respect.
-void clangd::runLanguageServerLoop(std::FILE *In, JSONOutput &Out,
-                                   JSONStreamStyle InputStyle,
-                                   JSONRPCDispatcher &Dispatcher,
-                                   bool &IsDone) {
-  auto &ReadMessage =
-      (InputStyle == Delimited) ? readDelimitedMessage : readStandardMessage;
-  while (!IsDone && !feof(In)) {
-    if (ferror(In)) {
-      elog("IO error: {0}", llvm::sys::StrError());
-      return;
-    }
-    if (auto JSON = ReadMessage(In, Out)) {
-      if (auto Doc = json::parse(*JSON)) {
-        // Log the formatted message.
-        vlog(Out.Pretty ? "<<< {0:2}\n" : "<<< {0}\n", *Doc);
-        // Finally, execute the action for this JSON message.
-        if (!Dispatcher.call(*Doc, Out))
-          elog("JSON dispatch failed!");
-      } else {
-        // Parse error. Log the raw message.
-        vlog("<<< {0}\n", *JSON);
-        elog("JSON parse error: {0}", llvm::toString(Doc.takeError()));
-      }
-    }
-  }
-}
-
-const json::Value *clangd::getRequestId() {
-  return Context::current().get(RequestID);
-}
+}

clangd/Protocol.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_PROTOCOL_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_PROTOCOL_H
 
 #include "URI.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/JSON.h"
 #include <bitset>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace clangd {
 
 enum class ErrorCode {
   // Defined by JSON RPC.
   ParseError = -32700,
   InvalidRequest = -32600,
   MethodNotFound = -32601,
   InvalidParams = -32602,
   InternalError = -32603,
 
   ServerNotInitialized = -32002,
   UnknownErrorCode = -32001,
 
   // Defined by the protocol.
   RequestCancelled = -32800,
 };
+struct LSPError : public llvm::ErrorInfo<LSPError> {
+  ErrorCode Code;
+  std::string Message;
+  static char ID;
+  void log(llvm::raw_ostream& OS) const override { OS << Message; }
+  std::error_code convertToErrorCode() const override {
+    return llvm::inconvertibleErrorCode();
+  }
+};
 
 struct URIForFile {
   URIForFile() = default;
   explicit URIForFile(std::string AbsPath);
 
   /// Retrieves absolute path to the file.
   llvm::StringRef file() const { return File; }
 
struct RenameParams {
   /// The position at which this request was sent.
   Position position;
 
   /// The new name of the symbol.
   std::string newName;
 };
 bool fromJSON(const llvm::json::Value &, RenameParams &);
 
+struct CancelRequestParams {
+  /* TODO */
+};
+
+// TODO
+inline bool fromJSON(const llvm::json::Value &, CancelRequestParams &) { return true; }
+
 enum class DocumentHighlightKind { Text = 1, Read = 2, Write = 3 };
 
 /// A document highlight is a range inside a text document which deserves
 /// special attention. Usually a document highlight is visualized by changing
 /// the background color of its range.
 
 struct DocumentHighlight {
   /// The range this highlight applies to.

clangd/Protocol.cpp

 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace clang {
 namespace clangd {
 using namespace llvm;
 
+char LSPError::ID;
+
 URIForFile::URIForFile(std::string AbsPath) {
   assert(llvm::sys::path::is_absolute(AbsPath) && "the path is relative");
   File = std::move(AbsPath);
 }
 
 bool fromJSON(const json::Value &E, URIForFile &R) {
   if (auto S = E.getAsString()) {
     auto U = URI::parse(*S);

clangd/ProtocolHandlers.h

-//===--- ProtocolHandlers.h - LSP callbacks ---------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// ProtocolHandlers translates incoming JSON requests from JSONRPCDispatcher
-// into method calls on ClangLSPServer.
-//
-// Currently it parses requests into objects, but the ClangLSPServer is
-// responsible for producing JSON responses. We should move that here, too.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_PROTOCOLHANDLERS_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_PROTOCOLHANDLERS_H
-
-#include "JSONRPCDispatcher.h"
-#include "Protocol.h"
-#include "llvm/ADT/Twine.h"
-#include "llvm/Support/raw_ostream.h"
-
-namespace clang {
-namespace clangd {
-
-// The interface implemented by ClangLSPServer to handle incoming requests.
-class ProtocolCallbacks {
-public:
-  virtual ~ProtocolCallbacks() = default;
-
-  virtual void onInitialize(InitializeParams &Params) = 0;
-  virtual void onShutdown(ShutdownParams &Params) = 0;
-  virtual void onExit(ExitParams &Params) = 0;
-  virtual void onDocumentDidOpen(DidOpenTextDocumentParams &Params) = 0;
-  virtual void onDocumentDidChange(DidChangeTextDocumentParams &Params) = 0;
-  virtual void onDocumentDidClose(DidCloseTextDocumentParams &Params) = 0;
-  virtual void onDocumentFormatting(DocumentFormattingParams &Params) = 0;
-  virtual void onDocumentSymbol(DocumentSymbolParams &Params) = 0;
-  virtual void
-  onDocumentOnTypeFormatting(DocumentOnTypeFormattingParams &Params) = 0;
-  virtual void
-  onDocumentRangeFormatting(DocumentRangeFormattingParams &Params) = 0;
-  virtual void onCodeAction(CodeActionParams &Params) = 0;
-  virtual void onCompletion(TextDocumentPositionParams &Params) = 0;
-  virtual void onSignatureHelp(TextDocumentPositionParams &Params) = 0;
-  virtual void onGoToDefinition(TextDocumentPositionParams &Params) = 0;
-  virtual void onReference(ReferenceParams &Params) = 0;
-  virtual void onSwitchSourceHeader(TextDocumentIdentifier &Params) = 0;
-  virtual void onFileEvent(DidChangeWatchedFilesParams &Params) = 0;
-  virtual void onCommand(ExecuteCommandParams &Params) = 0;
-  virtual void onWorkspaceSymbol(WorkspaceSymbolParams &Params) = 0;
-  virtual void onRename(RenameParams &Parames) = 0;
-  virtual void onDocumentHighlight(TextDocumentPositionParams &Params) = 0;
-  virtual void onHover(TextDocumentPositionParams &Params) = 0;
-  virtual void onChangeConfiguration(DidChangeConfigurationParams &Params) = 0;
-};
-
-void registerCallbackHandlers(JSONRPCDispatcher &Dispatcher,
-                              ProtocolCallbacks &Callbacks);
-
-} // namespace clangd
-} // namespace clang
-
-#endif

clangd/ProtocolHandlers.cpp

-//===--- ProtocolHandlers.cpp - LSP callbacks -----------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "ProtocolHandlers.h"
-#include "ClangdLSPServer.h"
-#include "ClangdServer.h"
-#include "DraftStore.h"
-#include "Trace.h"
-
-using namespace clang;
-using namespace clang::clangd;
-using namespace llvm;
-
-namespace {
-
-// Helper for attaching ProtocolCallbacks methods to a JSONRPCDispatcher.
-// Invoke like: Registerer("foo", &ProtocolCallbacks::onFoo)
-// onFoo should be: void onFoo(Ctx &C, FooParams &Params)
-// FooParams should have a fromJSON function.
-struct HandlerRegisterer {
-  template <typename Param>
-  void operator()(StringRef Method, void (ProtocolCallbacks::*Handler)(Param)) {
-    // Capture pointers by value, as the lambda will outlive this object.
-    auto *Callbacks = this->Callbacks;
-    Dispatcher.registerHandler(Method, [=](const json::Value &RawParams) {
-      typename std::remove_reference<Param>::type P;
-      if (fromJSON(RawParams, P)) {
-        (Callbacks->*Handler)(P);
-      } else {
-        elog("Failed to decode {0} request.", Method);
-      }
-    });
-  }
-
-  JSONRPCDispatcher &Dispatcher;
-  ProtocolCallbacks *Callbacks;
-};
-
-} // namespace
-
-void clangd::registerCallbackHandlers(JSONRPCDispatcher &Dispatcher,
-                                      ProtocolCallbacks &Callbacks) {
-  HandlerRegisterer Register{Dispatcher, &Callbacks};
-
-  Register("initialize", &ProtocolCallbacks::onInitialize);
-  Register("shutdown", &ProtocolCallbacks::onShutdown);
-  Register("exit", &ProtocolCallbacks::onExit);
-  Register("textDocument/didOpen", &ProtocolCallbacks::onDocumentDidOpen);
-  Register("textDocument/didClose", &ProtocolCallbacks::onDocumentDidClose);
-  Register("textDocument/didChange", &ProtocolCallbacks::onDocumentDidChange);
-  Register("textDocument/rangeFormatting",
-           &ProtocolCallbacks::onDocumentRangeFormatting);
-  Register("textDocument/onTypeFormatting",
-           &ProtocolCallbacks::onDocumentOnTypeFormatting);
-  Register("textDocument/formatting", &ProtocolCallbacks::onDocumentFormatting);
-  Register("textDocument/codeAction", &ProtocolCallbacks::onCodeAction);
-  Register("textDocument/completion", &ProtocolCallbacks::onCompletion);
-  Register("textDocument/signatureHelp", &ProtocolCallbacks::onSignatureHelp);
-  Register("textDocument/definition", &ProtocolCallbacks::onGoToDefinition);
-  Register("textDocument/references", &ProtocolCallbacks::onReference);
-  Register("textDocument/switchSourceHeader",
-           &ProtocolCallbacks::onSwitchSourceHeader);
-  Register("textDocument/rename", &ProtocolCallbacks::onRename);
-  Register("textDocument/hover", &ProtocolCallbacks::onHover);
-  Register("textDocument/documentSymbol", &ProtocolCallbacks::onDocumentSymbol);
-  Register("workspace/didChangeWatchedFiles", &ProtocolCallbacks::onFileEvent);
-  Register("workspace/executeCommand", &ProtocolCallbacks::onCommand);
-  Register("textDocument/documentHighlight",
-           &ProtocolCallbacks::onDocumentHighlight);
-  Register("workspace/didChangeConfiguration",
-           &ProtocolCallbacks::onChangeConfiguration);
-  Register("workspace/symbol", &ProtocolCallbacks::onWorkspaceSymbol);
-}

clangd/Transport.h

+//===--- Transport.h - sending and receiving LSP messages -------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// The language server protocol is usually implemented by writing messages as
+// JSON-RPC over the stdin/stdout of a subprocess. However other communications
+// mechanisms are possible, such as XPC on mac (see xpc/ directory).
+//
+// The Transport interface allows the mechanism to be replaced, and the JSONRPC
+// Transport is the standard implementation.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_TRANSPORT_H_
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_TRANSPORT_H_
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/JSON.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace clang {
+namespace clangd {
+
+// A transport is responsible for maintaining the connection to a client
+// application, and reading/writing structured messages to it.
+//
+// Transports have limited thread safety requirements:
+//  - messages will not be sent concurrently
+//  - messages MAY be sent while loop() is reading, or its callback is active
+class Transport {
+public:
+  Transport() : shouldTerminateLoop(false) { }
+  virtual ~Transport() = default;
+
+  // Called by Clangd to send messages to the client.
+  // (Because JSON and XPC are so similar, these are concrete and delegate to
+  // sendMessage. We could change this to support more diverse transports).
+  void notifyClient(llvm::StringRef Method, llvm::json::Value Params);
+  void callClient(llvm::StringRef Method, llvm::json::Value Params,
+            llvm::json::Value ID);
+  void replyToClient(llvm::json::Value ID, llvm::Expected<llvm::json::Value> Result);
+
+  // Implemented by Clangd to handle incoming messages. (See loop() below).
+  class MessageHandler {
+  public:
+    // TODO was originally abstract
+    virtual ~MessageHandler() {}
+    virtual bool notifyServer(llvm::StringRef Method, llvm::json::Value ) = 0;
+    virtual bool callServer(llvm::StringRef Method, llvm::json::Value Params,
+                      llvm::json::Value ID) = 0;
+    virtual bool replyToServer(llvm::json::Value ID,
+                       llvm::Expected<llvm::json::Value> Result) = 0;
+  };
+  // Called by Clangd to receive messages from the client.
+  // The transport should in turn invoke the handler to process messages.
+  // If handler returns true, the transport should immedately return success.
+  // Otherwise, it returns an error when the transport becomes unusable.
+  // (Because JSON and XPC are so similar, they share handleMessage()).
+  virtual bool loop(MessageHandler &) = 0;
+
+  std::atomic<bool> shouldTerminateLoop;
+
+protected:
+  // Common implementation for notify(), call(), and reply().
+  virtual void sendMessage(llvm::json::Value) = 0;
+  // Delegates to notify(), call(), and reply().
+  bool handleMessage(llvm::json::Value, MessageHandler&);
+};
+
+// Controls the way JSON-RPC messages are encoded (both input and output).
+enum JSONStreamStyle {
+  // Encoding per the LSP specification, with mandatory Content-Length header.
+  Standard,
+  // Messages are delimited by a '---' line. Comment lines start with #.
+  Delimited
+};
+
+// Returns a Transport that speaks JSON-RPC over a pair of streams.
+// The input stream must be opened in binary mode.
+std::unique_ptr<Transport>
+newJSONTransport(std::FILE *In, llvm::raw_ostream &Out,
+                 JSONStreamStyle = JSONStreamStyle::Standard);
+
+} // namespace clangd
+} // namespace clang
+
+#endif
+
+

clangd/Transport.cpp

+//===--- Transport.cpp - sending and receiving LSP messages -----*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// The JSON-RPC transport is implemented here.
+// The alternative Mac-only XPC transport is in the xpc/ directory.
+//
+//===----------------------------------------------------------------------===//
+#include "Transport.h"
+#include "Logger.h"
+#include "Protocol.h"
+#include "llvm/Support/Errno.h"
+
+using namespace llvm;
+namespace clang {
+namespace clangd {
+
+void Transport::notifyClient(llvm::StringRef Method, llvm::json::Value Params) {
+  sendMessage(json::Object{
+      {"jsonrpc", "2.0"},
+      {"method", Method},
+      {"params", std::move(Params)},
+  });
+}
+void Transport::callClient(llvm::StringRef Method, llvm::json::Value Params,
+                     llvm::json::Value ID) {
+  sendMessage(json::Object{
+      {"jsonrpc", "2.0"},
+      {"id", std::move(ID)},
+      {"method", Method},
+      {"params", std::move(Params)},
+  });
+}
+void Transport::replyToClient(llvm::json::Value ID,
+                      llvm::Expected<llvm::json::Value> Result) {
+  auto Message = json::Object{
+      {"jsonrpc", "2.0"},
+      {"id", std::move(ID)},
+  };
+  if (Result)
+    Message["result"] = std::move(*Result);
+  else {
+    ErrorCode Code = ErrorCode::UnknownErrorCode;
+    std::string Msg =
+        toString(handleErrors(Result.takeError(), [&](const LSPError &Err) {
+          Code = Err.Code;
+          return make_error<LSPError>(Err); // Recreate error for its message.
+        }));
+    Message["error"] = json::Object{
+        {"message", Msg},
+        {"code", static_cast<int>(Code)},
+    };
+  }
+  sendMessage(std::move(Message));
+}
+
+namespace {
+
+// Tries to read a line up to and including \n.
+// If failing, feof() or ferror() will be set.
+static bool readLine(std::FILE *In, std::string &Out) {
+  static constexpr int BufSize = 1024;
+  size_t Size = 0;
+  Out.clear();
+  for (;;) {
+    Out.resize(Size + BufSize);
+    // Handle EINTR which is sent when a debugger attaches on some platforms.
+    if (!llvm::sys::RetryAfterSignal(nullptr, ::fgets, &Out[Size], BufSize, In))
+      return false;
+    clearerr(In);
+    // If the line contained null bytes, anything after it (including \n) will
+    // be ignored. Fortunately this is not a legal header or JSON.
+    size_t Read = std::strlen(&Out[Size]);
+    if (Read > 0 && Out[Size + Read - 1] == '\n') {
+      Out.resize(Size + Read);
+      return true;
+    }
+    Size += Read;
+  }
+}
+
+// Returns None when:
+//  - ferror() or feof() are set.
+//  - Content-Length is missing or empty (protocol error)
+static llvm::Optional<std::string> readStandardMessage(std::FILE *In) {
+  // A Language Server Protocol message starts with a set of HTTP headers,
+  // delimited  by \r\n, and terminated by an empty line (\r\n).
+  unsigned long long ContentLength = 0;
+  std::string Line;
+  while (true) {
+    if (feof(In) || ferror(In) || !readLine(In, Line))
+      return llvm::None;
+
+    llvm::StringRef LineRef(Line);
+
+    // We allow comments in headers. Technically this isn't part
+    // of the LSP specification, but makes writing tests easier.
+    if (LineRef.startswith("#"))
+      continue;
+
+    // Content-Length is a mandatory header, and the only one we handle.
+    if (LineRef.consume_front("Content-Length: ")) {
+      if (ContentLength != 0) {
+        elog("Warning: Duplicate Content-Length header received. "
+             "The previous value for this message ({0}) was ignored.",
+             ContentLength);
+      }
+      llvm::getAsUnsignedInteger(LineRef.trim(), 0, ContentLength);
+      continue;
+    } else if (!LineRef.trim().empty()) {
+      // It's another header, ignore it.
+      continue;
+    } else {
+      // An empty line indicates the end of headers.
+      // Go ahead and read the JSON.
+      break;
+    }
+  }
+
+  // The fuzzer likes crashing us by sending "Content-Length: 9999999999999999"
+  if (ContentLength > 1 << 30) { // 1024M
+    elog("Refusing to read message with long Content-Length: {0}. "
+         "Expect protocol errors",
+         ContentLength);
+    return llvm::None;
+  }
+  if (ContentLength == 0) {
+    log("Warning: Missing Content-Length header, or zero-length message.");
+    return llvm::None;
+  }
+
+  std::string JSON(ContentLength, '\0');
+  for (size_t Pos = 0, Read; Pos < ContentLength; Pos += Read) {
+    // Handle EINTR which is sent when a debugger attaches on some platforms.
+    Read = llvm::sys::RetryAfterSignal(0u, ::fread, &JSON[Pos], 1,
+                                       ContentLength - Pos, In);
+    if (Read == 0) {
+      elog("Input was aborted. Read only {0} bytes of expected {1}.", Pos,
+           ContentLength);
+      return llvm::None;
+    }
+    clearerr(In); // If we're done, the error was transient. If we're not done,
+                  // either it was transient or we'll see it again on retry.
+    Pos += Read;
+  }
+  return std::move(JSON);
+}
+
+// For lit tests we support a simplified syntax:
+// - messages are delimited by '---' on a line by itself
+// - lines starting with # are ignored.
+// This is a testing path, so favor simplicity over performance here.
+// When returning None, feof() or ferror() will be set.
+llvm::Optional<std::string> readDelimitedMessage(std::FILE *In) {
+  std::string JSON;
+  std::string Line;
+  while (readLine(In, Line)) {
+    auto LineRef = llvm::StringRef(Line).trim();
+    if (LineRef.startswith("#")) // comment
+      continue;
+
+    // found a delimiter
+    if (LineRef.rtrim() == "---")
+      break;
+
+    JSON += Line;
+  }
+
+  if (ferror(In)) {
+    elog("Input error while reading message!");
+    return llvm::None;
+  }
+  return std::move(JSON); // Including at EOF
+}
+
+class JSONTransport : public Transport {
+public:
+  JSONTransport(std::FILE *In, llvm::raw_ostream &Out, JSONStreamStyle Style)
+      : In(In), Out(Out), Style(Style) {}
+
+  FILE *In;
+  llvm::raw_ostream &Out;
+  JSONStreamStyle Style;
+
+  bool loop(MessageHandler &Handler) override {
+    auto &ReadMessage =
+        (Style == Delimited) ? readDelimitedMessage : readStandardMessage;
+    while (!feof(In)) {
+      if (ferror(In))
+        // TODO XXX return errorCodeToError(std::error_code(errno, std::system_category()));
+        return false;
+      if (auto JSON = ReadMessage(In)) {
+        if (auto Doc = json::parse(*JSON)) {
+          if (!handleMessage(std::move(*Doc), Handler))
+            return false;
+          if (shouldTerminateLoop)
+            // TODO XXX
+            break;
+        } else {
+          // Parse error. Log the raw message.
+          vlog("<<< {0}\n", *JSON);
+          elog("JSON parse error: {0}", llvm::toString(Doc.takeError()));
+          // TODO XXX
+          return false;
+        }
+      } else {
+        // TODO XXX
+        return false;
+      }
+    }
+    return true;
+  }
+
+private:
+  void sendMessage(llvm::json::Value Message) override {
+    Out << llvm::formatv("{0:2}", Message);
+    Out.flush();
+  }
+};
+
+} // namespace
+
+bool Transport::handleMessage(llvm::json::Value LSPMessage, MessageHandler& Handler) {
+/*
+TODO
+
+  // Message must be an object with "jsonrpc":"2.0".
+  auto *Object = Message.getAsObject();
+  if (!Object || Object->getString("jsonrpc") != Optional<StringRef>("2.0"))
+    return false;
+
+  // ID may be any JSON value. If absent, this is a notification.
+  llvm::Optional<json::Value> ID;
+  if (auto *I = Object->get("id"))
+    ID = std::move(*I);
+  auto Method = Object->getString("method");
+  logIncomingMessage(ID, Method, Object->getObject("error"));
+  if (!Method) // We only handle incoming requests, and ignore responses.
+    return false;
+  // Params should be given, use null if not.
+  json::Value Params = nullptr;
+  if (auto *P = Object->get("params"))
+    Params = std::move(*P);
+
+*/
+  llvm::json::Object* LSPMessageObj = LSPMessage.getAsObject();
+  if (!LSPMessageObj) {
+    // TODO error - Value is not an object
+    return false;
+  }
+
+  llvm::Optional<llvm::StringRef> Method = [LSPMessageObj]() {
+    const llvm::json::Value *MethodValue = LSPMessageObj->get("method");
+    if (MethodValue) {
+      return MethodValue->getAsString();
+    }
+    return llvm::Optional<llvm::StringRef>{};
+  }();
+
+  llvm::Optional<int64_t> ID = [LSPMessageObj]() {
+    const llvm::json::Value *MethodValue = LSPMessageObj->get("id");
+    if (MethodValue) {
+      return MethodValue->getAsInteger();
+    }
+    return llvm::Optional<int64_t>{};
+  }();
+
+  if (Method && ID) {
+    const llvm::json::Value *Params = LSPMessageObj->get("params");
+    if (!Params) {
+      // TODO error - params are missing
+      return false;
+    }
+    Handler.callServer(Method.getValue(), *Params, ID.getValue());
+    return true;
+  }
+  if (!Method && ID) {
+    const llvm::json::Value *Result = LSPMessageObj->get("result");
+    if (!Result) {
+      // TODO error - result is missing
+      return false;
+    }
+    Handler.replyToServer(ID.getValue(), *Result);
+    return true;
+  }
+  if (Method && !ID) {
+    const llvm::json::Value *Params = LSPMessageObj->get("params");
+    if (!Params) {
+      // TODO error - params are missing
+      return false;
+    }
+    Handler.notifyServer(Method.getValue(), *Params);
+    return true;
+  }
+
+  // TODO error - invalid JSON LSP message
+  return false;
+}
+
+std::unique_ptr<Transport>
+newJSONTransport(std::FILE *In, llvm::raw_ostream &Out, JSONStreamStyle Style) {
+  return llvm::make_unique<JSONTransport>(In, Out, Style);
+}
+
+} // namespace clangd
+} // namespace clang

clangd/tool/ClangdMain.cpp

int main(int argc, char *argv[]) {
   if (!HeaderInsertionDecorators) {
     CCOpts.IncludeIndicator.Insert.clear();
     CCOpts.IncludeIndicator.NoInsert.clear();
   }
   CCOpts.SpeculativeIndexRequest = Opts.StaticIndex;
   CCOpts.EnableFunctionArgSnippets = EnableFunctionArgSnippets;
   CCOpts.AllScopes = AllScopesCompletion;
 
+  // TODO
+  std::unique_ptr<Transport> TransportLayer = newJSONTransport(stdin, llvm::outs(), InputStyle);
+  if (!TransportLayer.get()) {
+      // TODO
+      return 42;
+  }
+
   // Initialize and run ClangdLSPServer.
   ClangdLSPServer LSPServer(
-      Out, CCOpts, CompileCommandsDirPath,
+      *TransportLayer.get(), CCOpts, CompileCommandsDirPath,
       /*ShouldUseInMemoryCDB=*/CompileArgsFrom == LSPCompileArgs, Opts);
   constexpr int NoShutdownRequestErrorCode = 1;
   llvm::set_thread_name("clangd.main");
   // Change stdin to binary to not lose \r\n on windows.
   llvm::sys::ChangeStdinToBinary();
-  return LSPServer.run(stdin, InputStyle) ? 0 : NoShutdownRequestErrorCode;
+  return LSPServer.run() ? 0 : NoShutdownRequestErrorCode;
 }