[clangd] Move DraftStore from ClangdLSPServer into ClangdServer.

[sammccall]

Summary

ClangdServer already gets notified of every change, so it makes sense for it to
be the source of truth.
This is a step towards having ClangdServer expose a FS that includes dirty
buffers: D94554

Related changes:

• version is now optional for ClangdServer, to preserve our existing fuzziness in this area (missing version ==> autoincrement)
• ClangdServer::format{File,Range} are now more regular ClangdServer functions that don't need the code passed in. While here, combine into one function.
• incremental content update logic is moved from DraftStore to ClangdLSPServer, with most of the implementation in SourceCode.cpp. DraftStore is now fairly trivial, and will probably ultimately be *replaced* by the dirty FS stuff.

[kadircet]

as discussed offline, i am hesitant about validateEdits layering at the moment. but i suppose the best thing to do is move it into clangdserver and expose a structrual api, as you proposed, which can be done independently.

clang-tools-extra/clangd/ClangdServer.h

266

nit: Optional<Range> instead of a pointer?

clang-tools-extra/clangd/DraftStore.cpp

50

nit: s/return/break/ same below

57

nit: i'd drop the assert

65–67

why not a not_equals instead? we are going to override the version anyway

clang-tools-extra/clangd/SourceCode.h

208

i was going to complain about sourcecode depending on protocol, but apparently it already does...

[sammccall]

address comments
remove one more redundant getDraft() check

[sammccall]

In D97738#2597296, @kadircet wrote:

as discussed offline, i am hesitant about validateEdits layering at the moment. but i suppose the best thing to do is move it into clangdserver and expose a structrual api, as you proposed, which can be done independently.

Yup. It's not great, but it doesn't seem terrible or dangerous or anything. (We're not opening any new interfaces to support this, getDraft() is called in lots of places)
In the same bucket I think is sorting out TextEdits vs Replacements in a few interfaces etc.

clang-tools-extra/clangd/ClangdServer.h

266

Haha, I had this, then thought "but we pass things in by reference anyway".
Except... we don't, in ClangdServer. And I'm not sure why.

Anyway, done.

clang-tools-extra/clangd/DraftStore.cpp

65–67

I don't really understand the suggestion.

The purpose here is to notice and log when client-specified versions go backwards.
This is a protocol violation, which won't cause problems for clangd but may indicate something broken going on.

We don't want to log when versions go forwards!

[kadircet]

thanks, lgtm!

clang-tools-extra/clangd/DraftStore.cpp

65–67

ah nvm, i was reading this wrong. i thought it was logging when versions go "forward"

clang-tools-extra/clangd/ClangdLSPServer.h

private:
   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);
 
   /// 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.
enum class BackgroundIndexProgress {
     // The client has a progress bar, and we can send it updates immediately.
     Live,
   } BackgroundIndexProgressState = BackgroundIndexProgress::Unsupported;
   // The progress to send when the progress bar is created.
   // Only valid in state Creating.
   BackgroundQueue::Stats PendingBackgroundIndexProgress;
   /// LSP extension: skip WorkDoneProgressCreate, just send progress streams.
   bool BackgroundIndexSkipCreate = false;
-  // Store of the current versions of the open documents.
-  DraftStore DraftMgr;
 
   Options Opts;
   // The CDB is created by the "initialize" LSP method.
   std::unique_ptr<GlobalCompilationDatabase> BaseCDB;
   // CDB is BaseCDB plus any commands overridden via LSP extensions.
   llvm::Optional<OverlayCDB> CDB;
   // The ClangdServer is created by the "initialize" LSP method.
   llvm::Optional<ClangdServer> Server;
 };
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_CLANGDLSPSERVER_H

