[RFC] Feature modularization for clangd

[sammccall]

Summary

This is related to the ideas in D96244, but a bit more expansive...

Core ideas:

• the bulk of the features (though not everything) can be moved into modules, breaking up the Clangd[LSP]Server monoliths and allowing for out-of-tree features
• group together the LSP, C++ bound-to-server API, and free-function APIs for features. We no longer separate the first two in simple cases.
• allow modules to expose public C++ APIs, where we want to expose something richer than LSP

Caveats:

• this demo just pulls out formatting, which won't uncover all issues.
• Lit tests pass (so clangd works), but unit tests don't.
• Passing DraftStore into ClangdServer is a hack, need a real solution.
• I'm concerned whether richer C++ APIs will have a quite different style than the LSP-based ones. e.g. foo(Path, Position, Options) vs foo(FooParams).

clang-tools-extra/clangd/CMakeLists.txt

add_clang_library(clangDaemon
   FS.cpp
   FuzzyMatch.cpp
   GlobalCompilationDatabase.cpp
   Headers.cpp
   HeaderSourceSwitch.cpp
   Hover.cpp
   IncludeFixer.cpp
   JSONTransport.cpp
+  ModuleDefaults.cpp
   PathMapping.cpp
   Protocol.cpp
   Quality.cpp
   ParsedAST.cpp
   Preamble.cpp
   RIFF.cpp
   Selection.cpp
   SemanticHighlighting.cpp

clang-tools-extra/clangd/ClangdLSPServer.h

private:
   void onInitialized(const InitializedParams &);
   void onShutdown(Callback<std::nullptr_t>);
   void onSync(Callback<std::nullptr_t>);
   void onDocumentDidOpen(const DidOpenTextDocumentParams &);
   void onDocumentDidChange(const DidChangeTextDocumentParams &);
   void onDocumentDidClose(const DidCloseTextDocumentParams &);
   void onDocumentDidSave(const DidSaveTextDocumentParams &);
   void onAST(const ASTParams &, Callback<llvm::Optional<ASTNode>>);
-  void onDocumentOnTypeFormatting(const DocumentOnTypeFormattingParams &,
-                                  Callback<std::vector<TextEdit>>);
-  void onDocumentRangeFormatting(const DocumentRangeFormattingParams &,
-                                 Callback<std::vector<TextEdit>>);
-  void onDocumentFormatting(const DocumentFormattingParams &,
-                            Callback<std::vector<TextEdit>>);
   // The results are serialized 'vector<DocumentSymbol>' if
   // SupportsHierarchicalDocumentSymbol is true and 'vector<SymbolInformation>'
   // otherwise.
   void onDocumentSymbol(const DocumentSymbolParams &,
                         Callback<llvm::json::Value>);
   void onFoldingRange(const FoldingRangeParams &,
                       Callback<std::vector<FoldingRange>>);
   void onCodeAction(const CodeActionParams &, Callback<llvm::json::Value>);

clang-tools-extra/clangd/ClangdLSPServer.cpp

public:
   void bind(const char *Method,
             void (ClangdLSPServer::*Handler)(Callback<Result>)) {
     Calls[Method] = [Handler, this](llvm::json::Value RawParams,
                                     ReplyOnce Reply) {
       (Server.*Handler)(std::move(Reply));
     };
   }
 
+  void bindAll(ModuleSet &Mods) {
+    Module::MethodBinder Binder;
+    for (auto &Mod : Mods)
+      Mod.initializeLSP(Binder);
+    for (auto &M : Binder.Methods)
+      Calls.try_emplace(M.first(), std::move(M.second));
+    for (auto &M : Binder.Notifications)
+      Notifications.try_emplace(M.first(), std::move(M.second));
+  }
+
   // Bind a reply callback to a request. The callback will be invoked when
   // clangd receives the reply from the LSP client.
   // Return a call id of the request.
   llvm::json::Value bindReply(Callback<llvm::json::Value> Reply) {
     llvm::Optional<std::pair<int, Callback<llvm::json::Value>>> OldestCB;
     int ID;
     {
       std::lock_guard<std::mutex> Mutex(CallMutex);
void ClangdLSPServer::onInitialize(const InitializeParams &Params,
   {
     // Switch caller's context with LSPServer's background context. Since we
     // rather want to propagate information from LSPServer's context into the
     // Server, CDB, etc.
     WithContext MainContext(BackgroundContext.clone());
     llvm::Optional<WithContextValue> WithOffsetEncoding;
     if (Opts.Encoding)
       WithOffsetEncoding.emplace(kCurrentOffsetEncoding, *Opts.Encoding);
-    Server.emplace(*CDB, TFS, Opts,
+    Server.emplace(*CDB, TFS, DraftMgr, Opts,
                    static_cast<ClangdServer::Callbacks *>(this));
   }
   applyConfiguration(Params.initializationOptions.ConfigSettings);
 
   Opts.CodeComplete.EnableSnippets = Params.capabilities.CompletionSnippets;
   Opts.CodeComplete.IncludeFixIts = Params.capabilities.CompletionFixes;
   if (!Opts.CodeComplete.BundleOverloads.hasValue())
     Opts.CodeComplete.BundleOverloads = Params.capabilities.HasSignatureHelp;
llvm::json::Object Result{
        {"capabilities",
         llvm::json::Object{
             {"textDocumentSync",
              llvm::json::Object{
                  {"openClose", true},
                  {"change", (int)TextDocumentSyncKind::Incremental},
                  {"save", true},
              }},
+            // XXX move into format module
             {"documentFormattingProvider", true},
             {"documentRangeFormattingProvider", true},
             {"documentOnTypeFormattingProvider",
              llvm::json::Object{
                  {"firstTriggerCharacter", "\n"},
                  {"moreTriggerCharacter", {}},
              }},
             {"codeActionProvider", std::move(CodeActionProvider)},
void ClangdLSPServer::onDocumentDidClose(
   // 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);
 }
 
-void ClangdLSPServer::onDocumentOnTypeFormatting(
-    const DocumentOnTypeFormattingParams &Params,
-    Callback<std::vector<TextEdit>> Reply) {
-  auto File = Params.textDocument.uri.file();
-  auto Code = DraftMgr.getDraft(File);
-  if (!Code)
-    return Reply(llvm::make_error<LSPError>(
-        "onDocumentOnTypeFormatting called for non-added file",
-        ErrorCode::InvalidParams));
-
-  Server->formatOnType(File, Code->Contents, Params.position, Params.ch,
-                       std::move(Reply));
-}
-
-void ClangdLSPServer::onDocumentRangeFormatting(
-    const DocumentRangeFormattingParams &Params,
-    Callback<std::vector<TextEdit>> Reply) {
-  auto File = Params.textDocument.uri.file();
-  auto Code = DraftMgr.getDraft(File);
-  if (!Code)
-    return Reply(llvm::make_error<LSPError>(
-        "onDocumentRangeFormatting called for non-added file",
-        ErrorCode::InvalidParams));
-
-  Server->formatRange(
-      File, Code->Contents, Params.range,
-      [Code = Code->Contents, Reply = std::move(Reply)](
-          llvm::Expected<tooling::Replacements> Result) mutable {
-        if (Result)
-          Reply(replacementsToEdits(Code, Result.get()));
-        else
-          Reply(Result.takeError());
-      });
-}
-
-void ClangdLSPServer::onDocumentFormatting(
-    const DocumentFormattingParams &Params,
-    Callback<std::vector<TextEdit>> Reply) {
-  auto File = Params.textDocument.uri.file();
-  auto Code = DraftMgr.getDraft(File);
-  if (!Code)
-    return Reply(llvm::make_error<LSPError>(
-        "onDocumentFormatting called for non-added file",
-        ErrorCode::InvalidParams));
-
-  Server->formatFile(File, Code->Contents,
-                     [Code = Code->Contents, Reply = std::move(Reply)](
-                         llvm::Expected<tooling::Replacements> Result) mutable {
-                       if (Result)
-                         Reply(replacementsToEdits(Code, Result.get()));
-                       else
-                         Reply(Result.takeError());
-                     });
-}
-
 /// The functions constructs a flattened view of the DocumentSymbol hierarchy.
 /// Used by the clients that do not support the hierarchical view.
 static std::vector<SymbolInformation>
 flattenSymbolHierarchy(llvm::ArrayRef<DocumentSymbol> Symbols,
                        const URIForFile &FileURI) {
   std::vector<SymbolInformation> Results;
   std::function<void(const DocumentSymbol &, llvm::StringRef)> Process =
       [&](const DocumentSymbol &S, llvm::Optional<llvm::StringRef> ParentName) {
this->Opts.ContextProvider = ClangdServer::createConfiguredContextProvider(
         Opts.ConfigProvider, this);
   }
 
   // clang-format off
   MsgHandler->bind("initialize", &ClangdLSPServer::onInitialize);
   MsgHandler->bind("initialized", &ClangdLSPServer::onInitialized);
   MsgHandler->bind("shutdown", &ClangdLSPServer::onShutdown);
   MsgHandler->bind("sync", &ClangdLSPServer::onSync);
-  MsgHandler->bind("textDocument/rangeFormatting", &ClangdLSPServer::onDocumentRangeFormatting);
-  MsgHandler->bind("textDocument/onTypeFormatting", &ClangdLSPServer::onDocumentOnTypeFormatting);
-  MsgHandler->bind("textDocument/formatting", &ClangdLSPServer::onDocumentFormatting);
   MsgHandler->bind("textDocument/codeAction", &ClangdLSPServer::onCodeAction);
   MsgHandler->bind("textDocument/completion", &ClangdLSPServer::onCompletion);
   MsgHandler->bind("textDocument/signatureHelp", &ClangdLSPServer::onSignatureHelp);
   MsgHandler->bind("textDocument/definition", &ClangdLSPServer::onGoToDefinition);
   MsgHandler->bind("textDocument/declaration", &ClangdLSPServer::onGoToDeclaration);
   MsgHandler->bind("textDocument/implementation", &ClangdLSPServer::onGoToImplementation);
   MsgHandler->bind("textDocument/references", &ClangdLSPServer::onReference);
   MsgHandler->bind("textDocument/switchSourceHeader", &ClangdLSPServer::onSwitchSourceHeader);
ClangdLSPServer::ClangdLSPServer(class Transport &Transp,
   MsgHandler->bind("textDocument/selectionRange", &ClangdLSPServer::onSelectionRange);
   MsgHandler->bind("textDocument/documentLink", &ClangdLSPServer::onDocumentLink);
   MsgHandler->bind("textDocument/semanticTokens/full", &ClangdLSPServer::onSemanticTokens);
   MsgHandler->bind("textDocument/semanticTokens/full/delta", &ClangdLSPServer::onSemanticTokensDelta);
   MsgHandler->bind("$/memoryUsage", &ClangdLSPServer::onMemoryUsage);
   if (Opts.FoldingRanges)
     MsgHandler->bind("textDocument/foldingRange", &ClangdLSPServer::onFoldingRange);
   // clang-format on
+  if (Opts.Modules)
+    MsgHandler->bindAll(*Opts.Modules);
 }
 
 ClangdLSPServer::~ClangdLSPServer() {
   IsBeingDestroyed = true;
   // Explicitly destroy ClangdServer first, blocking on threads it owns.
   // This ensures they don't access any other members.
   Server.reset();
 }

clang-tools-extra/clangd/ClangdServer.h

 //===--- ClangdServer.h - Main clangd server code ----------------*- 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_CLANGDSERVER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_CLANGDSERVER_H
 
 #include "../clang-tidy/ClangTidyOptions.h"
 #include "CodeComplete.h"
 #include "ConfigProvider.h"
 #include "GlobalCompilationDatabase.h"
 #include "Hover.h"
+#include "Module.h"
 #include "Protocol.h"
 #include "SemanticHighlighting.h"
 #include "TUScheduler.h"
 #include "XRefs.h"
 #include "index/Background.h"
 #include "index/FileIndex.h"
 #include "index/Index.h"
 #include "refactor/Rename.h"
struct Options {
     /// To process requests asynchronously, ClangdServer spawns worker threads.
     /// If this is zero, no threads are spawned. All work is done on the calling
     /// thread, and callbacks are invoked before "async" functions return.
     unsigned AsyncThreadsCount = getDefaultAsyncThreadsCount();
 
     /// AST caching policy. The default is to keep up to 3 ASTs in memory.
     ASTRetentionPolicy RetentionPolicy;
 
+    ModuleSet *Modules = nullptr;
+
     /// Cached preambles are potentially large. If false, store them on disk.
     bool StorePreamblesInMemory = true;
 
     /// If true, ClangdServer builds a dynamic in-memory index for symbols in
     /// opened files and uses the index to augment code completion results.
     bool BuildDynamicSymbolIndex = false;
     /// If true, ClangdServer automatically indexes files in the current project
     /// on background threads. The index is stored in the project root.
public:
   /// Creates a new ClangdServer instance.
   ///
   /// ClangdServer uses \p CDB to obtain compilation arguments for parsing. Note
   /// that ClangdServer only obtains compilation arguments once for each newly
   /// added file (i.e., when processing a first call to addDocument) and reuses
   /// those arguments for subsequent reparses. However, ClangdServer will check
   /// if compilation arguments changed on calls to forceReparse().
   ClangdServer(const GlobalCompilationDatabase &CDB, const ThreadsafeFS &TFS,
+               const DraftStore &Drafts, // XXX
                const Options &Opts, Callbacks *Callbacks = nullptr);
 
   /// Add a \p File to the list of tracked C++ files or update the contents if
   /// \p File is already tracked. Also schedules parsing of the AST for it on a
   /// separate thread. When the parsing is complete, DiagConsumer passed in
   /// constructor will receive onDiagnosticsReady callback.
   /// Version identifies this snapshot and is propagated to ASTs, preambles,
   /// diagnostics etc built from it.
public:
   /// Retrieve implementations for virtual method.
   void findImplementations(PathRef File, Position Pos,
                            Callback<std::vector<LocatedSymbol>> CB);
 
   /// Retrieve locations for symbol references.
   void findReferences(PathRef File, Position Pos, uint32_t Limit,
                       Callback<ReferencesResult> CB);
 
-  /// Run formatting for \p Rng inside \p File with content \p Code.
-  void formatRange(PathRef File, StringRef Code, Range Rng,
-                   Callback<tooling::Replacements> CB);
-
-  /// Run formatting for the whole \p File with content \p Code.
-  void formatFile(PathRef File, StringRef Code,
-                  Callback<tooling::Replacements> CB);
-
-  /// Run formatting after \p TriggerText was typed at \p Pos in \p File with
-  /// content \p Code.
-  void formatOnType(PathRef File, StringRef Code, Position Pos,
-                    StringRef TriggerText, Callback<std::vector<TextEdit>> CB);
-
   /// Test the validity of a rename operation.
   ///
   /// If NewName is provided, it performs a name validation.
   void prepareRename(PathRef File, Position Pos,
                      llvm::Optional<std::string> NewName,
                      const RenameOptions &RenameOpts,
                      Callback<RenameResult> CB);
 

 
 private:
   void formatCode(PathRef File, llvm::StringRef Code,
                   ArrayRef<tooling::Range> Ranges,
                   Callback<tooling::Replacements> CB);
 
   const GlobalCompilationDatabase &CDB;
   const ThreadsafeFS &TFS;
+  ModuleSet *Modules;
 
   Path ResourceDir;
   // The index used to look up symbols. This could be:
   //   - null (all index functionality is optional)
   //   - the dynamic index owned by ClangdServer (DynamicIdx)
   //   - the static index passed to the constructor
   //   - a merged view of a static and dynamic index (MergedIndex)
   const SymbolIndex *Index = nullptr;

clang-tools-extra/clangd/ClangdServer.cpp

 //===--- ClangdServer.cpp - Main clangd server code --------------*- 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
 //
 //===-------------------------------------------------------------------===//
 
 #include "ClangdServer.h"
 #include "CodeComplete.h"
 #include "Config.h"
+#include "DraftStore.h"
 #include "DumpAST.h"
 #include "FindSymbols.h"
 #include "Format.h"
 #include "HeaderSourceSwitch.h"
 #include "Headers.h"
 #include "ParsedAST.h"
 #include "Preamble.h"
 #include "Protocol.h"
 #include "SemanticHighlighting.h"
 #include "SemanticSelection.h"
 #include "SourceCode.h"
 #include "TUScheduler.h"
 #include "XRefs.h"
 #include "index/CanonicalIncludes.h"
 #include "index/FileIndex.h"
 #include "index/Merge.h"
 #include "refactor/Rename.h"
 #include "refactor/Tweak.h"
 #include "support/Logger.h"
 #include "support/Markup.h"
 #include "support/MemoryTree.h"
 #include "support/ThreadsafeFS.h"
 #include "support/Trace.h"
-#include "clang/Format/Format.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "clang/Tooling/Core/Replacement.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
ClangdServer::Options::operator TUScheduler::Options() const {
   Opts.RetentionPolicy = RetentionPolicy;
   Opts.StorePreamblesInMemory = StorePreamblesInMemory;
   Opts.UpdateDebounce = UpdateDebounce;
   Opts.ContextProvider = ContextProvider;
   return Opts;
 }
 
 ClangdServer::ClangdServer(const GlobalCompilationDatabase &CDB,
-                           const ThreadsafeFS &TFS, const Options &Opts,
-                           Callbacks *Callbacks)
-    : CDB(CDB), TFS(TFS),
+                           const ThreadsafeFS &TFS,
+                           const DraftStore &Drafts, // XXX
+                           const Options &Opts, Callbacks *Callbacks)
+    : CDB(CDB), TFS(TFS), Modules(Opts.Modules),
       DynamicIdx(Opts.BuildDynamicSymbolIndex ? new FileIndex() : nullptr),
       ClangTidyProvider(Opts.ClangTidyProvider),
       WorkspaceRoot(Opts.WorkspaceRoot),
       // Pass a callback into `WorkScheduler` to extract symbols from a newly
       // parsed file and rebuild the file index synchronously each time an AST
       // is parsed.
       // FIXME(ioeric): this can be slow and we may be able to index on less
       // critical paths.
BackgroundIdx = std::make_unique<BackgroundIndex>(
         TFS, CDB,
         BackgroundIndexStorage::createDiskBackedStorageFactory(
             [&CDB](llvm::StringRef File) { return CDB.getProjectInfo(File); }),
         std::move(BGOpts));
     AddIndex(BackgroundIdx.get());
   }
   if (DynamicIdx)
     AddIndex(DynamicIdx.get());
+
+  if (Modules) {
+    Module::ServerFacilities Facilities{
+        Drafts,
+        WorkScheduler,
+        TFS,
+    };
+    for (auto &Mod : *Modules)
+      Mod.Facilities.emplace(Facilities);
+  }
 }
 
 void ClangdServer::addDocument(PathRef File, llvm::StringRef Contents,
                                llvm::StringRef Version,
                                WantDiagnostics WantDiags, bool ForceRebuild) {
   ParseOptions Opts;
 
   // Compile command is set asynchronously during update, as it can be slow.
auto Action = [Pos, File = File.str(), CB = std::move(CB),
     CB(clangd::signatureHelp(File, Pos, *PreambleData, ParseInput));
   };
 
   // Unlike code completion, we wait for a preamble here.
   WorkScheduler.runWithPreamble("SignatureHelp", File, TUScheduler::Stale,
                                 std::move(Action));
 }
 
-void ClangdServer::formatRange(PathRef File, llvm::StringRef Code, Range Rng,
-                               Callback<tooling::Replacements> CB) {
-  llvm::Expected<size_t> Begin = positionToOffset(Code, Rng.start);
-  if (!Begin)
-    return CB(Begin.takeError());
-  llvm::Expected<size_t> End = positionToOffset(Code, Rng.end);
-  if (!End)
-    return CB(End.takeError());
-  formatCode(File, Code, {tooling::Range(*Begin, *End - *Begin)},
-             std::move(CB));
-}
-
-void ClangdServer::formatFile(PathRef File, llvm::StringRef Code,
-                              Callback<tooling::Replacements> CB) {
-  // Format everything.
-  formatCode(File, Code, {tooling::Range(0, Code.size())}, std::move(CB));
-}
-
-void ClangdServer::formatOnType(PathRef File, llvm::StringRef Code,
-                                Position Pos, StringRef TriggerText,
-                                Callback<std::vector<TextEdit>> CB) {
-  llvm::Expected<size_t> CursorPos = positionToOffset(Code, Pos);
-  if (!CursorPos)
-    return CB(CursorPos.takeError());
-  auto Action = [File = File.str(), Code = Code.str(),
-                 TriggerText = TriggerText.str(), CursorPos = *CursorPos,
-                 CB = std::move(CB), this]() mutable {
-    auto Style = format::getStyle(format::DefaultFormatStyle, File,
-                                  format::DefaultFallbackStyle, Code,
-                                  TFS.view(/*CWD=*/llvm::None).get());
-    if (!Style)
-      return CB(Style.takeError());
-
-    std::vector<TextEdit> Result;
-    for (const tooling::Replacement &R :
-         formatIncremental(Code, CursorPos, TriggerText, *Style))
-      Result.push_back(replacementToEdit(Code, R));
-    return CB(Result);
-  };
-  WorkScheduler.runQuick("FormatOnType", File, std::move(Action));
-}
-
 void ClangdServer::prepareRename(PathRef File, Position Pos,
                                  llvm::Optional<std::string> NewName,
                                  const RenameOptions &RenameOpts,
                                  Callback<RenameResult> CB) {
   auto Action = [Pos, File = File.str(), CB = std::move(CB),
                  NewName = std::move(NewName), RenameOpts,
                  this](llvm::Expected<InputsAndAST> InpAST) mutable {
     if (!InpAST)
for (const auto &Selection : *Selections) {
       }
       Effect = T.takeError();
     }
     assert(Effect.hasValue() && "Expected at least one selection");
     if (*Effect) {
       // Tweaks don't apply clang-format, do that centrally here.
       for (auto &It : (*Effect)->ApplyEdits) {
         Edit &E = It.second;
-        format::FormatStyle Style =
-            getFormatStyleForFile(File, E.InitialCode, TFS);
+        auto Style = getFormatStyleForFile(File, E.InitialCode, TFS);
         if (llvm::Error Err = reformatEdit(E, Style))
           elog("Failed to format {0}: {1}", It.first(), std::move(Err));
       }
     } else {
       TweakFailed.record(1, TweakID);
     }
     return CB(std::move(*Effect));
   };
auto Action = [Path = Path.str(), CB = std::move(CB),
                  this](llvm::Expected<InputsAndAST> InpAST) mutable {
     if (!InpAST)
       return CB(InpAST.takeError());
     CB(getCorrespondingHeaderOrSource(Path, InpAST->AST, Index));
   };
   WorkScheduler.runWithAST("SwitchHeaderSource", Path, std::move(Action));
 }
 
-void ClangdServer::formatCode(PathRef File, llvm::StringRef Code,
-                              llvm::ArrayRef<tooling::Range> Ranges,
-                              Callback<tooling::Replacements> CB) {
-  // Call clang-format.
-  auto Action = [File = File.str(), Code = Code.str(), Ranges = Ranges.vec(),
-                 CB = std::move(CB), this]() mutable {
-    format::FormatStyle Style = getFormatStyleForFile(File, Code, TFS);
-    tooling::Replacements IncludeReplaces =
-        format::sortIncludes(Style, Code, Ranges, File);
-    auto Changed = tooling::applyAllReplacements(Code, IncludeReplaces);
-    if (!Changed)
-      return CB(Changed.takeError());
-
-    CB(IncludeReplaces.merge(format::reformat(
-        Style, *Changed,
-        tooling::calculateRangesAfterReplacements(IncludeReplaces, Ranges),
-        File)));
-  };
-  WorkScheduler.runQuick("Format", File, std::move(Action));
-}
-
 void ClangdServer::findDocumentHighlights(
     PathRef File, Position Pos, Callback<std::vector<DocumentHighlight>> CB) {
   auto Action =
       [Pos, CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable {
         if (!InpAST)
           return CB(InpAST.takeError());
         CB(clangd::findDocumentHighlights(InpAST->AST, Pos));
       };
 
   WorkScheduler.runWithAST("Highlights", File, std::move(Action),
                            TUScheduler::InvalidateOnUpdate);
 }
 
 void ClangdServer::findHover(PathRef File, Position Pos,
                              Callback<llvm::Optional<HoverInfo>> CB) {
   auto Action = [File = File.str(), Pos, CB = std::move(CB),
                  this](llvm::Expected<InputsAndAST> InpAST) mutable {
     if (!InpAST)
       return CB(InpAST.takeError());
-    format::FormatStyle Style = getFormatStyleForFile(
-        File, InpAST->Inputs.Contents, *InpAST->Inputs.TFS);
+    auto Style = getFormatStyleForFile(File, InpAST->Inputs.Contents,
+                                       *InpAST->Inputs.TFS);
     CB(clangd::getHover(InpAST->AST, Pos, std::move(Style), Index));
   };
 
   WorkScheduler.runWithAST("Hover", File, std::move(Action),
                            TUScheduler::InvalidateOnUpdate);
 }
 
 void ClangdServer::typeHierarchy(PathRef File, Position Pos, int Resolve,

clang-tools-extra/clangd/Format.h

 //===--- Format.h - automatic code formatting ---------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Clangd uses clang-format for formatting operations.
 // This file adapts it to support new scenarios like format-on-type.
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_FORMAT_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_FORMAT_H
 
+#include "Module.h"
 #include "Protocol.h"
 #include "clang/Format/Format.h"
-#include "clang/Tooling/Core/Replacement.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace clang {
 namespace clangd {
+namespace format {
 
 /// Applies limited formatting around new \p InsertedText.
 /// The \p Code already contains the updated text before \p Cursor, and may have
 /// had additional / characters (such as indentation) inserted by the editor.
 ///
 /// Example breaking a line (^ is the cursor):
 /// === before newline is typed ===
 /// if(1){^}
 /// === after newline is typed and editor indents ===
 /// if(1){
 ///   ^}
 /// === after formatIncremental(InsertedText="\n") ===
 /// if (1) {
 ///   ^
 /// }
 ///
 /// We return sorted vector<tooling::Replacement>, not tooling::Replacements!
 /// We may insert text both before and after the cursor. tooling::Replacements
 /// would merge these, and thus lose information about cursor position.
 std::vector<tooling::Replacement>
 formatIncremental(llvm::StringRef Code, unsigned Cursor,
-                  llvm::StringRef InsertedText, format::FormatStyle Style);
+                  llvm::StringRef InsertedText,
+                  clang::format::FormatStyle Style);
 
 /// Determine the new cursor position after applying \p Replacements.
 /// Analogue of tooling::Replacements::getShiftedCodePosition().
 unsigned
 transformCursorPosition(unsigned Offset,
                         const std::vector<tooling::Replacement> &Replacements);
 
+// Note: we do not parse FormattingOptions for *FormattingParams.
+// In general, we use a clang-format style detected from common mechanisms
+// (.clang-format files and the -fallback-style flag).
+// It would be possible to override these with FormatOptions, but:
+//  - the protocol makes FormatOptions mandatory, so many clients set them to
+//    useless values, and we can't tell when to respect them
+// - we also format in other places, where FormatOptions aren't available.
+
+struct DocumentRangeFormattingParams {
+  /// The document to format.
+  TextDocumentIdentifier textDocument;
+
+  /// The range to format
+  Range range;
+};
+bool fromJSON(const llvm::json::Value &, DocumentRangeFormattingParams &,
+              llvm::json::Path);
+
+struct DocumentOnTypeFormattingParams {
+  /// The document to format.
+  TextDocumentIdentifier textDocument;
+
+  /// The position at which this request was sent.
+  Position position;
+
+  /// The character that has been typed.
+  std::string ch;
+};
+bool fromJSON(const llvm::json::Value &, DocumentOnTypeFormattingParams &,
+              llvm::json::Path);
+
+struct DocumentFormattingParams {
+  /// The document to format.
+  TextDocumentIdentifier textDocument;
+};
+bool fromJSON(const llvm::json::Value &, DocumentFormattingParams &,
+              llvm::json::Path);
+
+} // namespace format
+
+class FormatModule final : public Module {
+public:
+  /// The document range formatting request is sent from the client to the
+  /// server to format a given range in a document.
+  void rangeFormatting(const format::DocumentRangeFormattingParams &,
+                       Callback<std::vector<TextEdit>>);
+  /// The document formatting request is sent from the client to the server to
+  /// format a whole document.
+  void formatting(const format::DocumentFormattingParams &,
+                  Callback<std::vector<TextEdit>>);
+  /// The document on type formatting request is sent from the client to the
+  /// server to format parts of the document during typing.
+  void onTypeFormatting(const format::DocumentOnTypeFormattingParams &,
+                        Callback<std::vector<TextEdit>>);
+
+private:
+  void formatImpl(llvm::StringRef Name, llvm::StringRef Code,
+                  tooling::Replacements Range, Callback<std::vector<TextEdit>>);
+
+  void initializeLSP(MethodBinder &MB) override;
+};
+
 } // namespace clangd
 } // namespace clang
 
 #endif
 

clang-tools-extra/clangd/Format.cpp

 //===--- Format.cpp -----------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
+
+// I wonder whether we should split this file into FormatModule.cpp and
+// Format.cpp, as they have pretty different sets of implementation deps...
+
 #include "Format.h"
+#include "SourceCode.h"
 #include "support/Logger.h"
+#include "support/ThreadsafeFS.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Format/Format.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Tooling/Core/Replacement.h"
 #include "llvm/Support/Unicode.h"
 
 namespace clang {
 namespace clangd {
+
+void FormatModule::initializeLSP(MethodBinder &Bind) {
+  Bind.method("textDocument/formatting", this, &FormatModule::formatting);
+  Bind.method("textDocument/rangeFormatting", this,
+              &FormatModule::rangeFormatting);
+  Bind.method("textDocument/onTypeFormatting", this,
+              &FormatModule::onTypeFormatting);
+}
+
+static llvm::Expected<std::vector<TextEdit>>
+formatCode(PathRef File, llvm::StringRef Code,
+           llvm::ArrayRef<tooling::Range> Ranges, const ThreadsafeFS &FS) {
+  auto Style = getFormatStyleForFile(File, Code, FS);
+  tooling::Replacements IncludeReplaces =
+      clang::format::sortIncludes(Style, Code, Ranges, File);
+  auto Changed = tooling::applyAllReplacements(Code, IncludeReplaces);
+  if (!Changed)
+    return Changed.takeError();
+  auto Replacements = IncludeReplaces.merge(clang::format::reformat(
+      Style, *Changed,
+      tooling::calculateRangesAfterReplacements(IncludeReplaces, Ranges),
+      File));
+  return replacementsToEdits(Code, Replacements);
+};
+
+void FormatModule::rangeFormatting(
+    const format::DocumentRangeFormattingParams &Params,
+    Callback<std::vector<TextEdit>> Reply) {
+  auto Draft = drafts().getDraft(Params.textDocument.uri.file());
+  if (!Draft)
+    return Reply(llvm::make_error<LSPError>("formatting non-added file",
+                                            ErrorCode::InvalidParams));
+  llvm::StringRef Code = Draft->Contents;
+  llvm::Expected<size_t> Begin = positionToOffset(Code, Params.range.start);
+  if (!Begin)
+    return Reply(Begin.takeError());
+  llvm::Expected<size_t> End = positionToOffset(Code, Params.range.end);
+  if (!End)
+    return Reply(End.takeError());
+
+  scheduler().runQuick("rangeFormatting", Params.textDocument.uri.file(),
+                       [File(std::string(Params.textDocument.uri.file())),
+                        Code(std::string(Code)), Begin(*Begin), End(*End),
+                        Reply(std::move(Reply)), FS(&fs())]() mutable {
+                         Reply(formatCode(File, Code,
+                                          {tooling::Range(Begin, End - Begin)},
+                                          *FS));
+                       });
+}
+
+void FormatModule::formatting(const format::DocumentFormattingParams &Params,
+                              Callback<std::vector<TextEdit>> Reply) {
+  auto Draft = drafts().getDraft(Params.textDocument.uri.file());
+  if (!Draft)
+    return Reply(llvm::make_error<LSPError>("formatting non-added file",
+                                            ErrorCode::InvalidParams));
+  scheduler().runQuick(
+      "formatting", Params.textDocument.uri.file(),
+      [File(std::string(Params.textDocument.uri.file())),
+       Code(std::string(Draft->Contents)), Reply(std::move(Reply)),
+       FS(&fs())]() mutable {
+        Reply(formatCode(File, Code, {tooling::Range(0, Code.size())}, *FS));
+      });
+}
+
+void FormatModule::onTypeFormatting(
+    const format::DocumentOnTypeFormattingParams &Params,
+    Callback<std::vector<TextEdit>> Reply) {
+  auto Draft = drafts().getDraft(Params.textDocument.uri.file());
+  if (!Draft)
+    return Reply(llvm::make_error<LSPError>("formatting non-added file",
+                                            ErrorCode::InvalidParams));
+  llvm::StringRef Code = Draft->Contents;
+  llvm::Expected<size_t> CursorPos = positionToOffset(Code, Params.position);
+  if (!CursorPos)
+    return Reply(CursorPos.takeError());
+
+  scheduler().runQuick(
+      "onTypeFormatting", Params.textDocument.uri.file(),
+      [File(std::string(Params.textDocument.uri.file())), CursorPos(*CursorPos),
+       TriggerText(Params.ch), Code(std::string(Code)), FS(&fs()),
+       Reply(std::move(Reply))]() mutable {
+        auto Style = getFormatStyleForFile(File, Code, *FS);
+        std::vector<TextEdit> Result;
+        for (const tooling::Replacement &R :
+             format::formatIncremental(Code, CursorPos, TriggerText, Style))
+          Result.push_back(replacementToEdit(Code, R));
+        return Reply(Result);
+      });
+}
+
+namespace format {
 namespace {
 
 /// Append closing brackets )]} to \p Code to make it well-formed.
 /// Clang-format conservatively refuses to format files with unmatched brackets
 /// as it isn't sure where the errors are and so can't correct.
 /// When editing, it's reasonable to assume code before the cursor is complete.
-void closeBrackets(std::string &Code, const format::FormatStyle &Style) {
+void closeBrackets(std::string &Code, const clang::format::FormatStyle &Style) {
   SourceManagerForFile FileSM("dummy.cpp", Code);
   auto &SM = FileSM.get();
   FileID FID = SM.getMainFileID();
   Lexer Lex(FID, SM.getBufferOrFake(FID), SM,
-            format::getFormattingLangOpts(Style));
+            clang::format::getFormattingLangOpts(Style));
   Token Tok;
   std::vector<char> Brackets;
   while (!Lex.LexFromRawLexer(Tok)) {
     switch(Tok.getKind()) {
       case tok::l_paren:
         Brackets.push_back(')');
         break;
       case tok::l_brace:

 //   - remove the cursor placeholder again
 // The replacements we return are produced by composing these.
 //
 // The text we actually pass to clang-format is slightly different from this,
 // e.g. we have to close brackets. We ensure these differences are *after*
 // all the regions we want to format, and discard changes in them.
 std::vector<tooling::Replacement>
 formatIncremental(llvm::StringRef OriginalCode, unsigned OriginalCursor,
-                  llvm::StringRef InsertedText, format::FormatStyle Style) {
+                  llvm::StringRef InsertedText,
+                  clang::format::FormatStyle Style) {
   IncrementalChanges Incremental =
       getIncrementalChanges(OriginalCode, OriginalCursor, InsertedText);
   // Never *remove* lines in response to pressing enter! This annoys users.
   if (InsertedText == "\n") {
     Style.MaxEmptyLinesToKeep = 1000;
     Style.KeepEmptyLinesAtTheStartOfBlocks = true;
   }
 
formatIncremental(llvm::StringRef OriginalCode, unsigned OriginalCursor,
   // We also format the cursor.
   RangesToFormat.push_back(
       tooling::Range(Cursor, Incremental.CursorPlaceholder.size()));
   // Also update FormatLimit for the placeholder, we'll use this later.
   FormatLimit += Incremental.CursorPlaceholder.size();
 
   // Run clang-format, and truncate changes at FormatLimit.
   tooling::Replacements FormattingChanges;
-  format::FormattingAttemptStatus Status;
-  for (const tooling::Replacement &R : format::reformat(
+  clang::format::FormattingAttemptStatus Status;
+  for (const tooling::Replacement &R : clang::format::reformat(
            Style, CodeToFormat, RangesToFormat, Filename, &Status)) {
     if (R.getOffset() + R.getLength() <= FormatLimit) // Before limit.
       cantFail(FormattingChanges.add(R));
     else if(R.getOffset() < FormatLimit) { // Overlaps limit.
       if (R.getReplacementText().empty()) // Deletions are easy to handle.
         cantFail(FormattingChanges.add(tooling::Replacement(Filename,
             R.getOffset(), FormatLimit - R.getOffset(), "")));
       else
for (const auto &R : Replacements) {
     } else {
       // Replacement after cursor.
       break; // Replacements are sorted, the rest are also after the cursor.
     }
   }
   return Offset;
 }
 
+bool fromJSON(const llvm::json::Value &Params, DocumentRangeFormattingParams &R,
+              llvm::json::Path P) {
+  llvm::json::ObjectMapper O(Params, P);
+  return O && O.map("textDocument", R.textDocument) && O.map("range", R.range);
+}
+
+bool fromJSON(const llvm::json::Value &Params,
+              DocumentOnTypeFormattingParams &R, llvm::json::Path P) {
+  llvm::json::ObjectMapper O(Params, P);
+  return O && O.map("textDocument", R.textDocument) &&
+         O.map("position", R.position) && O.map("ch", R.ch);
+}
+
+bool fromJSON(const llvm::json::Value &Params, DocumentFormattingParams &R,
+              llvm::json::Path P) {
+  llvm::json::ObjectMapper O(Params, P);
+  return O && O.map("textDocument", R.textDocument);
+}
+
+} // namespace format
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/Module.h

+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_MODULE_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_MODULE_H
+
+#include "DraftStore.h"
+#include "Protocol.h"
+#include "TUScheduler.h"
+#include "support/Function.h"
+#include "support/Logger.h"
+#include "support/ThreadsafeFS.h"
+#include "llvm/ADT/Sequence.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/iterator.h"
+#include "llvm/Support/JSON.h"
+#include <type_traits>
+
+namespace clang {
+namespace clangd {
+
+/// A Module contributes a vertical feature to clangd. This consists of:
+///
+///  - LSP bindings (e.g. setting capabilities, implementing methods)
+///  - a public interface to access the functionality from C++ embedders
+///    ClangdServer::getModule<FooModule>()->foo(...)
+///
+/// The lifetime of a module is roughly:
+///  - modules are created before the LSP server, in ClangdMain.cpp
+///  - when ClangdLSPServer is created, initializeLSP is called to bind methods
+///    FIXME: this should be later, during the initialize LSP call, and have
+///    access to capabilities.
+///  - when ClangdServer is created, it fills in the ServerFacilities
+///  - module hooks and LSP method handlers may be called at this point
+///  - ClangdServer will not be destroyed until all requests are done
+///    FIXME: I guess we need a way to to block server shutdown in case modules
+///    have background work.
+///  - ServerFacilities are removed before ClangdServer is destroyed.
+///    There are no more calls after this point.
+///  - The module is destroyed sometime after ClangdLSPServer
+///
+/// Conventionally, standard modules live in the `clangd` namespace, and other
+/// exposed details live in a sub-namespace.
+/// clang::clangd::
+///   FormatModule
+///   format::
+///     FormattingRequest
+///     formatIncremental() // exposed for testing
+class Module {
+public:
+  virtual ~Module() = default;
+
+protected: // hooks for subclasses to implement (called by module container)
+  class MethodBinder;
+  // Register handlers for LSP methods and notifications.
+  virtual void initializeLSP(MethodBinder &){};
+
+protected: // API for subclasses to use
+  const DraftStore &drafts() { return Facilities->Drafts; }
+  TUScheduler &scheduler() { return Facilities->Scheduler; }
+  const ThreadsafeFS &fs() { return Facilities->FS; }
+
+private: // State is set up by module container, which must be a friend.
+  struct ServerFacilities {
+    const DraftStore &Drafts;
+    TUScheduler &Scheduler;
+    const ThreadsafeFS &FS;
+  };
+  llvm::Optional<ServerFacilities> Facilities;
+  friend class ClangdServer;
+  friend class ClangdLSPServer;
+  friend class ModuleTesting;
+};
+
+class Module::MethodBinder {
+public:
+  // Binds an LSP method to a module method which handles it. e.g:
+  //   void FooModule::foo(const FooParams &, Callback<FooResult>);
+  //   Bind.method("textDocument/foo", this, &FooModule::foo)
+  template <typename Subclass, typename Param, typename Result>
+  void method(const char *Method, Subclass *This,
+              void (Subclass::*Handler)(const Param &, Callback<Result>));
+  // Binds an LSP notification to a module method which handles it. e.g:
+  //   void FooModule::ping(const PingParams &);
+  //   Bind.method("textDocument/onPing", this, &FooModule::ping)
+  template <typename Subclass, typename Param>
+  void notification(const char *Method, Subclass *This,
+                    void (Subclass::*Handler)(const Param &));
+
+private:
+  template <typename T> using HandlerMap = llvm::StringMap<std::function<T>>;
+  using Method = void(llvm::json::Value, Callback<llvm::json::Value>);
+  using Notification = void(llvm::json::Value);
+  HandlerMap<Method> Methods;
+  HandlerMap<Notification> Notifications;
+
+  template <typename T>
+  static llvm::Expected<T> parse(const llvm::json::Value &Raw,
+                                 llvm::StringRef PayloadName,
+                                 llvm::StringRef PayloadKind);
+
+  friend class ClangdLSPServer; // pulls out the results.
+};
+
+/// A collection of Modules, with type-based lookup.
+/// This allows modules to be used generically through the Module/LSP interface,
+/// but also to expose a public API to C++ callers.
+class ModuleSet {
+  std::vector<Module *> Vec;
+
+public:
+  /// The standard set of built-in modules.
+  static ModuleSet defaults();
+
+  using iterator = llvm::pointee_iterator<decltype(Vec)::iterator>;
+  using const_iterator = llvm::pointee_iterator<decltype(Vec)::const_iterator>;
+
+  iterator begin() { return iterator(Vec.begin()); }
+  iterator end() { return iterator(Vec.end()); }
+  const_iterator begin() const { return const_iterator(Vec.begin()); }
+  const_iterator end() const { return const_iterator(Vec.end()); }
+
+  template <typename T> const T *get() const {
+    static_assert(std::is_base_of<Module, T>(), "Can only get Modules!");
+    return static_cast<T *>(Map.lookup(&Key<T>));
+  }
+
+  template <typename T> bool add(std::unique_ptr<T> M) {
+    static_assert(std::is_base_of<Module, T>(), "Can only add Modules!");
+    static_assert(std::is_final<T>(), "Modules must be final!");
+    auto R = Map.try_emplace(&Key<T>, std::unique_ptr<Module>(std::move(M)));
+    if (R.second)
+      Vec.push_back(R.first->second.get());
+    return R.second;
+  }
+
+private:
+  template <typename T> static int Key;
+  llvm::DenseMap<int *, std::unique_ptr<Module>> Map;
+};
+
+/// Tedious template implementation stuff lives below.
+
+template <typename T> int ModuleSet::Key;
+
+template <typename Subclass, typename Param, typename Result>
+void Module::MethodBinder::method(const char *Method, Subclass *This,
+                                  void (Subclass::*Handler)(const Param &,
+                                                            Callback<Result>)) {
+  Methods[Method] = [Method, Handler, This](llvm::json::Value RawParams,
+                                            Callback<llvm::json::Value> Reply) {
+    llvm::Expected<Param> P = parse<Param>(RawParams, Method, "request");
+    if (!P)
+      return Reply(P.takeError());
+    (This->*Handler)(*P, std::move(Reply));
+  };
+}
+
+template <typename Subclass, typename Param>
+void Module::MethodBinder::notification(
+    const char *Method, Subclass *This,
+    void (Subclass::*Handler)(const Param &)) {
+  Notifications[Method] = [Method, Handler, This](llvm::json::Value RawParams) {
+    llvm::Expected<Param> P = parse<Param>(RawParams, Method, "request");
+    if (!P)
+      return llvm::consumeError(P.takeError());
+    // XXX trace latency
+    (This->*Handler)(*P);
+  };
+}
+
+template <typename T>
+llvm::Expected<T> Module::MethodBinder::parse(const llvm::json::Value &Raw,
+                                              llvm::StringRef PayloadName,
+                                              llvm::StringRef PayloadKind) {
+  T Result;
+  llvm::json::Path::Root Root;
+  if (!fromJSON(Raw, Result, Root)) {
+    elog("Failed to decode {0} {1}: {2}", PayloadName, PayloadKind,
+         Root.getError());
+    // Dump the relevant parts of the broken message.
+    std::string Context;
+    llvm::raw_string_ostream OS(Context);
+    Root.printErrorContext(Raw, OS);
+    vlog("{0}", OS.str());
+    // Report the error (e.g. to the client).
+    return llvm::make_error<LSPError>(
+        llvm::formatv("failed to decode {0} {1}: {2}", PayloadName, PayloadKind,
+                      fmt_consume(Root.getError())),
+        ErrorCode::InvalidParams);
+  }
+  return std::move(Result);
+}
+
+} // namespace clangd
+} // namespace clang
+
+#endif

clang-tools-extra/clangd/ModuleDefaults.cpp

+#include "Format.h"
+#include "Module.h"
+
+namespace clang {
+namespace clangd {
+
+// This could use registration magic if we wanted linked-in modules to
+// automatically be included without source changes.
+ModuleSet ModuleSet::defaults() {
+  ModuleSet All;
+  All.add(std::make_unique<FormatModule>());
+  return All;
+}
+
+} // namespace clangd
+} // namespace clang

clang-tools-extra/clangd/Protocol.h

bool fromJSON(const llvm::json::Value &, DidChangeWatchedFilesParams &,
               llvm::json::Path);
 
 struct DidChangeConfigurationParams {
   ConfigurationSettings settings;
 };
 bool fromJSON(const llvm::json::Value &, DidChangeConfigurationParams &,
               llvm::json::Path);
 
-// Note: we do not parse FormattingOptions for *FormattingParams.
-// In general, we use a clang-format style detected from common mechanisms
-// (.clang-format files and the -fallback-style flag).
-// It would be possible to override these with FormatOptions, but:
-//  - the protocol makes FormatOptions mandatory, so many clients set them to
-//    useless values, and we can't tell when to respect them
-// - we also format in other places, where FormatOptions aren't available.
-
-struct DocumentRangeFormattingParams {
-  /// The document to format.
-  TextDocumentIdentifier textDocument;
-
-  /// The range to format
-  Range range;
-};
-bool fromJSON(const llvm::json::Value &, DocumentRangeFormattingParams &,
-              llvm::json::Path);
-
-struct DocumentOnTypeFormattingParams {
-  /// The document to format.
-  TextDocumentIdentifier textDocument;
-
-  /// The position at which this request was sent.
-  Position position;
-
-  /// The character that has been typed.
-  std::string ch;
-};
-bool fromJSON(const llvm::json::Value &, DocumentOnTypeFormattingParams &,
-              llvm::json::Path);
-
-struct DocumentFormattingParams {
-  /// The document to format.
-  TextDocumentIdentifier textDocument;
-};
-bool fromJSON(const llvm::json::Value &, DocumentFormattingParams &,
-              llvm::json::Path);
-
 struct DocumentSymbolParams {
   // The text document to find symbols in.
   TextDocumentIdentifier textDocument;
 };
 bool fromJSON(const llvm::json::Value &, DocumentSymbolParams &,
               llvm::json::Path);
 
 /// Represents a related message and source code location for a diagnostic.

clang-tools-extra/clangd/Protocol.cpp

 
 bool fromJSON(const llvm::json::Value &Params,
               TextDocumentContentChangeEvent &R, llvm::json::Path P) {
   llvm::json::ObjectMapper O(Params, P);
   return O && O.map("range", R.range) && O.map("rangeLength", R.rangeLength) &&
          O.map("text", R.text);
 }
 
-bool fromJSON(const llvm::json::Value &Params, DocumentRangeFormattingParams &R,
-              llvm::json::Path P) {
-  llvm::json::ObjectMapper O(Params, P);
-  return O && O.map("textDocument", R.textDocument) && O.map("range", R.range);
-}
-
-bool fromJSON(const llvm::json::Value &Params,
-              DocumentOnTypeFormattingParams &R, llvm::json::Path P) {
-  llvm::json::ObjectMapper O(Params, P);
-  return O && O.map("textDocument", R.textDocument) &&
-         O.map("position", R.position) && O.map("ch", R.ch);
-}
-
-bool fromJSON(const llvm::json::Value &Params, DocumentFormattingParams &R,
-              llvm::json::Path P) {
-  llvm::json::ObjectMapper O(Params, P);
-  return O && O.map("textDocument", R.textDocument);
-}
-
 bool fromJSON(const llvm::json::Value &Params, DocumentSymbolParams &R,
               llvm::json::Path P) {
   llvm::json::ObjectMapper O(Params, P);
   return O && O.map("textDocument", R.textDocument);
 }
 
 llvm::json::Value toJSON(const DiagnosticRelatedInformation &DRI) {
   return llvm::json::Object{

clang-tools-extra/clangd/test/crash-non-added-files.test

 # RUN: clangd -lit-test < %s | FileCheck -strict-whitespace %s
 {"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":123,"rootPath":"clangd","capabilities":{},"trace":"off"}}
 ---
 {"jsonrpc":"2.0","id":2,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"test:///foo.c"},"range":{"start":{"line":104,"character":13},"end":{"line":0,"character":35}},"context":{"diagnostics":[{"range":{"start": {"line": 0, "character": 32}, "end": {"line": 0, "character": 37}},"severity":2,"message":"using the result of an assignment as a condition without parentheses"},{"range":{"start": {"line": 0, "character": 34}, "end": {"line": 0, "character": 35}},"severity":3,"message":"place parentheses around the assignment to silence this warning"},{"range":{"start": {"line": 0, "character": 34}, "end": {"line": 0, "character": 35}},"severity":3,"message":"use '==' to turn this assignment into an equality comparison"}]}}}
 #      CHECK:  "error": {
 # CHECK-NEXT:    "code": -32602
 # CHECK-NEXT:    "message": "onCodeAction called for non-added file"
 # CHECK-NEXT:  },
 # CHECK-NEXT:  "id": 2,
 ---
 {"jsonrpc":"2.0","id":3,"method":"textDocument/rangeFormatting","params":{"textDocument":{"uri":"test:///foo.c"},"range":{"start":{"line":1,"character":4},"end":{"line":1,"character":12}},"options":{"tabSize":4,"insertSpaces":true}}}
 #      CHECK:  "error": {
 # CHECK-NEXT:    "code": -32602
-# CHECK-NEXT:    "message": "onDocumentRangeFormatting called for non-added file"
+# CHECK-NEXT:    "message": "formatting non-added file"
 # CHECK-NEXT:  },
 # CHECK-NEXT:  "id": 3,
 ---
 {"jsonrpc":"2.0","id":4,"method":"textDocument/formatting","params":{"textDocument":{"uri":"test:///foo.c"},"options":{"tabSize":4,"insertSpaces":true}}}
 #      CHECK:  "error": {
 # CHECK-NEXT:    "code": -32602
-# CHECK-NEXT:    "message": "onDocumentFormatting called for non-added file"
+# CHECK-NEXT:    "message": "formatting non-added file"
 # CHECK-NEXT:  },
 # CHECK-NEXT:  "id": 4,
 ---
 {"jsonrpc":"2.0","id":5,"method":"textDocument/onTypeFormatting","params":{"textDocument":{"uri":"test:///foo.c"},"position":{"line":3,"character":1},"ch":"}","options":{"tabSize":4,"insertSpaces":true}}}
 #      CHECK:  "error": {
 # CHECK-NEXT:    "code": -32602
-# CHECK-NEXT:    "message": "onDocumentOnTypeFormatting called for non-added file"
+# CHECK-NEXT:    "message": "formatting non-added file"
 # CHECK-NEXT:  },
 # CHECK-NEXT:  "id": 5,
 ---
 {"jsonrpc":"2.0","id":6,"method":"shutdown"}
 ---
 {"jsonrpc":"2.0","method":"exit"}

clang-tools-extra/clangd/tool/ClangdMain.cpp

else
       log("Working directory: {0}", CWD);
   }
   for (int I = 0; I < argc; ++I)
     log("argv[{0}]: {1}", I, argv[I]);
   if (auto EnvFlags = llvm::sys::Process::GetEnv(FlagsEnvVar))
     log("{0}: {1}", FlagsEnvVar, *EnvFlags);
 
   ClangdLSPServer::Options Opts;
+  auto Modules = ModuleSet::defaults();
+  Opts.Modules = &Modules;
   Opts.UseDirBasedCDB = (CompileArgsFrom == FilesystemCompileArgs);
 
   // If --compile-commands-dir arg was invoked, check value and override default
   // path.
   if (!CompileCommandsDir.empty()) {
     if (llvm::sys::fs::exists(CompileCommandsDir)) {
       // We support passing both relative and absolute paths to the
       // --compile-commands-dir argument, but we assume the path is absolute in