[clangd] Refine the workflow for diagnostic Fixits.

[hokein]

Summary

• No longer store the diagnostic fixits in the clangdLSPServer
• When propagating the fixit via the code action, we use the Diag information stored in the ParsedAST (in clangdServer.cpp)

[kadircet]

clang-tools-extra/clangd/ClangdServer.cpp

671

this is tricky indeed and conceptually really hard to achieve inside ClangdServer layer.

what about keeping the cache in ClangdLSPServer, but changing the format? Similar to TweakRef, we now have a DiagRef, which is ClangdServer-native. So we can keep a cache from (FilePath, clangd::Diagnostic) to clangd::DiagRef, and pass those DiagRefs to ClangdServer and make sure we're doing the search for sure on the right domain here?

this also gives us the flexibility to change the definition of a DiagRef in the future.

683

we can have quick fix kind tweaks too (e.g. populate switch)

713–714

can you also move this counter to global scope and use it in ::codeAction too?

clang-tools-extra/clangd/ClangdServer.h

384

maybe a more structured output can be useful here:

struct CodeActionResult {
  std::string Version; // Version of content results belong to.
  struct QuickFix {
      DiagRef D; // Diagnostic being addressed by the fix.
      Fix F;
  };
  std::vector<QuickFix> QuickFixes;
  std::vector<TweakRef> TweakRefs;
};

[hokein]

address review comments.

clang-tools-extra/clangd/ClangdServer.cpp

671

I'm not a fan of keeping a cache in ClangdLSPServer, I'd like to remove it entirely.

What do you think about this alternative?

• pull out and exposed the mainMessage API from the toLSPDiags
• we add the ClangdDiagnosticOptions to the CodeActionInputs.
• when searching a diagnostic in ClangdServer.cpp, we check the equality by checking mainMessage(ClangdServerDiagnostic.message, Inputs.DiagOpts) == DiagRef.Message

The downside here is that we have to pay O(N * cost of mainMessage) to find a matched diagnostic.

683

oops, I weren't aware of that, removed.

713–714

