[clangd] Add batch fixes for include-cleaner diagnostics

[hokein]

Summary

For each unused-include/missing-include diagnostic, we provide fix-all
alternative to them.

[hokein]

The UI in VSCode looks like

• unused-include:

• missing-include:

[kadircet]

clang-tools-extra/clangd/IncludeCleaner.cpp

424

can we also derive these from an llvm::ArrayRef<Diag> ? to make sure there can't be a discrepancy between sum of these and individual unused include fixes

426

i think we should drop # (same for add all case)

440

rather than copying all the fixes and then sorting/deleting them, can we have a map here to make sure we're copying only 1 edit per Edit::newText ?

457

what if there's none? (same for add all)

464

again fixall shouldn't be attached if either of the sets is empty

464

this is quite wordy, what about just fix includes ?

[hokein]

• address review comments
• add LSP's ChangeAnnotations support and use it in the include-cleaner batch fix

[hokein]

some cleanups.

[hokein]

I have extended this patch a bit more (including the LSP ChangeAnnotation support part), it is based on https://reviews.llvm.org/D148783), and it implements a full workflow of batch fixes (verified it with VSCode). I hope it is not too big to review, happy to split it if you want.

[kadircet]

can you also add test coverage for the new LSP fields?

clang-tools-extra/clangd/IncludeCleaner.cpp

439

nit: E.annotationId.emplace(RemoveAllUnusedID); (same for others)

443

rather than an empty label, let's duplicate RemoveAll.Message here. As that context will probably be lost after executing the code action.

464

i think you want to populate AddAllMissing.Edits from Edits first

468

unless we want a really wordy description, this would actually require us to attach one annotation per edit, rather than using the same annotation for all the edits.
can you check what changes in the UI when we have multiple annotations for a single workspace edit?

484

again let's use FixAll.Message as label

493

can you declare these right before their use sides, rather than on the same line?

496

UnusedIncludes.size() > 1

501

MissingIncludeDiags.size() > 1

clang-tools-extra/clangd/Protocol.h

253

rather than packing up a new field here, can we have a struct AnnotatedTextEdit : TextEdit ?

it's surely more convenient this way but creates some confusion in call sites that're trying to create a regular textedit.

also we can use the empty string again, no need for optional.

264

nit: triple slashes, here and elsewhere

274

no need for optional here, we can use the empty string

1027

i don't think there's any difference between an empty map and a nullopt here, right?

[hokein]

address review comments:

• emit one annotation per textedit;
• remove unnecessary std::optional in the protocol structure
• add a lit test

[hokein]

more cleanup

clang-tools-extra/clangd/IncludeCleaner.cpp

443

I don't see much value on setting the label the the RemoveAll message (the preview window shows the content diff, it is clear enough for users to understand the purpose by viewing the diff).

And since we use one annotation per edit, the RemoveAll message doesn't seem to suit anymore.

464

oops, good catch!

468

as discussed, there is not UI difference (at least in VSCode) between these two, but we should swich to one annotation per edit (since the UI is based on the annotation, and we want each edit is controlled by the user).

[kadircet]

clang-tools-extra/clangd/IncludeCleaner.cpp

443

I don't see much value on setting the label the the RemoveAll message (the preview window shows the content diff, it is clear enough for users to understand the purpose by viewing the diff).

i think you're focusing too much on the way VSCode chooses to implement this interaction.

Showing the diff in the edit panel is a strategy chosen by VSCode, not per LSP. Spec indicates label as A human-readable string describing the actual change. The string is rendered prominent in the user interface.. So there's a good chance an editor might chose to just display the label. This makes even more sense especially when changes are complicated and don't fit a single line.

And since we use one annotation per edit, the RemoveAll message doesn't seem to suit anymore.

Right, but we actually now have the opportunity to describe each fix properly. We can change the fix message we generate in generateUnusedIncludeDiagnostics to contain proper include and use them as annotation labels instead. We already have the logic inside Diagnostics.cpp to synthesize messages for fixes (this would also unify the behaviour), i think we should re-use it here by exposing it in diagnostics.h. WDYT?

463

similar to above, let's at least mention the fix properly in label.

471

nit: you can std::move(It.getValue()) if you drop the const from It.

