clang  9.0.0svn
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 
18 #include "clang/Basic/Diagnostic.h"
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 
27 namespace clang {
28 
29 class LangOptions;
30 class SourceManager;
31 
32 using DiagOrStoredDiag =
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.
48 protected:
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 
71  DiagnosticRenderer(const LangOptions &LangOpts,
72  DiagnosticOptions *DiagOpts);
73 
74  virtual ~DiagnosticRenderer();
75 
76  virtual void emitDiagnosticMessage(FullSourceLoc Loc, PresumedLoc PLoc,
78  StringRef Message,
80  DiagOrStoredDiag Info) = 0;
81 
82  virtual void emitDiagnosticLoc(FullSourceLoc Loc, PresumedLoc PLoc,
84  ArrayRef<CharSourceRange> Ranges) = 0;
85 
86  virtual void emitCodeContext(FullSourceLoc Loc,
89  ArrayRef<FixItHint> Hints) = 0;
90 
91  virtual void emitIncludeLocation(FullSourceLoc Loc, PresumedLoc PLoc) = 0;
92  virtual void emitImportLocation(FullSourceLoc Loc, PresumedLoc PLoc,
93  StringRef ModuleName) = 0;
95  StringRef ModuleName) = 0;
96 
101 
102 private:
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 
119 public:
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.
143 public:
146  : DiagnosticRenderer(LangOpts, DiagOpts) {}
147 
148  ~DiagnosticNoteRenderer() override;
149 
150  void emitIncludeLocation(FullSourceLoc Loc, PresumedLoc PLoc) override;
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
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:1438
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:49
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:1568
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:151
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
Definition: Diagnostic.h:1317
A SourceLocation and its associated SourceManager.
This class handles loading and caching of source files into memory.