I added a similar local counter in codeAction method, since this method is being deprecated, and removed eventually (it doesn't seem too make much sense to use a shared counter)

clang-tools-extra/clangd/ClangdServer.h

384

good idea, also keep symmetry with the CodeActionInputs

[hokein]

Use the mainMessage to find the corresponding ClangdServer diagnostics.

clang-tools-extra/clangd/ClangdServer.cpp

671

I updated the patch with the mainMessage approach, please take a look.

[kadircet]

clang-tools-extra/clangd/ClangdServer.cpp

671

i believe this still runs into the same conceptual problems. we're trying to imitate the logic done by clangdlspserver when converting a clangd-native diagnostic into an lsp-diagnostic and all of this will break as soon as there's a change in that logic. so if we want to go down that path, the best option would be to call toLSPDiagevery time here and make sure we imitate that logic properly (e.g. right now we're relying on the ranges not being remapped because we only store fixes for the main file diagnostics).

but i feel like this is unnecessary cost both at runtime but also as code-complexity wise. this is ~the same as the data/args we publish with commands. it's just unfortunate that data field in diagnostic didn't exist pre LSP 3.16, hence we can't rely on it without breaking compatibility with some old clients (hopefully we can do that one day), hence instead of clients keeping this identifier around, I am merely suggesting to keep this alive on the server side. as conceptually this is the only layer that can do the mapping back and forth.

713–714

sorry i am confused. the counter has nothing to do with how we generated a tweak. it's merely counting number of times a tweak was returned. hence we don't need a new one (if a code action Bar was made available either through a call to ::enumerateTweaks or ::codeAction we should increment the same counter. clients won't be invoking both at the same time, they'll be using one or the other).

[hokein]

add LSPServer cache back and repurpose for lsp <=> naive diagnostic mapping, per offline discussion.

[hokein]

cleanup

[kadircet]

clang-tools-extra/clangd/ClangdLSPServer.cpp

1009–1018

we're already making a copy of Params.context.diagnostics when creating the CB.

so you might as well have a std::map<ClangdServer::DiagRef, clangd::Diagnostic> RefsToDiags; and get rid of the extra index conversions.

clang-tools-extra/clangd/ClangdLSPServer.h

237

instead of storing clangd::Diagnostic as the key, can we have a DiagnosticKey struct here (we can have a helper diagKey(const clangd::Diagnostic&) -> DiagnosticKey)? to make sure we don't get into trouble if there are too many "big" diagnostics :)

that way we can also get rid of the custom comparator.

[hokein]

address comments

• introduce DiagKey for the caching map
• get rid of extra index conversion

[hokein]

more cleanup

[kadircet]

thanks!

clang-tools-extra/clangd/ClangdLSPServer.cpp

1055

no need for LSPDiags anymore, you can just use ToLSPDiags.begin()

clang-tools-extra/clangd/ClangdServer.cpp

667

nit: you can return an llvm::ArrayRef<Fix> here and get rid of one extra layer of nesting down below

[hokein]

address comments

clang-tools-extra/clangd/ClangdLSPServer.h

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<CodeAction> 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<CodeAction>,
-                   LSPDiagnosticCompare>
-      DiagnosticToReplacementMap;
-  /// Caches FixIts per file and diagnostics
-  llvm::StringMap<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;
   std::unique_ptr<MessageHandler> MsgHandler;
   std::mutex TranspWriter;
 
   void callMethod(StringRef Method, llvm::json::Value Params,
                   Callback<llvm::json::Value> CB) override;
   void notify(StringRef Method, llvm::json::Value Params) override;

clang-tools-extra/clangd/ClangdLSPServer.cpp

 }
 
 void ClangdLSPServer::onDocumentDidClose(
     const DidCloseTextDocumentParams &Params) {
   PathRef File = Params.textDocument.uri.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.
static std::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;
-  // 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("."));
-    });
+  ClangdServer::CodeActionInputs Inputs;
+  for (const auto &D : Params.context.diagnostics)
+    Inputs.Diagnostics.push_back(ClangdServer::DiagRef{D.range, D.message});
+  Inputs.DiagOpts = DiagOpts;
+  Inputs.File = File.file();
+  Inputs.Selection = Params.range;
+  Inputs.RequestedActionKinds = Params.context.only;
+  Inputs.TweakFilter = [this](const Tweak &T) {
+    return Opts.TweakFilter(T);
   };
-
-  // 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 &CA : getFixes(File.file(), D)) {
-        FixIts.push_back(CA);
-        FixIts.back().diagnostics = {D};
+  auto CB = [this, Diags = Params.context.diagnostics, Reply = std::move(Reply),
+             File, Selection = Params.range](
+                llvm::Expected<ClangdServer::CodeActionResult>
+                    Fixits) mutable {
+    if (!Fixits)
+      return Reply(Fixits.takeError());
+    std::vector<CodeAction> CAs;
+    auto Version = decodeVersion(Fixits->Version);
+    for (const auto &QF : Fixits->QuickFixes) {
+      CAs.push_back(toCodeAction(QF.F, File, Version,
+                                 SupportsDocumentChanges,
+                                 SupportsChangeAnnotation));
+      for (const auto &D : Diags) {
+        if (QF.Diag == ClangdServer::DiagRef{D.range, D.message}) {
+          CAs.back().diagnostics = {D};
+          break;
         }
       }
     }
-
-  // Now enumerate the semantic code actions.
-  auto ConsumeActions =
-      [Diags = Params.context.diagnostics, 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));
+    for (const auto &TR : Fixits->TweakRefs)
+       CAs.push_back(toCodeAction(TR, File, Selection));
 
