1 //===--- Diagnostics.h -------------------------------------------*- C++-*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_DIAGNOSTICS_H 10 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_DIAGNOSTICS_H 11 12 #include "Protocol.h" 13 #include "clang/Basic/Diagnostic.h" 14 #include "clang/Basic/LangOptions.h" 15 #include "clang/Basic/SourceLocation.h" 16 #include "llvm/ADT/ArrayRef.h" 17 #include "llvm/ADT/DenseSet.h" 18 #include "llvm/ADT/Optional.h" 19 #include "llvm/ADT/SmallVector.h" 20 #include "llvm/ADT/StringSet.h" 21 #include "llvm/Support/JSON.h" 22 #include "llvm/Support/SourceMgr.h" 23 #include <cassert> 24 #include <functional> 25 #include <memory> 26 #include <string> 27 #include <utility> 28 #include <vector> 29 30 namespace clang { 31 namespace tidy { 32 class ClangTidyContext; 33 } // namespace tidy 34 namespace clangd { 35 36 struct ClangdDiagnosticOptions { 37 /// If true, Clangd uses an LSP extension to embed the fixes with the 38 /// diagnostics that are sent to the client. 39 bool EmbedFixesInDiagnostics = false; 40 41 /// If true, Clangd uses the relatedInformation field to include other 42 /// locations (in particular attached notes). 43 /// Otherwise, these are flattened into the diagnostic message. 44 bool EmitRelatedLocations = false; 45 46 /// If true, Clangd uses an LSP extension to send the diagnostic's 47 /// category to the client. The category typically describes the compilation 48 /// stage during which the issue was produced, e.g. "Semantic Issue" or "Parse 49 /// Issue". 50 bool SendDiagnosticCategory = false; 51 52 /// If true, Clangd will add a number of available fixes to the diagnostic's 53 /// message. 54 bool DisplayFixesCount = true; 55 }; 56 57 /// Contains basic information about a diagnostic. 58 struct DiagBase { 59 std::string Message; 60 // Intended to be used only in error messages. 61 // May be relative, absolute or even artificially constructed. 62 std::string File; 63 // Absolute path to containing file, if available. 64 llvm::Optional<std::string> AbsFile; 65 66 clangd::Range Range; 67 DiagnosticsEngine::Level Severity = DiagnosticsEngine::Note; 68 std::string Category; 69 // Since File is only descriptive, we store a separate flag to distinguish 70 // diags from the main file. 71 bool InsideMainFile = false; 72 unsigned ID = 0; // e.g. member of clang::diag, or clang-tidy assigned ID. 73 // Feature modules can make use of this field to propagate data from a 74 // diagnostic to a CodeAction request. Each module should only append to the 75 // list. 76 llvm::json::Object OpaqueData; 77 }; 78 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const DiagBase &D); 79 80 /// Represents a single fix-it that editor can apply to fix the error. 81 struct Fix { 82 /// Message for the fix-it. 83 std::string Message; 84 /// TextEdits from clang's fix-its. Must be non-empty. 85 llvm::SmallVector<TextEdit, 1> Edits; 86 }; 87 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Fix &F); 88 89 /// Represents a note for the diagnostic. Severity of notes can only be 'note' 90 /// or 'remark'. 91 struct Note : DiagBase {}; 92 93 /// A top-level diagnostic that may have Notes and Fixes. 94 struct Diag : DiagBase { 95 std::string Name; // if ID was recognized. 96 // The source of this diagnostic. 97 enum DiagSource { 98 Unknown, 99 Clang, 100 ClangTidy, 101 Clangd, 102 ClangdConfig, 103 } Source = Unknown; 104 /// Elaborate on the problem, usually pointing to a related piece of code. 105 std::vector<Note> Notes; 106 /// *Alternative* fixes for this diagnostic, one should be chosen. 107 std::vector<Fix> Fixes; 108 llvm::SmallVector<DiagnosticTag, 1> Tags; 109 }; 110 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Diag &D); 111 112 Diag toDiag(const llvm::SMDiagnostic &, Diag::DiagSource Source); 113 114 /// Conversion to LSP diagnostics. Formats the error message of each diagnostic 115 /// to include all its notes. Notes inside main file are also provided as 116 /// separate diagnostics with their corresponding fixits. Notes outside main 117 /// file do not have a corresponding LSP diagnostic, but can still be included 118 /// as part of their main diagnostic's message. 119 void toLSPDiags( 120 const Diag &D, const URIForFile &File, const ClangdDiagnosticOptions &Opts, 121 llvm::function_ref<void(clangd::Diagnostic, llvm::ArrayRef<Fix>)> OutFn); 122 123 /// Convert from Fix to LSP CodeAction. 124 CodeAction toCodeAction(const Fix &D, const URIForFile &File); 125 126 /// Convert from clang diagnostic level to LSP severity. 127 int getSeverity(DiagnosticsEngine::Level L); 128 129 /// Returns a URI providing more information about a particular diagnostic. 130 llvm::Optional<std::string> getDiagnosticDocURI(Diag::DiagSource, unsigned ID, 131 llvm::StringRef Name); 132 133 /// StoreDiags collects the diagnostics that can later be reported by 134 /// clangd. It groups all notes for a diagnostic into a single Diag 135 /// and filters out diagnostics that don't mention the main file (i.e. neither 136 /// the diag itself nor its notes are in the main file). 137 class StoreDiags : public DiagnosticConsumer { 138 public: 139 // The ClangTidyContext populates Source and Name for clang-tidy diagnostics. 140 std::vector<Diag> take(const clang::tidy::ClangTidyContext *Tidy = nullptr); 141 142 void BeginSourceFile(const LangOptions &Opts, 143 const Preprocessor *PP) override; 144 void EndSourceFile() override; 145 void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, 146 const clang::Diagnostic &Info) override; 147 148 /// When passed a main diagnostic, returns fixes to add to it. 149 /// When passed a note diagnostic, returns fixes to replace it with. 150 using DiagFixer = std::function<std::vector<Fix>(DiagnosticsEngine::Level, 151 const clang::Diagnostic &)>; 152 using LevelAdjuster = std::function<DiagnosticsEngine::Level( 153 DiagnosticsEngine::Level, const clang::Diagnostic &)>; 154 using DiagCallback = 155 std::function<void(const clang::Diagnostic &, clangd::Diag &)>; 156 /// If set, possibly adds fixes for diagnostics using \p Fixer. contributeFixes(DiagFixer Fixer)157 void contributeFixes(DiagFixer Fixer) { this->Fixer = Fixer; } 158 /// If set, this allows the client of this class to adjust the level of 159 /// diagnostics, such as promoting warnings to errors, or ignoring 160 /// diagnostics. setLevelAdjuster(LevelAdjuster Adjuster)161 void setLevelAdjuster(LevelAdjuster Adjuster) { this->Adjuster = Adjuster; } 162 /// Invokes a callback every time a diagnostics is completely formed. Handler 163 /// of the callback can also mutate the diagnostic. setDiagCallback(DiagCallback CB)164 void setDiagCallback(DiagCallback CB) { DiagCB = std::move(CB); } 165 166 private: 167 void flushLastDiag(); 168 169 DiagFixer Fixer = nullptr; 170 LevelAdjuster Adjuster = nullptr; 171 DiagCallback DiagCB = nullptr; 172 std::vector<Diag> Output; 173 llvm::Optional<LangOptions> LangOpts; 174 llvm::Optional<Diag> LastDiag; 175 llvm::Optional<FullSourceLoc> LastDiagLoc; // Valid only when LastDiag is set. 176 bool LastDiagOriginallyError = false; // Valid only when LastDiag is set. 177 SourceManager *OrigSrcMgr = nullptr; 178 179 llvm::DenseSet<std::pair<unsigned, unsigned>> IncludedErrorLocations; 180 }; 181 182 /// Determine whether a (non-clang-tidy) diagnostic is suppressed by config. 183 bool isBuiltinDiagnosticSuppressed(unsigned ID, 184 const llvm::StringSet<> &Suppressed, 185 const LangOptions &); 186 /// Take a user-specified diagnostic code, and convert it to a normalized form 187 /// stored in the config and consumed by isBuiltinDiagnosticsSuppressed. 188 /// 189 /// (This strips err_ and -W prefix so we can match with or without them.) 190 llvm::StringRef normalizeSuppressedCode(llvm::StringRef); 191 192 } // namespace clangd 193 } // namespace clang 194 195 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_DIAGNOSTICS_H 196