clang  8.0.0svn
DiagnosticRenderer.h
Go to the documentation of this file.
1 //===- DiagnosticRenderer.h - Diagnostic Pretty-Printing --------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This is a utility class that provides support for pretty-printing of
11 // diagnostics. It is used to implement the different code paths which require
12 // such functionality in a consistent way.
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #ifndef LLVM_CLANG_FRONTEND_DIAGNOSTICRENDERER_H
17 #define LLVM_CLANG_FRONTEND_DIAGNOSTICRENDERER_H
18 
19 #include "clang/Basic/Diagnostic.h"
21 #include "clang/Basic/LLVM.h"
23 #include "llvm/ADT/ArrayRef.h"
24 #include "llvm/ADT/IntrusiveRefCntPtr.h"
25 #include "llvm/ADT/PointerUnion.h"
26 #include "llvm/ADT/StringRef.h"
27 
28 namespace clang {
29 
30 class LangOptions;
31 class SourceManager;
32 
33 using DiagOrStoredDiag =
34  llvm::PointerUnion<const Diagnostic *, const StoredDiagnostic *>;
35 
36 /// Class to encapsulate the logic for formatting a diagnostic message.
37 ///
38 /// Actual "printing" logic is implemented by subclasses.
39 ///
40 /// This class provides an interface for building and emitting
41 /// diagnostic, including all of the macro backtraces, caret diagnostics, FixIt
42 /// Hints, and code snippets. In the presence of macros this involves
43 /// a recursive process, synthesizing notes for each macro expansion.
44 ///
45 /// A brief worklist:
46 /// FIXME: Sink the recursive printing of template instantiations into this
47 /// class.
49 protected:
52 
53  /// The location of the previous diagnostic if known.
54  ///
55  /// This will be invalid in cases where there is no (known) previous
56  /// diagnostic location, or that location itself is invalid or comes from
57  /// a different source manager than SM.
59 
60  /// The location of the last include whose stack was printed if known.
61  ///
62  /// Same restriction as LastLoc essentially, but tracking include stack
63  /// root locations rather than diagnostic locations.
65 
66  /// The level of the last diagnostic emitted.
67  ///
68  /// The level of the last diagnostic emitted. Used to detect level changes
69  /// which change the amount of information displayed.
71 
72  DiagnosticRenderer(const LangOptions &LangOpts,
73  DiagnosticOptions *DiagOpts);
74 
75  virtual ~DiagnosticRenderer();
76 
77  virtual void emitDiagnosticMessage(FullSourceLoc Loc, PresumedLoc PLoc,
79  StringRef Message,
81  DiagOrStoredDiag Info) = 0;
82 
83  virtual void emitDiagnosticLoc(FullSourceLoc Loc, PresumedLoc PLoc,
85  ArrayRef<CharSourceRange> Ranges) = 0;
86 
87  virtual void emitCodeContext(FullSourceLoc Loc,
90  ArrayRef<FixItHint> Hints) = 0;
91 
92  virtual void emitIncludeLocation(FullSourceLoc Loc, PresumedLoc PLoc) = 0;
93  virtual void emitImportLocation(FullSourceLoc Loc, PresumedLoc PLoc,
94  StringRef ModuleName) = 0;
96  StringRef ModuleName) = 0;
97 
102 
103 private:
104  void emitBasicNote(StringRef Message);
105  void emitIncludeStack(FullSourceLoc Loc, PresumedLoc PLoc,
107  void emitIncludeStackRecursively(FullSourceLoc Loc);
108  void emitImportStack(FullSourceLoc Loc);
109  void emitImportStackRecursively(FullSourceLoc Loc, StringRef ModuleName);
110  void emitModuleBuildStack(const SourceManager &SM);
111  void emitCaret(FullSourceLoc Loc, DiagnosticsEngine::Level Level,
113  void emitSingleMacroExpansion(FullSourceLoc Loc,
116  void emitMacroExpansions(FullSourceLoc Loc, DiagnosticsEngine::Level Level,
118  ArrayRef<FixItHint> Hints);
119 
120 public:
121  /// Emit a diagnostic.
122  ///
123  /// This is the primary entry point for emitting diagnostic messages.
124  /// It handles formatting and rendering the message as well as any ancillary
125  /// information needed based on macros whose expansions impact the
126  /// diagnostic.
127  ///
128  /// \param Loc The location for this caret.
129  /// \param Level The level of the diagnostic to be emitted.
130  /// \param Message The diagnostic message to emit.
131  /// \param Ranges The underlined ranges for this code snippet.
132  /// \param FixItHints The FixIt hints active for this diagnostic.
134  StringRef Message, ArrayRef<CharSourceRange> Ranges,
135  ArrayRef<FixItHint> FixItHints,
136  DiagOrStoredDiag D = (Diagnostic *)nullptr);
137 
139 };
140 
141 /// Subclass of DiagnosticRender that turns all subdiagostics into explicit
142 /// notes. It is up to subclasses to further define the behavior.
144 public:
147  : DiagnosticRenderer(LangOpts, DiagOpts) {}
148 
149  ~DiagnosticNoteRenderer() override;
150 
151  void emitIncludeLocation(FullSourceLoc Loc, PresumedLoc PLoc) override;
152 
154  StringRef ModuleName) override;
155 
157  StringRef ModuleName) override;
158 
159  virtual void emitNote(FullSourceLoc Loc, StringRef Message) = 0;
160 };
161 
162 } // namespace clang
163 
164 #endif // LLVM_CLANG_FRONTEND_DIAGNOSTICRENDERER_H
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.
virtual void emitCodeContext(FullSourceLoc Loc, DiagnosticsEngine::Level Level, SmallVectorImpl< CharSourceRange > &Ranges, ArrayRef< FixItHint > Hints)=0
Represents a diagnostic in a form that can be retained until its corresponding source manager is dest...
Definition: Diagnostic.h:1434
void emitStoredDiagnostic(StoredDiagnostic &Diag)
llvm::PointerUnion< const Diagnostic *, const StoredDiagnostic * > DiagOrStoredDiag
const LangOptions & LangOpts
virtual void emitBuildingModuleLocation(FullSourceLoc Loc, PresumedLoc PLoc, StringRef ModuleName)=0
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:50
Class to encapsulate the logic for formatting a diagnostic message.
virtual void emitImportLocation(FullSourceLoc Loc, PresumedLoc PLoc, StringRef ModuleName)=0
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
void emitDiagnostic(FullSourceLoc Loc, DiagnosticsEngine::Level Level, StringRef Message, ArrayRef< CharSourceRange > Ranges, ArrayRef< FixItHint > FixItHints, DiagOrStoredDiag D=(Diagnostic *) nullptr)
Emit a diagnostic.
DiagnosticsEngine::Level LastLevel
The level of the last diagnostic emitted.
Defines the Diagnostic-related interfaces.
IntrusiveRefCntPtr< DiagnosticOptions > DiagOpts
DiagnosticNoteRenderer(const LangOptions &LangOpts, DiagnosticOptions *DiagOpts)
Represents an unpacked "presumed" location which can be presented to the user.
const SourceManager & SM
Definition: Format.cpp:1490
virtual void emitDiagnosticLoc(FullSourceLoc Loc, PresumedLoc PLoc, DiagnosticsEngine::Level Level, ArrayRef< CharSourceRange > Ranges)=0
virtual void emitDiagnosticMessage(FullSourceLoc Loc, PresumedLoc PLoc, DiagnosticsEngine::Level Level, StringRef Message, ArrayRef< CharSourceRange > Ranges, DiagOrStoredDiag Info)=0
Encodes a location in the source.
Subclass of DiagnosticRender that turns all subdiagostics into explicit notes.
Options for controlling the compiler diagnostics engine.
virtual void beginDiagnostic(DiagOrStoredDiag D, DiagnosticsEngine::Level Level)
DiagnosticRenderer(const LangOptions &LangOpts, DiagnosticOptions *DiagOpts)
SourceLocation LastLoc
The location of the previous diagnostic if known.
Dataflow Directional Tag Classes.
SourceLocation LastIncludeLoc
The location of the last include whose stack was printed if known.
virtual void endDiagnostic(DiagOrStoredDiag D, DiagnosticsEngine::Level Level)
virtual void emitIncludeLocation(FullSourceLoc Loc, PresumedLoc PLoc)=0
Defines the clang::SourceLocation class and associated facilities.
Level
The level of the diagnostic, after it has been through mapping.
Definition: Diagnostic.h:152
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
Definition: Diagnostic.h:1313
A SourceLocation and its associated SourceManager.
This class handles loading and caching of source files into memory.