clang-tools-extra/clangd/ClangdLSPServer.cpp

 namespace {
 // Tracks end-to-end latency of high level lsp calls. Measurements are in
 // seconds.
 constexpr trace::Metric LSPLatency("lsp_latency", trace::Metric::Distribution,
                                    "method_name");
 
 // LSP defines file versions as numbers that increase.
 // ClangdServer treats them as opaque and therefore uses strings instead.
-std::string encodeVersion(int64_t LSPVersion) {
-  return llvm::to_string(LSPVersion);
+std::string encodeVersion(llvm::Optional<int64_t> LSPVersion) {
+  return LSPVersion ? llvm::to_string(*LSPVersion) : "";
 }
 llvm::Optional<int64_t> decodeVersion(llvm::StringRef Encoded) {
   int64_t Result;
   if (llvm::to_integer(Encoded, Result, 10))
     return Result;
   if (!Encoded.empty()) // Empty can be e.g. diagnostics on close.
     elog("unexpected non-numeric version {0}", Encoded);
   return llvm::None;
for (size_t I = CompletionItemKindMin;
        I <= static_cast<size_t>(CompletionItemKind::Reference); ++I)
     Defaults.set(I);
   return Defaults;
 }
 
 // Makes sure edits in \p FE are applicable to latest file contents reported by
 // editor. If not generates an error message containing information about files
 // that needs to be saved.
-llvm::Error validateEdits(const DraftStore &DraftMgr, const FileEdits &FE) {
+llvm::Error validateEdits(const ClangdServer &Server, const FileEdits &FE) {
   size_t InvalidFileCount = 0;
   llvm::StringRef LastInvalidFile;
   for (const auto &It : FE) {
-    if (auto Draft = DraftMgr.getDraft(It.first())) {
+    if (auto Draft = Server.getDraft(It.first())) {
       // If the file is open in user's editor, make sure the version we
       // saw and current version are compatible as this is the text that
       // will be replaced by editors.
-      if (!It.second.canApplyTo(Draft->Contents)) {
+      if (!It.second.canApplyTo(*Draft)) {
         ++InvalidFileCount;
         LastInvalidFile = It.first();
       }
     }
   }
   if (!InvalidFileCount)
     return llvm::Error::success();
   if (InvalidFileCount == 1)

 }
 
 void ClangdLSPServer::onDocumentDidOpen(
     const DidOpenTextDocumentParams &Params) {
   PathRef File = Params.textDocument.uri.file();
 
   const std::string &Contents = Params.textDocument.text;
 
-  auto Version = DraftMgr.addDraft(File, Params.textDocument.version, Contents);
-  Server->addDocument(File, Contents, encodeVersion(Version),
+  Server->addDocument(File, Contents,
+                      encodeVersion(Params.textDocument.version),
                       WantDiagnostics::Yes);
 }
 
 void ClangdLSPServer::onDocumentDidChange(
     const DidChangeTextDocumentParams &Params) {
   auto WantDiags = WantDiagnostics::Auto;
   if (Params.wantDiagnostics.hasValue())
     WantDiags = Params.wantDiagnostics.getValue() ? WantDiagnostics::Yes
                                                   : WantDiagnostics::No;
 
   PathRef File = Params.textDocument.uri.file();
-  llvm::Expected<DraftStore::Draft> Draft = DraftMgr.updateDraft(
-      File, Params.textDocument.version, Params.contentChanges);
-  if (!Draft) {
+  auto Code = Server->getDraft(File);
+  if (!Code) {
+    log("Trying to incrementally change non-added document: {0}", File);
+    return;
+  }
+  for (const auto &Change : Params.contentChanges) {
+    if (auto Err = applyChange(*Code, Change)) {
       // If this fails, we are most likely going to be not in sync anymore with
-    // the client.  It is better to remove the draft and let further operations
-    // fail rather than giving wrong results.
-    DraftMgr.removeDraft(File);
+      // the client.  It is better to remove the draft and let further
+      // operations fail rather than giving wrong results.
       Server->removeDocument(File);
-    elog("Failed to update {0}: {1}", File, Draft.takeError());
+      elog("Failed to update {0}: {1}", File, std::move(Err));
       return;
     }
-
-  Server->addDocument(File, Draft->Contents, encodeVersion(Draft->Version),
+  }
+  Server->addDocument(File, *Code, encodeVersion(Params.textDocument.version),
                       WantDiags, Params.forceRebuild);
 }
 
 void ClangdLSPServer::onDocumentDidSave(
     const DidSaveTextDocumentParams &Params) {
-  reparseOpenFilesIfNeeded([](llvm::StringRef) { return true; });
+  Server->reparseOpenFilesIfNeeded([](llvm::StringRef) { return true; });
 }
 
 void ClangdLSPServer::onFileEvent(const DidChangeWatchedFilesParams &Params) {
   // We could also reparse all open files here. However:
   //  - this could be frequent, and revalidating all the preambles isn't free
   //  - this is useful e.g. when switching git branches, but we're likely to see
   //    fresh headers but still have the old-branch main-file content
   Server->onFileEvent(Params);
void ClangdLSPServer::onCommandApplyEdit(const WorkspaceEdit &WE,
   // 5. We unwrap the changes and send them back to the editor
   // 6. The editor applies the changes (applyEdit), and sends us a reply
   // 7. We unwrap the reply and send a reply to the editor.
   applyEdit(WE, "Fix applied.", std::move(Reply));
 }
 
 void ClangdLSPServer::onCommandApplyTweak(const TweakArgs &Args,
                                           Callback<llvm::json::Value> Reply) {
-  auto Code = DraftMgr.getDraft(Args.file.file());
-  if (!Code)
-    return Reply(error("trying to apply a code action for a non-added file"));
-
-  auto Action = [this, Reply = std::move(Reply), File = Args.file,
-                 Code = std::move(*Code)](
-                    llvm::Expected<Tweak::Effect> R) mutable {
+  auto Action = [this, Reply = std::move(Reply),
+                 File = Args.file](llvm::Expected<Tweak::Effect> R) mutable {
     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;
       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))
+    if (auto Err = validateEdits(*Server, R->ApplyEdits))
       return Reply(std::move(Err));
 
     WorkspaceEdit WE;
     WE.changes.emplace();
     for (const auto &It : R->ApplyEdits) {
       (*WE.changes)[URI::createFile(It.first()).toString()] =
           It.second.asTextEdits();
     }
Server->prepareRename(
           return Reply(Result.takeError());
         return Reply(std::move(Result->Target));
       });
 }
 
 void ClangdLSPServer::onRename(const RenameParams &Params,
                                Callback<WorkspaceEdit> Reply) {
   Path File = std::string(Params.textDocument.uri.file());
-  if (!DraftMgr.getDraft(File))
+  if (!Server->getDraft(File))
     return Reply(llvm::make_error<LSPError>(
         "onRename called for non-added file", ErrorCode::InvalidParams));
   Server->rename(
       File, Params.position, Params.newName, Opts.Rename,
       [File, Params, Reply = std::move(Reply),
        this](llvm::Expected<RenameResult> R) mutable {
         if (!R)
           return Reply(R.takeError());
-        if (auto Err = validateEdits(DraftMgr, R->GlobalChanges))
+        if (auto Err = validateEdits(*Server, R->GlobalChanges))
           return Reply(std::move(Err));
         WorkspaceEdit Result;
         Result.changes.emplace();
         for (const auto &Rep : R->GlobalChanges) {
           (*Result.changes)[URI::createFile(Rep.first()).toString()] =
               Rep.second.asTextEdits();
         }
         Reply(Result);
       });
 }
 
 void ClangdLSPServer::onDocumentDidClose(
     const DidCloseTextDocumentParams &Params) {
   PathRef File = Params.textDocument.uri.file();
-  DraftMgr.removeDraft(File);
   Server->removeDocument(File);
 
   {
     std::lock_guard<std::mutex> Lock(FixItsMutex);
     FixItsMap.erase(File);
   }
   {
     std::lock_guard<std::mutex> HLock(SemanticTokensMutex);
     LastSemanticTokens.erase(File);
   }
   // 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);
 }
 
 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));
+  Server->formatOnType(File, 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)](
+  auto Code = Server->getDraft(File);
+  Server->formatFile(File, Params.range,
+                     [Code = std::move(Code), Reply = std::move(Reply)](
                          llvm::Expected<tooling::Replacements> Result) mutable {
                        if (Result)
-          Reply(replacementsToEdits(Code, Result.get()));
+                         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)](
+  auto Code = Server->getDraft(File);
+  Server->formatFile(File,
+                     /*Rng=*/llvm::None,
+                     [Code = std::move(Code), Reply = std::move(Reply)](
                          llvm::Expected<tooling::Replacements> Result) mutable {
                        if (Result)
-                         Reply(replacementsToEdits(Code, Result.get()));
+                         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>
static llvm::Optional<Command> asCommand(const CodeAction &Action) {
   if (Action.kind && *Action.kind == CodeAction::QUICKFIX_KIND)
     Cmd.title = "Apply fix: " + Cmd.title;
   return Cmd;
 }
 
 void ClangdLSPServer::onCodeAction(const CodeActionParams &Params,
                                    Callback<llvm::json::Value> Reply) {
   URIForFile File = Params.textDocument.uri;
-  auto Code = DraftMgr.getDraft(File.file());
-  if (!Code)
-    return Reply(llvm::make_error<LSPError>(
-        "onCodeAction called for non-added file", ErrorCode::InvalidParams));
-
   // Checks whether a particular CodeActionKind is included in the response.
   auto KindAllowed = [Only(Params.context.only)](llvm::StringRef Kind) {
     if (Only.empty())
       return true;
     return llvm::any_of(Only, [&](llvm::StringRef Base) {
       return Kind.consume_front(Base) && (Kind.empty() || Kind.startswith("."));
     });
   };
 
   // We provide a code action for Fixes on the specified diagnostics.
   std::vector<CodeAction> FixIts;
   if (KindAllowed(CodeAction::QUICKFIX_KIND)) {
     for (const Diagnostic &D : Params.context.diagnostics) {
       for (auto &F : getFixes(File.file(), D)) {
         FixIts.push_back(toCodeAction(F, Params.textDocument.uri));
         FixIts.back().diagnostics = {D};
       }
     }
   }
 
   // Now enumerate the semantic code actions.
   auto ConsumeActions =
-      [Reply = std::move(Reply), File, Code = std::move(*Code),
-       Selection = Params.range, FixIts = std::move(FixIts), this](
+      [Reply = std::move(Reply), File, Selection = Params.range,
+       FixIts = std::move(FixIts), this](
           llvm::Expected<std::vector<ClangdServer::TweakRef>> Tweaks) mutable {
         if (!Tweaks)
           return Reply(Tweaks.takeError());
 
         std::vector<CodeAction> Actions = std::move(FixIts);
         Actions.reserve(Actions.size() + Tweaks->size());
         for (const auto &T : *Tweaks)
           Actions.push_back(toCodeAction(T, File, Selection));
auto New =
                                 std::move(Entry.second.compilationCommand),
                                 /*Output=*/"");
     if (Old != New) {
       CDB->setCompileCommand(File, std::move(New));
       ModifiedFiles.insert(File);
     }
   }
 
-  reparseOpenFilesIfNeeded(
+  Server->reparseOpenFilesIfNeeded(
       [&](llvm::StringRef File) { return ModifiedFiles.count(File) != 0; });
 }
 
 void ClangdLSPServer::maybeExportMemoryProfile() {
   if (!trace::enabled() || !ShouldProfile())
     return;
 
   static constexpr trace::Metric MemoryUsage(

 // sure it matches what we expected.
 // Running the lexer here would be more robust (e.g. we can detect comments
 // and avoid triggering completion there), but we choose to err on the side
 // of simplicity here.
 bool ClangdLSPServer::shouldRunCompletion(
     const CompletionParams &Params) const {
   if (Params.context.triggerKind != CompletionTriggerKind::TriggerCharacter)
     return true;
-  auto Code = DraftMgr.getDraft(Params.textDocument.uri.file());
+  auto Code = Server->getDraft(Params.textDocument.uri.file());
   if (!Code)
     return true; // completion code will log the error for untracked doc.
-  auto Offset = positionToOffset(Code->Contents, Params.position,
+  auto Offset = positionToOffset(*Code, Params.position,
                                  /*AllowColumnsBeyondLineLength=*/false);
   if (!Offset) {
     vlog("could not convert position '{0}' to offset for file '{1}'",
          Params.position, Params.textDocument.uri.file());
     return true;
   }
-  return allowImplicitCompletion(Code->Contents, *Offset);
+  return allowImplicitCompletion(*Code, *Offset);
 }
 
 void ClangdLSPServer::onDiagnosticsReady(PathRef File, llvm::StringRef Version,
                                          std::vector<Diag> Diagnostics) {
   PublishDiagnosticsParams Notification;
   Notification.version = decodeVersion(Version);
   Notification.uri = URIForFile::canonicalize(File, /*TUPath=*/File);
   DiagnosticToReplacementMap LocalFixIts; // Temporary storage
void ClangdLSPServer::onFileUpdated(PathRef File, const TUStatus &Status) {
   // reasonable time interval (e.g. 0.5s).
   if (Status.PreambleActivity == PreambleAction::Idle &&
       (Status.ASTActivity.K == ASTAction::Building ||
        Status.ASTActivity.K == ASTAction::RunningAction))
     return;
   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/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 "DraftStore.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"
template <typename Mod> const Mod *getModule() const {
     return Modules ? Modules->get<Mod>() : 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.
+  /// diagnostics etc built from it. If empty, a version number is generated.
   void addDocument(PathRef File, StringRef Contents,
                    llvm::StringRef Version = "null",
                    WantDiagnostics WD = WantDiagnostics::Auto,
                    bool ForceRebuild = false);
 
   /// Remove \p File from list of tracked files, schedule a request to free
   /// resources associated with it. Pending diagnostics for closed files may not
   /// be delivered, even if requested with WantDiags::Auto or WantDiags::Yes.
   /// An empty set of diagnostics will be delivered, with Version = "".
   void removeDocument(PathRef File);
 
+  /// 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);
+
   /// Run code completion for \p File at \p Pos.
   ///
   /// This method should only be called for currently tracked files.
   void codeComplete(PathRef File, Position Pos,
                     const clangd::CodeCompleteOptions &Opts,
                     Callback<CodeCompleteResult> CB);
 
   /// Provide signature help for \p File at \p Pos.  This method should only be
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,
+  /// Run formatting for the \p File with content \p Code.
+  /// If \p Rng is non-null, formats only that region.
+  void formatFile(PathRef File, llvm::Optional<Range> Rng,
                   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);
+  void formatOnType(PathRef File, 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);
public:
   /// currently open files.
   /// Overall memory usage of clangd may be significantly more than reported
   /// here, as this metric does not account (at least) for:
   ///   - memory occupied by static and dynamic index,
   ///   - memory required for in-flight requests,
   /// FIXME: those metrics might be useful too, we should add them.
   llvm::StringMap<TUScheduler::FileStats> fileStats() const;
 
+  llvm::Optional<std::string> getDraft(PathRef File) const;
+
   // Blocks the main thread until the server is idle. Only for use in tests.
   // Returns false if the timeout expires.
   // FIXME: various subcomponents each get the full timeout, so it's more of
   // an order of magnitude than a hard deadline.
   LLVM_NODISCARD bool
   blockUntilIdleForTest(llvm::Optional<double> TimeoutSeconds = 10);
 
   /// Builds a nested representation of memory used by components.
   void profile(MemoryTree &MT) const;
 
 private:
-  void formatCode(PathRef File, llvm::StringRef Code,
-                  ArrayRef<tooling::Range> Ranges,
-                  Callback<tooling::Replacements> CB);
-
   ModuleSet *Modules;
   const GlobalCompilationDatabase &CDB;
   const ThreadsafeFS &TFS;
 
   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)
private:
 
   // GUARDED_BY(CachedCompletionFuzzyFindRequestMutex)
   llvm::StringMap<llvm::Optional<FuzzyFindRequest>>
       CachedCompletionFuzzyFindRequestByFile;
   mutable std::mutex CachedCompletionFuzzyFindRequestMutex;
 
   llvm::Optional<std::string> WorkspaceRoot;
   llvm::Optional<TUScheduler> WorkScheduler;
+
+  // Store of the current versions of the open documents.
+  // Only written from the main thread (despite being threadsafe).
+  // FIXME: TUScheduler also keeps these, unify?
+  DraftStore DraftMgr;
 };
 
 } // namespace clangd
 } // namespace clang
 
 #endif

clang-tools-extra/clangd/ClangdServer.cpp

if (Modules) {
     for (auto &Mod : *Modules)
       Mod.blockUntilIdle(Deadline::infinity());
   }
 }
 
 void ClangdServer::addDocument(PathRef File, llvm::StringRef Contents,
                                llvm::StringRef Version,
                                WantDiagnostics WantDiags, bool ForceRebuild) {
+  std::string ActualVersion = DraftMgr.addDraft(File, Version, Contents);
   ParseOptions Opts;
 
   // Compile command is set asynchronously during update, as it can be slow.
   ParseInputs Inputs;
   Inputs.TFS = &TFS;
   Inputs.Contents = std::string(Contents);
-  Inputs.Version = Version.str();
+  Inputs.Version = std::move(ActualVersion);
   Inputs.ForceRebuild = ForceRebuild;
   Inputs.Opts = std::move(Opts);
   Inputs.Index = Index;
   Inputs.ClangTidyProvider = ClangTidyProvider;
   bool NewFile = WorkScheduler->update(File, Inputs, WantDiags);
   // If we loaded Foo.h, we want to make sure Foo.cpp is indexed.
   if (NewFile && BackgroundIdx)
     BackgroundIdx->boostRelated(File);
 }
 
+void ClangdServer::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?
+        addDocument(FilePath, std::move(Draft->Contents), Draft->Version,
+                    WantDiagnostics::Auto);
+}
+
+llvm::Optional<std::string> ClangdServer::getDraft(PathRef File) const {
+  auto Draft = DraftMgr.getDraft(File);
+  if (!Draft)
+    return llvm::None;
+  return std::move(Draft->Contents);
+}
+
 std::function<Context(PathRef)>
 ClangdServer::createConfiguredContextProvider(const config::Provider *Provider,
                                               Callbacks *Publish) {
   if (!Provider)
     return [](llvm::StringRef) { return Context::current().clone(); };
 
   struct Impl {
     const config::Provider *Provider;
ClangdServer::createConfiguredContextProvider(const config::Provider *Provider,
   };
 
   // Copyable wrapper.
   return [I(std::make_shared<Impl>(Provider, Publish))](llvm::StringRef Path) {
     return (*I)(Path);
   };
 }
 
-void ClangdServer::removeDocument(PathRef File) { WorkScheduler->remove(File); }
+void ClangdServer::removeDocument(PathRef File) {
+  DraftMgr.removeDraft(File);
+  WorkScheduler->remove(File);
+}
 
 void ClangdServer::codeComplete(PathRef File, Position Pos,
                                 const clangd::CodeCompleteOptions &Opts,
                                 Callback<CodeCompleteResult> CB) {
   // Copy completion options for passing them to async task handler.
   auto CodeCompleteOpts = Opts;
   if (!CodeCompleteOpts.Index) // Respect overridden index.
     CodeCompleteOpts.Index = Index;
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);
+void ClangdServer::formatFile(PathRef File, llvm::Optional<Range> Rng,
+  auto Code = getDraft(File);
+  if (!Code)
+    return CB(llvm::make_error<LSPError>("trying to format non-added document",
+                                         ErrorCode::InvalidParams));
+  tooling::Range RequestedRange;
+  if (Rng) {
+    llvm::Expected<size_t> Begin = positionToOffset(*Code, Rng->start);
     if (!Begin)
       return CB(Begin.takeError());
-  llvm::Expected<size_t> End = positionToOffset(Code, Rng.end);
+    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));
+    RequestedRange = tooling::Range(*Begin, *End - *Begin);
+  } else {
+    RequestedRange = tooling::Range(0, Code->size());
   }
 
-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));
+  // Call clang-format.
+  auto Action = [File = File.str(), Code = std::move(*Code),
+                 Ranges = std::vector<tooling::Range>{RequestedRange},
+                 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::formatOnType(PathRef File, llvm::StringRef Code,
-                                Position Pos, StringRef TriggerText,
+void ClangdServer::formatOnType(PathRef File, Position Pos,
+                                StringRef TriggerText,
                                 Callback<std::vector<TextEdit>> CB) {
-  llvm::Expected<size_t> CursorPos = positionToOffset(Code, Pos);
+  auto Code = getDraft(File);
+  if (!Code)
+    return CB(llvm::make_error<LSPError>("trying to format non-added document",
+                                         ErrorCode::InvalidParams));
+  llvm::Expected<size_t> CursorPos = positionToOffset(*Code, Pos);
   if (!CursorPos)
     return CB(CursorPos.takeError());
-  auto Action = [File = File.str(), Code = Code.str(),
+  auto Action = [File = File.str(), Code = std::move(*Code),
                  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());
 
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));
       };

clang-tools-extra/clangd/DraftStore.h

 #include <mutex>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace clangd {
 
 /// A thread-safe container for files opened in a workspace, addressed by
-/// filenames. The contents are owned by the DraftStore. This class supports
-/// both whole and incremental updates of the documents.
-/// Each time a draft is updated, it is assigned a version number. This can be
+/// filenames. The contents are owned by the DraftStore.
+/// Each time a draft is updated, it is assigned a version. This can be
 /// specified by the caller or incremented from the previous version.
 class DraftStore {
 public:
   struct Draft {
     std::string Contents;
-    int64_t Version = -1;
+    std::string Version;
   };
 
   /// \return Contents of the stored document.
   /// For untracked files, a llvm::None is returned.
   llvm::Optional<Draft> getDraft(PathRef File) const;
 
   /// \return List of names of the drafts in this store.
   std::vector<Path> getActiveFiles() const;
 
   /// Replace contents of the draft for \p File with \p Contents.
-  /// If no version is specified, one will be automatically assigned.
+  /// If version is empty, one will be automatically assigned.
   /// Returns the version.
-  int64_t addDraft(PathRef File, llvm::Optional<int64_t> Version,
+  std::string addDraft(PathRef File, llvm::StringRef Version,
                        StringRef Contents);
 
-  /// Update the contents of the draft for \p File based on \p Changes.
-  /// If a position in \p Changes is invalid (e.g. out-of-range), the
-  /// draft is not modified.
-  /// If no version is specified, one will be automatically assigned.
-  ///
-  /// \return The new version of the draft for \p File, or an error if the
-  /// changes couldn't be applied.
-  llvm::Expected<Draft>
-  updateDraft(PathRef File, llvm::Optional<int64_t> Version,
-              llvm::ArrayRef<TextDocumentContentChangeEvent> Changes);
-
   /// Remove the draft from the store.
   void removeDraft(PathRef File);
 
 private:
   mutable std::mutex Mutex;
   llvm::StringMap<Draft> Drafts;
 };
 
 } // namespace clangd
 } // namespace clang
 
 #endif

clang-tools-extra/clangd/DraftStore.cpp

 //===--- DraftStore.cpp - File contents container ---------------*- 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 "DraftStore.h"
 #include "SourceCode.h"
 #include "support/Logger.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/Errc.h"
 
 namespace clang {
 namespace clangd {
 
 llvm::Optional<DraftStore::Draft> DraftStore::getDraft(PathRef File) const {
   std::lock_guard<std::mutex> Lock(Mutex);
 
std::vector<Path> DraftStore::getActiveFiles() const {
   std::vector<Path> ResultVector;
 
   for (auto DraftIt = Drafts.begin(); DraftIt != Drafts.end(); DraftIt++)
     ResultVector.push_back(std::string(DraftIt->getKey()));
 
   return ResultVector;
 }
 
+static void increment(std::string &S) {
+  // Ensure there is a numeric suffix.
+  if (S.empty() || !llvm::isDigit(S.back())) {
+    S.push_back('0');
+    return;
+  }
+  // Increment the numeric suffix.
+  auto I = S.rbegin(), E = S.rend();
+  for (;;) {
+    if (I == E || !llvm::isDigit(*I)) {
+      // Reached start of numeric section, it was all 9s.
+      S.insert(I.base(), '1');
+      break;
+    }
+    if (*I != '9') {
+      // Found a digit we can increment, we're done.
+      ++*I;
+      break;
+    }
+    *I = '0'; // and keep incrementing to the left.
+  }
+}
+
 static void updateVersion(DraftStore::Draft &D,
-                          llvm::Optional<int64_t> Version) {
-  if (Version) {
+                          llvm::StringRef SpecifiedVersion) {
+  if (!SpecifiedVersion.empty()) {
     // We treat versions as opaque, but the protocol says they increase.
-    if (*Version <= D.Version)
-      log("File version went from {0} to {1}", D.Version, Version);
-    D.Version = *Version;
+    if (SpecifiedVersion.compare_numeric(D.Version) <= 0)
+      log("File version went from {0} to {1}", D.Version, SpecifiedVersion);
+    D.Version = SpecifiedVersion.str();
   } else {
-    // Note that if D was newly-created, this will bump D.Version from -1 to 0.
-    ++D.Version;
+    // Note that if D was newly-created, this will bump D.Version from "" to 1.
+    increment(D.Version);
   }
 }
 
-int64_t DraftStore::addDraft(PathRef File, llvm::Optional<int64_t> Version,
+std::string DraftStore::addDraft(PathRef File, llvm::StringRef Version,
                                  llvm::StringRef Contents) {
   std::lock_guard<std::mutex> Lock(Mutex);
 
   Draft &D = Drafts[File];
   updateVersion(D, Version);
   D.Contents = Contents.str();
   return D.Version;
 }
 
-llvm::Expected<DraftStore::Draft> DraftStore::updateDraft(
-    PathRef File, llvm::Optional<int64_t> Version,
-    llvm::ArrayRef<TextDocumentContentChangeEvent> Changes) {
-  std::lock_guard<std::mutex> Lock(Mutex);
-
-  auto EntryIt = Drafts.find(File);
-  if (EntryIt == Drafts.end()) {
-    return error(llvm::errc::invalid_argument,
-                 "Trying to do incremental update on non-added document: {0}",
-                 File);
-  }
-  Draft &D = EntryIt->second;
-  std::string Contents = EntryIt->second.Contents;
-
-  for (const TextDocumentContentChangeEvent &Change : Changes) {
-    if (!Change.range) {
-      Contents = Change.text;
-      continue;
-    }
-
-    const Position &Start = Change.range->start;
-    llvm::Expected<size_t> StartIndex =
-        positionToOffset(Contents, Start, false);
-    if (!StartIndex)
-      return StartIndex.takeError();
-
-    const Position &End = Change.range->end;
-    llvm::Expected<size_t> EndIndex = positionToOffset(Contents, End, false);
-    if (!EndIndex)
-      return EndIndex.takeError();
-
-    if (*EndIndex < *StartIndex)
-      return error(llvm::errc::invalid_argument,
-                   "Range's end position ({0}) is before start position ({1})",
-                   End, Start);
-
-    // Since the range length between two LSP positions is dependent on the
-    // contents of the buffer we compute the range length between the start and
-    // end position ourselves and compare it to the range length of the LSP
-    // message to verify the buffers of the client and server are in sync.
-
-    // EndIndex and StartIndex are in bytes, but Change.rangeLength is in UTF-16
-    // code units.
-    ssize_t ComputedRangeLength =
-        lspLength(Contents.substr(*StartIndex, *EndIndex - *StartIndex));
-
-    if (Change.rangeLength && ComputedRangeLength != *Change.rangeLength)
-      return error(llvm::errc::invalid_argument,
-                   "Change's rangeLength ({0}) doesn't match the "
-                   "computed range length ({1}).",
-                   *Change.rangeLength, ComputedRangeLength);
-
-    std::string NewContents;
-    NewContents.reserve(*StartIndex + Change.text.length() +
-                        (Contents.length() - *EndIndex));
-
-    NewContents = Contents.substr(0, *StartIndex);
-    NewContents += Change.text;
-    NewContents += Contents.substr(*EndIndex);
-
-    Contents = std::move(NewContents);
-  }
-
-  updateVersion(D, Version);
-  D.Contents = std::move(Contents);
-  return D;
-}
-
 void DraftStore::removeDraft(PathRef File) {
   std::lock_guard<std::mutex> Lock(Mutex);
 
   Drafts.erase(File);
 }
 
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/SourceCode.h

 /// A mapping from absolute file path (the one used for accessing the underlying
 /// VFS) to edits.
 using FileEdits = llvm::StringMap<Edit>;
 
 /// Formats the edits and code around it according to Style. Changes
 /// Replacements to formatted ones if succeeds.
 llvm::Error reformatEdit(Edit &E, const format::FormatStyle &Style);
 
+/// Apply an incremental update to a text document.
+llvm::Error applyChange(std::string &Contents,
+                        const TextDocumentContentChangeEvent &Change);
+
 /// Collects identifiers with counts in the source code.
 llvm::StringMap<unsigned> collectIdentifiers(llvm::StringRef Content,
                                              const format::FormatStyle &Style);
 
 /// Collects all ranges of the given identifier in the source code.
 std::vector<Range> collectIdentifierRanges(llvm::StringRef Identifier,
                                            llvm::StringRef Content,
                                            const LangOptions &LangOpts);

clang-tools-extra/clangd/SourceCode.cpp

 llvm::Error reformatEdit(Edit &E, const format::FormatStyle &Style) {
   if (auto NewEdits = cleanupAndFormat(E.InitialCode, E.Replacements, Style))
     E.Replacements = std::move(*NewEdits);
   else
     return NewEdits.takeError();
   return llvm::Error::success();
 }
 
+llvm::Error applyChange(std::string &Contents,
+                        const TextDocumentContentChangeEvent &Change) {
+  if (!Change.range) {
+    Contents = Change.text;
+    return llvm::Error::success();
+  }
+
+  const Position &Start = Change.range->start;
+  llvm::Expected<size_t> StartIndex = positionToOffset(Contents, Start, false);
+  if (!StartIndex)
+    return StartIndex.takeError();
+
+  const Position &End = Change.range->end;
+  llvm::Expected<size_t> EndIndex = positionToOffset(Contents, End, false);
+  if (!EndIndex)
+    return EndIndex.takeError();
+
+  if (*EndIndex < *StartIndex)
+    return error(llvm::errc::invalid_argument,
+                 "Range's end position ({0}) is before start position ({1})",
+                 End, Start);
+
+  // Since the range length between two LSP positions is dependent on the
+  // contents of the buffer we compute the range length between the start and
+  // end position ourselves and compare it to the range length of the LSP
+  // message to verify the buffers of the client and server are in sync.
+
+  // EndIndex and StartIndex are in bytes, but Change.rangeLength is in UTF-16
+  // code units.
+  ssize_t ComputedRangeLength =
+      lspLength(Contents.substr(*StartIndex, *EndIndex - *StartIndex));
+
+  if (Change.rangeLength && ComputedRangeLength != *Change.rangeLength)
+    return error(llvm::errc::invalid_argument,
+                 "Change's rangeLength ({0}) doesn't match the "
+                 "computed range length ({1}).",
+                 *Change.rangeLength, ComputedRangeLength);
+
+  std::string NewContents;
+  NewContents.reserve(*StartIndex + Change.text.length() +
+                      (Contents.length() - *EndIndex));
+
+  NewContents = Contents.substr(0, *StartIndex);
+  NewContents += Change.text;
+  NewContents += Contents.substr(*EndIndex);
+
+  std::swap(Contents, NewContents);
+  return llvm::Error::success();
+}
+
 EligibleRegion getEligiblePoints(llvm::StringRef Code,
                                  llvm::StringRef FullyQualifiedName,
                                  const LangOptions &LangOpts) {
   EligibleRegion ER;
   // Start with global namespace.
   std::vector<std::string> Enclosing = {""};
   // FIXME: In addition to namespaces try to generate events for function
   // definitions as well. One might use a closing parantheses(")" followed by an

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:    "message": "trying to get AST for non-added document"
 # 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": "trying to format non-added document"
 # 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": "trying to format non-added document"
 # 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": "trying to format non-added document"
 # CHECK-NEXT:  },
 # CHECK-NEXT:  "id": 5,
 ---
 {"jsonrpc":"2.0","id":6,"method":"shutdown"}
 ---
 {"jsonrpc":"2.0","method":"exit"}

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

 #include "x.h"
 #include "y.h"
 
 void f() {}
 )cpp";
   FS.Files[Path] = Code;
   runAddDocument(Server, Path, Code);
 
-  auto Replaces = runFormatFile(Server, Path, Code);
+  auto Replaces = runFormatFile(Server, Path, /*Rng=*/llvm::None);
   EXPECT_TRUE(static_cast<bool>(Replaces));
   auto Changed = tooling::applyAllReplacements(Code, *Replaces);
   EXPECT_TRUE(static_cast<bool>(Changed));
   EXPECT_EQ(Expected, *Changed);
 }
 
 TEST(ClangdServerTest, ChangedHeaderFromISystem) {
   MockFS FS;

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

 //===-- DraftStoreTests.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
 //
 //===----------------------------------------------------------------------===//
 
 #include "Annotations.h"
 #include "DraftStore.h"
 #include "SourceCode.h"
+#include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace clangd {
 namespace {
 
-struct IncrementalTestStep {
-  llvm::StringRef Src;
-  llvm::StringRef Contents;
-};
-
-int rangeLength(llvm::StringRef Code, const Range &Rng) {
-  llvm::Expected<size_t> Start = positionToOffset(Code, Rng.start);
-  llvm::Expected<size_t> End = positionToOffset(Code, Rng.end);
-  assert(Start);
-  assert(End);
-  return *End - *Start;
-}
-
-/// Send the changes one by one to updateDraft, verify the intermediate results.
-void stepByStep(llvm::ArrayRef<IncrementalTestStep> Steps) {
-  DraftStore DS;
-  Annotations InitialSrc(Steps.front().Src);
-  constexpr llvm::StringLiteral Path("/hello.cpp");
-
-  // Set the initial content.
-  EXPECT_EQ(0, DS.addDraft(Path, llvm::None, InitialSrc.code()));
-
-  for (size_t i = 1; i < Steps.size(); i++) {
-    Annotations SrcBefore(Steps[i - 1].Src);
-    Annotations SrcAfter(Steps[i].Src);
-    llvm::StringRef Contents = Steps[i - 1].Contents;
-    TextDocumentContentChangeEvent Event{
-        SrcBefore.range(),
-        rangeLength(SrcBefore.code(), SrcBefore.range()),
-        Contents.str(),
-    };
-
-    llvm::Expected<DraftStore::Draft> Result =
-        DS.updateDraft(Path, llvm::None, {Event});
-    ASSERT_TRUE(!!Result);
-    EXPECT_EQ(Result->Contents, SrcAfter.code());
-    EXPECT_EQ(DS.getDraft(Path)->Contents, SrcAfter.code());
-    EXPECT_EQ(Result->Version, static_cast<int64_t>(i));
-  }
-}
-
-/// Send all the changes at once to updateDraft, check only the final result.
-void allAtOnce(llvm::ArrayRef<IncrementalTestStep> Steps) {
-  DraftStore DS;
-  Annotations InitialSrc(Steps.front().Src);
-  Annotations FinalSrc(Steps.back().Src);
-  constexpr llvm::StringLiteral Path("/hello.cpp");
-  std::vector<TextDocumentContentChangeEvent> Changes;
-
-  for (size_t i = 0; i < Steps.size() - 1; i++) {
-    Annotations Src(Steps[i].Src);
-    llvm::StringRef Contents = Steps[i].Contents;
-
-    Changes.push_back({
-        Src.range(),
-        rangeLength(Src.code(), Src.range()),
-        Contents.str(),
-    });
-  }
-
-  // Set the initial content.
-  EXPECT_EQ(0, DS.addDraft(Path, llvm::None, InitialSrc.code()));
-
-  llvm::Expected<DraftStore::Draft> Result =
-      DS.updateDraft(Path, llvm::None, Changes);
-
-  ASSERT_TRUE(!!Result) << llvm::toString(Result.takeError());
-  EXPECT_EQ(Result->Contents, FinalSrc.code());
-  EXPECT_EQ(DS.getDraft(Path)->Contents, FinalSrc.code());
-  EXPECT_EQ(Result->Version, 1);
-}
-
-TEST(DraftStoreIncrementalUpdateTest, Simple) {
-  // clang-format off
-  IncrementalTestStep Steps[] =
-    {
-      // Replace a range
-      {
-R"cpp(static int
-hello[[World]]()
-{})cpp",
-        "Universe"
-      },
-      // Delete a range
-      {
-R"cpp(static int
-hello[[Universe]]()
-{})cpp",
-        ""
-      },
-      // Add a range
-      {
-R"cpp(static int
-hello[[]]()
-{})cpp",
-        "Monde"
-      },
-      {
-R"cpp(static int
-helloMonde()
-{})cpp",
-        ""
-      }
-    };
-  // clang-format on
-
-  stepByStep(Steps);
-  allAtOnce(Steps);
-}
-
-TEST(DraftStoreIncrementalUpdateTest, MultiLine) {
-  // clang-format off
-  IncrementalTestStep Steps[] =
-    {
-      // Replace a range
-      {
-R"cpp(static [[int
-helloWorld]]()
-{})cpp",
-R"cpp(char
-welcome)cpp"
-      },
-      // Delete a range
-      {
-R"cpp(static char[[
-welcome]]()
-{})cpp",
-        ""
-      },
-      // Add a range
-      {
-R"cpp(static char[[]]()
-{})cpp",
-        R"cpp(
-cookies)cpp"
-      },
-      // Replace the whole file
-      {
-R"cpp([[static char
-cookies()
-{}]])cpp",
-        R"cpp(#include <stdio.h>
-)cpp"
-      },
-      // Delete the whole file
-      {
-        R"cpp([[#include <stdio.h>
-]])cpp",
-        "",
-      },
-      // Add something to an empty file
-      {
-        "[[]]",
-        R"cpp(int main() {
-)cpp",
-      },
-      {
-        R"cpp(int main() {
-)cpp",
-        ""
-      }
-    };
-  // clang-format on
-
-  stepByStep(Steps);
-  allAtOnce(Steps);
-}
-
-TEST(DraftStoreIncrementalUpdateTest, WrongRangeLength) {
-  DraftStore DS;
-  Path File = "foo.cpp";
-
-  DS.addDraft(File, llvm::None, "int main() {}\n");
-
-  TextDocumentContentChangeEvent Change;
-  Change.range.emplace();
-  Change.range->start.line = 0;
-  Change.range->start.character = 0;
-  Change.range->end.line = 0;
-  Change.range->end.character = 2;
-  Change.rangeLength = 10;
-
-  Expected<DraftStore::Draft> Result =
-      DS.updateDraft(File, llvm::None, {Change});
-
-  EXPECT_TRUE(!Result);
-  EXPECT_EQ(
-      toString(Result.takeError()),
-      "Change's rangeLength (10) doesn't match the computed range length (2).");
-}
-
-TEST(DraftStoreIncrementalUpdateTest, EndBeforeStart) {
-  DraftStore DS;
-  Path File = "foo.cpp";
-
-  DS.addDraft(File, llvm::None, "int main() {}\n");
-
-  TextDocumentContentChangeEvent Change;
-  Change.range.emplace();
-  Change.range->start.line = 0;
-  Change.range->start.character = 5;
-  Change.range->end.line = 0;
-  Change.range->end.character = 3;
-
-  auto Result = DS.updateDraft(File, llvm::None, {Change});
-
-  EXPECT_TRUE(!Result);
-  EXPECT_EQ(toString(Result.takeError()),
-            "Range's end position (0:3) is before start position (0:5)");
-}
-
-TEST(DraftStoreIncrementalUpdateTest, StartCharOutOfRange) {
-  DraftStore DS;
-  Path File = "foo.cpp";
-
-  DS.addDraft(File, llvm::None, "int main() {}\n");
-
-  TextDocumentContentChangeEvent Change;
-  Change.range.emplace();
-  Change.range->start.line = 0;
-  Change.range->start.character = 100;
-  Change.range->end.line = 0;
-  Change.range->end.character = 100;
-  Change.text = "foo";
-
-  auto Result = DS.updateDraft(File, llvm::None, {Change});
-
-  EXPECT_TRUE(!Result);
-  EXPECT_EQ(toString(Result.takeError()),
-            "utf-16 offset 100 is invalid for line 0");
-}
-
-TEST(DraftStoreIncrementalUpdateTest, EndCharOutOfRange) {
-  DraftStore DS;
-  Path File = "foo.cpp";
-
-  DS.addDraft(File, llvm::None, "int main() {}\n");
-
-  TextDocumentContentChangeEvent Change;
-  Change.range.emplace();
-  Change.range->start.line = 0;
-  Change.range->start.character = 0;
-  Change.range->end.line = 0;
-  Change.range->end.character = 100;
-  Change.text = "foo";
-
-  auto Result = DS.updateDraft(File, llvm::None, {Change});
-
-  EXPECT_TRUE(!Result);
-  EXPECT_EQ(toString(Result.takeError()),
-            "utf-16 offset 100 is invalid for line 0");
-}
-
-TEST(DraftStoreIncrementalUpdateTest, StartLineOutOfRange) {
-  DraftStore DS;
-  Path File = "foo.cpp";
-
-  DS.addDraft(File, llvm::None, "int main() {}\n");
-
-  TextDocumentContentChangeEvent Change;
-  Change.range.emplace();
-  Change.range->start.line = 100;
-  Change.range->start.character = 0;
-  Change.range->end.line = 100;
-  Change.range->end.character = 0;
-  Change.text = "foo";
-
-  auto Result = DS.updateDraft(File, llvm::None, {Change});
-
-  EXPECT_TRUE(!Result);
-  EXPECT_EQ(toString(Result.takeError()), "Line value is out of range (100)");
-}
-
-TEST(DraftStoreIncrementalUpdateTest, EndLineOutOfRange) {
+TEST(DraftStore, Versions) {
   DraftStore DS;
   Path File = "foo.cpp";
 
-  DS.addDraft(File, llvm::None, "int main() {}\n");
-
-  TextDocumentContentChangeEvent Change;
-  Change.range.emplace();
-  Change.range->start.line = 0;
-  Change.range->start.character = 0;
-  Change.range->end.line = 100;
-  Change.range->end.character = 0;
-  Change.text = "foo";
-
-  auto Result = DS.updateDraft(File, llvm::None, {Change});
-
-  EXPECT_TRUE(!Result);
-  EXPECT_EQ(toString(Result.takeError()), "Line value is out of range (100)");
-}
-
-/// Check that if a valid change is followed by an invalid change, the original
-/// version of the document (prior to all changes) is kept.
-TEST(DraftStoreIncrementalUpdateTest, InvalidRangeInASequence) {
-  DraftStore DS;
-  Path File = "foo.cpp";
-
-  StringRef OriginalContents = "int main() {}\n";
-  EXPECT_EQ(0, DS.addDraft(File, llvm::None, OriginalContents));
-
-  // The valid change
-  TextDocumentContentChangeEvent Change1;
-  Change1.range.emplace();
-  Change1.range->start.line = 0;
-  Change1.range->start.character = 0;
-  Change1.range->end.line = 0;
-  Change1.range->end.character = 0;
-  Change1.text = "Hello ";
-
-  // The invalid change
-  TextDocumentContentChangeEvent Change2;
-  Change2.range.emplace();
-  Change2.range->start.line = 0;
-  Change2.range->start.character = 5;
-  Change2.range->end.line = 0;
-  Change2.range->end.character = 100;
-  Change2.text = "something";
+  EXPECT_EQ("25", DS.addDraft(File, "25", ""));
+  EXPECT_EQ("25", DS.getDraft(File)->Version);
+  EXPECT_EQ("", DS.getDraft(File)->Contents);
 
-  auto Result = DS.updateDraft(File, llvm::None, {Change1, Change2});
+  EXPECT_EQ("26", DS.addDraft(File, "", "x"));
+  EXPECT_EQ("26", DS.getDraft(File)->Version);
+  EXPECT_EQ("x", DS.getDraft(File)->Contents);
 
-  EXPECT_TRUE(!Result);
-  EXPECT_EQ(toString(Result.takeError()),
-            "utf-16 offset 100 is invalid for line 0");
-
-  Optional<DraftStore::Draft> Contents = DS.getDraft(File);
-  EXPECT_TRUE(Contents);
-  EXPECT_EQ(Contents->Contents, OriginalContents);
-  EXPECT_EQ(Contents->Version, 0);
-}
-
-TEST(DraftStore, Version) {
-  DraftStore DS;
-  Path File = "foo.cpp";
-
-  EXPECT_EQ(25, DS.addDraft(File, 25, ""));
-  EXPECT_EQ(25, DS.getDraft(File)->Version);
-
-  EXPECT_EQ(26, DS.addDraft(File, llvm::None, ""));
-  EXPECT_EQ(26, DS.getDraft(File)->Version);
+  EXPECT_EQ("27", DS.addDraft(File, "", "x")) << "no-op change";
+  EXPECT_EQ("27", DS.getDraft(File)->Version);
+  EXPECT_EQ("x", DS.getDraft(File)->Contents);
 
   // We allow versions to go backwards.
-  EXPECT_EQ(7, DS.addDraft(File, 7, ""));
-  EXPECT_EQ(7, DS.getDraft(File)->Version);
-
-  // Valid (no-op) change modifies version.
-  auto Result = DS.updateDraft(File, 10, {});
-  EXPECT_TRUE(!!Result);
-  EXPECT_EQ(10, Result->Version);
-  EXPECT_EQ(10, DS.getDraft(File)->Version);
-
-  Result = DS.updateDraft(File, llvm::None, {});
-  EXPECT_TRUE(!!Result);
-  EXPECT_EQ(11, Result->Version);
-  EXPECT_EQ(11, DS.getDraft(File)->Version);
-
-  TextDocumentContentChangeEvent InvalidChange;
-  InvalidChange.range.emplace();
-  InvalidChange.rangeLength = 99;
-
-  Result = DS.updateDraft(File, 15, {InvalidChange});
-  EXPECT_FALSE(!!Result);
-  consumeError(Result.takeError());
-  EXPECT_EQ(11, DS.getDraft(File)->Version);
+  EXPECT_EQ("7", DS.addDraft(File, "7", "y"));
+  EXPECT_EQ("7", DS.getDraft(File)->Version);
+  EXPECT_EQ("y", DS.getDraft(File)->Contents);
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang

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

 #include "gtest/gtest.h"
 #include <tuple>
 
 namespace clang {
 namespace clangd {
 namespace {
 
 using llvm::Failed;
+using llvm::FailedWithMessage;
 using llvm::HasValue;
 
 MATCHER_P2(Pos, Line, Col, "") {
   return arg.line == int(Line) && arg.character == int(Col);
 }
 
 MATCHER_P(MacroName, Name, "") { return arg.Name == Name; }
 
TEST(SourceCodeTests, isKeywords) {
   EXPECT_TRUE(isKeyword("co_await", LangOpts));
 
   // these are identifiers (not keywords!) with special meaning in some
   // contexts.
   EXPECT_FALSE(isKeyword("final", LangOpts));
   EXPECT_FALSE(isKeyword("override", LangOpts));
 }
 
+struct IncrementalTestStep {
+  llvm::StringRef Src;
+  llvm::StringRef Contents;
+};
+
+int rangeLength(llvm::StringRef Code, const Range &Rng) {
+  llvm::Expected<size_t> Start = positionToOffset(Code, Rng.start);
+  llvm::Expected<size_t> End = positionToOffset(Code, Rng.end);
+  assert(Start);
+  assert(End);
+  return *End - *Start;
+}
+
+/// Send the changes one by one to updateDraft, verify the intermediate results.
+void stepByStep(llvm::ArrayRef<IncrementalTestStep> Steps) {
+  std::string Code = Annotations(Steps.front().Src).code().str();
+
+  for (size_t I = 1; I < Steps.size(); I++) {
+    Annotations SrcBefore(Steps[I - 1].Src);
+    Annotations SrcAfter(Steps[I].Src);
+    llvm::StringRef Contents = Steps[I - 1].Contents;
+    TextDocumentContentChangeEvent Event{
+        SrcBefore.range(),
+        rangeLength(SrcBefore.code(), SrcBefore.range()),
+        Contents.str(),
+    };
+
+    EXPECT_THAT_ERROR(applyChange(Code, Event), llvm::Succeeded());
+    EXPECT_EQ(Code, SrcAfter.code());
+  }
+}
+
+TEST(ApplyEditsTest, Simple) {
+  // clang-format off
+  IncrementalTestStep Steps[] =
+    {
+      // Replace a range
+      {
+R"cpp(static int
+hello[[World]]()
+{})cpp",
+        "Universe"
+      },
+      // Delete a range
+      {
+R"cpp(static int
+hello[[Universe]]()
+{})cpp",
+        ""
+      },
+      // Add a range
+      {
+R"cpp(static int
+hello[[]]()
+{})cpp",
+        "Monde"
+      },
+      {
+R"cpp(static int
+helloMonde()
+{})cpp",
+        ""
+      }
+    };
+  // clang-format on
+
+  stepByStep(Steps);
+}
+
+TEST(ApplyEditsTest, MultiLine) {
+  // clang-format off
+  IncrementalTestStep Steps[] =
+    {
+      // Replace a range
+      {
+R"cpp(static [[int
+helloWorld]]()
+{})cpp",
+R"cpp(char
+welcome)cpp"
+      },
+      // Delete a range
+      {
+R"cpp(static char[[
+welcome]]()
+{})cpp",
+        ""
+      },
+      // Add a range
+      {
+R"cpp(static char[[]]()
+{})cpp",
+        R"cpp(
+cookies)cpp"
+      },
+      // Replace the whole file
+      {
+R"cpp([[static char
+cookies()
+{}]])cpp",
+        R"cpp(#include <stdio.h>
+)cpp"
+      },
+      // Delete the whole file
+      {
+        R"cpp([[#include <stdio.h>
+]])cpp",
+        "",
+      },
+      // Add something to an empty file
+      {
+        "[[]]",
+        R"cpp(int main() {
+)cpp",
+      },
+      {
+        R"cpp(int main() {
+)cpp",
+        ""
+      }
+    };
+  // clang-format on
+
+  stepByStep(Steps);
+}
+
+TEST(ApplyEditsTest, WrongRangeLength) {
+  std::string Code = "int main() {}\n";
+
+  TextDocumentContentChangeEvent Change;
+  Change.range.emplace();
+  Change.range->start.line = 0;
+  Change.range->start.character = 0;
+  Change.range->end.line = 0;
+  Change.range->end.character = 2;
+  Change.rangeLength = 10;
+
+  EXPECT_THAT_ERROR(applyChange(Code, Change),
+                    FailedWithMessage("Change's rangeLength (10) doesn't match "
+                                      "the computed range length (2)."));
+}
+
+TEST(ApplyEditsTest, EndBeforeStart) {
+  std::string Code = "int main() {}\n";
+
+  TextDocumentContentChangeEvent Change;
+  Change.range.emplace();
+  Change.range->start.line = 0;
+  Change.range->start.character = 5;
+  Change.range->end.line = 0;
+  Change.range->end.character = 3;
+
+  EXPECT_THAT_ERROR(
+      applyChange(Code, Change),
+      FailedWithMessage(
+          "Range's end position (0:3) is before start position (0:5)"));
+}
+
+TEST(ApplyEditsTest, StartCharOutOfRange) {
+  std::string Code = "int main() {}\n";
+
+  TextDocumentContentChangeEvent Change;
+  Change.range.emplace();
+  Change.range->start.line = 0;
+  Change.range->start.character = 100;
+  Change.range->end.line = 0;
+  Change.range->end.character = 100;
+  Change.text = "foo";
+
+  EXPECT_THAT_ERROR(
+      applyChange(Code, Change),
+      FailedWithMessage("utf-16 offset 100 is invalid for line 0"));
+}
+
+TEST(ApplyEditsTest, EndCharOutOfRange) {
+  std::string Code = "int main() {}\n";
+
+  TextDocumentContentChangeEvent Change;
+  Change.range.emplace();
+  Change.range->start.line = 0;
+  Change.range->start.character = 0;
+  Change.range->end.line = 0;
+  Change.range->end.character = 100;
+  Change.text = "foo";
+
+  EXPECT_THAT_ERROR(
+      applyChange(Code, Change),
+      FailedWithMessage("utf-16 offset 100 is invalid for line 0"));
+}
+
+TEST(ApplyEditsTest, StartLineOutOfRange) {
+  std::string Code = "int main() {}\n";
+
+  TextDocumentContentChangeEvent Change;
+  Change.range.emplace();
+  Change.range->start.line = 100;
+  Change.range->start.character = 0;
+  Change.range->end.line = 100;
+  Change.range->end.character = 0;
+  Change.text = "foo";
+
+  EXPECT_THAT_ERROR(applyChange(Code, Change),
+                    FailedWithMessage("Line value is out of range (100)"));
+}
+
+TEST(ApplyEditsTest, EndLineOutOfRange) {
+  std::string Code = "int main() {}\n";
+
+  TextDocumentContentChangeEvent Change;
+  Change.range.emplace();
+  Change.range->start.line = 0;
+  Change.range->start.character = 0;
+  Change.range->end.line = 100;
+  Change.range->end.character = 0;
+  Change.text = "foo";
+
+  EXPECT_THAT_ERROR(applyChange(Code, Change),
+                    FailedWithMessage("Line value is out of range (100)"));
+}
+
 } // namespace
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/unittests/SyncAPI.h