481

why are we creating new annotations here? rather than just merging everything from RemoveAllUnused and AddAllMissing ?

clang-tools-extra/clangd/Protocol.h

253

despite keeping this one as-is, we still don't need to optional, right?

[hokein]

address comments.

[hokein]

fix the lit-test uri path on windows

clang-tools-extra/clangd/IncludeCleaner.cpp

443

Thanks, the plan sounds good to me. As discussed, I will address it in a followup patch (added a FIXME here).

481

right, we can do that, it is simpler.

clang-tools-extra/clangd/Protocol.h

253

right, I missed this field when updating other fields.

[kadircet]

thanks!

clang-tools-extra/clangd/ClangdLSPServer.h

private:
   /// 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;
+  /// Whether the client supports change annotations on text edits.
+  bool SupportsChangeAnnotation = 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

CodeAction toCodeAction(const ClangdServer::TweakRef &T, const URIForFile &File,
   Args.selection = Selection;
   CA.command->argument = std::move(Args);
   return CA;
 }
 
 /// Convert from Fix to LSP CodeAction.
 CodeAction toCodeAction(const Fix &F, const URIForFile &File,
                         const std::optional<int64_t> &Version,
-                        bool SupportsDocumentChanges) {
+                        bool SupportsDocumentChanges,
+                        bool SupportChangeAnnotation) {
   CodeAction Action;
   Action.title = F.Message;
   Action.kind = std::string(CodeAction::QUICKFIX_KIND);
   Action.edit.emplace();
   if (!SupportsDocumentChanges) {
     Action.edit->changes.emplace();
-    (*Action.edit->changes)[File.uri()] = {F.Edits.begin(), F.Edits.end()};
+    auto &Changes = (*Action.edit->changes)[File.uri()];
+    for (const auto &E : F.Edits)
+      Changes.push_back({E.range, E.newText, /*annotationId=*/std::nullopt});
   } else {
     Action.edit->documentChanges.emplace();
-    TextDocumentEdit& Edit = Action.edit->documentChanges->emplace_back();
+    TextDocumentEdit &Edit = Action.edit->documentChanges->emplace_back();
     Edit.textDocument = VersionedTextDocumentIdentifier{{File}, Version};
-    Edit.edits = {F.Edits.begin(), F.Edits.end()};
+    for (const auto &E : F.Edits)
+      Edit.edits.push_back(
+          {E.range, E.newText,
+           SupportChangeAnnotation ? E.annotationId : std::nullopt});
+    if (SupportChangeAnnotation) {
+      Action.edit->changeAnnotations.emplace();
+      for (const auto &[AID, Annotation]: F.Annotations)
+        (*Action.edit->changeAnnotations)[AID] = Annotation;
+    }
   }
   return Action;
 }
 
 void adjustSymbolKinds(llvm::MutableArrayRef<DocumentSymbol> Syms,
                        SymbolKindBitset Kinds) {
   for (auto &S : Syms) {
     S.kind = adjustKindToCapability(S.kind, Kinds);
void ClangdLSPServer::onInitialize(const InitializeParams &Params,
   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;
+  SupportsChangeAnnotation = Params.capabilities.ChangeAnnotation;
   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;
void ClangdLSPServer::onDiagnosticsReady(PathRef File, llvm::StringRef Version,
   DiagnosticToReplacementMap LocalFixIts; // Temporary storage
   for (auto &Diag : Diagnostics) {
     toLSPDiags(Diag, Notification.uri, DiagOpts,
                [&](clangd::Diagnostic Diag, llvm::ArrayRef<Fix> Fixes) {
                  std::vector<CodeAction> CodeActions;
                  for (const auto &Fix : Fixes)
                    CodeActions.push_back(toCodeAction(Fix, Notification.uri,
                                                       Notification.version,
-                                                      SupportsDocumentChanges));
+                                                      SupportsDocumentChanges,
+                                                      SupportsChangeAnnotation));
 
                  if (DiagOpts.EmbedFixesInDiagnostics && !CodeActions.empty()) {
                    Diag.codeActions.emplace(CodeActions);
                    if (Diag.codeActions->size() == 1)
                      Diag.codeActions->front().isPreferred = true;
                  }
                  auto &FixItsForDiagnostic = LocalFixIts[Diag];
                  llvm::move(std::move(CodeActions),

clang-tools-extra/clangd/Diagnostics.h

 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const DiagBase &D);
 
 /// Represents a single fix-it that editor can apply to fix the error.
 struct Fix {
   /// Message for the fix-it.
   std::string Message;
   /// TextEdits from clang's fix-its. Must be non-empty.
   llvm::SmallVector<TextEdit, 1> Edits;
+
+  /// Annotations for the Edits.
+  llvm::SmallVector<std::pair<ChangeAnnotationIdentifier, ChangeAnnotation>>
+      Annotations;
 };
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Fix &F);
 
 /// Represents a note for the diagnostic. Severity of notes can only be 'note'
 /// or 'remark'.
 struct Note : DiagBase {};
 
 /// A top-level diagnostic that may have Notes and Fixes.

clang-tools-extra/clangd/IncludeCleaner.cpp

 #include "clang/Tooling/Inclusions/StandardLibrary.h"
 #include "clang/Tooling/Syntax/Tokens.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/STLFunctionalExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Regex.h"
include_cleaner::walkUsed(
             Ref.Target, TouchingTokens.back().range(SM), Providers};
         MissingIncludes.push_back(std::move(DiagInfo));
       });
   std::vector<const Inclusion *> UnusedIncludes =
       getUnused(AST, Used, /*ReferencedPublicHeaders*/ {});
   return {std::move(UnusedIncludes), std::move(MissingIncludes)};
 }
 
+Fix removeAllUnusedIncludes(llvm::ArrayRef<Diag> UnusedIncludes) {
+  assert(!UnusedIncludes.empty());
+
+  Fix RemoveAll;
+  RemoveAll.Message = "remove all unused includes";
+  for (const auto &Diag : UnusedIncludes) {
+    assert(Diag.Fixes.size() == 1 && "Expected exactly one fix.");
+    RemoveAll.Edits.insert(RemoveAll.Edits.end(),
+         Diag.Fixes.front().Edits.begin(),
+         Diag.Fixes.front().Edits.end());
+  }
+
+  static const ChangeAnnotationIdentifier RemoveAllUnusedID =
+      "RemoveAllUnusedIncludes";
+  for (auto &E : RemoveAll.Edits) {
+    E.annotationId.emplace();
+    *E.annotationId = RemoveAllUnusedID;
+  }
+  RemoveAll.Annotations.push_back({RemoveAllUnusedID,
+                                   {/*label=*/"", /*needsConfirmation=*/true,
+                                    /*description=*/std::nullopt}});
+  return RemoveAll;
+}
+Fix addAllMissingIncludes(llvm::ArrayRef<Diag> MissingIncludeDiags) {
+  assert(!MissingIncludeDiags.empty());
+
+  Fix AddAllMissing;
+  AddAllMissing.Message = "add all missing includes";
+  // A map to deduplicate the edits with the same new text.
+  // newText (#include "my_missing_header.h") -> TextEdit.
+  llvm::StringMap<TextEdit> Edits;
+  for (const auto &Diag : MissingIncludeDiags) {
+    assert(Diag.Fixes.size() == 1 && "Expected exactly one fix.");
+    for (const auto& Edit : Diag.Fixes.front().Edits) {
+      Edits.try_emplace(Edit.newText, Edit);
+    }
+  }
+
+  static const ChangeAnnotationIdentifier AddAllMissingID =
+      "AddAllMissingIncludes";
+  for (auto &E : AddAllMissing.Edits) {
+    E.annotationId.emplace();
+    *E.annotationId = AddAllMissingID;
+  }
+  // FIXME(hokein): emit used symbol reference in the annotation.
+  AddAllMissing.Annotations.push_back(
+      {AddAllMissingID,
+       {/*label=*/"", /*needsConfirmation=*/true,
+        /*description=*/std::nullopt}});
+  return AddAllMissing;
+}
+Fix fixAll(const Fix& RemoveAllUnused, const Fix& AddAllMissing) {
+  Fix FixAll;
+  FixAll.Message = "Fix all includes";
+  static const ChangeAnnotationIdentifier FixAllID = "FixAll";
+  for (const auto& F : RemoveAllUnused.Edits)
+    FixAll.Edits.push_back({F.range, F.newText, FixAllID});
+  for (const auto& F : AddAllMissing.Edits)
+    FixAll.Edits.push_back({F.range, F.newText, FixAllID});
+  FixAll.Annotations.push_back({FixAllID, {
+    /*label=*/"", /*needsConfirmation=*/true, /*description=*/std::nullopt
+  }});
+
+  return FixAll;
+}
+
+std::vector<Diag> generateIncludeCleanerDiagnostic(
+    ParsedAST &AST, const IncludeCleanerFindings &Findings,
+    llvm::StringRef Code) {
+  std::optional<Fix> RemoveAllUnused, AddAllMissing, FixAll;
+  std::vector<Diag> UnusedIncludes = generateUnusedIncludeDiagnostics(
+      AST.tuPath(), Findings.UnusedIncludes, Code);
+  if (!UnusedIncludes.empty())
+    RemoveAllUnused = removeAllUnusedIncludes(UnusedIncludes);
+
+  std::vector<Diag> MissingIncludeDiags = generateMissingIncludeDiagnostics(
+      AST, Findings.MissingIncludes, Code);
+  if (!MissingIncludeDiags.empty())
+    AddAllMissing = addAllMissingIncludes(MissingIncludeDiags);
+
+  if (RemoveAllUnused && AddAllMissing)
+    FixAll = fixAll(*RemoveAllUnused, *AddAllMissing);
+
+  auto AddBatchFix = [](const std::optional<Fix> &F, clang::clangd::Diag *Out) {
+    if (!F) return;
+    Out->Fixes.push_back(*F);
+  };
+  for (auto &Diag : MissingIncludeDiags) {
+    AddBatchFix(AddAllMissing, &Diag);
+    AddBatchFix(FixAll, &Diag);
+  }
+  for (auto &Diag : UnusedIncludes) {
+    AddBatchFix(RemoveAllUnused, &Diag);
+    AddBatchFix(FixAll, &Diag);
+  }
+
+  auto Result = std::move(MissingIncludeDiags);
+  llvm::move(UnusedIncludes,
+             std::back_inserter(Result));
+  return Result;
+}
+
 std::vector<Diag> issueIncludeCleanerDiagnostics(ParsedAST &AST,
                                                  llvm::StringRef Code) {
   // Interaction is only polished for C/CPP.
   if (AST.getLangOpts().ObjC)
     return {};
 
   trace::Span Tracer("IncludeCleaner::issueIncludeCleanerDiagnostics");
 
   const Config &Cfg = Config::current();
   IncludeCleanerFindings Findings;
   if (Cfg.Diagnostics.MissingIncludes == Config::IncludesPolicy::Strict ||
       Cfg.Diagnostics.UnusedIncludes == Config::IncludesPolicy::Strict) {
     // will need include-cleaner results, call it once
     Findings = computeIncludeCleanerFindings(AST);
   }
-
-  std::vector<Diag> Result = generateUnusedIncludeDiagnostics(
-      AST.tuPath(), Findings.UnusedIncludes, Code);
-  llvm::move(
-      generateMissingIncludeDiagnostics(AST, Findings.MissingIncludes, Code),
-      std::back_inserter(Result));
-  return Result;
+  return generateIncludeCleanerDiagnostic(AST, Findings, Code);
 }
 
 std::optional<include_cleaner::Header>
 firstMatchedProvider(const include_cleaner::Includes &Includes,
                      llvm::ArrayRef<include_cleaner::Header> Providers) {
   for (const auto &H : Providers) {
     if (!Includes.match(H).empty())
       return H;
   }
   // No match for this provider in the includes list.
   return std::nullopt;
 }
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/Protocol.h

 struct ReferenceLocation : Location {
   /// clangd extension: contains the name of the function or class in which the
   /// reference occurs
   std::optional<std::string> containerName;
 };
 llvm::json::Value toJSON(const ReferenceLocation &);
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const ReferenceLocation &);
 
