[clangd] Bind outgoing calls through LSPBinder too. NFC

[sammccall]

Summary

The redundancy around work-done-progress is annoying but ok for now.

There's a weirdness with context lifetimes around outgoing method calls, which
I've preserved to keep this NFC. We should probably fix it though.

[sammccall]

Remove fixedme

[kadircet]

mostly LG. some comments around the way we set up outgoinmethod stubs though.

clang-tools-extra/clangd/LSPBinder.h

88

well this one filling an out-parameter definitely tripped me over while reading the code a couple times, and once more on the tests.

what about making this return the handler instead? E.g. Edit = Bind.outgoingMethod<EditParams, EditResult>("edit"), I know it is ugly that we duplicate template params on declaration + here now. Maybe we can get away by making OutgoingMethod a class with a call operator and a RawOutgoing *Out member that can be bound later on ? e.g:

template <StringLiteral Method, typename P, typename R>
class OutgoingMethod {
  RawOutgoing *Out = nullptr;
public:
  void operator()(const P& Params, Callback<R> CB) {
    assert(Out && "Method haven't bound");
    Out->callMethod(Method, JSON(Params), ....);
  }
};

then we either make LSPBinder a friend of OutgoingMethod and set Out through it, or the other way around and have a OutgoingMethod::bindOut(LSPBinder&) ?

not sure if it is any better though, as we still construct a somewhat invalid object :/

90

nit: maybe move bodies for these functions out-of-line too?

93

haha feels like confusing Context and WithContext issue i talked about yesterday :D

[sammccall]

clang-tools-extra/clangd/LSPBinder.h

88

well this one filling an out-parameter definitely tripped me over while reading the code a couple times, and once more on the tests.

Yup. My feeling is the wins are:

• avoid writing the types over and over (we can't really avoid it on the instance variable)
• resembles syntax for binding incoming things

And the main loss is definitely that we're not using assignment syntax for assignment.

what about making this return the handler instead? E.g. Edit = Bind.outgoingMethod<EditParams, EditResult>("edit")

This is a reasonable alternative, as you say the duplication is the downside.

Maybe we can get away by making OutgoingMethod a class with a call operator

Yeah, I don't really understand what this achieves - the usage looks the same, just now the logical assignment doesn't use assignment syntax *or* assignment semantics :-)

Other ideas I had:

• the object is untyped, and the call operator is templated/typed - no type-safety at callsite, yuck
• outgoingMethod returns an untyped proxy object with a template conversion operator to unique_function<Req, Rsp>. This gives us assignment syntax... and horrible compiler errors on mismatch.

I'm going to try the latter out to see how bad it is.

93

Exactly. I'm fairly sure we need a WithContext here but don't want to risk changing it at the same time.

clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp

236

whoops, after rebasing against 40cc63ea6eec7874d3a358f9fa549ef2f6543512 this uncovered a bug - we're testing the public API from the wrong thread (server thread != main thread).

So I've had to remove that test in this patch. We can test public APIs again in D96755.

[sammccall]

rebase & address comments (except bind out API, still to come)

[sammccall]

OK, the awful proxy object thing works :-)
It requires a SFINAE fix to unique_function though, which i'll send separately.

[kadircet]

thanks! can't wait for the unique_function sfinae fix :)

clang-tools-extra/clangd/LSPBinder.h

88

thanks! this looks a whole lot better!

185

maybe put inline at the start of the declaration ? :D

clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp

236

yikes, i see what you mean now.. (i was searching for the failure in the previous commit you mentioned)

[sammccall]

clang-tools-extra/clangd/LSPBinder.h

88

Glad you like it... personally I felt a little ill after writing it :-)

[sammccall]

fix nit

[kadircet]

still LG!

clang-tools-extra/clangd/ClangdLSPServer.h

 
 class SymbolIndex;
 
 /// This class exposes ClangdServer's capabilities via Language Server Protocol.
 ///
 /// MessageHandler binds the implemented LSP methods (e.g. onInitialize) to
 /// corresponding JSON-RPC methods ("initialize").
 /// The server also supports $/cancelRequest (MessageHandler provides this).
