[clangd][wip] Add 'related information' to diagnostics. Does not work for built-in notes

[ilya-biryukov]

Summary

A prototype that I made a while ago and never landed.
Not suppossed to be a final solution and will probably merge-conflict now,
publishing to not loose it.

[ilya-biryukov]

Abandoning, same functionality landed in separate revision by @sammccall

clangd/ClangdLSPServer.cpp

void ClangdLSPServer::onDiagnosticsReady(PathRef File,
 
   DiagnosticToReplacementMap LocalFixIts; // Temporary storage
   for (auto &Diag : Diagnostics) {
     toLSPDiags(Diag, [&](clangd::Diagnostic Diag, llvm::ArrayRef<Fix> Fixes) {
       DiagnosticsJSON.push_back(json::Object{
           {"range", Diag.range},
           {"severity", Diag.severity},
           {"message", Diag.message},
+          {"relatedInformation", json::Array(Diag.relatedInformation)}
       });
 
       auto &FixItsForDiagnostic = LocalFixIts[Diag];
       std::copy(Fixes.begin(), Fixes.end(),
                 std::back_inserter(FixItsForDiagnostic));
     });
   }
 

clangd/Diagnostics.h

 //===--- Diagnostics.h ------------------------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===---------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_DIAGNOSTICS_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_DIAGNOSTICS_H
 
 #include "Path.h"
 #include "Protocol.h"
+#include "URI.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/LangOptions.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringSet.h"
+#include "llvm/ADT/Optional.h"
 #include <cassert>
 #include <string>
 
 namespace clang {
 namespace clangd {
 
 /// Contains basic information about a diagnostic.
 struct DiagBase {
   std::string Message;
   // Intended to be used only in error messages.
   // May be relative, absolute or even artifically constructed.
   std::string File;
+  llvm::Optional<std::string> AbsPath;
   clangd::Range Range;
   DiagnosticsEngine::Level Severity = DiagnosticsEngine::Note;
   // Since File is only descriptive, we store a separate flag to distinguish
   // diags from the main file.
   bool InsideMainFile = false;
 };
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const DiagBase &D);
 

clangd/Diagnostics.cpp

void toLSPDiags(
     llvm::function_ref<void(clangd::Diagnostic, llvm::ArrayRef<Fix>)> OutFn) {
   auto FillBasicFields = [](const DiagBase &D) -> clangd::Diagnostic {
     clangd::Diagnostic Res;
     Res.range = D.Range;
     Res.severity = getSeverity(D.Severity);
     return Res;
   };
 
-  {
-    clangd::Diagnostic Main = FillBasicFields(D);
-    Main.message = mainMessage(D);
-    OutFn(std::move(Main), D.Fixes);
-  }
-
+  Main.message = D.Message;
+  Main.relatedInformation.reserve(D.Notes.size());
   for (auto &Note : D.Notes) {
-    if (!Note.InsideMainFile)
-      continue;
-    clangd::Diagnostic Res = FillBasicFields(Note);
-    Res.message = noteMessage(D, Note);
-    OutFn(std::move(Res), llvm::ArrayRef<Fix>());
+    log("Note {0}", Note.Message);
+    DiagnosticRelatedInformation NoteInfo;
+    NoteInfo.location = clangd::Location{
+        clangd::URIForFile(), Note.Range};
+    NoteInfo.message = Note.Message;
+
+    Main.relatedInformation.push_back(std::move(NoteInfo));
   }
+  OutFn(std::move(Main), D.Fixes);
 }
 
 int getSeverity(DiagnosticsEngine::Level L) {
   switch (L) {
   case DiagnosticsEngine::Remark:
     return 4;
   case DiagnosticsEngine::Note:
     return 3;
void StoreDiags::HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
   DiagnosticConsumer::HandleDiagnostic(DiagLevel, Info);
 
   if (!LangOpts || !Info.hasSourceManager()) {
     IgnoreDiagnostics::log(DiagLevel, Info);
     return;
   }
 
   bool InsideMainFile = isInsideMainFile(Info);
+  const SourceManager &SrcMgr = Info.getSourceManager();
 
   auto FillDiagBase = [&](DiagBase &D) {
     D.Range = diagnosticRange(Info, *LangOpts);
     llvm::SmallString<64> Message;
     Info.FormatDiagnostic(Message);
     D.Message = Message.str();
     D.InsideMainFile = InsideMainFile;
-    D.File = Info.getSourceManager().getFilename(Info.getLocation());
+
+    D.File = SrcMgr.getFilename(Info.getLocation());
+    const FileID FID =
+        SrcMgr.getFileID(Info.getLocation());
+    const FileEntry *FE = SrcMgr.getFileEntryForID(FID);
+    D.AbsPath = getAbsoluteFilePath(FE, SrcMgr);
     D.Severity = DiagLevel;
     return D;
   };
 
   auto AddFix = [&](bool SyntheticMessage) -> bool {
     assert(!Info.getFixItHints().empty() &&
            "diagnostic does not have attached fix-its");
     if (!InsideMainFile)

clangd/Protocol.h

struct Location {
   friend bool operator!=(const Location &LHS, const Location &RHS) {
     return !(LHS == RHS);
   }
 
   friend bool operator<(const Location &LHS, const Location &RHS) {
     return std::tie(LHS.uri, LHS.range) < std::tie(RHS.uri, RHS.range);
   }
 };
+bool fromJSON(const llvm::json::Value&, Location &);
 llvm::json::Value toJSON(const Location &);
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Location &);
 
 struct Metadata {
   std::vector<std::string> extraFlags;
 };
 bool fromJSON(const llvm::json::Value &, Metadata &);
 

 // FIXME: most of the capabilities are missing from this struct. Only the ones
 // used by clangd are currently there.
 struct WorkspaceClientCapabilities {
   /// Capabilities specific to `workspace/symbol`.
   llvm::Optional<WorkspaceSymbolCapabilities> symbol;
 };
 bool fromJSON(const llvm::json::Value &, WorkspaceClientCapabilities &);
 
+struct PublishDiagnosticsClientCapabilities {
+  /// Whether the clients accepts diagnostics with related information.
+  bool relatedInformation = false;
+};
+bool fromJSON(const llvm::json::Value &, PublishDiagnosticsClientCapabilities &);
+
 // FIXME: most of the capabilities are missing from this struct. Only the ones
 // used by clangd are currently there.
 struct TextDocumentClientCapabilities {
   /// Capabilities specific to the `textDocument/completion`
   CompletionClientCapabilities completion;
+
+  /// Capabilities specific to `textDocument/publishDiagnostics`.
+  PublishDiagnosticsClientCapabilities publishDiagnostics;
 };
 bool fromJSON(const llvm::json::Value &, TextDocumentClientCapabilities &);
 
 struct ClientCapabilities {
   // Workspace specific client capabilities.
   llvm::Optional<WorkspaceClientCapabilities> workspace;
 
   // Text document specific client capabilities.

 bool fromJSON(const llvm::json::Value &, DocumentFormattingParams &);
 
 struct DocumentSymbolParams {
   // The text document to find symbols in.
   TextDocumentIdentifier textDocument;
 };
 bool fromJSON(const llvm::json::Value &, DocumentSymbolParams &);
 
+struct DiagnosticRelatedInformation {
+  /// The location of this related diagnostic information.
+  Location location;
+  /// The message of this related diagnostic information.
+  std::string message;
+};
+bool fromJSON(const llvm::json::Value &, DiagnosticRelatedInformation &);
+llvm::json::Value toJSON(const DiagnosticRelatedInformation &);
+
 struct Diagnostic {
   /// The range at which the message applies.
   Range range;
 
   /// The diagnostic's severity. Can be omitted. If omitted it is up to the
   /// client to interpret diagnostics as error, warning, info or hint.
   int severity = 0;
 
   /// The diagnostic's code. Can be omitted.
   /// Note: Not currently used by clangd
   // std::string code;
 
   /// A human-readable string describing the source of this
   /// diagnostic, e.g. 'typescript' or 'super lint'.
   /// Note: Not currently used by clangd
   // std::string source;
 
   /// The diagnostic's message.
   std::string message;
+
+  /// An array of related diagnostic information, e.g. when symbol-names within
+  /// a scope collide all definitions can be marked via this property.
+  std::vector<DiagnosticRelatedInformation> relatedInformation; 
 };
 
 /// 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 comparsion to avoid
 /// any regression issues from LSP clients (e.g. VScode), see
 /// https://git.io/vbr29
 struct LSPDiagnosticCompare {

clangd/Protocol.cpp

return json::Object{
       {"end", P.end},
   };
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Range &R) {
   return OS << R.start << '-' << R.end;
 }
 
+bool fromJSON(const llvm::json::Value& Params, Location &P) {
+  json::ObjectMapper O(Params);
+  return O && O.map("uri", P.uri) && O.map("range", P.range);
+}
+
 json::Value toJSON(const Location &P) {
   return json::Object{
       {"uri", P.uri},
       {"range", P.range},
   };
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Location &L) {
bool fromJSON(const json::Value &Params, WorkspaceSymbolCapabilities &R) {
   return O && O.map("symbolKind", R.symbolKind);
 }
 
 bool fromJSON(const json::Value &Params, WorkspaceClientCapabilities &R) {
   json::ObjectMapper O(Params);
   return O && O.map("symbol", R.symbol);
 }
 
+bool fromJSON(const json::Value &Params, PublishDiagnosticsClientCapabilities &R) {
+  json::ObjectMapper O(Params);
+  return O && O.map("symbol", R.relatedInformation);
+}
+
 bool fromJSON(const json::Value &Params, TextDocumentClientCapabilities &R) {
   json::ObjectMapper O(Params);
   if (!O)
     return false;
   O.map("completion", R.completion);
+  O.map("publishDiagnostics", R.publishDiagnostics);
   return true;
 }
 
 bool fromJSON(const json::Value &Params, ClientCapabilities &R) {
   json::ObjectMapper O(Params);
   if (!O)
     return false;
   O.map("textDocument", R.textDocument);
return O && O.map("textDocument", R.textDocument) &&
          O.map("options", R.options);
 }
 
 bool fromJSON(const json::Value &Params, DocumentSymbolParams &R) {
   json::ObjectMapper O(Params);
   return O && O.map("textDocument", R.textDocument);
 }
 
+bool fromJSON(const llvm::json::Value &Params, DiagnosticRelatedInformation &I) {
+  json::ObjectMapper O(Params);
+  return O && O.map("location", I.location) && O.map("message", I.message);
+}
+
+llvm::json::Value toJSON(const DiagnosticRelatedInformation &I) {
+  return json::Object{{"location", I.location}, {"message", I.message}};
+}
+
 bool fromJSON(const json::Value &Params, Diagnostic &R) {
   json::ObjectMapper O(Params);
   if (!O || !O.map("range", R.range) || !O.map("message", R.message))
     return false;
   O.map("severity", R.severity);
+  O.map("relatedInformation", R.relatedInformation);
   return true;
 }
 
 bool fromJSON(const json::Value &Params, CodeActionContext &R) {
   json::ObjectMapper O(Params);
   return O && O.map("diagnostics", R.diagnostics);
 }