[clangd] Emit ChangeAnnotation label and description for include-cleaner diagnostics.

[hokein]

VSCode UI:

• missing-include

• unused-include

[kadircet]

clang-tools-extra/clangd/IncludeCleaner.cpp

529–530

i think rather than a single diag info, we should actually store a set of them now, right? as we want to surface not only the "first" use of a header, but all. (possibly with some trimming).

529–530

what about just taking in llvm::ArrayRef<const Inclusion *> UnusedIncludes and having a TextEdit dropInclude(const Inclusion&); that we can use in here & inside generateUnusedIncludeDiagnostics? That way we can just use the spelling inside the inclusion to generate the label, without all the extra logic.

540

i don't think line information is as useful (as there's no structured link to it). what about something like:

label: `Include "foo.h"`
description: `Provides 'X', 'Y', 'Z', ...`

548

sorry for missing it during last review, but this should actually be if (!UnusedIncludes.empty() && !MissingIncludeDiags.empty()) as even if we have only 1 fix for each category, we should still show the fix all. probably it deserves a fix in a separate patch.

[hokein]

clang-tools-extra/clangd/IncludeCleaner.cpp

548

good catch, send a fix in https://reviews.llvm.org/D149822. (it turns out more tricky than we thought, only changing the if is not enough, I added some unittests for it).

[hokein]

address comments and polish implementations.

[hokein]

I have polished the implementation about the fix-all for missing-include diagnostics, please take a look on the new code.

[kadircet]

thanks, mostly LG. I think we need to be a little careful when generating insertions for all the missing includes though.

clang-tools-extra/clangd/IncludeCleaner.cpp

149–150

what do we gain by preserving the insertion order here exactly?

in generateMissingIncludeDiagnostics, we already traverse using the order of MissingIncludeDiagInfos and inside addAllMissingIncludes the order we preserved here (diagnostic order) doesn't really make much sense, we probably should generate fixes in the order of insertion location, or header spelling.

so what about just using a DenseMap ?

156

nit: maybe inline into the call site

312

we might still have symbols with the same name (ns1::Foo vs ns2::Foo), they'll show up the same in the final annotation.

since we're already sorting by name, we might as well deduplicate after sorting and store just a SmallVector here

335

we might generate multiple insertions to same location here e.g. insert a.h and b.h at the top of the file. LSP says that order reported by the server will be preserved. hence we should actually make sure our edits are ordered by spelling.

clang-tools-extra/clangd/IncludeCleaner.h

48

can you put definition out-of-line ?

clang-tools-extra/include-cleaner/include/clang-include-cleaner/Types.h

71 ↗