-        // If there's exactly one quick-fix, call it "preferred".
-        // We never consider refactorings etc as preferred.
-        CodeAction *OnlyFix = nullptr;
-        for (auto &Action : Actions) {
-          if (Action.kind && *Action.kind == CodeAction::QUICKFIX_KIND) {
-            if (OnlyFix) {
-              OnlyFix = nullptr;
-              break;
-            }
-            OnlyFix = &Action;
-          }
-        }
-        if (OnlyFix) {
-          OnlyFix->isPreferred = true;
-          if (Diags.size() == 1 && Diags.front().range == Selection)
-            OnlyFix->diagnostics = {Diags.front()};
-        }
+    for (auto &Action : CAs) {
 
-        if (SupportsCodeAction)
-          return Reply(llvm::json::Array(Actions));
-        std::vector<Command> Commands;
-        for (const auto &Action : Actions) {
-          if (auto Command = asCommand(Action))
-            Commands.push_back(std::move(*Command));
-        }
-        return Reply(llvm::json::Array(Commands));
-      };
-  Server->enumerateTweaks(
-      File.file(), Params.range,
-      [this, KindAllowed(std::move(KindAllowed))](const Tweak &T) {
-        return Opts.TweakFilter(T) && KindAllowed(T.kind());
-      },
-      std::move(ConsumeActions));
+      return Reply(llvm::json::Array(CAs));
+    for (const auto &Action : CAs) {
+  Server->codeAction(Inputs, std::move(CB));
 }
 
 void ClangdLSPServer::onCompletion(const CompletionParams &Params,
                                    Callback<CompletionList> Reply) {
   if (!shouldRunCompletion(Params)) {
     // Clients sometimes auto-trigger completions in undesired places (e.g.
     // 'a >^ '), we return empty results in those cases.
     vlog("ignored auto-triggered completion, preceding char did not match");
bool ClangdLSPServer::run() {
   return CleanExit && ShutdownRequestReceived;
 }
 
 void ClangdLSPServer::profile(MemoryTree &MT) const {
   if (Server)
     Server->profile(MT.child("clangd_server"));
 }
 
-std::vector<CodeAction> 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())
-    return {};
-
-  return FixItsIter->second;
-}
-
 // A completion request is sent when the user types '>' or ':', but we only
 // want to trigger on '->' and '::'. We check the preceding 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.
 bool ClangdLSPServer::shouldRunCompletion(
     const CompletionParams &Params) const {
bool ClangdLSPServer::shouldRunCompletion(
   return allowImplicitCompletion(*Code, *Offset);
 }
 
 void ClangdLSPServer::onDiagnosticsReady(PathRef File, llvm::StringRef Version,
                                          llvm::ArrayRef<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) {
                    std::vector<CodeAction> CodeActions;
                    for (const auto &Fix : Fixes)
-                   CodeActions.push_back(toCodeAction(Fix, Notification.uri,
-                                                      Notification.version,
-                                                      SupportsDocumentChanges,
-                                                      SupportsChangeAnnotation));
-
-                 if (DiagOpts.EmbedFixesInDiagnostics) {
-                   Diag.codeActions.emplace(CodeActions);
+                     CodeActions.push_back(toCodeAction(
+                         Fix, Notification.uri, Notification.version,
+                         SupportsDocumentChanges, SupportsChangeAnnotation));
+                   Diag.codeActions.emplace(std::move(CodeActions));
                    if (Diag.codeActions->size() == 1)
                      Diag.codeActions->front().isPreferred = true;
                  }
-                 LocalFixIts[Diag] = std::move(CodeActions);
                  Notification.diagnostics.push_back(std::move(Diag));
                });
   }
 
