clang 19.0.0git
DiagnosticRenderer.h
Go to the documentation of this file.
1//===- DiagnosticRenderer.h - Diagnostic Pretty-Printing --------*- 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// This is a utility class that provides support for pretty-printing of
10// diagnostics. It is used to implement the different code paths which require
11// such functionality in a consistent way.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_CLANG_FRONTEND_DIAGNOSTICRENDERER_H
16#define LLVM_CLANG_FRONTEND_DIAGNOSTICRENDERER_H
17
20#include "clang/Basic/LLVM.h"
22#include "llvm/ADT/ArrayRef.h"
23#include "llvm/ADT/IntrusiveRefCntPtr.h"
24#include "llvm/ADT/PointerUnion.h"
25#include "llvm/ADT/StringRef.h"
26
27namespace clang {
28
29class LangOptions;
30class SourceManager;
31
33 llvm::PointerUnion<const Diagnostic *, const StoredDiagnostic *>;
34
35/// Class to encapsulate the logic for formatting a diagnostic message.
36///
37/// Actual "printing" logic is implemented by subclasses.
38///
39/// This class provides an interface for building and emitting
40/// diagnostic, including all of the macro backtraces, caret diagnostics, FixIt
41/// Hints, and code snippets. In the presence of macros this involves
42/// a recursive process, synthesizing notes for each macro expansion.
43///
44/// A brief worklist:
45/// FIXME: Sink the recursive printing of template instantiations into this
46/// class.
48protected:
51
52 /// The location of the previous diagnostic if known.
53 ///
54 /// This will be invalid in cases where there is no (known) previous
55 /// diagnostic location, or that location itself is invalid or comes from
56 /// a different source manager than SM.
58
59 /// The location of the last include whose stack was printed if known.
60 ///
61 /// Same restriction as LastLoc essentially, but tracking include stack
62 /// root locations rather than diagnostic locations.
64
65 /// The level of the last diagnostic emitted.
66 ///
67 /// The level of the last diagnostic emitted. Used to detect level changes
68 /// which change the amount of information displayed.
70
73
75
78 StringRef Message,
80 DiagOrStoredDiag Info) = 0;
81
84 ArrayRef<CharSourceRange> Ranges) = 0;
85
89 ArrayRef<FixItHint> Hints) = 0;
90
93 StringRef ModuleName) = 0;
95 StringRef ModuleName) = 0;
96
101
102private:
103 void emitBasicNote(StringRef Message);
104 void emitIncludeStack(FullSourceLoc Loc, PresumedLoc PLoc,
106 void emitIncludeStackRecursively(FullSourceLoc Loc);
107 void emitImportStack(FullSourceLoc Loc);
108 void emitImportStackRecursively(FullSourceLoc Loc, StringRef ModuleName);
109 void emitModuleBuildStack(const SourceManager &SM);
110 void emitCaret(FullSourceLoc Loc, DiagnosticsEngine::Level Level,
112 void emitSingleMacroExpansion(FullSourceLoc Loc,
115 void emitMacroExpansions(FullSourceLoc Loc, DiagnosticsEngine::Level Level,
117 ArrayRef<FixItHint> Hints);
118
119public:
120 /// Emit a diagnostic.
121 ///
122 /// This is the primary entry point for emitting diagnostic messages.
123 /// It handles formatting and rendering the message as well as any ancillary
124 /// information needed based on macros whose expansions impact the
125 /// diagnostic.
126 ///
127 /// \param Loc The location for this caret.
128 /// \param Level The level of the diagnostic to be emitted.
129 /// \param Message The diagnostic message to emit.
130 /// \param Ranges The underlined ranges for this code snippet.
131 /// \param FixItHints The FixIt hints active for this diagnostic.
133 StringRef Message, ArrayRef<CharSourceRange> Ranges,
134 ArrayRef<FixItHint> FixItHints,
135 DiagOrStoredDiag D = (Diagnostic *)nullptr);
136
138};
139
140/// Subclass of DiagnosticRender that turns all subdiagostics into explicit
141/// notes. It is up to subclasses to further define the behavior.
143public:
147
149
151
153 StringRef ModuleName) override;
154
156 StringRef ModuleName) override;
157
158 virtual void emitNote(FullSourceLoc Loc, StringRef Message) = 0;
159};
160
161} // namespace clang
162
163#endif // LLVM_CLANG_FRONTEND_DIAGNOSTICRENDERER_H
#define SM(sm)
Definition: Cuda.cpp:84
Defines the Diagnostic-related interfaces.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
SourceLocation Loc
Definition: SemaObjC.cpp:758
Defines the clang::SourceLocation class and associated facilities.
Subclass of DiagnosticRender that turns all subdiagostics into explicit notes.
virtual void emitNote(FullSourceLoc Loc, StringRef Message)=0
void emitBuildingModuleLocation(FullSourceLoc Loc, PresumedLoc PLoc, StringRef ModuleName) override
void emitIncludeLocation(FullSourceLoc Loc, PresumedLoc PLoc) override
DiagnosticNoteRenderer(const LangOptions &LangOpts, DiagnosticOptions *DiagOpts)
void emitImportLocation(FullSourceLoc Loc, PresumedLoc PLoc, StringRef ModuleName) override
Options for controlling the compiler diagnostics engine.
Class to encapsulate the logic for formatting a diagnostic message.
virtual void endDiagnostic(DiagOrStoredDiag D, DiagnosticsEngine::Level Level)
virtual void emitIncludeLocation(FullSourceLoc Loc, PresumedLoc PLoc)=0
const LangOptions & LangOpts
void emitStoredDiagnostic(StoredDiagnostic &Diag)
virtual void emitDiagnosticLoc(FullSourceLoc Loc, PresumedLoc PLoc, DiagnosticsEngine::Level Level, ArrayRef< CharSourceRange > Ranges)=0
SourceLocation LastLoc
The location of the previous diagnostic if known.
DiagnosticsEngine::Level LastLevel
The level of the last diagnostic emitted.
virtual void emitImportLocation(FullSourceLoc Loc, PresumedLoc PLoc, StringRef ModuleName)=0
virtual void emitDiagnosticMessage(FullSourceLoc Loc, PresumedLoc PLoc, DiagnosticsEngine::Level Level, StringRef Message, ArrayRef< CharSourceRange > Ranges, DiagOrStoredDiag Info)=0
SourceLocation LastIncludeLoc
The location of the last include whose stack was printed if known.
virtual void emitBuildingModuleLocation(FullSourceLoc Loc, PresumedLoc PLoc, StringRef ModuleName)=0
void emitDiagnostic(FullSourceLoc Loc, DiagnosticsEngine::Level Level, StringRef Message, ArrayRef< CharSourceRange > Ranges, ArrayRef< FixItHint > FixItHints, DiagOrStoredDiag D=(Diagnostic *) nullptr)
Emit a diagnostic.
virtual void emitCodeContext(FullSourceLoc Loc, DiagnosticsEngine::Level Level, SmallVectorImpl< CharSourceRange > &Ranges, ArrayRef< FixItHint > Hints)=0
IntrusiveRefCntPtr< DiagnosticOptions > DiagOpts
virtual void beginDiagnostic(DiagOrStoredDiag D, DiagnosticsEngine::Level Level)
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
Definition: Diagnostic.h:1571
Level
The level of the diagnostic, after it has been through mapping.
Definition: Diagnostic.h:195
A SourceLocation and its associated SourceManager.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:461
Represents an unpacked "presumed" location which can be presented to the user.
Encodes a location in the source.
This class handles loading and caching of source files into memory.
Represents a diagnostic in a form that can be retained until its corresponding source manager is dest...
Definition: Diagnostic.h:1695
The JSON file list parser is used to communicate input to InstallAPI.
llvm::PointerUnion< const Diagnostic *, const StoredDiagnostic * > DiagOrStoredDiag