clang 19.0.0git
TextNodeDumper.h
Go to the documentation of this file.
1//===--- TextNodeDumper.h - Printing of AST nodes -------------------------===//
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 file implements AST dumping of components of individual AST nodes.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CLANG_AST_TEXTNODEDUMPER_H
14#define LLVM_CLANG_AST_TEXTNODEDUMPER_H
15
23#include "clang/AST/ExprCXX.h"
26#include "clang/AST/Type.h"
29
30namespace clang {
31
32class APValue;
33
35 raw_ostream &OS;
36 const bool ShowColors;
37
38 /// Pending[i] is an action to dump an entity at level i.
39 llvm::SmallVector<std::function<void(bool IsLastChild)>, 32> Pending;
40
41 /// Indicates whether we're at the top level.
42 bool TopLevel = true;
43
44 /// Indicates if we're handling the first child after entering a new depth.
45 bool FirstChild = true;
46
47 /// Prefix for currently-being-dumped entity.
48 std::string Prefix;
49
50public:
51 /// Add a child of the current node. Calls DoAddChild without arguments
52 template <typename Fn> void AddChild(Fn DoAddChild) {
53 return AddChild("", DoAddChild);
54 }
55
56 /// Add a child of the current node with an optional label.
57 /// Calls DoAddChild without arguments.
58 template <typename Fn> void AddChild(StringRef Label, Fn DoAddChild) {
59 // If we're at the top level, there's nothing interesting to do; just
60 // run the dumper.
61 if (TopLevel) {
62 TopLevel = false;
63 DoAddChild();
64 while (!Pending.empty()) {
65 Pending.back()(true);
66 Pending.pop_back();
67 }
68 Prefix.clear();
69 OS << "\n";
70 TopLevel = true;
71 return;
72 }
73
74 auto DumpWithIndent = [this, DoAddChild,
75 Label(Label.str())](bool IsLastChild) {
76 // Print out the appropriate tree structure and work out the prefix for
77 // children of this node. For instance:
78 //
79 // A Prefix = ""
80 // |-B Prefix = "| "
81 // | `-C Prefix = "| "
82 // `-D Prefix = " "
83 // |-E Prefix = " | "
84 // `-F Prefix = " "
85 // G Prefix = ""
86 //
87 // Note that the first level gets no prefix.
88 {
89 OS << '\n';
91 OS << Prefix << (IsLastChild ? '`' : '|') << '-';
92 if (!Label.empty())
93 OS << Label << ": ";
94
95 this->Prefix.push_back(IsLastChild ? ' ' : '|');
96 this->Prefix.push_back(' ');
97 }
98
99 FirstChild = true;
100 unsigned Depth = Pending.size();
101
102 DoAddChild();
103
104 // If any children are left, they're the last at their nesting level.
105 // Dump those ones out now.
106 while (Depth < Pending.size()) {
107 Pending.back()(true);
108 this->Pending.pop_back();
109 }
110
111 // Restore the old prefix.
112 this->Prefix.resize(Prefix.size() - 2);
113 };
114
115 if (FirstChild) {
116 Pending.push_back(std::move(DumpWithIndent));
117 } else {
118 Pending.back()(false);
119 Pending.back() = std::move(DumpWithIndent);
120 }
121 FirstChild = false;
122 }
123
124 TextTreeStructure(raw_ostream &OS, bool ShowColors)
125 : OS(OS), ShowColors(ShowColors) {}
126};
127
129 : public TextTreeStructure,
130 public comments::ConstCommentVisitor<TextNodeDumper, void,
131 const comments::FullComment *>,
132 public ConstAttrVisitor<TextNodeDumper>,
133 public ConstTemplateArgumentVisitor<TextNodeDumper>,
134 public ConstStmtVisitor<TextNodeDumper>,
135 public TypeVisitor<TextNodeDumper>,
136 public TypeLocVisitor<TextNodeDumper>,
137 public ConstDeclVisitor<TextNodeDumper> {
138 raw_ostream &OS;
139 const bool ShowColors;
140
141 /// Keep track of the last location we print out so that we can
142 /// print out deltas from then on out.
143 const char *LastLocFilename = "";
144 unsigned LastLocLine = ~0U;
145
146 /// \p Context, \p SM, and \p Traits can be null. This is because we want
147 /// to be able to call \p dump() in a debugger without having to pass the
148 /// \p ASTContext to \p dump. Not all parts of the AST dump output will be
149 /// available without the \p ASTContext.
150 const ASTContext *Context = nullptr;
151 const SourceManager *SM = nullptr;
152
153 /// The policy to use for printing; can be defaulted.
154 PrintingPolicy PrintPolicy = LangOptions();
155
156 const comments::CommandTraits *Traits = nullptr;
157
158 const char *getCommandName(unsigned CommandID);
159 void printFPOptions(FPOptionsOverride FPO);
160
161 void dumpAPValueChildren(const APValue &Value, QualType Ty,
162 const APValue &(*IdxToChildFun)(const APValue &,
163 unsigned),
164 unsigned NumChildren, StringRef LabelSingular,
165 StringRef LabelPlurial);
166
167public:
168 TextNodeDumper(raw_ostream &OS, const ASTContext &Context, bool ShowColors);
169 TextNodeDumper(raw_ostream &OS, bool ShowColors);
170
171 void Visit(const comments::Comment *C, const comments::FullComment *FC);
172
173 void Visit(const Attr *A);
174
175 void Visit(const TemplateArgument &TA, SourceRange R,
176 const Decl *From = nullptr, StringRef Label = {});
177
178 void Visit(const Stmt *Node);
179
180 void Visit(const Type *T);
181
182 void Visit(QualType T);
183
184 void Visit(TypeLoc);
185
186 void Visit(const Decl *D);
187
188 void Visit(const CXXCtorInitializer *Init);
189
190 void Visit(const OMPClause *C);
191
192 void Visit(const BlockDecl::Capture &C);
193
195
196 void Visit(const ConceptReference *);
197
198 void Visit(const concepts::Requirement *R);
199
200 void Visit(const APValue &Value, QualType Ty);
201
202 void dumpPointer(const void *Ptr);
205 void dumpBareType(QualType T, bool Desugar = true);
206 void dumpType(QualType T);
207 void dumpBareDeclRef(const Decl *D);
208 void dumpName(const NamedDecl *ND);
214
215 void dumpDeclRef(const Decl *D, StringRef Label = {});
216
218 const comments::FullComment *);
220 const comments::FullComment *);
222 const comments::FullComment *);
224 const comments::FullComment *);
226 const comments::FullComment *);
228 const comments::FullComment *FC);
230 const comments::FullComment *FC);
232 const comments::FullComment *);
233 void
235 const comments::FullComment *);
237 const comments::FullComment *);
238
239// Implements Visit methods for Attrs.
240#include "clang/AST/AttrTextNodeDump.inc"
241
251
252 void VisitIfStmt(const IfStmt *Node);
253 void VisitSwitchStmt(const SwitchStmt *Node);
254 void VisitWhileStmt(const WhileStmt *Node);
255 void VisitLabelStmt(const LabelStmt *Node);
256 void VisitGotoStmt(const GotoStmt *Node);
257 void VisitCaseStmt(const CaseStmt *Node);
258 void VisitReturnStmt(const ReturnStmt *Node);
259 void VisitCoawaitExpr(const CoawaitExpr *Node);
263 void VisitCallExpr(const CallExpr *Node);
265 void VisitCastExpr(const CastExpr *Node);
267 void VisitDeclRefExpr(const DeclRefExpr *Node);
275 void VisitStringLiteral(const StringLiteral *Str);
276 void VisitInitListExpr(const InitListExpr *ILE);
280 void VisitMemberExpr(const MemberExpr *Node);
287 void VisitCXXThisExpr(const CXXThisExpr *Node);
293 void VisitCXXNewExpr(const CXXNewExpr *Node);
304 void
319
321 void VisitArrayType(const ArrayType *T);
326 void VisitVectorType(const VectorType *T);
327 void VisitFunctionType(const FunctionType *T);
330 void VisitUsingType(const UsingType *T);
331 void VisitTypedefType(const TypedefType *T);
333 void VisitTagType(const TagType *T);
336 void
338 void VisitAutoType(const AutoType *T);
345
346 void VisitTypeLoc(TypeLoc TL);
347
348 void VisitLabelDecl(const LabelDecl *D);
349 void VisitTypedefDecl(const TypedefDecl *D);
350 void VisitEnumDecl(const EnumDecl *D);
351 void VisitRecordDecl(const RecordDecl *D);
354 void VisitFunctionDecl(const FunctionDecl *D);
355 void VisitFieldDecl(const FieldDecl *D);
356 void VisitVarDecl(const VarDecl *D);
357 void VisitBindingDecl(const BindingDecl *D);
358 void VisitCapturedDecl(const CapturedDecl *D);
359 void VisitImportDecl(const ImportDecl *D);
366 void VisitNamespaceDecl(const NamespaceDecl *D);
369 void VisitTypeAliasDecl(const TypeAliasDecl *D);
371 void VisitCXXRecordDecl(const CXXRecordDecl *D);
379 void VisitUsingDecl(const UsingDecl *D);
382 void VisitUsingEnumDecl(const UsingEnumDecl *D);
386 void VisitAccessSpecDecl(const AccessSpecDecl *D);
387 void VisitFriendDecl(const FriendDecl *D);
388 void VisitObjCIvarDecl(const ObjCIvarDecl *D);
389 void VisitObjCMethodDecl(const ObjCMethodDecl *D);
399 void VisitBlockDecl(const BlockDecl *D);
400 void VisitConceptDecl(const ConceptDecl *D);
401 void
403 void VisitHLSLBufferDecl(const HLSLBufferDecl *D);
405};
406
407} // namespace clang
408
409#endif // LLVM_CLANG_AST_TEXTNODEDUMPER_H
Defines the clang::ASTContext interface.
DynTypedNode Node
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines Expressions and AST nodes for C++2a concepts.
bool ShowColors
Definition: Logger.cpp:29
C Language Family Type Representation.
std::string Label
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Definition: APValue.h:122
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:182
Represents an access specifier followed by colon ':'.
Definition: DeclCXX.h:86
AddrLabelExpr - The GNU address of label extension, representing &&label.
Definition: Expr.h:4308
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent.
Definition: ExprCXX.h:2836
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:3146
Attr - This represents one attribute.
Definition: Attr.h:42
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
Definition: Type.h:5523
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3810
A binding in a decomposition declaration.
Definition: DeclCXX.h:4100
A class which contains all the information about a particular captured value.
Definition: Decl.h:4461
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:4455
Represents the builtin template declaration which is used to implement __make_integer_seq and other b...
Represents binding an expression to a temporary.
Definition: ExprCXX.h:1475
A boolean literal, per ([C++ lex.bool] Boolean literals).
Definition: ExprCXX.h:720
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1530
Represents a C++ base or member initializer.
Definition: DeclCXX.h:2293
A default argument (C++ [dcl.fct.default]).
Definition: ExprCXX.h:1254
A use of a default initializer in a constructor or in aggregate initialization.
Definition: ExprCXX.h:1361
Represents a delete expression for memory deallocation and destructor calls, e.g.
Definition: ExprCXX.h:2481
Represents a C++ member access expression where the actual member referenced could not be resolved be...
Definition: ExprCXX.h:3645
Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr....
Definition: ExprCXX.h:1801
Abstract class common to all of the C++ "named"/"keyword" casts.
Definition: ExprCXX.h:372
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
Definition: ExprCXX.h:2224
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:81
Represents a C++ struct/union/class.
Definition: DeclCXX.h:258
A C++ static_cast expression (C++ [expr.static.cast]).
Definition: ExprCXX.h:433
Represents the this expression in C++.
Definition: ExprCXX.h:1148
Describes an explicit type conversion that uses functional notion but could not be resolved because o...
Definition: ExprCXX.h:3519
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2795
Represents the body of a CapturedStmt, and serves as its DeclContext.
Definition: Decl.h:4647
CaseStmt - Represent a case statement.
Definition: Stmt.h:1799
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:3465
Declaration of a class template.
Represents a 'co_await' expression.
Definition: ExprCXX.h:5123
CompoundAssignOperator - For compound assignments (e.g.
Definition: Expr.h:4058
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:1604
Declaration of a C++20 concept.
A reference to a concept and its template args, as it appears in the code.
Definition: ASTConcept.h:128
Represents the specialization of a concept - evaluates to a prvalue of type bool.
Definition: ExprConcepts.h:42
A simple visitor class that helps create attribute visitors.
Definition: AttrVisitor.h:71
A simple visitor class that helps create declaration visitors.
Definition: DeclVisitor.h:74
ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:195
A simple visitor class that helps create template argument visitors.
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:3185
ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...
Definition: Expr.h:1059
Represents a shadow constructor declaration introduced into a class by a C++11 using-declaration that...
Definition: DeclCXX.h:3591
Represents a 'co_return' statement in the C++ Coroutines TS.
Definition: StmtCXX.h:473
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1247
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:85
Represents a C++17 deduced template specialization type.
Definition: Type.h:5571
A qualified reference to a name whose declaration cannot yet be resolved.
Definition: ExprCXX.h:3285
Represents an array type in C++ whose size is a value-dependent expression.
Definition: Type.h:3343
Represents an extended vector type where either the type or size is dependent.
Definition: Type.h:3441
An instance of this object exists for each enum constant that is defined.
Definition: Decl.h:3265
Represents an enum.
Definition: Decl.h:3832
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
Definition: ExprCXX.h:3436
llvm::PointerUnion< BlockDecl *, CompoundLiteralExpr * > CleanupObject
The type of objects that are kept in the cleanup.
Definition: ExprCXX.h:3442
An expression trait intrinsic.
Definition: ExprCXX.h:2907
ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...
Definition: Expr.h:6083
Represents difference between two FPOptions values.
Definition: LangOptions.h:875
Represents a member of a struct/union/class.
Definition: Decl.h:3025
FriendDecl - Represents the declaration of a friend entity, which can be a function,...
Definition: DeclFriend.h:54
Represents a function declaration or definition.
Definition: Decl.h:1959
Represents a prototype with parameter type info, e.g.
Definition: Type.h:4198
Declaration of a template function.
Definition: DeclTemplate.h:958
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3798
Represents a C11 generic selection.
Definition: Expr.h:5695
AssociationTy< true > ConstAssociation
Definition: Expr.h:5927
GotoStmt - This represents a direct goto.
Definition: Stmt.h:2860
HLSLBufferDecl - Represent a cbuffer or tbuffer declaration.
Definition: Decl.h:4901
IfStmt - This represents an if/then/else.
Definition: Stmt.h:2136
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:3625
Describes a module import declaration, which makes the contents of the named module visible in the cu...
Definition: Decl.h:4760
Represents a field injected from an anonymous union/struct into the parent scope.
Definition: Decl.h:3309
Describes an C or C++ initializer list.
Definition: Expr.h:4817
The injected class name of a C++ class template or class template partial specialization.
Definition: Type.h:5763
Represents the declaration of a label.
Definition: Decl.h:499
LabelStmt - Represents a label, which has a substatement.
Definition: Stmt.h:2029
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:418
Implicit declaration of a temporary that was materialized by a MaterializeTemporaryExpr and lifetime-...
Definition: DeclCXX.h:3222
Represents a linkage specification.
Definition: DeclCXX.h:2927
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
Definition: ExprCXX.h:4679
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:3158
This represents a decl that may have a name.
Definition: Decl.h:249
Represents a C++ namespace alias.
Definition: DeclCXX.h:3113
Represent a C++ namespace.
Definition: Decl.h:547
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
Pseudo declaration for capturing expressions.
Definition: DeclOpenMP.h:383
This is a basic class for representing single OpenMP clause.
Definition: OpenMPClause.h:55
This represents '#pragma omp declare reduction ...' directive.
Definition: DeclOpenMP.h:177
This is a basic class for representing single OpenMP executable directive.
Definition: StmtOpenMP.h:266
OpenMP 5.0 [2.1.6 Iterators] Iterators are identifiers that expand to multiple values in the clause o...
Definition: ExprOpenMP.h:275
This represents '#pragma omp requires...' directive.
Definition: DeclOpenMP.h:416
Represents Objective-C's @catch statement.
Definition: StmtObjC.h:77
ObjCBoolLiteralExpr - Objective-C Boolean Literal.
Definition: ExprObjC.h:87
ObjCBoxedExpr - used for generalized expression boxing.
Definition: ExprObjC.h:127
ObjCCategoryDecl - Represents a category declaration.
Definition: DeclObjC.h:2323
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration.
Definition: DeclObjC.h:2542
ObjCCompatibleAliasDecl - Represents alias of a class.
Definition: DeclObjC.h:2772
ObjCEncodeExpr, used for @encode in Objective-C.
Definition: ExprObjC.h:410
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2595
Represents an ObjC class declaration.
Definition: DeclObjC.h:1150
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:6494
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1947
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:549
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:945
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:140
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:729
ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category imp...
Definition: DeclObjC.h:2802
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
Definition: ExprObjC.h:617
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:2079
ObjCProtocolExpr used for protocol expression in Objective-C.
Definition: ExprObjC.h:505
ObjCSelectorExpr used for @selector in Objective-C.
Definition: ExprObjC.h:455
ObjCSubscriptRefExpr - used for array and dictionary subscripting.
Definition: ExprObjC.h:844
Represents the declaration of an Objective-C type parameter.
Definition: DeclObjC.h:578
This is the base class for an OpenACC statement-level construct, other construct types are expected t...
Definition: StmtOpenACC.h:23
Represents a pack expansion of types.
Definition: Type.h:6111
Represents a #pragma comment line.
Definition: Decl.h:142
Represents a #pragma detect_mismatch line.
Definition: Decl.h:176
[C99 6.4.2.2] - A predefined identifier such as func.
Definition: Expr.h:1962
A (possibly-)qualified type.
Definition: Type.h:737
Represents a struct/union/class.
Definition: Decl.h:4133
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:3008
C++2a [expr.prim.req]: A requires-expression provides a concise way to express requirements on templa...
Definition: ExprConcepts.h:510
ReturnStmt - This represents a return, optionally of an expression: return; return 4;.
Definition: Stmt.h:3017
Represents an expression that computes the length of a parameter pack.
Definition: ExprCXX.h:4220
Encodes a location in the source.
This class handles loading and caching of source files into memory.
A trivial tuple used to represent a source range.
Stmt - This represents one statement.
Definition: Stmt.h:84
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1760
Represents the result of substituting a set of types for a template type parameter pack.
Definition: Type.h:5431
Represents the result of substituting a type for a template type parameter.
Definition: Type.h:5361
SwitchStmt - This represents a 'switch' stmt.
Definition: Stmt.h:2386
Represents a template argument.
Definition: TemplateBase.h:61
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:5631
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
Declaration of a template type parameter.
void VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *Node)
void VisitEnumDecl(const EnumDecl *D)
void VisitExprWithCleanups(const ExprWithCleanups *Node)
void visitInlineCommandComment(const comments::InlineCommandComment *C, const comments::FullComment *)
void VisitCXXStaticCastExpr(const CXXStaticCastExpr *Node)
void visitVerbatimBlockComment(const comments::VerbatimBlockComment *C, const comments::FullComment *)
void dumpPointer(const void *Ptr)
void VisitDeclarationTemplateArgument(const TemplateArgument &TA)
void VisitLinkageSpecDecl(const LinkageSpecDecl *D)
void VisitVectorType(const VectorType *T)
void VisitCoawaitExpr(const CoawaitExpr *Node)
void VisitUnaryOperator(const UnaryOperator *Node)
void dumpAccessSpecifier(AccessSpecifier AS)
void VisitDeducedTemplateSpecializationType(const DeducedTemplateSpecializationType *T)
void VisitObjCSelectorExpr(const ObjCSelectorExpr *Node)
void VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *Node)
void VisitCXXUnresolvedConstructExpr(const CXXUnresolvedConstructExpr *Node)
void VisitPragmaCommentDecl(const PragmaCommentDecl *D)
void VisitDependentScopeDeclRefExpr(const DependentScopeDeclRefExpr *Node)
void VisitImportDecl(const ImportDecl *D)
void VisitUsingEnumDecl(const UsingEnumDecl *D)
void VisitOMPCapturedExprDecl(const OMPCapturedExprDecl *D)
void VisitUnresolvedUsingType(const UnresolvedUsingType *T)
void VisitObjCProtocolExpr(const ObjCProtocolExpr *Node)
void VisitIntegralTemplateArgument(const TemplateArgument &TA)
void VisitObjCCategoryDecl(const ObjCCategoryDecl *D)
void VisitIndirectFieldDecl(const IndirectFieldDecl *D)
void VisitNullTemplateArgument(const TemplateArgument &TA)
void VisitPackTemplateArgument(const TemplateArgument &TA)
void VisitUsingType(const UsingType *T)
void VisitInjectedClassNameType(const InjectedClassNameType *T)
void VisitBinaryOperator(const BinaryOperator *Node)
void VisitUnresolvedLookupExpr(const UnresolvedLookupExpr *Node)
void VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D)
void VisitBlockDecl(const BlockDecl *D)
void VisitCXXDeleteExpr(const CXXDeleteExpr *Node)
void VisitObjCBoxedExpr(const ObjCBoxedExpr *Node)
void VisitNullPtrTemplateArgument(const TemplateArgument &TA)
void VisitVarTemplateDecl(const VarTemplateDecl *D)
void VisitSubstTemplateTypeParmPackType(const SubstTemplateTypeParmPackType *T)
void VisitConceptSpecializationExpr(const ConceptSpecializationExpr *Node)
void VisitPredefinedExpr(const PredefinedExpr *Node)
void dumpType(QualType T)
void VisitObjCEncodeExpr(const ObjCEncodeExpr *Node)
void VisitHLSLBufferDecl(const HLSLBufferDecl *D)
void VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl *D)
void VisitNamespaceAliasDecl(const NamespaceAliasDecl *D)
void VisitObjCMessageExpr(const ObjCMessageExpr *Node)
void dumpSourceRange(SourceRange R)
void VisitMemberExpr(const MemberExpr *Node)
void VisitOpenACCConstructStmt(const OpenACCConstructStmt *S)
void VisitCompoundStmt(const CompoundStmt *Node)
void VisitConstantExpr(const ConstantExpr *Node)
void VisitObjCIvarRefExpr(const ObjCIvarRefExpr *Node)
void VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *Node)
void VisitConstructorUsingShadowDecl(const ConstructorUsingShadowDecl *D)
void VisitWhileStmt(const WhileStmt *Node)
void VisitCharacterLiteral(const CharacterLiteral *Node)
void VisitAccessSpecDecl(const AccessSpecDecl *D)
void VisitFunctionType(const FunctionType *T)
void VisitObjCImplementationDecl(const ObjCImplementationDecl *D)
void VisitReturnStmt(const ReturnStmt *Node)
void VisitTypeLoc(TypeLoc TL)
void VisitAutoType(const AutoType *T)
void VisitObjCInterfaceType(const ObjCInterfaceType *T)
void visitVerbatimLineComment(const comments::VerbatimLineComment *C, const comments::FullComment *)
void VisitTypedefDecl(const TypedefDecl *D)
void VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *Node)
void visitParamCommandComment(const comments::ParamCommandComment *C, const comments::FullComment *FC)
void VisitIntegerLiteral(const IntegerLiteral *Node)
void VisitObjCProtocolDecl(const ObjCProtocolDecl *D)
void VisitGotoStmt(const GotoStmt *Node)
void VisitDependentSizedExtVectorType(const DependentSizedExtVectorType *T)
void VisitFriendDecl(const FriendDecl *D)
void VisitSwitchStmt(const SwitchStmt *Node)
void VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *Node)
void VisitFunctionTemplateDecl(const FunctionTemplateDecl *D)
void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D)
void VisitUsingDecl(const UsingDecl *D)
void VisitConstantArrayType(const ConstantArrayType *T)
void VisitTypeTemplateArgument(const TemplateArgument &TA)
void VisitObjCPropertyDecl(const ObjCPropertyDecl *D)
void VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D)
void VisitObjCSubscriptRefExpr(const ObjCSubscriptRefExpr *Node)
void VisitArrayType(const ArrayType *T)
void visitHTMLEndTagComment(const comments::HTMLEndTagComment *C, const comments::FullComment *)
void VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node)
void visitTextComment(const comments::TextComment *C, const comments::FullComment *)
void VisitLifetimeExtendedTemporaryDecl(const LifetimeExtendedTemporaryDecl *D)
void VisitCXXRecordDecl(const CXXRecordDecl *D)
void VisitTemplateTemplateArgument(const TemplateArgument &TA)
void dumpCleanupObject(const ExprWithCleanups::CleanupObject &C)
void VisitCaseStmt(const CaseStmt *Node)
void VisitRValueReferenceType(const ReferenceType *T)
void VisitPackExpansionType(const PackExpansionType *T)
void VisitConceptDecl(const ConceptDecl *D)
void VisitCallExpr(const CallExpr *Node)
void VisitCapturedDecl(const CapturedDecl *D)
void VisitBuiltinTemplateDecl(const BuiltinTemplateDecl *D)
void VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *Node)
void VisitOMPDeclareReductionDecl(const OMPDeclareReductionDecl *D)
void VisitCoreturnStmt(const CoreturnStmt *Node)
void VisitSizeOfPackExpr(const SizeOfPackExpr *Node)
void VisitDeclRefExpr(const DeclRefExpr *Node)
void VisitLabelStmt(const LabelStmt *Node)
void Visit(const comments::Comment *C, const comments::FullComment *FC)
void dumpNestedNameSpecifier(const NestedNameSpecifier *NNS)
void VisitLabelDecl(const LabelDecl *D)
void VisitUnaryTransformType(const UnaryTransformType *T)
void VisitStringLiteral(const StringLiteral *Str)
void VisitOMPRequiresDecl(const OMPRequiresDecl *D)
void dumpBareType(QualType T, bool Desugar=true)
void VisitTemplateSpecializationType(const TemplateSpecializationType *T)
void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D)
void VisitCompoundAssignOperator(const CompoundAssignOperator *Node)
void VisitCXXThisExpr(const CXXThisExpr *Node)
void dumpName(const NamedDecl *ND)
void VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *Node)
void VisitObjCIvarDecl(const ObjCIvarDecl *D)
void VisitFieldDecl(const FieldDecl *D)
void dumpDeclRef(const Decl *D, StringRef Label={})
void VisitRecordDecl(const RecordDecl *D)
void VisitCXXNewExpr(const CXXNewExpr *Node)
void VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *Node)
void VisitCastExpr(const CastExpr *Node)
void VisitObjCTypeParamDecl(const ObjCTypeParamDecl *D)
void VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T)
void VisitExpressionTraitExpr(const ExpressionTraitExpr *Node)
void VisitAddrLabelExpr(const AddrLabelExpr *Node)
void VisitUnresolvedUsingTypenameDecl(const UnresolvedUsingTypenameDecl *D)
void VisitCXXDependentScopeMemberExpr(const CXXDependentScopeMemberExpr *Node)
void visitBlockCommandComment(const comments::BlockCommandComment *C, const comments::FullComment *)
void VisitExpressionTemplateArgument(const TemplateArgument &TA)
void VisitTypeAliasDecl(const TypeAliasDecl *D)
void VisitVarDecl(const VarDecl *D)
void VisitFixedPointLiteral(const FixedPointLiteral *Node)
void VisitOMPIteratorExpr(const OMPIteratorExpr *Node)
void VisitUsingDirectiveDecl(const UsingDirectiveDecl *D)
void VisitObjCMethodDecl(const ObjCMethodDecl *D)
void VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D)
void VisitUsingShadowDecl(const UsingShadowDecl *D)
void VisitNamespaceDecl(const NamespaceDecl *D)
void VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D)
void VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *Node)
void VisitIfStmt(const IfStmt *Node)
void VisitCXXConstructExpr(const CXXConstructExpr *Node)
void VisitFunctionProtoType(const FunctionProtoType *T)
void dumpLocation(SourceLocation Loc)
void VisitDependentSizedArrayType(const DependentSizedArrayType *T)
void VisitOMPExecutableDirective(const OMPExecutableDirective *D)
void VisitImplicitCastExpr(const ImplicitCastExpr *Node)
void VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *Node)
void VisitCXXNamedCastExpr(const CXXNamedCastExpr *Node)
void VisitTagType(const TagType *T)
void VisitTemplateExpansionTemplateArgument(const TemplateArgument &TA)
void VisitSYCLUniqueStableNameExpr(const SYCLUniqueStableNameExpr *Node)
void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D)
void VisitFunctionDecl(const FunctionDecl *D)
void visitTParamCommandComment(const comments::TParamCommandComment *C, const comments::FullComment *FC)
void VisitTypeTraitExpr(const TypeTraitExpr *Node)
void dumpBareDeclRef(const Decl *D)
void VisitExtVectorElementExpr(const ExtVectorElementExpr *Node)
void visitVerbatimBlockLineComment(const comments::VerbatimBlockLineComment *C, const comments::FullComment *)
void VisitFloatingLiteral(const FloatingLiteral *Node)
void VisitInitListExpr(const InitListExpr *ILE)
void VisitRequiresExpr(const RequiresExpr *Node)
void VisitVariableArrayType(const VariableArrayType *T)
void VisitGenericSelectionExpr(const GenericSelectionExpr *E)
void VisitTemplateTypeParmType(const TemplateTypeParmType *T)
void VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *Node)
void visitHTMLStartTagComment(const comments::HTMLStartTagComment *C, const comments::FullComment *)
void VisitEnumConstantDecl(const EnumConstantDecl *D)
void dumpConceptReference(const ConceptReference *R)
void VisitPragmaDetectMismatchDecl(const PragmaDetectMismatchDecl *D)
void dumpTemplateSpecializationKind(TemplateSpecializationKind TSK)
void VisitObjCCompatibleAliasDecl(const ObjCCompatibleAliasDecl *D)
void VisitClassTemplateDecl(const ClassTemplateDecl *D)
void VisitBindingDecl(const BindingDecl *D)
void VisitTypedefType(const TypedefType *T)
void AddChild(StringRef Label, Fn DoAddChild)
Add a child of the current node with an optional label.
TextTreeStructure(raw_ostream &OS, bool ShowColors)
void AddChild(Fn DoAddChild)
Add a child of the current node. Calls DoAddChild without arguments.
Represents the declaration of a typedef-name via a C++11 alias-declaration.
Definition: Decl.h:3521
Declaration of an alias template.
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:59
A type trait used in the implementation of various C++11 and Library TR1 trait templates.
Definition: ExprCXX.h:2751
An operation on a type.
Definition: TypeVisitor.h:64
The base class of the type hierarchy.
Definition: Type.h:1606
Represents the declaration of a typedef-name via the 'typedef' type specifier.
Definition: Decl.h:3501
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand.
Definition: Expr.h:2543
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Definition: Expr.h:2158
A unary type transform, which is a type constructed from another.
Definition: Type.h:5008
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
Definition: ExprCXX.h:3163
Represents the dependent type named by a dependently-scoped typename using declaration,...
Definition: Type.h:4686
Represents a dependent using declaration which was marked with typename.
Definition: DeclCXX.h:3952
Represents a dependent using declaration which was not marked with typename.
Definition: DeclCXX.h:3855
Represents a C++ using-declaration.
Definition: DeclCXX.h:3505
Represents C++ using-directive.
Definition: DeclCXX.h:3008
Represents a C++ using-enum-declaration.
Definition: DeclCXX.h:3706
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
Definition: DeclCXX.h:3313
Represents a variable declaration or definition.
Definition: Decl.h:918
Declaration of a variable template.
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:3289
Represents a GCC generic vector type.
Definition: Type.h:3511
WhileStmt - This represents a 'while' stmt.
Definition: Stmt.h:2582
A command that has zero or more word-like arguments (number of word-like arguments depends on command...
Definition: Comment.h:604
This class provides information about commands that can be used in comments.
Any part of the comment.
Definition: Comment.h:65
A full comment attached to a declaration, contains block content.
Definition: Comment.h:1083
An opening HTML tag with attributes.
Definition: Comment.h:433
A command with word-like arguments that is considered inline content.
Definition: Comment.h:335
Doxygen \param command.
Definition: Comment.h:711
Doxygen \tparam command, describes a template parameter.
Definition: Comment.h:793
A verbatim block command (e.
Definition: Comment.h:879
A line of text contained in a verbatim block.
Definition: Comment.h:854
A verbatim line command.
Definition: Comment.h:930
A static requirement that can be used in a requires-expression to check properties of types and expre...
Definition: ExprConcepts.h:168
The JSON file list parser is used to communicate input to InstallAPI.
static const TerminalColor IndentColor
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
Definition: Specifiers.h:185
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:120
Describes how types, statements, expressions, and declarations should be printed.
Definition: PrettyPrinter.h:57