+using ChangeAnnotationIdentifier = std::string;
+// A combination of a LSP standard TextEdit and AnnotatedTextEdit.
 struct TextEdit {
   /// The range of the text document to be manipulated. To insert
   /// text into a document create a range where start === end.
   Range range;
 
   /// The string to be inserted. For delete operations use an
   /// empty string.
   std::string newText;
+
+  /// The actual annotation identifier.
+  std::optional<ChangeAnnotationIdentifier> annotationId = std::nullopt;
 };
 inline bool operator==(const TextEdit &L, const TextEdit &R) {
-  return std::tie(L.newText, L.range) == std::tie(R.newText, R.range);
+  return std::tie(L.newText, L.range, L.annotationId) ==
+         std::tie(R.newText, R.range, L.annotationId);
 }
 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 ChangeAnnotation {
+  // A human-readable string describing the actual change. The string
+  // is rendered prominent in the user interface.
+  std::string label;
+
+  // A flag which indicates that user confirmation is needed
+  // before applying the change.
+  std::optional<bool> needsConfirmation;
+
+  // A human-readable string which is rendered less prominent in
+  // the user interface.
+  std::optional<std::string> description;
+};
+bool fromJSON(const llvm::json::Value &, ChangeAnnotation &, llvm::json::Path);
+llvm::json::Value toJSON(const ChangeAnnotation &);
+
 struct TextDocumentEdit {
   /// The text document to change.
   VersionedTextDocumentIdentifier textDocument;
 
   /// The edits to be applied.
   /// FIXME: support the AnnotatedTextEdit variant.
   std::vector<TextEdit> edits;
 };