-  // Cache FixIts
-  {
-    std::lock_guard<std::mutex> Lock(FixItsMutex);
-    FixItsMap[File] = LocalFixIts;
-  }
 
   // Send a notification to the LSP client.
   PublishDiagnostics(Notification);
 }
 
 void ClangdLSPServer::onInactiveRegionsReady(
     PathRef File, std::vector<Range> InactiveRegions) {
   InactiveRegionsParams Notification;

clang-tools-extra/clangd/ClangdServer.h

 #include "clang/Tooling/Core/Replacement.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include <functional>
 #include <memory>
 #include <optional>
 #include <string>
-#include <type_traits>
-#include <utility>
+#include <tuple>
 #include <vector>
 
 namespace clang {
 namespace clangd {
 /// Manages a collection of source files and derived data (ASTs, indexes),
 /// and provides language-aware features such as code completion.
 ///
 /// The primary client is ClangdLSPServer which exposes these features via
public:
   void rename(PathRef File, Position Pos, llvm::StringRef NewName,
               const RenameOptions &Opts, Callback<RenameResult> CB);
 
   struct TweakRef {
     std::string ID;    /// ID to pass for applyTweak.
     std::string Title; /// A single-line message to show in the UI.
     llvm::StringLiteral Kind;
   };
+
+  // Contains fields (LSP-form) to identify corresponding clangd::Diag.
+  struct DiagRef {
+    Range Range;
+    std::string Message;
+    bool operator==(const DiagRef &Other) const {
+      return std::tie(Range, Message) == std::tie(Other.Range, Other.Message);
+    }
+  };
+
+  struct CodeActionInputs {
+    std::string File;
+    Range Selection;
+
+    ClangdDiagnosticOptions DiagOpts;
+
+    /// Requested kind of actions to return.
+    std::vector<std::string> RequestedActionKinds;
+
+    /// Diagnostics attached to the code action request.
+    std::vector<DiagRef> Diagnostics;
+
+    /// Tweaks where Filter returns false will not be checked or included.
+    std::function<bool(const Tweak &)> TweakFilter;
+  };
+  struct CodeActionResult {
+    std::string Version;
+    struct QuickFix {
+      DiagRef Diag;
+      Fix F;
+    };
+    std::vector<QuickFix> QuickFixes;
+    std::vector<TweakRef> TweakRefs;
+  };
+  /// Surface code actions (quick-fixes for diagnostics, or available code
+  /// tweaks) for a given range in a file.
+  void codeAction(const CodeActionInputs &Inputs,
+                  Callback<CodeActionResult> CB);
+
   /// Enumerate the code tweaks available to the user at a specified point.
   /// Tweaks where Filter returns false will not be checked or included.
+  /// Deprecated, use codeAction instead.
   void enumerateTweaks(PathRef File, Range Sel,
                        llvm::unique_function<bool(const Tweak &)> Filter,
                        Callback<std::vector<TweakRef>> CB);
 
   /// Apply the code tweak with a specified \p ID.
   void applyTweak(PathRef File, Range Sel, StringRef ID,
                   Callback<Tweak::Effect> CB);
 

clang-tools-extra/clangd/ClangdServer.cpp

 #include <algorithm>
 #include <chrono>
 #include <future>
 #include <memory>
 #include <mutex>
 #include <optional>
 #include <string>
 #include <type_traits>
+#include <vector>
 
 namespace clang {
 namespace clangd {
 namespace {
 
 // Update the FileIndex with new ASTs and plumb the diagnostics responses.
 struct UpdateIndexCallbacks : public ParsingCallbacks {
   UpdateIndexCallbacks(FileIndex *FIndex,
SelectionTree::createEach(
         Result.push_back(std::make_unique<Tweak::Selection>(
             AST.Inputs.Index, AST.AST, *Begin, *End, std::move(T), FS));
         return false;
       });
   assert(!Result.empty() && "Expected at least one SelectionTree");
   return std::move(Result);
 }
 
+void ClangdServer::codeAction(const CodeActionInputs &Params,
+                              Callback<CodeActionResult> CB) {
+  static constexpr trace::Metric TweakAvailable(
+      "code_action_tweak_available", trace::Metric::Counter, "tweak_id");
+  auto Action = [Params, CB = std::move(CB),
+                 FeatureModules(this->FeatureModules)](
+                    Expected<InputsAndAST> InpAST) mutable {
+    if (!InpAST)
+      return CB(InpAST.takeError());
+    auto KindAllowed =
+        [Only(Params.RequestedActionKinds)](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("."));
+          });
+        };
+
+    CodeActionResult Result;
+    Result.Version = InpAST->AST.version().str();
+    if (KindAllowed(CodeAction::QUICKFIX_KIND)) {
+      auto FindMatched =
+          [&InpAST, &Params](const DiagRef &LSPDiag) -> const clangd::Diag * {
+        for (const auto &Diag : InpAST->AST.getDiagnostics()) {
+          if (Diag.Range == LSPDiag.Range &&
+              LSPDiag.Message == mainMessage(Diag, Params.DiagOpts))
+            return &Diag;
+        }
+        return nullptr;
+      };
+      for (const auto &Diag : Params.Diagnostics) {
+        if (const auto *Match = FindMatched(Diag))
+          for (const auto &Fix : Match->Fixes)
+            Result.QuickFixes.push_back({Diag, Fix});
+      }
+    }
+
+    // Collect Tweaks
+    auto Selections = tweakSelection(Params.Selection, *InpAST, /*FS=*/nullptr);
+    if (!Selections)
+      return CB(Selections.takeError());
+    // Don't allow a tweak to fire more than once across ambiguous selections.
+    llvm::DenseSet<llvm::StringRef> PreparedTweaks;
+    auto DeduplicatingFilter = [&](const Tweak &T) {
+      return KindAllowed(T.kind()) && Params.TweakFilter(T) &&
+             !PreparedTweaks.count(T.id());
+    };
+    for (const auto &Sel : *Selections) {
+      for (auto &T : prepareTweaks(*Sel, DeduplicatingFilter, FeatureModules)) {
+        Result.TweakRefs.push_back(TweakRef{T->id(), T->title(), T->kind()});
+        PreparedTweaks.insert(T->id());
+        TweakAvailable.record(1, T->id());
+      }
+    }
+    CB(std::move(Result));
+  };
+
+  WorkScheduler->runWithAST("EnumerateTweaks", Params.File, std::move(Action),
+                            Transient);
+}
+
 void ClangdServer::enumerateTweaks(
     PathRef File, Range Sel, llvm::unique_function<bool(const Tweak &)> Filter,
     Callback<std::vector<TweakRef>> CB) {
   // Tracks number of times a tweak has been offered.
   static constexpr trace::Metric TweakAvailable(
       "tweak_available", trace::Metric::Counter, "tweak_id");
   auto Action = [Sel, CB = std::move(CB), Filter = std::move(Filter),
                  FeatureModules(this->FeatureModules)](
                     Expected<InputsAndAST> InpAST) mutable {
     if (!InpAST)
       return CB(InpAST.takeError());
     auto Selections = tweakSelection(Sel, *InpAST, /*FS=*/nullptr);
     if (!Selections)
       return CB(Selections.takeError());

clang-tools-extra/clangd/Diagnostics.h

 /// to include all its notes. Notes inside main file are also provided as
 /// 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);
 
+/// Returns a message sent to LSP for the main diagnostic in \p D.
+/// This message may include notes, if they're not emitted in some other way.
+/// Example output:
+///
+///     no matching function for call to 'foo'
+///
+///     main.cpp:3:5: note: candidate function not viable: requires 2 arguments
+///
+///     dir1/dir2/dir3/../../dir4/header.h:12:23
+///     note: candidate function not viable: requires 3 arguments
+std::string mainMessage(const Diag &D, const ClangdDiagnosticOptions &Opts);
+
 /// 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);
 
 /// StoreDiags collects the diagnostics that can later be reported by

clang-tools-extra/clangd/Diagnostics.cpp

 
 /// Capitalizes the first word in the diagnostic's message.
 std::string capitalize(std::string Message) {
   if (!Message.empty())
     Message[0] = llvm::toUpper(Message[0]);
   return Message;
 }
 
-/// Returns a message sent to LSP for the main diagnostic in \p D.
-/// This message may include notes, if they're not emitted in some other way.
-/// Example output:
-///
-///     no matching function for call to 'foo'
-///
-///     main.cpp:3:5: note: candidate function not viable: requires 2 arguments
-///
-///     dir1/dir2/dir3/../../dir4/header.h:12:23
-///     note: candidate function not viable: requires 3 arguments
-std::string mainMessage(const Diag &D, const ClangdDiagnosticOptions &Opts) {
-  std::string Result;
-  llvm::raw_string_ostream OS(Result);
-  OS << D.Message;
-  if (Opts.DisplayFixesCount && !D.Fixes.empty())
-    OS << " (" << (D.Fixes.size() > 1 ? "fixes" : "fix") << " available)";
-  // If notes aren't emitted as structured info, add them to the message.
-  if (!Opts.EmitRelatedLocations)
-    for (auto &Note : D.Notes) {
-      OS << "\n\n";
-      printDiag(OS, Note);
-    }
-  OS.flush();
-  return capitalize(std::move(Result));
-}
-
 /// Returns a message sent to LSP for the note of the main diagnostic.
 std::string noteMessage(const Diag &Main, const DiagBase &Note,
                         const ClangdDiagnosticOptions &Opts) {
   std::string Result;
   llvm::raw_string_ostream OS(Result);
   OS << Note.Message;
   // If the client doesn't support structured links between the note and the
   // original diagnostic, then emit the main diagnostic to give context.
for (auto &Note : D.Notes) {
       clangd::Diagnostic Res;
       Res.severity = getSeverity(Note.Severity);
       Res.range = Note.Range;
       Res.message = noteMessage(D, Note, Opts);
       OutFn(std::move(Res), llvm::ArrayRef<Fix>());
     }
 }
 
+std::string mainMessage(const Diag &D, const ClangdDiagnosticOptions &Opts) {
+  std::string Result;
+  llvm::raw_string_ostream OS(Result);
+  OS << D.Message;
+  if (Opts.DisplayFixesCount && !D.Fixes.empty())
+    OS << " (" << (D.Fixes.size() > 1 ? "fixes" : "fix") << " available)";
+  // If notes aren't emitted as structured info, add them to the message.
+  if (!Opts.EmitRelatedLocations)
+    for (auto &Note : D.Notes) {
+      OS << "\n\n";
+      printDiag(OS, Note);
+    }
+  OS.flush();
+  return capitalize(std::move(Result));
+}
+
+
 int getSeverity(DiagnosticsEngine::Level L) {
   switch (L) {
   case DiagnosticsEngine::Remark:
     return 4;
   case DiagnosticsEngine::Note:
     return 3;
   case DiagnosticsEngine::Warning:
     return 2;

clang-tools-extra/clangd/Protocol.h

struct Diagnostic {
   /// `textDocument/publishDiagnostics` notification
   /// and `textDocument/codeAction` request.
   /// Mutating users should associate their data with a unique key they can use
   /// to retrieve later on.
   llvm::json::Object data;
 };
 llvm::json::Value toJSON(const Diagnostic &);
 
-/// A LSP-specific comparator used to find diagnostic in a container like
-/// std:map.
-/// We only use the required fields of Diagnostic to do the comparison to avoid
-/// any regression issues from LSP clients (e.g. VScode), see
-/// https://git.io/vbr29
-struct LSPDiagnosticCompare {
-  bool operator()(const Diagnostic &LHS, const Diagnostic &RHS) const {
-    return std::tie(LHS.range, LHS.message) < std::tie(RHS.range, RHS.message);
-  }
-};
 bool fromJSON(const llvm::json::Value &, Diagnostic &, llvm::json::Path);
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Diagnostic &);
 
 struct PublishDiagnosticsParams {
   /// The URI for which diagnostic information is reported.
   URIForFile uri;
   /// An array of diagnostic information items.
   std::vector<Diagnostic> diagnostics;