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