struct ClientCapabilities {
   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;
   
+  /// The client supports change annotations on text edits,
+  bool ChangeAnnotation = 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 WorkspaceEdit {
   /// Holds changes to existing resources.
   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;
+  
+  /// A map of change annotations that can be referenced in
+  /// AnnotatedTextEdit.
+  std::optional<std::map<std::string, ChangeAnnotation>> changeAnnotations;
 };
 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

bool fromJSON(const llvm::json::Value &Params, TextDocumentItem &R,
   llvm::json::ObjectMapper O(Params, P);
   return O && O.map("uri", R.uri) && O.map("languageId", R.languageId) &&
          O.map("version", R.version) && O.map("text", R.text);
 }
 
 bool fromJSON(const llvm::json::Value &Params, TextEdit &R,
               llvm::json::Path P) {
   llvm::json::ObjectMapper O(Params, P);
-  return O && O.map("range", R.range) && O.map("newText", R.newText);
+  return O && O.map("range", R.range) && O.map("newText", R.newText) &&
+         O.map("annotationId", R.annotationId);
 }
 
 llvm::json::Value toJSON(const TextEdit &P) {
-  return llvm::json::Object{
+  llvm::json::Object Result{
       {"range", P.range},
       {"newText", P.newText},
   };
+  if (P.annotationId)
+    Result["annotationId"] = P.annotationId;
+  return Result;
+}
+
+bool fromJSON(const llvm::json::Value &Params, ChangeAnnotation &R,
+              llvm::json::Path P) {
+  llvm::json::ObjectMapper O(Params, P);
+  return O && O.map("label", R.label) &&
+         O.map("needsConfirmation", R.needsConfirmation) &&
+         O.map("description", R.description);
+}
+llvm::json::Value toJSON(const ChangeAnnotation & CA) {
+  llvm::json::Object Result{{"label", CA.label}};
+  if (CA.needsConfirmation)
+    Result["needsConfirmation"] = *CA.needsConfirmation;
+  if (CA.description)
+    Result["description"] = *CA.description;
+  return Result;
 }
 
 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) {
if (auto *Workspace = O->getObject("workspace")) {
     }
     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 (const auto& ChangeAnnotation =
+              WorkspaceEdit->getObject("changeAnnotationSupport")) {
+        R.ChangeAnnotation = true;
+      }
     }
   }
   if (auto *Window = O->getObject("window")) {
     if (auto WorkDoneProgress = Window->getBoolean("workDoneProgress"))
       R.WorkDoneProgress = *WorkDoneProgress;
     if (auto Implicit = Window->getBoolean("implicitWorkDoneProgressCreate"))
       R.ImplicitProgressCreation = *Implicit;
   }
