[clangd] Add support TextDocumentEdit.

[hokein]

Summary

This is an initial patch to add TextDocumentEdit (versioned edits) support in
clangd, the scope is minimal:

• add and extend the corresponding protocol structures
• propagate the documentChanges for diagnostic codeactions (our motivated case)

[hokein]

clang-tools-extra/clangd/ClangdLSPServer.cpp

1722

This part of code is moved from the toLSPDiags, we can keep it unchanged then we have to pass the Version and SupportsDocumentChanges to toLSPDiags which makes the API ugly. Open for ideas.

[hokein]

add missing test.

[kadircet]

can you also have a version of the clang-tools-extra/clangd/test/fixits-command.test with documentChanges support? it's unlikely to have clients in that configuration but i believe the deserialization issue i mentioned above would be discoverable by such a test.

clang-tools-extra/clangd/ClangdLSPServer.cpp

1722

no i think it makes more sense in LSP layer, as it's an LSP extension. I believe we had it in the guts because i believe we were using it internally with a client that doesn't use LSPServer at some point.

it would be better to drop the extension but i see that qt-creator & sourcekit-lsp has mentions of this :/ so as I mentioned above, we can convert the fixes to CodeActions here unconditionally (it's not more expensive than the copy we perform today). afterwards we only make copying those CodeActions into the Diag conditioned on the capability.

clang-tools-extra/clangd/ClangdLSPServer.h

201–202

instead of a pair maybe a:

struct VersionedFixes {
  std::optional<int64_t> DocumentVersion;
  std::vector<Fix> Fixes;
};

236

can we instead have a:

std::map<clangd::Diagnostic, std::vector<CodeAction>, LSPDiagnosticCompare> Fixes;

We'll make sure we store code actions with necessary version information.
That way FixItsMap can stay the same, and rest of the code will look more uniform; we'll do the conversion from Fixes to CodeActions during onDiagnosticsReady

clang-tools-extra/clangd/Diagnostics.cpp

426–428

we can now move this into clangdlsperver.cpp

clang-tools-extra/clangd/Protocol.cpp

735

we actually want O.mapOptional for both "changes" and "documentChanges".

[hokein]

address review comments

[hokein]

can you also have a version of the clang-tools-extra/clangd/test/fixits-command.test with documentChanges support? it's unlikely to have clients in that configuration but i believe the deserialization issue i mentioned above would be discoverable by such a test.

I'm happy to add a test for that, but I'm not sure the deserialization issue you mentioned in the comment, is the one to use mapOptional?

clang-tools-extra/clangd/ClangdLSPServer.h

201–202

we don't need this struct now, as we switch to store the CodeAction.

236

good idea!

clang-tools-extra/clangd/Protocol.cpp

735

I think map is a better fit here, it has a specific version of std::optional, see https://github.com/llvm/llvm-project/blob/main/llvm/include/llvm/Support/JSON.h#L852.

mapOptional doesn't set the field when missing the key in json object,

[kadircet]

In D148783#4286652, @hokein wrote:

can you also have a version of the clang-tools-extra/clangd/test/fixits-command.test with documentChanges support? it's unlikely to have clients in that configuration but i believe the deserialization issue i mentioned above would be discoverable by such a test.

I'm happy to add a test for that, but I'm not sure the deserialization issue you mentioned in the comment, is the one to use mapOptional?

yes it was for mapOptional, which turns out not to be an issue as there's a specialization for optional<T>.

but still having that test to verify deserialization logic wouldn't hurt.

clang-tools-extra/clangd/ClangdLSPServer.cpp

1728

we didn't have the empty check before, let's not introduce it now (i.e. we'll still reply with an empty set of code actions rather than "none" when there are no fixes known to clangd)

1731–1734

i am not sure why this logic was appending to the vector rather than just overwriting. but we shouldn't receive the same diagnostics from the callback here, am i missing something? so what about just:

LocalFixIts[Diag] = std::move(CodeActions);

clang-tools-extra/clangd/Protocol.cpp

735

yeah you're right, i missed the specialization of map for optional<T>

[hokein]

address review comments, added one more test for command code-actions

clang-tools-extra/clangd/ClangdLSPServer.cpp

1728

yeah, I added this empty check to keep fixits-embed-in-diagnostic.test unchanged (we don't emit code-action for diagnostic notes), but I think it is fair enough to change it.

1731–1734

Agreed, changed to overwriting.

[kadircet]

thanks!

clang-tools-extra/clangd/ClangdLSPServer.cpp

1680

nit: let's keep llvm::StringRef

[hokein]

update and rebase

[DavidSpickett]

Hi, these tests are failing on our (Linaro's) Windows on Arm buildbot. First appearance here https://lab.llvm.org/buildbot/#/builders/65/builds/9346

Still failing as of a few hours ago https://lab.llvm.org/buildbot/#/builders/65/builds/9360 (maybe you have fixed this already, I am checking in infrequently over the next few days).

If you need any help debugging it let me know. It appears there is a drive letter on Windows:

# CHECK-NEXT:              "uri": "file:///clangd-test/foo.c",
                           ^
<stdin>:224:30: note: scanning from here
            "textDocument": {
                             ^
<stdin>:225:15: note: possible intended match here
              "uri": "file:///C:/clangd-test/foo.c",
              ^

[hokein]

In D148783#4298398, @DavidSpickett wrote:

Hi, these tests are failing on our (Linaro's) Windows on Arm buildbot. First appearance here https://lab.llvm.org/buildbot/#/builders/65/builds/9346

Still failing as of a few hours ago https://lab.llvm.org/buildbot/#/builders/65/builds/9360 (maybe you have fixed this already, I am checking in infrequently over the next few days).

If you need any help debugging it let me know. It appears there is a drive letter on Windows:

# CHECK-NEXT:              "uri": "file:///clangd-test/foo.c",
                           ^
<stdin>:224:30: note: scanning from here
            "textDocument": {
                             ^
<stdin>:225:15: note: possible intended match here
              "uri": "file:///C:/clangd-test/foo.c",
              ^

sorry for the breakage, looking now.

[hokein]

should be fixed in https://github.com/llvm/llvm-project/commit/4294619b4cdfed49502dcebc7efd5f044e587267.

[DavidSpickett]

Thanks!

clang-tools-extra/clangd/ClangdLSPServer.h

 #include "Transport.h"
 #include "support/Context.h"
 #include "support/MemoryTree.h"
 #include "support/Path.h"
 #include "support/Threading.h"
 #include "llvm/Support/JSON.h"
 #include <chrono>
 #include <cstddef>
+#include <cstdint>
 #include <memory>
 #include <optional>
 #include <vector>
 
 namespace clang {
 namespace clangd {
 
 /// This class exposes ClangdServer's capabilities via Language Server Protocol.
private:
   LSPBinder::OutgoingNotification<ProgressParams<WorkDoneProgressEnd>>
       EndWorkDoneProgress;
   LSPBinder::OutgoingMethod<NoParams, std::nullptr_t> SemanticTokensRefresh;
 
   void applyEdit(WorkspaceEdit WE, llvm::json::Value Success,
                  Callback<llvm::json::Value> Reply);
 
   void bindMethods(LSPBinder &, const ClientCapabilities &Caps);
-  std::vector<Fix> getFixes(StringRef File, const clangd::Diagnostic &D);
+  std::pair<std::optional<int64_t>, 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;
 
   void applyConfiguration(const ConfigurationSettings &Settings);
private:
   /// Used to indicate that the 'shutdown' request was received from the
   /// Language Server client.
   bool ShutdownRequestReceived = false;
 
   /// Used to indicate the ClangdLSPServer is being destroyed.
   std::atomic<bool> IsBeingDestroyed = {false};
 
   std::mutex FixItsMutex;
   typedef std::map<clangd::Diagnostic, std::vector<Fix>, LSPDiagnosticCompare>
       DiagnosticToReplacementMap;
   /// Caches FixIts per file and diagnostics
-  llvm::StringMap<DiagnosticToReplacementMap> FixItsMap;
+  llvm::StringMap<
+      std::pair</*version*/ std::optional<int64_t>, DiagnosticToReplacementMap>>
+      FixItsMap;
   // Last semantic-tokens response, for incremental requests.
   std::mutex SemanticTokensMutex;
   llvm::StringMap<SemanticTokens> LastSemanticTokens;
 
   // Most code should not deal with Transport, callMethod, notify directly.
   // Use LSPBinder to handle incoming and outgoing calls.
   clangd::Transport &Transp;
   class MessageHandler;
private:
   /// Whether the client supports showing file status.
   bool SupportFileStatus = false;
   /// Whether the client supports attaching a container string to references.
   bool SupportsReferenceContainer = false;
   /// Which kind of markup should we use in textDocument/hover responses.
   MarkupKind HoverContentFormat = MarkupKind::PlainText;
   /// Whether the client supports offsets for parameter info labels.
   bool SupportsOffsetsInSignatureHelp = false;
+  /// Whether the client supports the versioned document changes.
+  bool SupportsDocumentChanges = false;
   std::mutex BackgroundIndexProgressMutex;
   enum class BackgroundIndexProgress {
     // Client doesn't support reporting progress. No transitions possible.
     Unsupported,
     // The queue is idle, and the client has no progress bar.
     // Can transition to Creating when we have some activity.
     Empty,
     // We've requested the client to create a progress bar.

clang-tools-extra/clangd/ClangdLSPServer.cpp

if (Params.capabilities.WorkspaceSymbolKinds)
     SupportedSymbolKinds |= *Params.capabilities.WorkspaceSymbolKinds;
   if (Params.capabilities.CompletionItemKinds)
     SupportedCompletionItemKinds |= *Params.capabilities.CompletionItemKinds;
   SupportsCodeAction = Params.capabilities.CodeActionStructure;
   SupportsHierarchicalDocumentSymbol =
       Params.capabilities.HierarchicalDocumentSymbol;
   SupportsReferenceContainer = Params.capabilities.ReferenceContainer;
   SupportFileStatus = Params.initializationOptions.FileStatus;
+  SupportsDocumentChanges = Params.capabilities.DocumentChanges;
   HoverContentFormat = Params.capabilities.HoverContentFormat;
   Opts.LineFoldingOnly = Params.capabilities.LineFoldingOnly;
   SupportsOffsetsInSignatureHelp = Params.capabilities.OffsetsInSignatureHelp;
   if (Params.capabilities.WorkDoneProgress)
     BackgroundIndexProgressState = BackgroundIndexProgress::Empty;
   BackgroundIndexSkipCreate = Params.capabilities.ImplicitProgressCreation;
   Opts.ImplicitCancellation = !Params.capabilities.CancelsStaleRequests;
   Opts.PublishInactiveRegions = Params.capabilities.InactiveRegions;
auto Action = [this, Reply = std::move(Reply)](
     // When no edit is specified, make sure we Reply().
     if (R->ApplyEdits.empty())
       return Reply("Tweak applied.");
 
     if (auto Err = validateEdits(*Server, R->ApplyEdits))
       return Reply(std::move(Err));
 
     WorkspaceEdit WE;
+    // FIXME: use documentChanges when SupportDocumentChanges is true.
+    WE.changes.emplace();
     for (const auto &It : R->ApplyEdits) {
-      WE.changes[URI::createFile(It.first()).toString()] =
+      (*WE.changes)[URI::createFile(It.first()).toString()] =
           It.second.asTextEdits();
     }
     // ApplyEdit will take care of calling Reply().
     return applyEdit(std::move(WE), "Tweak applied.", std::move(Reply));
   };
   Server->applyTweak(Args.file.file(), Args.selection, Args.tweakID,
                      std::move(Action));
 }
void ClangdLSPServer::onRename(const RenameParams &Params,
   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(*Server, R->GlobalChanges))
                      return Reply(std::move(Err));
                    WorkspaceEdit Result;
+                   // FIXME: use documentChanges if SupportDocumentChanges is
+                   // true.
+                   Result.changes.emplace();
                    for (const auto &Rep : R->GlobalChanges) {
-                     Result.changes[URI::createFile(Rep.first()).toString()] =
+                     (*Result
+                           .changes)[URI::createFile(Rep.first()).toString()] =
                          Rep.second.asTextEdits();
                    }
                    Reply(Result);
                  });
 }
 
 void ClangdLSPServer::onDocumentDidClose(
     const DidCloseTextDocumentParams &Params) {
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));
+      const auto& [Version, Fixes] = getFixes(File.file(), D);
+      for (auto &F : Fixes) {
+        FixIts.push_back(toCodeAction(F, Params.textDocument.uri, Version,
+                                      SupportsDocumentChanges));
         FixIts.back().diagnostics = {D};
       }
     }
   }
 
   // Now enumerate the semantic code actions.
   auto ConsumeActions =
       [Diags = Params.context.diagnostics, Reply = std::move(Reply), File,
bool ClangdLSPServer::run() {
   return CleanExit && ShutdownRequestReceived;
 }
 
 void ClangdLSPServer::profile(MemoryTree &MT) const {
   if (Server)
     Server->profile(MT.child("clangd_server"));
 }
 
-std::vector<Fix> ClangdLSPServer::getFixes(llvm::StringRef File,
-                                           const clangd::Diagnostic &D) {
+std::pair<std::optional<int64_t>, std::vector<Fix>>
+ClangdLSPServer::getFixes(llvm::StringRef File, const clangd::Diagnostic &D) {
   std::lock_guard<std::mutex> Lock(FixItsMutex);
   auto DiagToFixItsIter = FixItsMap.find(File);
   if (DiagToFixItsIter == FixItsMap.end())
     return {};
 
   const auto &DiagToFixItsMap = DiagToFixItsIter->second;
-  auto FixItsIter = DiagToFixItsMap.find(D);
-  if (FixItsIter == DiagToFixItsMap.end())
+  auto FixItsIter = DiagToFixItsMap.second.find(D);
+  if (FixItsIter == DiagToFixItsMap.second.end())
     return {};
 
-  return FixItsIter->second;
+  return {DiagToFixItsMap.first, FixItsIter->second};
 }
 
 // A completion request is sent when the user types '>' or ':', but we only
 // want to trigger on '->' and '::'. We check the preceeding text to make
 // 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.
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
   for (auto &Diag : Diagnostics) {
     toLSPDiags(Diag, Notification.uri, DiagOpts,
                [&](clangd::Diagnostic Diag, llvm::ArrayRef<Fix> Fixes) {
+                 if (DiagOpts.EmbedFixesInDiagnostics && !Fixes.empty()) {
+                   Diag.codeActions.emplace();
+                   for (const auto &Fix : Fixes)
+                     Diag.codeActions->push_back(toCodeAction(
+                         Fix, Notification.uri, Notification.version,
+                         SupportsDocumentChanges));
+                   if (Diag.codeActions->size() == 1)
+                     Diag.codeActions->front().isPreferred = true;
+                 }
                  auto &FixItsForDiagnostic = LocalFixIts[Diag];
                  llvm::copy(Fixes, std::back_inserter(FixItsForDiagnostic));
+
                  Notification.diagnostics.push_back(std::move(Diag));
                });
   }
 
   // Cache FixIts
   {
     std::lock_guard<std::mutex> Lock(FixItsMutex);
-    FixItsMap[File] = LocalFixIts;
+    FixItsMap[File] = {Notification.version, LocalFixIts};
   }
 
   // Send a notification to the LSP client.
   PublishDiagnostics(Notification);
 }
 
 void ClangdLSPServer::onInactiveRegionsReady(
     PathRef File, std::vector<Range> InactiveRegions) {

clang-tools-extra/clangd/Diagnostics.h

 /// separate diagnostics with their corresponding fixits. Notes outside main
 /// file do not have a corresponding LSP diagnostic, but can still be included
 /// as part of their main diagnostic's message.
 void toLSPDiags(
     const Diag &D, const URIForFile &File, const ClangdDiagnosticOptions &Opts,
     llvm::function_ref<void(clangd::Diagnostic, llvm::ArrayRef<Fix>)> OutFn);
 
 /// Convert from Fix to LSP CodeAction.
-CodeAction toCodeAction(const Fix &D, const URIForFile &File);
+CodeAction toCodeAction(const Fix &D, const URIForFile &File,
+                        const std::optional<int64_t> &Version,
+                        bool SupportsDocumentChanges);
 
 /// Convert from clang diagnostic level to LSP severity.
 int getSeverity(DiagnosticsEngine::Level L);
 
 /// Returns a URI providing more information about a particular diagnostic.
 std::optional<std::string> getDiagnosticDocURI(Diag::DiagSource, unsigned ID,
                                                llvm::StringRef Name);
 

clang-tools-extra/clangd/Diagnostics.cpp

for (auto &Fix : D.Fixes) {
       OS << Sep << Fix;
       Sep = ", ";
     }
     OS << "}";
   }
   return OS;
 }
 
-CodeAction toCodeAction(const Fix &F, const URIForFile &File) {
+CodeAction toCodeAction(const Fix &F, const URIForFile &File,
+                        const std::optional<int64_t> &Version,
+                        bool SupportsDocumentChanges) {
   CodeAction Action;
   Action.title = F.Message;
   Action.kind = std::string(CodeAction::QUICKFIX_KIND);
   Action.edit.emplace();
-  Action.edit->changes[File.uri()] = {F.Edits.begin(), F.Edits.end()};
+  if (!SupportsDocumentChanges) {
+    Action.edit->changes.emplace();
+    (*Action.edit->changes)[File.uri()] = {F.Edits.begin(), F.Edits.end()};
+  } else {
+    Action.edit->documentChanges.emplace();
+    TextDocumentEdit& Edit = Action.edit->documentChanges->emplace_back();
+    Edit.textDocument = VersionedTextDocumentIdentifier{{File}, Version};
+    Edit.edits = {F.Edits.begin(), F.Edits.end()};
+  }
   return Action;
 }
 
 Diag toDiag(const llvm::SMDiagnostic &D, Diag::DiagSource Source) {
   Diag Result;
   Result.Message = D.getMessage().str();
   switch (D.getKind()) {
   case llvm::SourceMgr::DK_Error:
case Diag::Clangd:
     Main.source = "clangd";
     break;
   case Diag::ClangdConfig:
     Main.source = "clangd-config";
     break;
   case Diag::Unknown:
     break;
   }
-  if (Opts.EmbedFixesInDiagnostics) {
-    Main.codeActions.emplace();
-    for (const auto &Fix : D.Fixes)
-      Main.codeActions->push_back(toCodeAction(Fix, File));
-    if (Main.codeActions->size() == 1)
-      Main.codeActions->front().isPreferred = true;
-  }
   if (Opts.SendDiagnosticCategory && !D.Category.empty())
     Main.category = D.Category;
 
   Main.message = mainMessage(D, Opts);
   if (Opts.EmitRelatedLocations) {
     Main.relatedInformation.emplace();
     for (auto &Note : D.Notes) {
       if (!Note.AbsFile) {

clang-tools-extra/clangd/Protocol.h

 };
 inline bool operator==(const TextEdit &L, const TextEdit &R) {
   return std::tie(L.newText, L.range) == std::tie(R.newText, R.range);
 }
 bool fromJSON(const llvm::json::Value &, TextEdit &, llvm::json::Path);
 llvm::json::Value toJSON(const TextEdit &);
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const TextEdit &);
 
+struct TextDocumentEdit {
+  /// The text document to change.
+  VersionedTextDocumentIdentifier textDocument;
+
+  /// The edits to be applied.
+  /// FIXME: support the AnnotatedTextEdit variant.
+  std::vector<TextEdit> edits;
+};
+bool fromJSON(const llvm::json::Value &, TextDocumentEdit &, llvm::json::Path);
+llvm::json::Value toJSON(const TextDocumentEdit &);
+
 struct TextDocumentItem {
   /// The text document's URI.
   URIForFile uri;
 
   /// The text document's language identifier.
   std::string languageId;
 
   /// The version number of this document (it will strictly increase after each
struct ClientCapabilities {
   /// Whether the client claims to cancel stale requests.
   /// general.staleRequestSupport.cancel
   bool CancelsStaleRequests = false;
 
   /// Whether the client implementation supports a refresh request sent from the
   /// server to the client.
   bool SemanticTokenRefreshSupport = false;
 
+  /// The client supports versioned document changes for WorkspaceEdit.
+  bool DocumentChanges = false;
+
   /// Whether the client supports the textDocument/inactiveRegions
   /// notification. This is a clangd extension.
   bool InactiveRegions = false;
 };
 bool fromJSON(const llvm::json::Value &, ClientCapabilities &,
               llvm::json::Path);
 
 /// Clangd extension that's used in the 'compilationDatabaseChanges' in
struct CodeActionParams {
   /// The range for which the command was invoked.
   Range range;
 
   /// Context carrying additional information.
   CodeActionContext context;
 };
 bool fromJSON(const llvm::json::Value &, CodeActionParams &, llvm::json::Path);
 
+/// The edit should either provide changes or documentChanges. If the client
+/// can handle versioned document edits and if documentChanges are present,
+/// the latter are preferred over changes.
 struct WorkspaceEdit {
   /// Holds changes to existing resources.
-  std::map<std::string, std::vector<TextEdit>> changes;
-
-  /// Note: "documentChanges" is not currently used because currently there is
-  /// no support for versioned edits.
+  std::optional<std::map<std::string, std::vector<TextEdit>>> changes;
+  /// Versioned document edits.
+  ///
+  /// If a client neither supports `documentChanges` nor
+  /// `workspace.workspaceEdit.resourceOperations` then only plain `TextEdit`s
+  /// using the `changes` property are supported.
+  std::optional<std::vector<TextDocumentEdit>> documentChanges;
 };
 bool fromJSON(const llvm::json::Value &, WorkspaceEdit &, llvm::json::Path);
 llvm::json::Value toJSON(const WorkspaceEdit &WE);
 
 /// Arguments for the 'applyTweak' command. The server sends these commands as a
 /// response to the textDocument/codeAction request. The client can later send a
 /// command back to the server if the user requests to execute a particular code
 /// tweak.

clang-tools-extra/clangd/Protocol.cpp

 
 llvm::json::Value toJSON(const TextEdit &P) {
   return llvm::json::Object{
       {"range", P.range},
       {"newText", P.newText},
   };
 }
 
+bool fromJSON(const llvm::json::Value &Params, TextDocumentEdit &R,
+              llvm::json::Path P) {
+  llvm::json::ObjectMapper O(Params, P);
+  return O && O.map("textDocument", R.textDocument) && O.map("edits", R.edits);
+}
+llvm::json::Value toJSON(const TextDocumentEdit &P) {
+  llvm::json::Object Result{{"textDocument", P.textDocument},
+                            {"edits", P.edits}};
+  return Result;
+}
+
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const TextEdit &TE) {
   OS << TE.range << " => \"";
   llvm::printEscapedString(TE.newText, OS);
   return OS << '"';
 }
 
 bool fromJSON(const llvm::json::Value &E, TraceLevel &Out, llvm::json::Path P) {
   if (auto S = E.getAsString()) {
if (auto *Symbol = Workspace->getObject("symbol")) {
             return false;
         }
       }
     }
     if (auto *SemanticTokens = Workspace->getObject("semanticTokens")) {
       if (auto RefreshSupport = SemanticTokens->getBoolean("refreshSupport"))
         R.SemanticTokenRefreshSupport = *RefreshSupport;
     }
+    if (auto *WorkspaceEdit = Workspace->getObject("workspaceEdit")) {
+      if (auto DocumentChanges = WorkspaceEdit->getBoolean("documentChanges"))
+        R.DocumentChanges = *DocumentChanges;
+    }
   }
   if (auto *Window = O->getObject("window")) {
     if (auto WorkDoneProgress = Window->getBoolean("workDoneProgress"))
       R.WorkDoneProgress = *WorkDoneProgress;
     if (auto Implicit = Window->getBoolean("implicitWorkDoneProgressCreate"))
       R.ImplicitProgressCreation = *Implicit;
   }
   if (auto *General = O->getObject("general")) {
bool fromJSON(const llvm::json::Value &Params, CodeActionParams &R,
   llvm::json::ObjectMapper O(Params, P);
   return O && O.map("textDocument", R.textDocument) &&
          O.map("range", R.range) && O.map("context", R.context);
 }
 
 bool fromJSON(const llvm::json::Value &Params, WorkspaceEdit &R,
               llvm::json::Path P) {
   llvm::json::ObjectMapper O(Params, P);
-  return O && O.map("changes", R.changes);
+  return O && O.map("changes", R.changes) && O.map("documentChanges", R.documentChanges);
 }
 
 bool fromJSON(const llvm::json::Value &Params, ExecuteCommandParams &R,
               llvm::json::Path P) {
   llvm::json::ObjectMapper O(Params, P);
   if (!O || !O.map("command", R.command))
     return false;
 
if (!S.children.empty())
     Result["children"] = S.children;
   if (S.deprecated)
     Result["deprecated"] = true;
   // FIXME: workaround for older gcc/clang
   return std::move(Result);
 }
 
 llvm::json::Value toJSON(const WorkspaceEdit &WE) {
+  llvm::json::Object Result;
+  if (WE.changes) {
     llvm::json::Object FileChanges;
-  for (auto &Change : WE.changes)
+    for (auto &Change : *WE.changes)
       FileChanges[Change.first] = llvm::json::Array(Change.second);
-  return llvm::json::Object{{"changes", std::move(FileChanges)}};
+    Result["changes"] = std::move(FileChanges);
+  }
+  if (WE.documentChanges)
+    Result["documentChanges"] = *WE.documentChanges;
+  return Result;
 }
 
 bool fromJSON(const llvm::json::Value &Params, TweakArgs &A,
               llvm::json::Path P) {
   llvm::json::ObjectMapper O(Params, P);
   return O && O.map("file", A.file) && O.map("selection", A.selection) &&
          O.map("tweakID", A.tweakID);
 }