llvm::Expected<RenameResult> runRename(ClangdServer &Server, PathRef File,
                                        const clangd::RenameOptions &RenameOpts);
 
 llvm::Expected<RenameResult>
 runPrepareRename(ClangdServer &Server, PathRef File, Position Pos,
                  llvm::Optional<std::string> NewName,
                  const clangd::RenameOptions &RenameOpts);
 
 llvm::Expected<tooling::Replacements>
-runFormatFile(ClangdServer &Server, PathRef File, StringRef Code);
+runFormatFile(ClangdServer &Server, PathRef File, llvm::Optional<Range>);
 
 SymbolSlab runFuzzyFind(const SymbolIndex &Index, StringRef Query);
 SymbolSlab runFuzzyFind(const SymbolIndex &Index, const FuzzyFindRequest &Req);
 RefSlab getRefs(const SymbolIndex &Index, SymbolID ID);
 
 llvm::Expected<std::vector<SelectionRange>>
 runSemanticRanges(ClangdServer &Server, PathRef File,
                   const std::vector<Position> &Pos);

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

runPrepareRename(ClangdServer &Server, PathRef File, Position Pos,
                  llvm::Optional<std::string> NewName,
                  const RenameOptions &RenameOpts) {
   llvm::Optional<llvm::Expected<RenameResult>> Result;
   Server.prepareRename(File, Pos, NewName, RenameOpts, capture(Result));
   return std::move(*Result);
 }
 
 llvm::Expected<tooling::Replacements>
-runFormatFile(ClangdServer &Server, PathRef File, StringRef Code) {
+runFormatFile(ClangdServer &Server, PathRef File, llvm::Optional<Range> Rng) {
   llvm::Optional<llvm::Expected<tooling::Replacements>> Result;
-  Server.formatFile(File, Code, capture(Result));
+  Server.formatFile(File, Rng, capture(Result));
   return std::move(*Result);
 }
 
 SymbolSlab runFuzzyFind(const SymbolIndex &Index, llvm::StringRef Query) {
   FuzzyFindRequest Req;
   Req.Query = std::string(Query);
   Req.AnyScope = true;
   return runFuzzyFind(Index, Req);