bool fromJSON(const llvm::json::Value &Params, CodeActionParams &R,
   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) &&
-         O.map("documentChanges", R.documentChanges);
+         O.map("documentChanges", R.documentChanges) &&
+         O.map("changeAnnotations", R.changeAnnotations);
 }
 
 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;
 
llvm::json::Value toJSON(const WorkspaceEdit &WE) {
   if (WE.changes) {
     llvm::json::Object FileChanges;
     for (auto &Change : *WE.changes)
       FileChanges[Change.first] = llvm::json::Array(Change.second);
     Result["changes"] = std::move(FileChanges);
   }
   if (WE.documentChanges)
     Result["documentChanges"] = *WE.documentChanges;
+  if (WE.changeAnnotations) {
+    llvm::json::Object ChangeAnnotations;
+    for (auto &Annotation : *(WE.changeAnnotations))
+      ChangeAnnotations[Annotation.first] = Annotation.second;
+    Result["changeAnnotations"] = std::move(ChangeAnnotations);
+  }
   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);

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

]]
   Cfg.Diagnostics.UnusedIncludes = Config::IncludesPolicy::Strict;
   // Set filtering.
   Cfg.Diagnostics.Includes.IgnoreHeader.emplace_back(
       [](llvm::StringRef Header) { return Header.endswith("ignore.h"); });
   WithContextValue WithCfg(Config::Key, std::move(Cfg));
   auto AST = TU.build();
   EXPECT_THAT(
       *AST.getDiagnostics(),
-      UnorderedElementsAre(AllOf(
-          Diag(Test.range("diag"),
+      UnorderedElementsAre(
+          AllOf(Diag(Test.range("diag"),
                      "included header unused.h is not used directly"),
                 withTag(DiagnosticTag::Unnecessary), diagSource(Diag::Clangd),
-          withFix(Fix(Test.range("fix"), "", "remove #include directive")))));
+                withFix(Fix(Test.range("fix"), "", "remove #include directive"),
+                        fixMessage("remove all unused includes")))));
   auto &Diag = AST.getDiagnostics()->front();
   EXPECT_EQ(getDiagnosticDocURI(Diag.Source, Diag.ID, Diag.Name),
             std::string("https://clangd.llvm.org/guides/include-cleaner"));
   Cfg.Diagnostics.SuppressAll = true;
   WithContextValue SuppressAllWithCfg(Config::Key, std::move(Cfg));
   EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
   Cfg.Diagnostics.SuppressAll = false;
   Cfg.Diagnostics.Suppress = {"unused-includes"};

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

 
 using ::testing::AllOf;
 using ::testing::ElementsAre;
 using ::testing::IsEmpty;
 using ::testing::Matcher;
 using ::testing::Pointee;
 using ::testing::UnorderedElementsAre;
 
