[clang-tidy] Fix ParentVirtualCallCheck for old MSVS compilers
[lldb.git] / clang-tools-extra / pp-trace / PPCallbacksTracker.h
1 //===--- PPCallbacksTracker.h - Preprocessor tracking -----------*- 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 /// \file
11 /// \brief Classes and definitions for preprocessor tracking.
12 ///
13 /// The core definition is the PPCallbacksTracker class, derived from Clang's
14 /// PPCallbacks class from the Lex library, which overrides all the callbacks
15 /// and collects information about each callback call, saving it in a
16 /// data structure built up of CallbackCall and Argument objects, which
17 /// record the preprocessor callback name and arguments in high-level string
18 /// form for later inspection.
19 ///
20 //===----------------------------------------------------------------------===//
21
22 #ifndef PPTRACE_PPCALLBACKSTRACKER_H
23 #define PPTRACE_PPCALLBACKSTRACKER_H
24
25 #include "clang/Lex/PPCallbacks.h"
26 #include "clang/Lex/Preprocessor.h"
27 #include "clang/Basic/SourceManager.h"
28 #include "llvm/ADT/ArrayRef.h"
29 #include "llvm/ADT/SmallSet.h"
30 #include "llvm/ADT/StringRef.h"
31 #include <string>
32 #include <vector>
33
34 /// \brief This class represents one callback function argument by name
35 ///   and value.
36 class Argument {
37 public:
38   Argument(llvm::StringRef Name, llvm::StringRef Value)
39       : Name(Name), Value(Value) {}
40   Argument() = default;
41
42   std::string Name;
43   std::string Value;
44 };
45
46 /// \brief This class represents one callback call by name and an array
47 ///   of arguments.
48 class CallbackCall {
49 public:
50   CallbackCall(llvm::StringRef Name) : Name(Name) {}
51   CallbackCall() = default;
52
53   std::string Name;
54   std::vector<Argument> Arguments;
55 };
56
57 /// \brief This class overrides the PPCallbacks class for tracking preprocessor
58 ///   activity by means of its callback functions.
59 ///
60 /// This object is given a vector for storing the trace information, built up
61 /// of CallbackCall and subordinate Argument objects for representing the
62 /// callback calls and their arguments.  It's a reference so the vector can
63 /// exist beyond the lifetime of this object, because it's deleted by the
64 /// preprocessor automatically in its destructor.
65 ///
66 /// This class supports a mechanism for inhibiting trace output for
67 /// specific callbacks by name, for the purpose of eliminating output for
68 /// callbacks of no interest that might clutter the output.
69 ///
70 /// Following the constructor and destructor function declarations, the
71 /// overidden callback functions are defined.  The remaining functions are
72 /// helpers for recording the trace data, to reduce the coupling between it
73 /// and the recorded data structure.
74 class PPCallbacksTracker : public clang::PPCallbacks {
75 public:
76   /// \brief Note that all of the arguments are references, and owned
77   /// by the caller.
78   /// \param Ignore - Set of names of callbacks to ignore.
79   /// \param CallbackCalls - Trace buffer.
80   /// \param PP - The preprocessor.  Needed for getting some argument strings.
81   PPCallbacksTracker(llvm::SmallSet<std::string, 4> &Ignore,
82                      std::vector<CallbackCall> &CallbackCalls,
83                      clang::Preprocessor &PP);
84
85   ~PPCallbacksTracker() override;
86
87   // Overidden callback functions.
88
89   void FileChanged(clang::SourceLocation Loc,
90                    clang::PPCallbacks::FileChangeReason Reason,
91                    clang::SrcMgr::CharacteristicKind FileType,
92                    clang::FileID PrevFID = clang::FileID()) override;
93   void FileSkipped(const clang::FileEntry &SkippedFile,
94                    const clang::Token &FilenameTok,
95                    clang::SrcMgr::CharacteristicKind FileType) override;
96   bool FileNotFound(llvm::StringRef FileName,
97                     llvm::SmallVectorImpl<char> &RecoveryPath) override;
98   void InclusionDirective(clang::SourceLocation HashLoc,
99                           const clang::Token &IncludeTok,
100                           llvm::StringRef FileName, bool IsAngled,
101                           clang::CharSourceRange FilenameRange,
102                           const clang::FileEntry *File,
103                           llvm::StringRef SearchPath,
104                           llvm::StringRef RelativePath,
105                           const clang::Module *Imported) override;
106   void moduleImport(clang::SourceLocation ImportLoc, clang::ModuleIdPath Path,
107                     const clang::Module *Imported) override;
108   void EndOfMainFile() override;
109   void Ident(clang::SourceLocation Loc, llvm::StringRef str) override;
110   void PragmaDirective(clang::SourceLocation Loc,
111                        clang::PragmaIntroducerKind Introducer) override;
112   void PragmaComment(clang::SourceLocation Loc,
113                      const clang::IdentifierInfo *Kind,
114                      llvm::StringRef Str) override;
115   void PragmaDetectMismatch(clang::SourceLocation Loc, llvm::StringRef Name,
116                             llvm::StringRef Value) override;
117   void PragmaDebug(clang::SourceLocation Loc,
118                    llvm::StringRef DebugType) override;
119   void PragmaMessage(clang::SourceLocation Loc, llvm::StringRef Namespace,
120                      clang::PPCallbacks::PragmaMessageKind Kind,
121                      llvm::StringRef Str) override;
122   void PragmaDiagnosticPush(clang::SourceLocation Loc,
123                             llvm::StringRef Namespace) override;
124   void PragmaDiagnosticPop(clang::SourceLocation Loc,
125                            llvm::StringRef Namespace) override;
126   void PragmaDiagnostic(clang::SourceLocation Loc, llvm::StringRef Namespace,
127                         clang::diag::Severity mapping,
128                         llvm::StringRef Str) override;
129   void PragmaOpenCLExtension(clang::SourceLocation NameLoc,
130                              const clang::IdentifierInfo *Name,
131                              clang::SourceLocation StateLoc,
132                              unsigned State) override;
133   void PragmaWarning(clang::SourceLocation Loc, llvm::StringRef WarningSpec,
134                      llvm::ArrayRef<int> Ids) override;
135   void PragmaWarningPush(clang::SourceLocation Loc, int Level) override;
136   void PragmaWarningPop(clang::SourceLocation Loc) override;
137   void MacroExpands(const clang::Token &MacroNameTok,
138                     const clang::MacroDefinition &MD, clang::SourceRange Range,
139                     const clang::MacroArgs *Args) override;
140   void MacroDefined(const clang::Token &MacroNameTok,
141                     const clang::MacroDirective *MD) override;
142   void MacroUndefined(const clang::Token &MacroNameTok,
143                       const clang::MacroDefinition &MD,
144                       const clang::MacroDirective *Undef) override;
145   void Defined(const clang::Token &MacroNameTok,
146                const clang::MacroDefinition &MD,
147                clang::SourceRange Range) override;
148   void SourceRangeSkipped(clang::SourceRange Range,
149                           clang::SourceLocation EndifLoc) override;
150   void If(clang::SourceLocation Loc, clang::SourceRange ConditionRange,
151           ConditionValueKind ConditionValue) override;
152   void Elif(clang::SourceLocation Loc, clang::SourceRange ConditionRange,
153             ConditionValueKind ConditionValue, clang::SourceLocation IfLoc) override;
154   void Ifdef(clang::SourceLocation Loc, const clang::Token &MacroNameTok,
155              const clang::MacroDefinition &MD) override;
156   void Ifndef(clang::SourceLocation Loc, const clang::Token &MacroNameTok,
157               const clang::MacroDefinition &MD) override;
158   void Else(clang::SourceLocation Loc,
159             clang::SourceLocation IfLoc) override;
160   void Endif(clang::SourceLocation Loc,
161              clang::SourceLocation IfLoc) override;
162
163   // Helper functions.
164
165   /// \brief Start a new callback.
166   void beginCallback(const char *Name);
167
168   /// \brief Append a string to the top trace item.
169   void append(const char *Str);
170
171   /// \brief Append a bool argument to the top trace item.
172   void appendArgument(const char *Name, bool Value);
173
174   /// \brief Append an int argument to the top trace item.
175   void appendArgument(const char *Name, int Value);
176
177   /// \brief Append a string argument to the top trace item.
178   void appendArgument(const char *Name, const char *Value);
179
180   /// \brief Append a string reference object argument to the top trace item.
181   void appendArgument(const char *Name, llvm::StringRef Value);
182
183   /// \brief Append a string object argument to the top trace item.
184   void appendArgument(const char *Name, const std::string &Value);
185
186   /// \brief Append a token argument to the top trace item.
187   void appendArgument(const char *Name, const clang::Token &Value);
188
189   /// \brief Append an enum argument to the top trace item.
190   void appendArgument(const char *Name, int Value, const char *const Strings[]);
191
192   /// \brief Append a FileID argument to the top trace item.
193   void appendArgument(const char *Name, clang::FileID Value);
194
195   /// \brief Append a FileEntry argument to the top trace item.
196   void appendArgument(const char *Name, const clang::FileEntry *Value);
197
198   /// \brief Append a SourceLocation argument to the top trace item.
199   void appendArgument(const char *Name, clang::SourceLocation Value);
200
201   /// \brief Append a SourceRange argument to the top trace item.
202   void appendArgument(const char *Name, clang::SourceRange Value);
203
204   /// \brief Append a CharSourceRange argument to the top trace item.
205   void appendArgument(const char *Name, clang::CharSourceRange Value);
206
207   /// \brief Append a ModuleIdPath argument to the top trace item.
208   void appendArgument(const char *Name, clang::ModuleIdPath Value);
209
210   /// \brief Append an IdentifierInfo argument to the top trace item.
211   void appendArgument(const char *Name, const clang::IdentifierInfo *Value);
212
213   /// \brief Append a MacroDirective argument to the top trace item.
214   void appendArgument(const char *Name, const clang::MacroDirective *Value);
215
216   /// \brief Append a MacroDefinition argument to the top trace item.
217   void appendArgument(const char *Name, const clang::MacroDefinition &Value);
218
219   /// \brief Append a MacroArgs argument to the top trace item.
220   void appendArgument(const char *Name, const clang::MacroArgs *Value);
221
222   /// \brief Append a Module argument to the top trace item.
223   void appendArgument(const char *Name, const clang::Module *Value);
224
225   /// \brief Append a double-quoted argument to the top trace item.
226   void appendQuotedArgument(const char *Name, const std::string &Value);
227
228   /// \brief Append a double-quoted file path argument to the top trace item.
229   void appendFilePathArgument(const char *Name, llvm::StringRef Value);
230
231   /// \brief Get the raw source string of the range.
232   llvm::StringRef getSourceString(clang::CharSourceRange Range);
233
234   /// \brief Callback trace information.
235   /// We use a reference so the trace will be preserved for the caller
236   /// after this object is destructed.
237   std::vector<CallbackCall> &CallbackCalls;
238
239   /// \brief Names of callbacks to ignore.
240   llvm::SmallSet<std::string, 4> &Ignore;
241
242   /// \brief Inhibit trace while this is set.
243   bool DisableTrace;
244
245   clang::Preprocessor &PP;
246 };
247
248 #endif // PPTRACE_PPCALLBACKSTRACKER_H