| 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/SmallVector.h" |
| 19 |
#include "llvm/ADT/StringSet.h" |
| 20 |
#include "llvm/Support/JSON.h" |
| 21 |
#include "llvm/Support/SourceMgr.h" |
| 22 |
#include <cassert> |
| 23 |
#include <functional> |
| 24 |
#include <memory> |
| 25 |
#include <optional> |
| 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 |
std::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 |
std::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. |
| 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. |
| 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. |
| 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 |
std::optional<LangOptions> LangOpts; |
| 174 |
std::optional<Diag> LastDiag; |
| 175 |
std::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 |