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"
20 #include "clang/Basic/DiagnosticOptions.h"
21 #include "clang/Basic/LLVM.h"
22 #include "clang/Basic/SourceLocation.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.
48 class DiagnosticRenderer {
49 protected:
50   const LangOptions &LangOpts;
51   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
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.
58   SourceLocation LastLoc;
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.
64   SourceLocation LastIncludeLoc;
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.
70   DiagnosticsEngine::Level LastLevel = DiagnosticsEngine::Ignored;
71 
72   DiagnosticRenderer(const LangOptions &LangOpts,
73                      DiagnosticOptions *DiagOpts);
74 
75   virtual ~DiagnosticRenderer();
76 
77   virtual void emitDiagnosticMessage(FullSourceLoc Loc, PresumedLoc PLoc,
78                                      DiagnosticsEngine::Level Level,
79                                      StringRef Message,
80                                      ArrayRef<CharSourceRange> Ranges,
81                                      DiagOrStoredDiag Info) = 0;
82 
83   virtual void emitDiagnosticLoc(FullSourceLoc Loc, PresumedLoc PLoc,
84                                  DiagnosticsEngine::Level Level,
85                                  ArrayRef<CharSourceRange> Ranges) = 0;
86 
87   virtual void emitCodeContext(FullSourceLoc Loc,
88                                DiagnosticsEngine::Level Level,
89                                SmallVectorImpl<CharSourceRange> &Ranges,
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;
95   virtual void emitBuildingModuleLocation(FullSourceLoc Loc, PresumedLoc PLoc,
96                                           StringRef ModuleName) = 0;
97 
beginDiagnostic(DiagOrStoredDiag D,DiagnosticsEngine::Level Level)98   virtual void beginDiagnostic(DiagOrStoredDiag D,
99                                DiagnosticsEngine::Level Level) {}
endDiagnostic(DiagOrStoredDiag D,DiagnosticsEngine::Level Level)100   virtual void endDiagnostic(DiagOrStoredDiag D,
101                              DiagnosticsEngine::Level Level) {}
102 
103 private:
104   void emitBasicNote(StringRef Message);
105   void emitIncludeStack(FullSourceLoc Loc, PresumedLoc PLoc,
106                         DiagnosticsEngine::Level Level);
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,
112                  ArrayRef<CharSourceRange> Ranges, ArrayRef<FixItHint> Hints);
113   void emitSingleMacroExpansion(FullSourceLoc Loc,
114                                 DiagnosticsEngine::Level Level,
115                                 ArrayRef<CharSourceRange> Ranges);
116   void emitMacroExpansions(FullSourceLoc Loc, DiagnosticsEngine::Level Level,
117                            ArrayRef<CharSourceRange> Ranges,
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.
133   void emitDiagnostic(FullSourceLoc Loc, DiagnosticsEngine::Level Level,
134                       StringRef Message, ArrayRef<CharSourceRange> Ranges,
135                       ArrayRef<FixItHint> FixItHints,
136                       DiagOrStoredDiag D = (Diagnostic *)nullptr);
137 
138   void emitStoredDiagnostic(StoredDiagnostic &Diag);
139 };
140 
141 /// Subclass of DiagnosticRender that turns all subdiagostics into explicit
142 /// notes.  It is up to subclasses to further define the behavior.
143 class DiagnosticNoteRenderer : public DiagnosticRenderer {
144 public:
DiagnosticNoteRenderer(const LangOptions & LangOpts,DiagnosticOptions * DiagOpts)145   DiagnosticNoteRenderer(const LangOptions &LangOpts,
146                          DiagnosticOptions *DiagOpts)
147       : DiagnosticRenderer(LangOpts, DiagOpts) {}
148 
149   ~DiagnosticNoteRenderer() override;
150 
151   void emitIncludeLocation(FullSourceLoc Loc, PresumedLoc PLoc) override;
152 
153   void emitImportLocation(FullSourceLoc Loc, PresumedLoc PLoc,
154                           StringRef ModuleName) override;
155 
156   void emitBuildingModuleLocation(FullSourceLoc Loc, PresumedLoc PLoc,
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
165