-Matcher<const Diag &> withFix(::testing::Matcher<Fix> FixMatcher) {
-  return Field(&Diag::Fixes, ElementsAre(FixMatcher));
+Matcher<const Diag &> withFix(std::vector<::testing::Matcher<Fix>> FixMatcheres) {
+  return Field(&Diag::Fixes, testing::UnorderedElementsAreArray(FixMatcheres));
 }
 
 MATCHER_P2(Diag, Range, Message,
            "Diag at " + llvm::to_string(Range) + " = [" + Message + "]") {
   return arg.Range == Range && arg.Message == Message;
 }
 
 MATCHER_P3(Fix, Range, Replacement, Message,
            "Fix " + llvm::to_string(Range) + " => " +
                ::testing::PrintToString(Replacement) + " = [" + Message + "]") {
   return arg.Message == Message && arg.Edits.size() == 1 &&
          arg.Edits[0].range == Range && arg.Edits[0].newText == Replacement;
 }
+MATCHER_P(FixMessage, Message, "") { return arg.Message == Message; }
+
 
 std::string guard(llvm::StringRef Code) {
   return "#pragma once\n" + Code.str();
 }
 
 MATCHER_P(writtenInclusion, Written, "") {
   if (arg.Written != Written)
     *result_listener << arg.Written;
#define BAZ(X) const X x
 
   std::vector<clangd::Diag> Diags =
       issueIncludeCleanerDiagnostics(AST, TU.Code);
   EXPECT_THAT(
       Diags,
       UnorderedElementsAre(
           AllOf(Diag(MainFile.range("b"),
                      "No header providing \"b\" is directly included"),
-                withFix(Fix(MainFile.range("insert_b"), "#include \"b.h\"\n",
-                            "#include \"b.h\""))),
+                withFix({Fix(MainFile.range("insert_b"), "#include \"b.h\"\n",
+                             "#include \"b.h\""),
+                         FixMessage("add all missing includes")})),
           AllOf(Diag(MainFile.range("bar"),
                      "No header providing \"ns::Bar\" is directly included"),
-                withFix(Fix(MainFile.range("insert_d"),
-                            "#include \"dir/d.h\"\n", "#include \"dir/d.h\""))),
+                withFix({Fix(MainFile.range("insert_d"),
+                             "#include \"dir/d.h\"\n", "#include \"dir/d.h\""),
+                         FixMessage("add all missing includes")})),
           AllOf(Diag(MainFile.range("f"),
                      "No header providing \"f\" is directly included"),
-                withFix(Fix(MainFile.range("insert_f"), "#include <f.h>\n",
-                            "#include <f.h>"))),
+                withFix({Fix(MainFile.range("insert_f"), "#include <f.h>\n",
+                             "#include <f.h>"),
+                         FixMessage("add all missing includes")})),
           AllOf(
               Diag(MainFile.range("foobar"),
                    "No header providing \"foobar\" is directly included"),
-              withFix(Fix(MainFile.range("insert_foobar"),
-                          "#include \"public.h\"\n", "#include \"public.h\""))),
+              withFix({Fix(MainFile.range("insert_foobar"),
+                           "#include \"public.h\"\n", "#include \"public.h\""),
+                       FixMessage("add all missing includes")})),
           AllOf(
               Diag(MainFile.range("vector"),
                    "No header providing \"std::vector\" is directly included"),
-              withFix(Fix(MainFile.range("insert_vector"),
-                          "#include <vector>\n", "#include <vector>"))),
+              withFix({Fix(MainFile.range("insert_vector"),
+                           "#include <vector>\n", "#include <vector>"),
+                       FixMessage("add all missing includes"),})),
           AllOf(Diag(MainFile.range("FOO"),
                      "No header providing \"FOO\" is directly included"),
-                withFix(Fix(MainFile.range("insert_foo"),
-                            "#include \"foo.h\"\n", "#include \"foo.h\""))),
+                withFix({Fix(MainFile.range("insert_foo"),
+                             "#include \"foo.h\"\n", "#include \"foo.h\""),
+                         FixMessage("add all missing includes")})),
           AllOf(Diag(MainFile.range("DEF"),
                      "No header providing \"Foo\" is directly included"),
-                withFix(Fix(MainFile.range("insert_foo"),
-                            "#include \"foo.h\"\n", "#include \"foo.h\""))),
+                withFix({Fix(MainFile.range("insert_foo"),
+                             "#include \"foo.h\"\n", "#include \"foo.h\""),
+                         FixMessage("add all missing includes")})),
           AllOf(Diag(MainFile.range("BAR"),
                      "No header providing \"BAR\" is directly included"),
-                withFix(Fix(MainFile.range("insert_foo"),
-                            "#include \"foo.h\"\n", "#include \"foo.h\""))),
+                withFix({Fix(MainFile.range("insert_foo"),
+                             "#include \"foo.h\"\n", "#include \"foo.h\""),
+                         FixMessage("add all missing includes")})),
           AllOf(Diag(MainFile.range("Foo"),
                      "No header providing \"Foo\" is directly included"),
-                withFix(Fix(MainFile.range("insert_foo"),
-                            "#include \"foo.h\"\n", "#include \"foo.h\"")))));
+                withFix({Fix(MainFile.range("insert_foo"),
+                             "#include \"foo.h\"\n", "#include \"foo.h\""),
+                         FixMessage("add all missing includes")}))));
 }
 
 TEST(IncludeCleaner, IWYUPragmas) {
   TestTU TU;
   TU.Code = R"cpp(
     #include "behind_keep.h" // IWYU pragma: keep
     #include "exported.h" // IWYU pragma: export
     #include "public.h"