-class ClangdLSPServer : private ClangdServer::Callbacks {
+class ClangdLSPServer : private ClangdServer::Callbacks,
+                        private LSPBinder::RawOutgoing {
 public:
   struct Options : ClangdServer::Options {
     /// Supplies configuration (overrides ClangdServer::ContextProvider).
     config::Provider *ConfigProvider = nullptr;
     /// Look for compilation databases, rather than using compile commands
     /// set via LSP (extensions) only.
     bool UseDirBasedCDB = true;
     /// A fixed directory to search for a compilation database in.
private:
   /// hierarchy.
   void onMemoryUsage(const NoParams &, Callback<MemoryTree>);
   void onCommand(const ExecuteCommandParams &, Callback<llvm::json::Value>);
 
   /// Implement commands.
   void onCommandApplyEdit(const WorkspaceEdit &, Callback<llvm::json::Value>);
   void onCommandApplyTweak(const TweakArgs &, Callback<llvm::json::Value>);
 
+  /// Outgoing LSP calls.
+  LSPBinder::OutgoingMethod<ApplyWorkspaceEditParams,
+                            ApplyWorkspaceEditResponse>
+      ApplyWorkspaceEdit;
+  LSPBinder::OutgoingNotification<ShowMessageParams> ShowMessage;
+  LSPBinder::OutgoingNotification<PublishDiagnosticsParams> PublishDiagnostics;
+  LSPBinder::OutgoingNotification<FileStatus> NotifyFileStatus;
+  LSPBinder::OutgoingMethod<WorkDoneProgressCreateParams, std::nullptr_t>
+      CreateWorkDoneProgress;
+  LSPBinder::OutgoingNotification<ProgressParams<WorkDoneProgressBegin>>
+      BeginWorkDoneProgress;
+  LSPBinder::OutgoingNotification<ProgressParams<WorkDoneProgressReport>>
+      ReportWorkDoneProgress;
+  LSPBinder::OutgoingNotification<ProgressParams<WorkDoneProgressEnd>>
+      EndWorkDoneProgress;
+
   void applyEdit(WorkspaceEdit WE, llvm::json::Value Success,
                  Callback<llvm::json::Value> Reply);
 
   void bindMethods(LSPBinder &);
   std::vector<Fix> getFixes(StringRef File, const clangd::Diagnostic &D);
 
   /// Checks if completion request should be ignored. We need this due to the
   /// limitation of the LSP. Per LSP, a client sends requests for all "trigger
   /// character" we specify, but for '>' and ':' we need to check they actually
   /// produce '->' and '::', respectively.
   bool shouldRunCompletion(const CompletionParams &Params) const;
 
   /// Requests a reparse of currently opened files using their latest source.
   /// This will typically only rebuild if something other than the source has
   /// changed (e.g. the CDB yields different flags, or files included in the
   /// preamble have been modified).
   void reparseOpenFilesIfNeeded(
       llvm::function_ref<bool(llvm::StringRef File)> Filter);
   void applyConfiguration(const ConfigurationSettings &Settings);
 
-  /// Sends a "publishDiagnostics" notification to the LSP client.
-  void publishDiagnostics(const PublishDiagnosticsParams &);
-
   /// Runs profiling and exports memory usage metrics if tracing is enabled and
   /// profiling hasn't happened recently.
   void maybeExportMemoryProfile();
   PeriodicThrottler ShouldProfile;
 
   /// Run the MemoryCleanup callback if it's time.
   /// This method is thread safe.
   void maybeCleanupMemory();
private:
   typedef std::map<clangd::Diagnostic, std::vector<Fix>, LSPDiagnosticCompare>
       DiagnosticToReplacementMap;
   /// Caches FixIts per file and diagnostics
   llvm::StringMap<DiagnosticToReplacementMap> FixItsMap;
   // Last semantic-tokens response, for incremental requests.
   std::mutex SemanticTokensMutex;
   llvm::StringMap<SemanticTokens> LastSemanticTokens;
 
-  // Most code should not deal with Transport directly.
-  // MessageHandler deals with incoming messages, use call() etc for outgoing.
+  // Most code should not deal with Transport, callMethod, notify directly.
+  // Use LSPBinder to handle incoming and outgoing calls.
   clangd::Transport &Transp;
   class MessageHandler;
   std::unique_ptr<MessageHandler> MsgHandler;
   std::mutex TranspWriter;
 
-  template <typename Response>
-  void call(StringRef Method, llvm::json::Value Params, Callback<Response> CB) {
-    // Wrap the callback with LSP conversion and error-handling.
-    auto HandleReply =
-        [CB = std::move(CB), Ctx = Context::current().clone(),
-         Method = Method.str()](
-            llvm::Expected<llvm::json::Value> RawResponse) mutable {
-          if (!RawResponse)
-            return CB(RawResponse.takeError());
-          CB(LSPBinder::parse<Response>(*RawResponse, Method, "response"));
-        };
-    callRaw(Method, std::move(Params), std::move(HandleReply));
-  }
-  void callRaw(StringRef Method, llvm::json::Value Params,
-               Callback<llvm::json::Value> CB);
-  void notify(StringRef Method, llvm::json::Value Params);
-  template <typename T> void progress(const llvm::json::Value &Token, T Value) {
-    ProgressParams<T> Params;
-    Params.token = Token;
-    Params.value = std::move(Value);
-    notify("$/progress", Params);
-  }
+  void callMethod(StringRef Method, llvm::json::Value Params,
+                  Callback<llvm::json::Value> CB) override;
+  void notify(StringRef Method, llvm::json::Value Params) override;
 
   LSPBinder::RawHandlers Handlers;
 
   const ThreadsafeFS &TFS;
   /// Options used for diagnostics.
   ClangdDiagnosticOptions DiagOpts;
   /// The supported kinds of the client.
   SymbolKindBitset SupportedSymbolKinds;

clang-tools-extra/clangd/ClangdLSPServer.cpp

std::deque<std::pair</*RequestID*/ int,
                        /*ReplyHandler*/ Callback<llvm::json::Value>>>
       ReplyCallbacks; /* GUARDED_BY(CallMutex) */
 
   ClangdLSPServer &Server;
 };
 constexpr int ClangdLSPServer::MessageHandler::MaxReplayCallbacks;
 
 // call(), notify(), and reply() wrap the Transport, adding logging and locking.
-void ClangdLSPServer::callRaw(StringRef Method, llvm::json::Value Params,
+void ClangdLSPServer::callMethod(StringRef Method, llvm::json::Value Params,
                                  Callback<llvm::json::Value> CB) {
   auto ID = MsgHandler->bindReply(std::move(CB));
   log("--> {0}({1})", Method, ID);
   std::lock_guard<std::mutex> Lock(TranspWriter);
   Transp.call(Method, std::move(Params), ID);
 }
 
 void ClangdLSPServer::notify(llvm::StringRef Method, llvm::json::Value Params) {
   log("--> {0}", Method);
llvm::json::Object ServerCaps{
       {"typeHierarchyProvider", true},
       {"memoryUsageProvider", true}, // clangd extension
       {"compilationDatabase",        // clangd extension
        llvm::json::Object{{"automaticReload", true}}},
       {"callHierarchyProvider", true},
   };
 
   {
-    LSPBinder Binder(Handlers);
+    LSPBinder Binder(Handlers, *this);
     bindMethods(Binder);
     if (Opts.Modules)
       for (auto &Mod : *Opts.Modules)
         Mod.initializeLSP(Binder, Params.rawCapabilities, ServerCaps);
   }
 
   // Per LSP, renameProvider can be either boolean or RenameOptions.
   // RenameOptions will be specified if the client states it supports prepare.
if (!R)
       return Reply(R.takeError());
 
     assert(R->ShowMessage || (!R->ApplyEdits.empty() && "tweak has no effect"));
 
     if (R->ShowMessage) {
       ShowMessageParams Msg;
       Msg.message = *R->ShowMessage;
       Msg.type = MessageType::Info;
-      notify("window/showMessage", Msg);
+      ShowMessage(Msg);
     }
     // When no edit is specified, make sure we Reply().
     if (R->ApplyEdits.empty())
       return Reply("Tweak applied.");
 
     if (auto Err = validateEdits(DraftMgr, R->ApplyEdits))
       return Reply(std::move(Err));
 
void ClangdLSPServer::onCommandApplyTweak(const TweakArgs &Args,
   Server->applyTweak(Args.file.file(), Args.selection, Args.tweakID,
                      std::move(Action));
 }
 
 void ClangdLSPServer::applyEdit(WorkspaceEdit WE, llvm::json::Value Success,
                                 Callback<llvm::json::Value> Reply) {
   ApplyWorkspaceEditParams Edit;
   Edit.edit = std::move(WE);
-  call<ApplyWorkspaceEditResponse>(
-      "workspace/applyEdit", std::move(Edit),
-      [Reply = std::move(Reply), SuccessMessage = std::move(Success)](
+  ApplyWorkspaceEdit(
+      Edit, [Reply = std::move(Reply), SuccessMessage = std::move(Success)](
                 llvm::Expected<ApplyWorkspaceEditResponse> Response) mutable {
         if (!Response)
           return Reply(Response.takeError());
         if (!Response->applied) {
           std::string Reason = Response->failureReason
                                    ? *Response->failureReason
                                    : "unknown reason";
           return Reply(error("edits were not applied: {0}", Reason));
         }
void ClangdLSPServer::onDocumentDidClose(
   }
   // clangd will not send updates for this file anymore, so we empty out the
   // list of diagnostics shown on the client (e.g. in the "Problems" pane of
   // VSCode). Note that this cannot race with actual diagnostics responses
   // because removeDocument() guarantees no diagnostic callbacks will be
   // executed after it returns.
   PublishDiagnosticsParams Notification;
   Notification.uri = URIForFile::canonicalize(File, /*TUPath=*/File);
-  publishDiagnostics(Notification);
+  PublishDiagnostics(Notification);
 }
 
 void ClangdLSPServer::onDocumentOnTypeFormatting(
     const DocumentOnTypeFormattingParams &Params,
     Callback<std::vector<TextEdit>> Reply) {
   auto File = Params.textDocument.uri.file();
   auto Code = DraftMgr.getDraft(File);
   if (!Code)
if (Old != New) {
       ModifiedFiles.insert(File);
     }
   }
 
   reparseOpenFilesIfNeeded(
       [&](llvm::StringRef File) { return ModifiedFiles.count(File) != 0; });
 }
 
-void ClangdLSPServer::publishDiagnostics(
-    const PublishDiagnosticsParams &Params) {
-  notify("textDocument/publishDiagnostics", Params);
-}
-
 void ClangdLSPServer::maybeExportMemoryProfile() {
   if (!trace::enabled() || !ShouldProfile())
     return;
 
   static constexpr trace::Metric MemoryUsage(
       "memory_usage", trace::Metric::Value, "component_name");
   trace::Span Tracer("ProfileBrief");
   MemoryTree MT;
: ShouldProfile(/*Period=*/std::chrono::minutes(5),
       SupportedSymbolKinds(defaultSymbolKinds()),
       SupportedCompletionItemKinds(defaultCompletionItemKinds()), Opts(Opts) {
   if (Opts.ConfigProvider) {
     assert(!Opts.ContextProvider &&
            "Only one of ConfigProvider and ContextProvider allowed!");
     this->Opts.ContextProvider = ClangdServer::createConfiguredContextProvider(
         Opts.ConfigProvider, this);
   }
-  LSPBinder Bind(this->Handlers);
+  LSPBinder Bind(this->Handlers, *this);
   Bind.method("initialize", this, &ClangdLSPServer::onInitialize);
 }
 
 void ClangdLSPServer::bindMethods(LSPBinder &Bind) {
   // clang-format off
   Bind.notification("initialized", this, &ClangdLSPServer::onInitialized);
   Bind.method("shutdown", this, &ClangdLSPServer::onShutdown);
   Bind.method("sync", this, &ClangdLSPServer::onSync);
void ClangdLSPServer::bindMethods(LSPBinder &Bind) {
   Bind.method("textDocument/documentLink", this, &ClangdLSPServer::onDocumentLink);
   Bind.method("textDocument/semanticTokens/full", this, &ClangdLSPServer::onSemanticTokens);
   Bind.method("textDocument/semanticTokens/full/delta", this, &ClangdLSPServer::onSemanticTokensDelta);
   Bind.method("$/memoryUsage", this, &ClangdLSPServer::onMemoryUsage);
   if (Opts.FoldingRanges)
     Bind.method("textDocument/foldingRange", this, &ClangdLSPServer::onFoldingRange);
   Bind.command(APPLY_FIX_COMMAND, this, &ClangdLSPServer::onCommandApplyEdit);
   Bind.command(APPLY_TWEAK_COMMAND, this, &ClangdLSPServer::onCommandApplyTweak);
+
+  ApplyWorkspaceEdit = Bind.outgoingMethod("workspace/applyEdit");
+  PublishDiagnostics = Bind.outgoingNotification("textDocument/publishDiagnostics");
+  ShowMessage = Bind.outgoingNotification("window/showMessage");
+  NotifyFileStatus = Bind.outgoingNotification("textDocument/clangd.fileStatus");
+  CreateWorkDoneProgress = Bind.outgoingMethod("window/workDoneProgress/create");
+  BeginWorkDoneProgress = Bind.outgoingNotification("$/progress");
+  ReportWorkDoneProgress = Bind.outgoingNotification("$/progress");
+  EndWorkDoneProgress = Bind.outgoingNotification("$/progress");
   // clang-format on
 }
 
 ClangdLSPServer::~ClangdLSPServer() {
   IsBeingDestroyed = true;
   // Explicitly destroy ClangdServer first, blocking on threads it owns.
   // This ensures they don't access any other members.
   Server.reset();
void ClangdLSPServer::onDiagnosticsReady(PathRef File, llvm::StringRef Version,
 
   // Cache FixIts
   {
     std::lock_guard<std::mutex> Lock(FixItsMutex);
     FixItsMap[File] = LocalFixIts;
   }
 
   // Send a notification to the LSP client.
-  publishDiagnostics(Notification);
+  PublishDiagnostics(Notification);
 }
 
 void ClangdLSPServer::onBackgroundIndexProgress(
     const BackgroundQueue::Stats &Stats) {
   static const char ProgressToken[] = "backgroundIndexProgress";
 
   // The background index did some work, maybe we need to cleanup
   maybeCleanupMemory();
 
   std::lock_guard<std::mutex> Lock(BackgroundIndexProgressMutex);
 
   auto NotifyProgress = [this](const BackgroundQueue::Stats &Stats) {
     if (BackgroundIndexProgressState != BackgroundIndexProgress::Live) {
       WorkDoneProgressBegin Begin;
       Begin.percentage = true;
       Begin.title = "indexing";
-      progress(ProgressToken, std::move(Begin));
+      BeginWorkDoneProgress({ProgressToken, std::move(Begin)});
       BackgroundIndexProgressState = BackgroundIndexProgress::Live;
     }
 
     if (Stats.Completed < Stats.Enqueued) {
       assert(Stats.Enqueued > Stats.LastIdle);
       WorkDoneProgressReport Report;
       Report.percentage = 100.0 * (Stats.Completed - Stats.LastIdle) /
                           (Stats.Enqueued - Stats.LastIdle);
       Report.message =
           llvm::formatv("{0}/{1}", Stats.Completed - Stats.LastIdle,
                         Stats.Enqueued - Stats.LastIdle);
-      progress(ProgressToken, std::move(Report));
+      ReportWorkDoneProgress({ProgressToken, std::move(Report)});
     } else {
       assert(Stats.Completed == Stats.Enqueued);
-      progress(ProgressToken, WorkDoneProgressEnd());
+      EndWorkDoneProgress({ProgressToken, WorkDoneProgressEnd()});
       BackgroundIndexProgressState = BackgroundIndexProgress::Empty;
     }
   };
 
   switch (BackgroundIndexProgressState) {
   case BackgroundIndexProgress::Unsupported:
     return;
   case BackgroundIndexProgress::Creating:
     // Cache this update for when the progress bar is available.
     PendingBackgroundIndexProgress = Stats;
     return;
   case BackgroundIndexProgress::Empty: {
     if (BackgroundIndexSkipCreate) {
       NotifyProgress(Stats);
       break;
     }
     // Cache this update for when the progress bar is available.
     PendingBackgroundIndexProgress = Stats;
     BackgroundIndexProgressState = BackgroundIndexProgress::Creating;
     WorkDoneProgressCreateParams CreateRequest;
     CreateRequest.token = ProgressToken;
-    call<std::nullptr_t>(
-        "window/workDoneProgress/create", CreateRequest,
+    CreateWorkDoneProgress(
+        CreateRequest,
         [this, NotifyProgress](llvm::Expected<std::nullptr_t> E) {
           std::lock_guard<std::mutex> Lock(BackgroundIndexProgressMutex);
           if (E) {
             NotifyProgress(this->PendingBackgroundIndexProgress);
           } else {
             elog("Failed to create background index progress bar: {0}",
                  E.takeError());
             // give up forever rather than thrashing about
void ClangdLSPServer::onFileUpdated(PathRef File, const TUStatus &Status) {
   // FIXME: we don't emit "BuildingFile" and `RunningAction`, as these
   // two statuses are running faster in practice, which leads the UI constantly
   // changing, and doesn't provide much value. We may want to emit status at a
   // reasonable time interval (e.g. 0.5s).
   if (Status.PreambleActivity == PreambleAction::Idle &&
       (Status.ASTActivity.K == ASTAction::Building ||
        Status.ASTActivity.K == ASTAction::RunningAction))
     return;
-  notify("textDocument/clangd.fileStatus", Status.render(File));
+  NotifyFileStatus(Status.render(File));
 }
 
 void ClangdLSPServer::reparseOpenFilesIfNeeded(
     llvm::function_ref<bool(llvm::StringRef File)> Filter) {
   // Reparse only opened files that were modified.
   for (const Path &FilePath : DraftMgr.getActiveFiles())
     if (Filter(FilePath))
       if (auto Draft = DraftMgr.getDraft(FilePath)) // else disappeared in race?
         Server->addDocument(FilePath, std::move(Draft->Contents),
                             encodeVersion(Draft->Version),
                             WantDiagnostics::Auto);
 }
 
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/LSPBinder.h

public:
   struct RawHandlers {
     template <typename HandlerT>
     using HandlerMap = llvm::StringMap<llvm::unique_function<HandlerT>>;
 
     HandlerMap<void(JSON)> NotificationHandlers;
     HandlerMap<void(JSON, Callback<JSON>)> MethodHandlers;
     HandlerMap<void(JSON, Callback<JSON>)> CommandHandlers;
   };
+  class RawOutgoing {
+  public:
+    virtual ~RawOutgoing() = default;
+    virtual void callMethod(llvm::StringRef Method, JSON Params,
+                            Callback<JSON> Reply) = 0;
+    virtual void notify(llvm::StringRef Method, JSON Params) = 0;
+  };
 
-  LSPBinder(RawHandlers &Raw) : Raw(Raw) {}
+  LSPBinder(RawHandlers &Raw, RawOutgoing &Out) : Raw(Raw), Out(Out) {}
 
   /// Bind a handler for an LSP method.
   /// e.g. Bind.method("peek", this, &ThisModule::peek);
   /// Handler should be e.g. void peek(const PeekParams&, Callback<PeekResult>);
   /// PeekParams must be JSON-parseable and PeekResult must be serializable.
   template <typename Param, typename Result, typename ThisT>
   void method(llvm::StringLiteral Method, ThisT *This,
               void (ThisT::*Handler)(const Param &, Callback<Result>));
public:
   /// Bind a handler for an LSP command.
   /// e.g. Bind.command("load", this, &ThisModule::load);
   /// Handler should be e.g. void load(const LoadParams&, Callback<LoadResult>);
   /// LoadParams must be JSON-parseable and LoadResult must be serializable.
   template <typename Param, typename Result, typename ThisT>
   void command(llvm::StringLiteral Command, ThisT *This,
                void (ThisT::*Handler)(const Param &, Callback<Result>));
 
+  template <typename P, typename R>
+  using OutgoingMethod = llvm::unique_function<void(const P &, Callback<R>)>;
+  /// UntypedOutgoingMethod is convertible to OutgoingMethod<P, R>.
+  class UntypedOutgoingMethod;
+  /// Bind a function object to be used for outgoing method calls.
+  /// e.g. OutgoingMethod<EParams, EResult> Edit = Bind.outgoingMethod("edit");
+  /// EParams must be JSON-serializable, EResult must be parseable.
+  UntypedOutgoingMethod outgoingMethod(llvm::StringLiteral Method);
+
+  template <typename P>
+  using OutgoingNotification = llvm::unique_function<void(const P &)>;
+  /// UntypedOutgoingNotification is convertible to OutgoingNotification<T>.
+  class UntypedOutgoingNotification;
+  /// Bind a function object to be used for outgoing notifications.
+  /// e.g. OutgoingNotification<LogParams> Log = Bind.outgoingMethod("log");
+  /// LogParams must be JSON-serializable.
+  UntypedOutgoingNotification outgoingNotification(llvm::StringLiteral Method);
+
+private:
   // FIXME: remove usage from ClangdLSPServer and make this private.
   template <typename T>
   static llvm::Expected<T> parse(const llvm::json::Value &Raw,
                                  llvm::StringRef PayloadName,
                                  llvm::StringRef PayloadKind);
 
-private:
   RawHandlers &Raw;
+  RawOutgoing &Out;
 };
 
 template <typename T>
 llvm::Expected<T> LSPBinder::parse(const llvm::json::Value &Raw,
                                    llvm::StringRef PayloadName,
                                    llvm::StringRef PayloadKind) {
   T Result;
   llvm::json::Path::Root Root;
Raw.CommandHandlers[Method] = [Method, Handler, This](JSON RawParams,
                                                         Callback<JSON> Reply) {
     auto P = LSPBinder::parse<Param>(RawParams, Method, "command");
     if (!P)
       return Reply(P.takeError());
     (This->*Handler)(*P, std::move(Reply));
   };
 }
 
+class LSPBinder::UntypedOutgoingNotification {
+  llvm::StringLiteral Method;
+  RawOutgoing *Out;
+  UntypedOutgoingNotification(llvm::StringLiteral Method, RawOutgoing *Out)
+      : Method(Method), Out(Out) {}
+  friend UntypedOutgoingNotification
+      LSPBinder::outgoingNotification(llvm::StringLiteral);
+
+public:
+  template <typename Request> operator OutgoingNotification<Request>() && {
+    return
+        [Method(Method), Out(Out)](Request R) { Out->notify(Method, JSON(R)); };
+  }
+};
+
+inline LSPBinder::UntypedOutgoingNotification
+LSPBinder::outgoingNotification(llvm::StringLiteral Method) {
+  return UntypedOutgoingNotification(Method, &Out);
+}
+
+class LSPBinder::UntypedOutgoingMethod {
+  llvm::StringLiteral Method;
+  RawOutgoing *Out;
+  UntypedOutgoingMethod(llvm::StringLiteral Method, RawOutgoing *Out)
+      : Method(Method), Out(Out) {}
+  friend UntypedOutgoingMethod LSPBinder::outgoingMethod(llvm::StringLiteral);
+
+public:
+  template <typename Request, typename Response>
+  operator OutgoingMethod<Request, Response>() && {
+    return [Method(Method), Out(Out)](Request R, Callback<Response> Reply) {
+      Out->callMethod(
+          Method, JSON(R),
+          // FIXME: why keep ctx alive but not restore it for the callback?
+          [Reply(std::move(Reply)), Ctx(Context::current().clone()),
+           Method](llvm::Expected<JSON> RawRsp) mutable {
+            if (!RawRsp)
+              return Reply(RawRsp.takeError());
+            Reply(LSPBinder::parse<Response>(std::move(*RawRsp), Method,
+                                             "reply"));
+          });
+    };
+  }
+};
+
+inline LSPBinder::UntypedOutgoingMethod
+LSPBinder::outgoingMethod(llvm::StringLiteral Method) {
+  return UntypedOutgoingMethod(Method, &Out);
+}
+
 } // namespace clangd
 } // namespace clang
 
 #endif

clang-tools-extra/clangd/Module.h

 //===--- Module.h - Plugging features into clangd -----------------*-C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_MODULE_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_MODULE_H
 
+#include "support/Function.h"
+#include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/JSON.h"
 #include <memory>
 #include <type_traits>
 #include <vector>
 
 namespace clang {
 namespace clangd {
 class LSPBinder;
 class SymbolIndex;
 class ThreadsafeFS;
 class TUScheduler;
 
 /// A Module contributes a vertical feature to clangd.
 ///
-/// FIXME: Extend this to support outgoing LSP calls.
-///
 /// The lifetime of a module is roughly:
 ///  - modules are created before the LSP server, in ClangdMain.cpp
 ///  - these modules are then passed to ClangdLSPServer in a ModuleSet
 ///  - initializeLSP() is called when the editor calls initialize.
 //   - initialize() is then called by ClangdServer as it is constructed.
 ///  - module hooks can be called by the server at this point.
 ///    Server facilities (scheduler etc) are available.
 ///  - ClangdServer will not be destroyed until all the requests are done.
protected:
   Facilities &facilities();
   /// The scheduler is used to run tasks on worker threads and access ASTs.
   TUScheduler &scheduler() { return facilities().Scheduler; }
   /// The index is used to get information about the whole codebase.
   const SymbolIndex *index() { return facilities().Index; }
   /// The filesystem is used to read source files on disk.
   const ThreadsafeFS &fs() { return facilities().FS; }
 
+  /// Types of function objects that modules use for outgoing calls.
+  /// (Bound throuh LSPBinder, made available here for convenience).
+  template <typename P>
+  using OutgoingNotification = llvm::unique_function<void(const P &)>;
+  template <typename P, typename R>
+  using OutgoingMethod = llvm::unique_function<void(const P &, Callback<R>)>;
+
 private:
   llvm::Optional<Facilities> Fac;
 };
 
 /// A ModuleSet is a collection of modules installed in clangd.
 ///
 /// Modules can be looked up by type, or used through the Module interface.
 /// This allows individual modules to expose a public API.

clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp

 #include "llvm/Support/JSON.h"
 #include "llvm/Testing/Support/SupportHelpers.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace clangd {
 namespace {
+using testing::ElementsAre;
 
 MATCHER_P(DiagMessage, M, "") {
   if (const auto *O = arg.getAsObject()) {
     if (const auto Msg = O->getString("message"))
       return *Msg == M;
   }
   return false;
 }
)yaml";
   Client.didOpen("bar.cpp", "int x = FOO;");
   EXPECT_THAT(Client.diagnostics("bar.cpp"),
               llvm::ValueIs(testing::ElementsAre(
                   DiagMessage("Use of undeclared identifier 'BAR'"))));
 }
 
 TEST_F(LSPTest, ModulesTest) {
   class MathModule final : public Module {
+    OutgoingNotification<int> Changed;
     void initializeLSP(LSPBinder &Bind, const llvm::json::Object &ClientCaps,
                        llvm::json::Object &ServerCaps) override {
       Bind.notification("add", this, &MathModule::add);
       Bind.method("get", this, &MathModule::get);
+      Changed = Bind.outgoingNotification("changed");
     }
 
     int Value = 0;
 
-  public:
-    void add(const int &X) { Value += X; }
+    void add(const int &X) {
+      Value += X;
+      Changed(Value);
+    }
     void get(const std::nullptr_t &, Callback<int> Reply) {
       scheduler().runQuick(
           "get", "",
           [Reply(std::move(Reply)), Value(Value)]() mutable { Reply(Value); });
     }
   };
   ModuleSet Mods;
   Mods.add(std::make_unique<MathModule>());
   Opts.Modules = &Mods;
 
   auto &Client = start();
   Client.notify("add", 2);
-  Mods.get<MathModule>()->add(8);
+  Client.notify("add", 8);
   EXPECT_EQ(10, Client.call("get", nullptr).takeValue());
+  EXPECT_THAT(Client.takeNotifications("changed"),
+              ElementsAre(llvm::json::Value(2), llvm::json::Value(10)));
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/unittests/LSPBinderTests.cpp

 #include "llvm/Testing/Support/Error.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace clangd {
 namespace {
 
+using testing::ElementsAre;
 using testing::HasSubstr;
+using testing::IsEmpty;
 using testing::UnorderedElementsAre;
 
 // JSON-serializable type for testing.
 struct Foo {
   int X;
+  friend bool operator==(Foo A, Foo B) { return A.X == B.X; }
 };
 bool fromJSON(const llvm::json::Value &V, Foo &F, llvm::json::Path P) {
   return fromJSON(V, F.X, P.field("X"));
 }
 llvm::json::Value toJSON(const Foo &F) { return F.X; }
 
 // Creates a Callback that writes its received value into an Optional<Expected>.
 template <typename T>
 llvm::unique_function<void(llvm::Expected<T>)>
 capture(llvm::Optional<llvm::Expected<T>> &Out) {
   Out.reset();
   return [&Out](llvm::Expected<T> V) { Out.emplace(std::move(V)); };
 }
 
+struct OutgoingRecorder : public LSPBinder::RawOutgoing {
+  llvm::StringMap<std::vector<llvm::json::Value>> Received;
+
+  void callMethod(llvm::StringRef Method, llvm::json::Value Params,
+                  Callback<llvm::json::Value> Reply) override {
+    Received[Method].push_back(Params);
+    if (Method == "fail")
+      return Reply(error("Params={0}", Params));
+    Reply(Params); // echo back the request
+  }
+  void notify(llvm::StringRef Method, llvm::json::Value Params) override {
+    Received[Method].push_back(std::move(Params));
+  }
+
+  std::vector<llvm::json::Value> take(llvm::StringRef Method) {
+    std::vector<llvm::json::Value> Result = Received.lookup(Method);
+    Received.erase(Method);
+    return Result;
+  }
+};
+
 TEST(LSPBinderTest, IncomingCalls) {
   LSPBinder::RawHandlers RawHandlers;
-  LSPBinder Binder{RawHandlers};
+  OutgoingRecorder RawOutgoing;
+  LSPBinder Binder{RawHandlers, RawOutgoing};
   struct Handler {
     void plusOne(const Foo &Params, Callback<Foo> Reply) {
       Reply(Foo{Params.X + 1});
     }
     void fail(const Foo &Params, Callback<Foo> Reply) {
       Reply(error("X={0}", Params.X));
     }
     void notify(const Foo &Params) {
TEST(LSPBinderTest, IncomingCalls) {
   RawNotify("hi"); // invalid, will be logged
   EXPECT_EQ(H.LastNotify, 42);
   EXPECT_EQ(H.NotifyCount, 1);
 
   auto &RawCmdPlusOne = RawHandlers.CommandHandlers["cmdPlusOne"];
   RawCmdPlusOne(1, capture(Reply));
   ASSERT_TRUE(Reply.hasValue());
   EXPECT_THAT_EXPECTED(Reply.getValue(), llvm::HasValue(2));
+
+  // None of this generated any outgoing traffic.
+  EXPECT_THAT(RawOutgoing.Received, IsEmpty());
+}
+
+TEST(LSPBinderTest, OutgoingCalls) {
+  LSPBinder::RawHandlers RawHandlers;
+  OutgoingRecorder RawOutgoing;
+  LSPBinder Binder{RawHandlers, RawOutgoing};
+
+  LSPBinder::OutgoingMethod<Foo, Foo> Echo;
+  Echo = Binder.outgoingMethod("echo");
+  LSPBinder::OutgoingMethod<Foo, std::string> WrongSignature;
+  WrongSignature = Binder.outgoingMethod("wrongSignature");
+  LSPBinder::OutgoingMethod<Foo, Foo> Fail;
+  Fail = Binder.outgoingMethod("fail");
+
+  llvm::Optional<llvm::Expected<Foo>> Reply;
+  Echo(Foo{2}, capture(Reply));
+  EXPECT_THAT(RawOutgoing.take("echo"), ElementsAre(llvm::json::Value(2)));
+  ASSERT_TRUE(Reply.hasValue());
+  EXPECT_THAT_EXPECTED(Reply.getValue(), llvm::HasValue(Foo{2}));
+
+  // JSON response is integer, can't be parsed as string.
+  llvm::Optional<llvm::Expected<std::string>> WrongTypeReply;
+  WrongSignature(Foo{2}, capture(WrongTypeReply));
+  EXPECT_THAT(RawOutgoing.take("wrongSignature"),
+              ElementsAre(llvm::json::Value(2)));
+  ASSERT_TRUE(Reply.hasValue());
+  EXPECT_THAT_EXPECTED(WrongTypeReply.getValue(),
+                       llvm::FailedWithMessage(
+                           HasSubstr("failed to decode wrongSignature reply")));
+
+  Fail(Foo{2}, capture(Reply));
+  EXPECT_THAT(RawOutgoing.take("fail"), ElementsAre(llvm::json::Value(2)));
+  ASSERT_TRUE(Reply.hasValue());
+  EXPECT_THAT_EXPECTED(Reply.getValue(), llvm::FailedWithMessage("Params=2"));
 }
+
 } // namespace
 } // namespace clangd
 } // namespace clang