(On Diff #522067)

// Unqualified name of the symbol

[hokein]

rebase, and address review comments

clang-tools-extra/clangd/IncludeCleaner.cpp

149–150

The reason was that we need a deterministic-order for visting MissingIncludeEdits, otherwise that batch-fix lit test might fail from time to time.

particularly, in addAllMissingIncludes, we generate a Fix by iterating MissingIncludeEdits, we construct the Fix.Edits, and Fix.Annotations.

• For Fix.Edits, as you pointed out in another comment, we can sort it by (range, newText), to make the case where multiple #includes insertion are at the same place better;
• For Fix.Annotations, this is a bit hard to do a sort afterward as we construct the ID + Annotation, but luckily the final order doesn't matter there, we only need a deterministic order to make lit test happy.

The other alternative is to switch MissingIncludeEdits to a vector<{Header, TextEdit}> sorted by the TextEdit, but in generateMissingIncludeDiagnostics, we need to lookup from a Header, then this means we have to do a linear scan which doesn't feel good.

312

you're right, done.

335

Good catch, this seems like an existing problem today. Sorting these edits by spelling header is one solution,

I'm planning to do it in this patch, added a FIXME.

clang-tools-extra/clangd/IncludeCleaner.h

struct MissingIncludeDiagInfo {
   include_cleaner::Symbol Symbol;
   syntax::FileRange SymRefRange;
   std::vector<include_cleaner::Header> Providers;
 
   bool operator==(const MissingIncludeDiagInfo &Other) const {
     return std::tie(SymRefRange, Providers, Symbol) ==
            std::tie(Other.SymRefRange, Other.Providers, Other.Symbol);
   }
+  include_cleaner::Header header() const;
 };
 
 struct IncludeCleanerFindings {
   std::vector<const Inclusion *> UnusedIncludes;
   std::vector<MissingIncludeDiagInfo> MissingIncludes;
 };
 
 IncludeCleanerFindings computeIncludeCleanerFindings(ParsedAST &AST);

clang-tools-extra/clangd/IncludeCleaner.cpp

 #include "clang/Tooling/Syntax/Tokens.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/GenericUniformityImpl.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/STLFunctionalExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.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 <algorithm>
 #include <cassert>
 #include <iterator>
 #include <optional>
 #include <string>
 #include <utility>
 #include <vector>
 
 namespace clang::clangd {
llvm::StringRef getResolvedPath(const include_cleaner::Header &SymProvider) {
   case include_cleaner::Header::Standard:
     return SymProvider.standard().name().trim("<>\"");
   case include_cleaner::Header::Verbatim:
     return SymProvider.verbatim().trim("<>\"");
   }
   llvm_unreachable("Unknown header kind");
 }
 
-std::vector<Diag> generateMissingIncludeDiagnostics(
+using MissingIncludeEdits = llvm::MapVector<include_cleaner::Header, TextEdit>;
+MissingIncludeEdits generateMissingIncludeEdits(
     ParsedAST &AST, llvm::ArrayRef<MissingIncludeDiagInfo> MissingIncludes,
     llvm::StringRef Code, HeaderFilter IgnoreHeaders) {
-  std::vector<Diag> Result;
+  MissingIncludeEdits Result;
   const SourceManager &SM = AST.getSourceManager();
   const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID());
 
   auto FileStyle = format::getStyle(
       format::DefaultFormatStyle, AST.tuPath(), format::DefaultFallbackStyle,
       Code, &SM.getFileManager().getVirtualFileSystem());
   if (!FileStyle) {
     elog("Couldn't infer style", FileStyle.takeError());
     FileStyle = format::getLLVMStyle();
   }
 
   tooling::HeaderIncludes HeaderIncludes(AST.tuPath(), Code,
                                          FileStyle->IncludeStyle);
   for (const auto &SymbolWithMissingInclude : MissingIncludes) {
+    if (Result.contains(SymbolWithMissingInclude.header()))
+      continue;
+
     llvm::StringRef ResolvedPath =
-        getResolvedPath(SymbolWithMissingInclude.Providers.front());
+        getResolvedPath(SymbolWithMissingInclude.header());
     if (isIgnored(ResolvedPath, IgnoreHeaders)) {
       dlog("IncludeCleaner: not diagnosing missing include {0}, filtered by "
            "config",
            ResolvedPath);
       continue;
     }
 
     std::string Spelling = include_cleaner::spellHeader(
-        {SymbolWithMissingInclude.Providers.front(),
+        {SymbolWithMissingInclude.header(),
          AST.getPreprocessor().getHeaderSearchInfo(), MainFile});
 
     llvm::StringRef HeaderRef{Spelling};
     bool Angled = HeaderRef.starts_with("<");
     // We might suggest insertion of an existing include in edge cases, e.g.,
     // include is present in a PP-disabled region, or spelling of the header
     // turns out to be the same as one of the unresolved includes in the
     // main file.
     std::optional<tooling::Replacement> Replacement = HeaderIncludes.insert(
         HeaderRef.trim("\"<>"), Angled, tooling::IncludeDirective::Include);
     if (!Replacement.has_value())
       continue;
+    TextEdit Edit = replacementToEdit(Code, *Replacement);
+    Result.insert({SymbolWithMissingInclude.header(), Edit});
+  }
+
+  return Result;
+}
+
+std::vector<Diag> generateMissingIncludeDiagnostics(
+    ParsedAST &AST, llvm::ArrayRef<MissingIncludeDiagInfo> MissingIncludes,
+    llvm::StringRef Code, const MissingIncludeEdits &Edits) {
+  std::vector<Diag> Result;
+
+  for (const auto &SymbolWithMissingInclude : MissingIncludes) {
+    auto EditIt = Edits.find(SymbolWithMissingInclude.header());
+    if (EditIt == Edits.end())
+      continue;
 
     Diag &D = Result.emplace_back();
     D.Message =
         llvm::formatv("No header providing \"{0}\" is directly included",
                       SymbolWithMissingInclude.Symbol.name());
     D.Name = "missing-includes";
     D.Source = Diag::DiagSource::Clangd;
     D.File = AST.tuPath();
for (const auto &SymbolWithMissingInclude : MissingIncludes) {
     // But not here: these aren't processed by clangd's DiagnosticConsumer.
     D.Severity = DiagnosticsEngine::Note;
     D.Range = clangd::Range{
         offsetToPosition(Code,
                          SymbolWithMissingInclude.SymRefRange.beginOffset()),
         offsetToPosition(Code,
                          SymbolWithMissingInclude.SymRefRange.endOffset())};
     auto &F = D.Fixes.emplace_back();
-    F.Message = "#include " + Spelling;
-    TextEdit Edit = replacementToEdit(Code, *Replacement);
-    F.Edits.emplace_back(std::move(Edit));
+    F.Message = llvm::StringRef(EditIt->second.newText).rtrim("\n");
+    F.Edits.emplace_back(EditIt->second);
   }
   return Result;
 }
 
 std::vector<Diag> generateUnusedIncludeDiagnostics(
     PathRef FileName, llvm::ArrayRef<const Inclusion *> UnusedIncludes,
     llvm::StringRef Code, HeaderFilter IgnoreHeaders) {
   std::vector<Diag> Result;
for (const auto *Inc : UnusedIncludes) {
     F.Edits.emplace_back();
     F.Edits.back().range.start.line = Inc->HashLine;
     F.Edits.back().range.end.line = Inc->HashLine + 1;
   }
   return Result;
 }
 
 std::optional<Fix>
-removeAllUnusedIncludes(llvm::ArrayRef<Diag> UnusedIncludes) {
-  if (UnusedIncludes.empty())
+removeAllUnusedIncludes(llvm::ArrayRef<const Inclusion *> Includes) {
+  if (Includes.empty())
     return std::nullopt;
 
   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());
-  }
-
-  // TODO(hokein): emit a suitable text for the label.
-  ChangeAnnotation Annotation = {/*label=*/"",
-                                 /*needsConfirmation=*/true,
-                                 /*description=*/""};
   static const ChangeAnnotationIdentifier RemoveAllUnusedID =
       "RemoveAllUnusedIncludes";
-  for (unsigned I = 0; I < RemoveAll.Edits.size(); ++I) {
-    ChangeAnnotationIdentifier ID = RemoveAllUnusedID + std::to_string(I);
-    RemoveAll.Edits[I].annotationId = ID;
-    RemoveAll.Annotations.push_back({ID, Annotation});
+  unsigned I = 0;
+  for (const auto *Inc : Includes) {
+    RemoveAll.Edits.emplace_back();
+    RemoveAll.Edits.back().range.start.line = Inc->HashLine;
+    RemoveAll.Edits.back().range.end.line = Inc->HashLine + 1;
+    ChangeAnnotationIdentifier ID = RemoveAllUnusedID + std::to_string(I++);
+    RemoveAll.Edits.back().annotationId = ID;
+    RemoveAll.Annotations.push_back(
+        {ID, ChangeAnnotation{
+                 /*label=*/llvm::formatv("Remove '#include {0}'", Inc->Written),
+                 /*needsConfirmation=*/true,
+                 /*description=*/""}});
   }
   return RemoveAll;
 }
 
-std::optional<Fix>
-addAllMissingIncludes(llvm::ArrayRef<Diag> MissingIncludeDiags) {
+std::optional<Fix> addAllMissingIncludes(
+    llvm::ArrayRef<MissingIncludeDiagInfo> MissingIncludeDiags,
+    const MissingIncludeEdits &Edits) {
   if (MissingIncludeDiags.empty())
     return std::nullopt;
 
   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);
-    }
+
+  llvm::DenseMap<include_cleaner::Header,
+                 /*symbol names*/std::vector<std::string>>
+      HeaderToSymbols;
+  for (const auto &Diag : MissingIncludeDiags)
+    HeaderToSymbols[Diag.header()].push_back(Diag.Symbol.name());
+  for (auto &[_, Symbols] : HeaderToSymbols) {
+    // Deduplicate symbol names.
+    llvm::sort(Symbols);
+    Symbols.erase(std::unique(Symbols.begin(), Symbols.end()), Symbols.end());
   }
-  // FIXME(hokein): emit used symbol reference in the annotation.
-  ChangeAnnotation Annotation = {/*label=*/"",
-                                 /*needsConfirmation=*/true,
-                                 /*description=*/""};
+
   static const ChangeAnnotationIdentifier AddAllMissingID =
       "AddAllMissingIncludes";
+  auto ProvidedSymbols = [](llvm::ArrayRef<std::string> Symbols) {
+    std::string Result;
+    llvm::raw_string_ostream OS(Result);
+    static constexpr int MaxSymbols = 5;
+    OS << "Provides " << llvm::join(Symbols.take_front(MaxSymbols), ", ");
+    if (Symbols.size() > MaxSymbols)
+      OS << " and " << Symbols.size() - MaxSymbols << " more";
+    return OS.str();
+  };
   unsigned I = 0;
-  for (auto &It : Edits) {
+  // FIXME: figure out a way to better handle cases where multiple #include are
+  // inserted at the same location, the order is somewhat arbitrary now.
+  // LSP spec says that order reported by the server will be preserved.
+  for (auto &[Header, Edit] : Edits) {
     ChangeAnnotationIdentifier ID = AddAllMissingID + std::to_string(I++);
-    AddAllMissing.Edits.push_back(std::move(It.getValue()));
+    AddAllMissing.Edits.push_back(Edit);
     AddAllMissing.Edits.back().annotationId = ID;
 
-    AddAllMissing.Annotations.push_back({ID, Annotation});
+    AddAllMissing.Annotations.push_back(
+        {ID, ChangeAnnotation{
+                 /*label=*/llvm::formatv("{0}",
+                                         StringRef(Edit.newText).trim('\n')),
+                 /*needsConfirmation=*/true,
+                 /*description=*/
+                 ProvidedSymbols(HeaderToSymbols[Header])}});
   }
   return AddAllMissing;
 }
 Fix fixAll(const Fix &RemoveAllUnused, const Fix &AddAllMissing) {
   Fix FixAll;
   FixAll.Message = "fix all includes";
 
   for (const auto &F : RemoveAllUnused.Edits)
for (const Inclusion &MFI : AST.getIncludeStructure().MainFileIncludes) {
     }
     Unused.push_back(&MFI);
   }
   return Unused;
 }
 
 } // namespace
 
+include_cleaner::Header MissingIncludeDiagInfo::header() const {
+  assert(!Providers.empty());
+  return Providers.front();
+}
+
 std::vector<include_cleaner::SymbolReference>
 collectMacroReferences(ParsedAST &AST) {
   const auto &SM = AST.getSourceManager();
   //  FIXME: !!this is a hacky way to collect macro references.
   std::vector<include_cleaner::SymbolReference> Macros;
   auto &PP = AST.getPreprocessor();
   for (const syntax::Token &Tok :
        AST.getTokens().spelledTokens(SM.getMainFileID())) {
llvm::stable_sort(MissingIncludes, [](const MissingIncludeDiagInfo &LHS,
     using MapInfo = llvm::DenseMapInfo<include_cleaner::Symbol>;
     return MapInfo::getHashValue(LHS.Symbol) <
            MapInfo::getHashValue(RHS.Symbol);
   });
   MissingIncludes.erase(llvm::unique(MissingIncludes), MissingIncludes.end());
   std::vector<const Inclusion *> UnusedIncludes = getUnused(AST, Used);
   return {std::move(UnusedIncludes), std::move(MissingIncludes)};
 }
 
 std::vector<Diag>
 issueIncludeCleanerDiagnostics(ParsedAST &AST, llvm::StringRef Code,
                                const IncludeCleanerFindings &Findings,
                                HeaderFilter IgnoreHeaders) {
   trace::Span Tracer("IncludeCleaner::issueIncludeCleanerDiagnostics");
   std::vector<Diag> UnusedIncludes = generateUnusedIncludeDiagnostics(
       AST.tuPath(), Findings.UnusedIncludes, Code, IgnoreHeaders);
-  std::optional<Fix> RemoveAllUnused = removeAllUnusedIncludes(UnusedIncludes);
+  std::optional<Fix> RemoveAllUnused =
+      removeAllUnusedIncludes(Findings.UnusedIncludes);
 
-  std::vector<Diag> MissingIncludeDiags = generateMissingIncludeDiagnostics(
+  auto AddMissingIncludesEdits = generateMissingIncludeEdits(
       AST, Findings.MissingIncludes, Code, IgnoreHeaders);
-  std::optional<Fix> AddAllMissing = addAllMissingIncludes(MissingIncludeDiags);
+  auto MissingIncludeDiags = generateMissingIncludeDiagnostics(
+      AST, Findings.MissingIncludes, Code, AddMissingIncludesEdits);
+  std::optional<Fix> AddAllMissing =
+      addAllMissingIncludes(Findings.MissingIncludes, AddMissingIncludesEdits);
 
   std::optional<Fix> FixAll;
   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) {

clang-tools-extra/clangd/test/include-cleaner-batch-fix.test

 # CHECK-NEXT:           1
 # CHECK-NEXT:         ]
 # CHECK-NEXT:       }
 # CHECK-NEXT:     ],
 # CHECK-NEXT:     "uri": "file://{{.*}}/simple.cpp",
 # CHECK-NEXT:     "version": 0
 # CHECK-NEXT:   }
 ---
-{"jsonrpc":"2.0","id":2,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"test:///simple.cpp"},"range":{"start":{"line":2,"character":1},"end":{"line":2,"character":4}},"context":{"diagnostics":[{"range":{"start": {"line": 2, "character": 1}, "end": {"line": 2, "character": 4}},"severity":3,"message":"No header providing \"Foo\" is directly included (fixes available)", "code": "missing-includes", "source": "clangd"}]}}}
+{"jsonrpc":"2.0","id":2,"method":"textDocument/codeAction","params":{"textDocument":{"uri":"test:///simple.cpp"},"range":{"start":{"line":2,"character":1},"end":{"line":2,"character":4}},"context":{"diagnostics":[{"range":{"start": {"line": 2, "character": 1}, "end": {"line": 2, "character": 4}},"severity":2,"message":"No header providing \"Foo\" is directly included (fixes available)", "code": "missing-includes", "source": "clangd"}]}}}
 #      CHECK:  "id": 2,
 # CHECK-NEXT:  "jsonrpc": "2.0",
 # CHECK-NEXT:  "result": [
 # CHECK-NEXT:    {
 # CHECK-NEXT:      "arguments": [
 # CHECK-NEXT:        {
 # CHECK-NEXT:          "documentChanges": [
 # CHECK-NEXT:            {

 # CHECK-NEXT:      "command": "clangd.applyFix",
 # CHECK-NEXT:      "title": "Apply fix: #include {{.*}}foo.h{{.*}}"
 # CHECK-NEXT:    },
 # CHECK-NEXT:    {
 # CHECK-NEXT:      "arguments": [
 # CHECK-NEXT:        {
 # CHECK-NEXT:          "changeAnnotations": {
 # CHECK-NEXT:            "AddAllMissingIncludes0": {
-# CHECK-NEXT:              "label": "",
+# CHECK-NEXT:              "description": "Provides Foo",
+# CHECK-NEXT:              "label": "{{.*}}foo.h{{.*}}",
 # CHECK-NEXT:              "needsConfirmation": true
 # CHECK-NEXT:            },
 # CHECK-NEXT:            "AddAllMissingIncludes1": {
-# CHECK-NEXT:              "label": "",
+# CHECK-NEXT:              "description": "Provides Bar",
+# CHECK-NEXT:              "label": "{{.*}}bar.h{{.*}}",
 # CHECK-NEXT:              "needsConfirmation": true
 # CHECK-NEXT:            }
 # CHECK-NEXT:          },
 # CHECK-NEXT:          "documentChanges": [
 # CHECK-NEXT:            {
 # CHECK-NEXT:              "edits": [
 # CHECK-NEXT:                {
 # CHECK-NEXT:                  "annotationId": "AddAllMissingIncludes0",
-# CHECK-NEXT:                  "newText": "#include {{.*}}bar.h{{.*}}",
+# CHECK-NEXT:                  "newText": "#include {{.*}}foo.h{{.*}}",
 # CHECK-NEXT:                  "range": {
 # CHECK-NEXT:                    "end": {
 # CHECK-NEXT:                      "character": 0,
 # CHECK-NEXT:                      "line": 2
 # CHECK-NEXT:                    },
 # CHECK-NEXT:                    "start": {
 # CHECK-NEXT:                      "character": 0,
 # CHECK-NEXT:                      "line": 2
 # CHECK-NEXT:                    }
 # CHECK-NEXT:                  }
 # CHECK-NEXT:                },
 # CHECK-NEXT:                {
 # CHECK-NEXT:                  "annotationId": "AddAllMissingIncludes1",
-# CHECK-NEXT:                  "newText": "#include {{.*}}foo.h{{.*}}",
+# CHECK-NEXT:                  "newText": "#include {{.*}}bar.h{{.*}}",
 # CHECK-NEXT:                  "range": {
 # CHECK-NEXT:                    "end": {
 # CHECK-NEXT:                      "character": 0,
 # CHECK-NEXT:                      "line": 2
 # CHECK-NEXT:                    },
 # CHECK-NEXT:                    "start": {
 # CHECK-NEXT:                      "character": 0,
 # CHECK-NEXT:                      "line": 2

 # CHECK-NEXT:      "command": "clangd.applyFix",
 # CHECK-NEXT:      "title": "Apply fix: add all missing includes"
 # CHECK-NEXT:    },
 # CHECK-NEXT:    {
 # CHECK-NEXT:      "arguments": [
 # CHECK-NEXT:        {
 # CHECK-NEXT:          "changeAnnotations": {
 # CHECK-NEXT:            "AddAllMissingIncludes0": {
-# CHECK-NEXT:              "label": "",
+# CHECK-NEXT:              "description": "Provides Foo",
+# CHECK-NEXT:              "label": "{{.*}}foo.h{{.*}}",
 # CHECK-NEXT:              "needsConfirmation": true
 # CHECK-NEXT:            },
 # CHECK-NEXT:            "AddAllMissingIncludes1": {
-# CHECK-NEXT:              "label": "",
+# CHECK-NEXT:              "description": "Provides Bar",
+# CHECK-NEXT:              "label": "{{.*}}bar.h{{.*}}",
 # CHECK-NEXT:              "needsConfirmation": true
 # CHECK-NEXT:            },
 # CHECK-NEXT:            "RemoveAllUnusedIncludes0": {
-# CHECK-NEXT:              "label": "",
+# CHECK-NEXT:              "label": "Remove {{.*}}all1.h{{.*}}",
 # CHECK-NEXT:              "needsConfirmation": true
 # CHECK-NEXT:            },
 # CHECK-NEXT:            "RemoveAllUnusedIncludes1": {
-# CHECK-NEXT:              "label": "",
+# CHECK-NEXT:              "label": "Remove {{.*}}all2.h{{.*}}",
 # CHECK-NEXT:              "needsConfirmation": true
 # CHECK-NEXT:            }
 # CHECK-NEXT:          },
 # CHECK-NEXT:          "documentChanges": [
 # CHECK-NEXT:            {
 # CHECK-NEXT:              "edits": [
 # CHECK-NEXT:                {
 # CHECK-NEXT:                  "annotationId": "RemoveAllUnusedIncludes0",

 # CHECK-NEXT:                    "start": {
 # CHECK-NEXT:                      "character": 0,
 # CHECK-NEXT:                      "line": 1
 # CHECK-NEXT:                    }
 # CHECK-NEXT:                  }
 # CHECK-NEXT:                },
 # CHECK-NEXT:                {
 # CHECK-NEXT:                  "annotationId": "AddAllMissingIncludes0",
-# CHECK-NEXT:                  "newText": "#include {{.*}}bar.h{{.*}}",
+# CHECK-NEXT:                  "newText": "#include {{.*}}foo.h{{.*}}",
 # CHECK-NEXT:                  "range": {
 # CHECK-NEXT:                    "end": {
 # CHECK-NEXT:                      "character": 0,
 # CHECK-NEXT:                      "line": 2
 # CHECK-NEXT:                    },
 # CHECK-NEXT:                    "start": {
 # CHECK-NEXT:                      "character": 0,
 # CHECK-NEXT:                      "line": 2
 # CHECK-NEXT:                    }
 # CHECK-NEXT:                  }
 # CHECK-NEXT:                },
 # CHECK-NEXT:                {
 # CHECK-NEXT:                  "annotationId": "AddAllMissingIncludes1",
-# CHECK-NEXT:                  "newText": "#include {{.*}}foo.h{{.*}}",
+# CHECK-NEXT:                  "newText": "#include {{.*}}bar.h{{.*}}",
 # CHECK-NEXT:                  "range": {
 # CHECK-NEXT:                    "end": {
 # CHECK-NEXT:                      "character": 0,
 # CHECK-NEXT:                      "line": 2
 # CHECK-NEXT:                    },
 # CHECK-NEXT:                    "start": {
 # CHECK-NEXT:                      "character": 0,
 # CHECK-NEXT:                      "line": 2

 # CHECK-NEXT:      "command": "clangd.applyFix",
 # CHECK-NEXT:      "title": "Apply fix: remove #include directive"
 # CHECK-NEXT:    },
 # CHECK-NEXT:    {
 # CHECK-NEXT:      "arguments": [
 # CHECK-NEXT:        {
 # CHECK-NEXT:          "changeAnnotations": {
 # CHECK-NEXT:            "RemoveAllUnusedIncludes0": {
-# CHECK-NEXT:              "label": "",
+# CHECK-NEXT:              "label": "Remove {{.*}}",
 # CHECK-NEXT:              "needsConfirmation": true
 # CHECK-NEXT:            },
 # CHECK-NEXT:            "RemoveAllUnusedIncludes1": {
-# CHECK-NEXT:              "label": "",
+# CHECK-NEXT:              "label": "Remove {{.*}}",
 # CHECK-NEXT:              "needsConfirmation": true
 # CHECK-NEXT:            }
 # CHECK-NEXT:          },
 # CHECK-NEXT:          "documentChanges": [
 # CHECK-NEXT:            {
 # CHECK-NEXT:              "edits": [
 # CHECK-NEXT:                {
 # CHECK-NEXT:                  "annotationId": "RemoveAllUnusedIncludes0",

 # CHECK-NEXT:      "command": "clangd.applyFix",
 # CHECK-NEXT:      "title": "Apply fix: remove all unused includes"
 # CHECK-NEXT:    },
 # CHECK-NEXT:    {
 # CHECK-NEXT:      "arguments": [
 # CHECK-NEXT:        {
 # CHECK-NEXT:          "changeAnnotations": {
 # CHECK-NEXT:            "AddAllMissingIncludes0": {
-# CHECK-NEXT:              "label": "",
+# CHECK-NEXT:              "description": "Provides {{.*}}",
+# CHECK-NEXT:              "label": "{{.*}}",
 # CHECK-NEXT:              "needsConfirmation": true
 # CHECK-NEXT:            },
 # CHECK-NEXT:            "AddAllMissingIncludes1": {
-# CHECK-NEXT:              "label": "",
+# CHECK-NEXT:              "description": "Provides {{.*}}",
+# CHECK-NEXT:              "label": "{{.*}}",
 # CHECK-NEXT:              "needsConfirmation": true
 # CHECK-NEXT:            },
 # CHECK-NEXT:            "RemoveAllUnusedIncludes0": {
-# CHECK-NEXT:              "label": "",
+# CHECK-NEXT:              "label": "Remove {{.*}}",
 # CHECK-NEXT:              "needsConfirmation": true
 # CHECK-NEXT:            },
 # CHECK-NEXT:            "RemoveAllUnusedIncludes1": {
-# CHECK-NEXT:              "label": "",
+# CHECK-NEXT:              "label": "Remove {{.*}}",
 # CHECK-NEXT:              "needsConfirmation": true
 # CHECK-NEXT:            }
 # CHECK-NEXT:          },
 # CHECK-NEXT:          "documentChanges": [
 # CHECK-NEXT:            {
 # CHECK-NEXT:              "edits": [
 # CHECK-NEXT:                {
 # CHECK-NEXT:                  "annotationId": "RemoveAllUnusedIncludes0",

 # CHECK-NEXT:                    "start": {
 # CHECK-NEXT:                      "character": 0,
 # CHECK-NEXT:                      "line": 1
 # CHECK-NEXT:                    }
 # CHECK-NEXT:                  }
 # CHECK-NEXT:                },
 # CHECK-NEXT:                {
 # CHECK-NEXT:                  "annotationId": "AddAllMissingIncludes0",
-# CHECK-NEXT:                  "newText": "#include {{.*}}bar.h{{.*}}",
+# CHECK-NEXT:                  "newText": "#include {{.*}}foo.h{{.*}}",
 # CHECK-NEXT:                  "range": {
 # CHECK-NEXT:                    "end": {
 # CHECK-NEXT:                      "character": 0,
 # CHECK-NEXT:                      "line": 2
 # CHECK-NEXT:                    },
 # CHECK-NEXT:                    "start": {
 # CHECK-NEXT:                      "character": 0,
 # CHECK-NEXT:                      "line": 2
 # CHECK-NEXT:                    }
 # CHECK-NEXT:                  }
 # CHECK-NEXT:                },
 # CHECK-NEXT:                {
 # CHECK-NEXT:                  "annotationId": "AddAllMissingIncludes1",
-# CHECK-NEXT:                  "newText": "#include {{.*}}foo.h{{.*}}",
+# CHECK-NEXT:                  "newText": "#include {{.*}}bar.h{{.*}}",
 # CHECK-NEXT:                  "range": {
 # CHECK-NEXT:                    "end": {
 # CHECK-NEXT:                      "character": 0,
 # CHECK-NEXT:                      "line": 2
 # CHECK-NEXT:                    },
 # CHECK-NEXT:                    "start": {
 # CHECK-NEXT:                      "character": 0,
 # CHECK-NEXT:                      "line": 2