1 //===--- ASTDumper.cpp - Dumping implementation for ASTs ------------------===//
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 file implements the AST dump methods, which dump out the
11 // AST in a form that exposes type details and other fields.
12 //
13 //===----------------------------------------------------------------------===//
14
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/Attr.h"
17 #include "clang/AST/CommentVisitor.h"
18 #include "clang/AST/DeclCXX.h"
19 #include "clang/AST/DeclLookups.h"
20 #include "clang/AST/DeclObjC.h"
21 #include "clang/AST/DeclVisitor.h"
22 #include "clang/AST/StmtVisitor.h"
23 #include "clang/Basic/Module.h"
24 #include "clang/Basic/SourceManager.h"
25 #include "llvm/Support/raw_ostream.h"
26 using namespace clang;
27 using namespace clang::comments;
28
29 //===----------------------------------------------------------------------===//
30 // ASTDumper Visitor
31 //===----------------------------------------------------------------------===//
32
33 namespace {
34 // Colors used for various parts of the AST dump
35 // Do not use bold yellow for any text. It is hard to read on white screens.
36
37 struct TerminalColor {
38 raw_ostream::Colors Color;
39 bool Bold;
40 };
41
42 // Red - CastColor
43 // Green - TypeColor
44 // Bold Green - DeclKindNameColor, UndeserializedColor
45 // Yellow - AddressColor, LocationColor
46 // Blue - CommentColor, NullColor, IndentColor
47 // Bold Blue - AttrColor
48 // Bold Magenta - StmtColor
49 // Cyan - ValueKindColor, ObjectKindColor
50 // Bold Cyan - ValueColor, DeclNameColor
51
52 // Decl kind names (VarDecl, FunctionDecl, etc)
53 static const TerminalColor DeclKindNameColor = { raw_ostream::GREEN, true };
54 // Attr names (CleanupAttr, GuardedByAttr, etc)
55 static const TerminalColor AttrColor = { raw_ostream::BLUE, true };
56 // Statement names (DeclStmt, ImplicitCastExpr, etc)
57 static const TerminalColor StmtColor = { raw_ostream::MAGENTA, true };
58 // Comment names (FullComment, ParagraphComment, TextComment, etc)
59 static const TerminalColor CommentColor = { raw_ostream::BLUE, false };
60
61 // Type names (int, float, etc, plus user defined types)
62 static const TerminalColor TypeColor = { raw_ostream::GREEN, false };
63
64 // Pointer address
65 static const TerminalColor AddressColor = { raw_ostream::YELLOW, false };
66 // Source locations
67 static const TerminalColor LocationColor = { raw_ostream::YELLOW, false };
68
69 // lvalue/xvalue
70 static const TerminalColor ValueKindColor = { raw_ostream::CYAN, false };
71 // bitfield/objcproperty/objcsubscript/vectorcomponent
72 static const TerminalColor ObjectKindColor = { raw_ostream::CYAN, false };
73
74 // Null statements
75 static const TerminalColor NullColor = { raw_ostream::BLUE, false };
76
77 // Undeserialized entities
78 static const TerminalColor UndeserializedColor = { raw_ostream::GREEN, true };
79
80 // CastKind from CastExpr's
81 static const TerminalColor CastColor = { raw_ostream::RED, false };
82
83 // Value of the statement
84 static const TerminalColor ValueColor = { raw_ostream::CYAN, true };
85 // Decl names
86 static const TerminalColor DeclNameColor = { raw_ostream::CYAN, true };
87
88 // Indents ( `, -. | )
89 static const TerminalColor IndentColor = { raw_ostream::BLUE, false };
90
91 class ASTDumper
92 : public ConstDeclVisitor<ASTDumper>, public ConstStmtVisitor<ASTDumper>,
93 public ConstCommentVisitor<ASTDumper> {
94 raw_ostream &OS;
95 const CommandTraits *Traits;
96 const SourceManager *SM;
97 bool IsFirstLine;
98
99 // Indicates whether more child are expected at the current tree depth
100 enum IndentType { IT_Child, IT_LastChild };
101
102 /// Indents[i] indicates if another child exists at level i.
103 /// Used by Indent() to print the tree structure.
104 llvm::SmallVector<IndentType, 32> Indents;
105
106 /// Indicates that more children will be needed at this indent level.
107 /// If true, prevents lastChild() from marking the node as the last child.
108 /// This is used when there are multiple collections of children to be
109 /// dumped as well as during conditional node dumping.
110 bool MoreChildren;
111
112 /// Keep track of the last location we print out so that we can
113 /// print out deltas from then on out.
114 const char *LastLocFilename;
115 unsigned LastLocLine;
116
117 /// The \c FullComment parent of the comment being dumped.
118 const FullComment *FC;
119
120 bool ShowColors;
121
122 class IndentScope {
123 ASTDumper &Dumper;
124 // Preserve the Dumper's MoreChildren value from the previous IndentScope
125 bool MoreChildren;
126 public:
IndentScope(ASTDumper & Dumper)127 IndentScope(ASTDumper &Dumper) : Dumper(Dumper) {
128 MoreChildren = Dumper.hasMoreChildren();
129 Dumper.setMoreChildren(false);
130 Dumper.indent();
131 }
~IndentScope()132 ~IndentScope() {
133 Dumper.setMoreChildren(MoreChildren);
134 Dumper.unindent();
135 }
136 };
137
138 class ColorScope {
139 ASTDumper &Dumper;
140 public:
ColorScope(ASTDumper & Dumper,TerminalColor Color)141 ColorScope(ASTDumper &Dumper, TerminalColor Color)
142 : Dumper(Dumper) {
143 if (Dumper.ShowColors)
144 Dumper.OS.changeColor(Color.Color, Color.Bold);
145 }
~ColorScope()146 ~ColorScope() {
147 if (Dumper.ShowColors)
148 Dumper.OS.resetColor();
149 }
150 };
151
152 class ChildDumper {
153 ASTDumper &Dumper;
154
155 const Decl *Prev;
156 bool PrevRef;
157 public:
ChildDumper(ASTDumper & Dumper)158 ChildDumper(ASTDumper &Dumper) : Dumper(Dumper), Prev(nullptr) {}
~ChildDumper()159 ~ChildDumper() {
160 if (Prev) {
161 Dumper.lastChild();
162 dump(nullptr);
163 }
164 }
165
166 // FIXME: This should take an arbitrary callable as the dumping action.
dump(const Decl * D,bool Ref=false)167 void dump(const Decl *D, bool Ref = false) {
168 if (Prev) {
169 if (PrevRef)
170 Dumper.dumpDeclRef(Prev);
171 else
172 Dumper.dumpDecl(Prev);
173 }
174 Prev = D;
175 PrevRef = Ref;
176 }
dumpRef(const Decl * D)177 void dumpRef(const Decl *D) { dump(D, true); }
178
179 // Give up ownership of the children of the node. By calling this,
180 // the caller takes back responsibility for calling lastChild().
release()181 void release() { dump(nullptr); }
182 };
183
184 public:
ASTDumper(raw_ostream & OS,const CommandTraits * Traits,const SourceManager * SM)185 ASTDumper(raw_ostream &OS, const CommandTraits *Traits,
186 const SourceManager *SM)
187 : OS(OS), Traits(Traits), SM(SM), IsFirstLine(true), MoreChildren(false),
188 LastLocFilename(""), LastLocLine(~0U), FC(nullptr),
189 ShowColors(SM && SM->getDiagnostics().getShowColors()) { }
190
ASTDumper(raw_ostream & OS,const CommandTraits * Traits,const SourceManager * SM,bool ShowColors)191 ASTDumper(raw_ostream &OS, const CommandTraits *Traits,
192 const SourceManager *SM, bool ShowColors)
193 : OS(OS), Traits(Traits), SM(SM), IsFirstLine(true), MoreChildren(false),
194 LastLocFilename(""), LastLocLine(~0U),
195 ShowColors(ShowColors) { }
196
~ASTDumper()197 ~ASTDumper() {
198 OS << "\n";
199 }
200
201 void dumpDecl(const Decl *D);
202 void dumpStmt(const Stmt *S);
203 void dumpFullComment(const FullComment *C);
204
205 // Formatting
206 void indent();
207 void unindent();
208 void lastChild();
209 bool hasMoreChildren();
210 void setMoreChildren(bool Value);
211
212 // Utilities
213 void dumpPointer(const void *Ptr);
214 void dumpSourceRange(SourceRange R);
215 void dumpLocation(SourceLocation Loc);
216 void dumpBareType(QualType T);
217 void dumpType(QualType T);
218 void dumpBareDeclRef(const Decl *Node);
219 void dumpDeclRef(const Decl *Node, const char *Label = nullptr);
220 void dumpName(const NamedDecl *D);
221 bool hasNodes(const DeclContext *DC);
222 void dumpDeclContext(const DeclContext *DC);
223 void dumpLookups(const DeclContext *DC);
224 void dumpAttr(const Attr *A);
225
226 // C++ Utilities
227 void dumpAccessSpecifier(AccessSpecifier AS);
228 void dumpCXXCtorInitializer(const CXXCtorInitializer *Init);
229 void dumpTemplateParameters(const TemplateParameterList *TPL);
230 void dumpTemplateArgumentListInfo(const TemplateArgumentListInfo &TALI);
231 void dumpTemplateArgumentLoc(const TemplateArgumentLoc &A);
232 void dumpTemplateArgumentList(const TemplateArgumentList &TAL);
233 void dumpTemplateArgument(const TemplateArgument &A,
234 SourceRange R = SourceRange());
235
236 // Decls
237 void VisitLabelDecl(const LabelDecl *D);
238 void VisitTypedefDecl(const TypedefDecl *D);
239 void VisitEnumDecl(const EnumDecl *D);
240 void VisitRecordDecl(const RecordDecl *D);
241 void VisitEnumConstantDecl(const EnumConstantDecl *D);
242 void VisitIndirectFieldDecl(const IndirectFieldDecl *D);
243 void VisitFunctionDecl(const FunctionDecl *D);
244 void VisitFieldDecl(const FieldDecl *D);
245 void VisitVarDecl(const VarDecl *D);
246 void VisitFileScopeAsmDecl(const FileScopeAsmDecl *D);
247 void VisitImportDecl(const ImportDecl *D);
248
249 // C++ Decls
250 void VisitNamespaceDecl(const NamespaceDecl *D);
251 void VisitUsingDirectiveDecl(const UsingDirectiveDecl *D);
252 void VisitNamespaceAliasDecl(const NamespaceAliasDecl *D);
253 void VisitTypeAliasDecl(const TypeAliasDecl *D);
254 void VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D);
255 void VisitCXXRecordDecl(const CXXRecordDecl *D);
256 void VisitStaticAssertDecl(const StaticAssertDecl *D);
257 template<typename SpecializationDecl>
258 void VisitTemplateDeclSpecialization(ChildDumper &Children,
259 const SpecializationDecl *D,
260 bool DumpExplicitInst,
261 bool DumpRefOnly);
262 template<typename TemplateDecl>
263 void VisitTemplateDecl(const TemplateDecl *D, bool DumpExplicitInst);
264 void VisitFunctionTemplateDecl(const FunctionTemplateDecl *D);
265 void VisitClassTemplateDecl(const ClassTemplateDecl *D);
266 void VisitClassTemplateSpecializationDecl(
267 const ClassTemplateSpecializationDecl *D);
268 void VisitClassTemplatePartialSpecializationDecl(
269 const ClassTemplatePartialSpecializationDecl *D);
270 void VisitClassScopeFunctionSpecializationDecl(
271 const ClassScopeFunctionSpecializationDecl *D);
272 void VisitVarTemplateDecl(const VarTemplateDecl *D);
273 void VisitVarTemplateSpecializationDecl(
274 const VarTemplateSpecializationDecl *D);
275 void VisitVarTemplatePartialSpecializationDecl(
276 const VarTemplatePartialSpecializationDecl *D);
277 void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D);
278 void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D);
279 void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D);
280 void VisitUsingDecl(const UsingDecl *D);
281 void VisitUnresolvedUsingTypenameDecl(const UnresolvedUsingTypenameDecl *D);
282 void VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl *D);
283 void VisitUsingShadowDecl(const UsingShadowDecl *D);
284 void VisitLinkageSpecDecl(const LinkageSpecDecl *D);
285 void VisitAccessSpecDecl(const AccessSpecDecl *D);
286 void VisitFriendDecl(const FriendDecl *D);
287
288 // ObjC Decls
289 void VisitObjCIvarDecl(const ObjCIvarDecl *D);
290 void VisitObjCMethodDecl(const ObjCMethodDecl *D);
291 void VisitObjCCategoryDecl(const ObjCCategoryDecl *D);
292 void VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D);
293 void VisitObjCProtocolDecl(const ObjCProtocolDecl *D);
294 void VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D);
295 void VisitObjCImplementationDecl(const ObjCImplementationDecl *D);
296 void VisitObjCCompatibleAliasDecl(const ObjCCompatibleAliasDecl *D);
297 void VisitObjCPropertyDecl(const ObjCPropertyDecl *D);
298 void VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D);
299 void VisitBlockDecl(const BlockDecl *D);
300
301 // Stmts.
302 void VisitStmt(const Stmt *Node);
303 void VisitDeclStmt(const DeclStmt *Node);
304 void VisitAttributedStmt(const AttributedStmt *Node);
305 void VisitLabelStmt(const LabelStmt *Node);
306 void VisitGotoStmt(const GotoStmt *Node);
307 void VisitCXXCatchStmt(const CXXCatchStmt *Node);
308
309 // Exprs
310 void VisitExpr(const Expr *Node);
311 void VisitCastExpr(const CastExpr *Node);
312 void VisitDeclRefExpr(const DeclRefExpr *Node);
313 void VisitPredefinedExpr(const PredefinedExpr *Node);
314 void VisitCharacterLiteral(const CharacterLiteral *Node);
315 void VisitIntegerLiteral(const IntegerLiteral *Node);
316 void VisitFloatingLiteral(const FloatingLiteral *Node);
317 void VisitStringLiteral(const StringLiteral *Str);
318 void VisitInitListExpr(const InitListExpr *ILE);
319 void VisitUnaryOperator(const UnaryOperator *Node);
320 void VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *Node);
321 void VisitMemberExpr(const MemberExpr *Node);
322 void VisitExtVectorElementExpr(const ExtVectorElementExpr *Node);
323 void VisitBinaryOperator(const BinaryOperator *Node);
324 void VisitCompoundAssignOperator(const CompoundAssignOperator *Node);
325 void VisitAddrLabelExpr(const AddrLabelExpr *Node);
326 void VisitBlockExpr(const BlockExpr *Node);
327 void VisitOpaqueValueExpr(const OpaqueValueExpr *Node);
328
329 // C++
330 void VisitCXXNamedCastExpr(const CXXNamedCastExpr *Node);
331 void VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *Node);
332 void VisitCXXThisExpr(const CXXThisExpr *Node);
333 void VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *Node);
334 void VisitCXXConstructExpr(const CXXConstructExpr *Node);
335 void VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *Node);
336 void VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *Node);
337 void VisitExprWithCleanups(const ExprWithCleanups *Node);
338 void VisitUnresolvedLookupExpr(const UnresolvedLookupExpr *Node);
339 void dumpCXXTemporary(const CXXTemporary *Temporary);
VisitLambdaExpr(const LambdaExpr * Node)340 void VisitLambdaExpr(const LambdaExpr *Node) {
341 VisitExpr(Node);
342 dumpDecl(Node->getLambdaClass());
343 }
344
345 // ObjC
346 void VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node);
347 void VisitObjCEncodeExpr(const ObjCEncodeExpr *Node);
348 void VisitObjCMessageExpr(const ObjCMessageExpr *Node);
349 void VisitObjCBoxedExpr(const ObjCBoxedExpr *Node);
350 void VisitObjCSelectorExpr(const ObjCSelectorExpr *Node);
351 void VisitObjCProtocolExpr(const ObjCProtocolExpr *Node);
352 void VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *Node);
353 void VisitObjCSubscriptRefExpr(const ObjCSubscriptRefExpr *Node);
354 void VisitObjCIvarRefExpr(const ObjCIvarRefExpr *Node);
355 void VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *Node);
356
357 // Comments.
358 const char *getCommandName(unsigned CommandID);
359 void dumpComment(const Comment *C);
360
361 // Inline comments.
362 void visitTextComment(const TextComment *C);
363 void visitInlineCommandComment(const InlineCommandComment *C);
364 void visitHTMLStartTagComment(const HTMLStartTagComment *C);
365 void visitHTMLEndTagComment(const HTMLEndTagComment *C);
366
367 // Block comments.
368 void visitBlockCommandComment(const BlockCommandComment *C);
369 void visitParamCommandComment(const ParamCommandComment *C);
370 void visitTParamCommandComment(const TParamCommandComment *C);
371 void visitVerbatimBlockComment(const VerbatimBlockComment *C);
372 void visitVerbatimBlockLineComment(const VerbatimBlockLineComment *C);
373 void visitVerbatimLineComment(const VerbatimLineComment *C);
374 };
375 }
376
377 //===----------------------------------------------------------------------===//
378 // Utilities
379 //===----------------------------------------------------------------------===//
380
381 // Print out the appropriate tree structure using the Indents vector.
382 // Example of tree and the Indents vector at each level.
383 // A { }
384 // |-B { IT_Child }
385 // | `-C { IT_Child, IT_LastChild }
386 // `-D { IT_LastChild }
387 // |-E { IT_LastChild, IT_Child }
388 // `-F { IT_LastChild, IT_LastChild }
389 // Type non-last element, last element
390 // IT_Child "| " "|-"
391 // IT_LastChild " " "`-"
indent()392 void ASTDumper::indent() {
393 if (IsFirstLine)
394 IsFirstLine = false;
395 else
396 OS << "\n";
397
398 ColorScope Color(*this, IndentColor);
399 for (SmallVectorImpl<IndentType>::const_iterator I = Indents.begin(),
400 E = Indents.end();
401 I != E; ++I) {
402 switch (*I) {
403 case IT_Child:
404 if (I == E - 1)
405 OS << "|-";
406 else
407 OS << "| ";
408 continue;
409 case IT_LastChild:
410 if (I == E - 1)
411 OS << "`-";
412 else
413 OS << " ";
414 continue;
415 }
416 llvm_unreachable("Invalid IndentType");
417 }
418 Indents.push_back(IT_Child);
419 }
420
unindent()421 void ASTDumper::unindent() {
422 Indents.pop_back();
423 }
424
425 // Call before each potential last child node is to be dumped. If MoreChildren
426 // is false, then this is the last child, otherwise treat as a regular node.
lastChild()427 void ASTDumper::lastChild() {
428 if (!hasMoreChildren())
429 Indents.back() = IT_LastChild;
430 }
431
432 // MoreChildren should be set before calling another function that may print
433 // additional nodes to prevent conflicting final child nodes.
hasMoreChildren()434 bool ASTDumper::hasMoreChildren() {
435 return MoreChildren;
436 }
437
setMoreChildren(bool Value)438 void ASTDumper::setMoreChildren(bool Value) {
439 MoreChildren = Value;
440 }
441
dumpPointer(const void * Ptr)442 void ASTDumper::dumpPointer(const void *Ptr) {
443 ColorScope Color(*this, AddressColor);
444 OS << ' ' << Ptr;
445 }
446
dumpLocation(SourceLocation Loc)447 void ASTDumper::dumpLocation(SourceLocation Loc) {
448 if (!SM)
449 return;
450
451 ColorScope Color(*this, LocationColor);
452 SourceLocation SpellingLoc = SM->getSpellingLoc(Loc);
453
454 // The general format we print out is filename:line:col, but we drop pieces
455 // that haven't changed since the last loc printed.
456 PresumedLoc PLoc = SM->getPresumedLoc(SpellingLoc);
457
458 if (PLoc.isInvalid()) {
459 OS << "<invalid sloc>";
460 return;
461 }
462
463 if (strcmp(PLoc.getFilename(), LastLocFilename) != 0) {
464 OS << PLoc.getFilename() << ':' << PLoc.getLine()
465 << ':' << PLoc.getColumn();
466 LastLocFilename = PLoc.getFilename();
467 LastLocLine = PLoc.getLine();
468 } else if (PLoc.getLine() != LastLocLine) {
469 OS << "line" << ':' << PLoc.getLine()
470 << ':' << PLoc.getColumn();
471 LastLocLine = PLoc.getLine();
472 } else {
473 OS << "col" << ':' << PLoc.getColumn();
474 }
475 }
476
dumpSourceRange(SourceRange R)477 void ASTDumper::dumpSourceRange(SourceRange R) {
478 // Can't translate locations if a SourceManager isn't available.
479 if (!SM)
480 return;
481
482 OS << " <";
483 dumpLocation(R.getBegin());
484 if (R.getBegin() != R.getEnd()) {
485 OS << ", ";
486 dumpLocation(R.getEnd());
487 }
488 OS << ">";
489
490 // <t2.c:123:421[blah], t2.c:412:321>
491
492 }
493
dumpBareType(QualType T)494 void ASTDumper::dumpBareType(QualType T) {
495 ColorScope Color(*this, TypeColor);
496
497 SplitQualType T_split = T.split();
498 OS << "'" << QualType::getAsString(T_split) << "'";
499
500 if (!T.isNull()) {
501 // If the type is sugared, also dump a (shallow) desugared type.
502 SplitQualType D_split = T.getSplitDesugaredType();
503 if (T_split != D_split)
504 OS << ":'" << QualType::getAsString(D_split) << "'";
505 }
506 }
507
dumpType(QualType T)508 void ASTDumper::dumpType(QualType T) {
509 OS << ' ';
510 dumpBareType(T);
511 }
512
dumpBareDeclRef(const Decl * D)513 void ASTDumper::dumpBareDeclRef(const Decl *D) {
514 {
515 ColorScope Color(*this, DeclKindNameColor);
516 OS << D->getDeclKindName();
517 }
518 dumpPointer(D);
519
520 if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
521 ColorScope Color(*this, DeclNameColor);
522 OS << " '" << ND->getDeclName() << '\'';
523 }
524
525 if (const ValueDecl *VD = dyn_cast<ValueDecl>(D))
526 dumpType(VD->getType());
527 }
528
dumpDeclRef(const Decl * D,const char * Label)529 void ASTDumper::dumpDeclRef(const Decl *D, const char *Label) {
530 if (!D)
531 return;
532
533 IndentScope Indent(*this);
534 if (Label)
535 OS << Label << ' ';
536 dumpBareDeclRef(D);
537 }
538
dumpName(const NamedDecl * ND)539 void ASTDumper::dumpName(const NamedDecl *ND) {
540 if (ND->getDeclName()) {
541 ColorScope Color(*this, DeclNameColor);
542 OS << ' ' << ND->getNameAsString();
543 }
544 }
545
hasNodes(const DeclContext * DC)546 bool ASTDumper::hasNodes(const DeclContext *DC) {
547 if (!DC)
548 return false;
549
550 return DC->hasExternalLexicalStorage() ||
551 DC->noload_decls_begin() != DC->noload_decls_end();
552 }
553
dumpDeclContext(const DeclContext * DC)554 void ASTDumper::dumpDeclContext(const DeclContext *DC) {
555 if (!DC)
556 return;
557
558 ChildDumper Children(*this);
559 for (auto *D : DC->noload_decls())
560 Children.dump(D);
561
562 if (DC->hasExternalLexicalStorage()) {
563 Children.release();
564
565 lastChild();
566 IndentScope Indent(*this);
567 ColorScope Color(*this, UndeserializedColor);
568 OS << "<undeserialized declarations>";
569 }
570 }
571
dumpLookups(const DeclContext * DC)572 void ASTDumper::dumpLookups(const DeclContext *DC) {
573 IndentScope Indent(*this);
574
575 OS << "StoredDeclsMap ";
576 dumpBareDeclRef(cast<Decl>(DC));
577
578 const DeclContext *Primary = DC->getPrimaryContext();
579 if (Primary != DC) {
580 OS << " primary";
581 dumpPointer(cast<Decl>(Primary));
582 }
583
584 bool HasUndeserializedLookups = Primary->hasExternalVisibleStorage();
585
586 DeclContext::all_lookups_iterator I = Primary->noload_lookups_begin(),
587 E = Primary->noload_lookups_end();
588 while (I != E) {
589 DeclarationName Name = I.getLookupName();
590 DeclContextLookupResult R = *I++;
591 if (I == E && !HasUndeserializedLookups)
592 lastChild();
593
594 IndentScope Indent(*this);
595 OS << "DeclarationName ";
596 {
597 ColorScope Color(*this, DeclNameColor);
598 OS << '\'' << Name << '\'';
599 }
600
601 for (DeclContextLookupResult::iterator RI = R.begin(), RE = R.end();
602 RI != RE; ++RI) {
603 if (RI + 1 == RE)
604 lastChild();
605 dumpDeclRef(*RI);
606 if ((*RI)->isHidden())
607 OS << " hidden";
608 }
609 }
610
611 if (HasUndeserializedLookups) {
612 lastChild();
613 IndentScope Indent(*this);
614 ColorScope Color(*this, UndeserializedColor);
615 OS << "<undeserialized lookups>";
616 }
617 }
618
dumpAttr(const Attr * A)619 void ASTDumper::dumpAttr(const Attr *A) {
620 IndentScope Indent(*this);
621 {
622 ColorScope Color(*this, AttrColor);
623
624 switch (A->getKind()) {
625 #define ATTR(X) case attr::X: OS << #X; break;
626 #include "clang/Basic/AttrList.inc"
627 default: llvm_unreachable("unexpected attribute kind");
628 }
629 OS << "Attr";
630 }
631 dumpPointer(A);
632 dumpSourceRange(A->getRange());
633 if (A->isInherited())
634 OS << " Inherited";
635 if (A->isImplicit())
636 OS << " Implicit";
637 #include "clang/AST/AttrDump.inc"
638 }
639
dumpPreviousDeclImpl(raw_ostream & OS,...)640 static void dumpPreviousDeclImpl(raw_ostream &OS, ...) {}
641
642 template<typename T>
dumpPreviousDeclImpl(raw_ostream & OS,const Mergeable<T> * D)643 static void dumpPreviousDeclImpl(raw_ostream &OS, const Mergeable<T> *D) {
644 const T *First = D->getFirstDecl();
645 if (First != D)
646 OS << " first " << First;
647 }
648
649 template<typename T>
dumpPreviousDeclImpl(raw_ostream & OS,const Redeclarable<T> * D)650 static void dumpPreviousDeclImpl(raw_ostream &OS, const Redeclarable<T> *D) {
651 const T *Prev = D->getPreviousDecl();
652 if (Prev)
653 OS << " prev " << Prev;
654 }
655
656 /// Dump the previous declaration in the redeclaration chain for a declaration,
657 /// if any.
dumpPreviousDecl(raw_ostream & OS,const Decl * D)658 static void dumpPreviousDecl(raw_ostream &OS, const Decl *D) {
659 switch (D->getKind()) {
660 #define DECL(DERIVED, BASE) \
661 case Decl::DERIVED: \
662 return dumpPreviousDeclImpl(OS, cast<DERIVED##Decl>(D));
663 #define ABSTRACT_DECL(DECL)
664 #include "clang/AST/DeclNodes.inc"
665 }
666 llvm_unreachable("Decl that isn't part of DeclNodes.inc!");
667 }
668
669 //===----------------------------------------------------------------------===//
670 // C++ Utilities
671 //===----------------------------------------------------------------------===//
672
dumpAccessSpecifier(AccessSpecifier AS)673 void ASTDumper::dumpAccessSpecifier(AccessSpecifier AS) {
674 switch (AS) {
675 case AS_none:
676 break;
677 case AS_public:
678 OS << "public";
679 break;
680 case AS_protected:
681 OS << "protected";
682 break;
683 case AS_private:
684 OS << "private";
685 break;
686 }
687 }
688
dumpCXXCtorInitializer(const CXXCtorInitializer * Init)689 void ASTDumper::dumpCXXCtorInitializer(const CXXCtorInitializer *Init) {
690 IndentScope Indent(*this);
691 OS << "CXXCtorInitializer";
692 if (Init->isAnyMemberInitializer()) {
693 OS << ' ';
694 dumpBareDeclRef(Init->getAnyMember());
695 } else {
696 dumpType(QualType(Init->getBaseClass(), 0));
697 }
698 dumpStmt(Init->getInit());
699 }
700
dumpTemplateParameters(const TemplateParameterList * TPL)701 void ASTDumper::dumpTemplateParameters(const TemplateParameterList *TPL) {
702 if (!TPL)
703 return;
704
705 for (TemplateParameterList::const_iterator I = TPL->begin(), E = TPL->end();
706 I != E; ++I)
707 dumpDecl(*I);
708 }
709
dumpTemplateArgumentListInfo(const TemplateArgumentListInfo & TALI)710 void ASTDumper::dumpTemplateArgumentListInfo(
711 const TemplateArgumentListInfo &TALI) {
712 for (unsigned i = 0, e = TALI.size(); i < e; ++i) {
713 if (i + 1 == e)
714 lastChild();
715 dumpTemplateArgumentLoc(TALI[i]);
716 }
717 }
718
dumpTemplateArgumentLoc(const TemplateArgumentLoc & A)719 void ASTDumper::dumpTemplateArgumentLoc(const TemplateArgumentLoc &A) {
720 dumpTemplateArgument(A.getArgument(), A.getSourceRange());
721 }
722
dumpTemplateArgumentList(const TemplateArgumentList & TAL)723 void ASTDumper::dumpTemplateArgumentList(const TemplateArgumentList &TAL) {
724 for (unsigned i = 0, e = TAL.size(); i < e; ++i)
725 dumpTemplateArgument(TAL[i]);
726 }
727
dumpTemplateArgument(const TemplateArgument & A,SourceRange R)728 void ASTDumper::dumpTemplateArgument(const TemplateArgument &A, SourceRange R) {
729 IndentScope Indent(*this);
730 OS << "TemplateArgument";
731 if (R.isValid())
732 dumpSourceRange(R);
733
734 switch (A.getKind()) {
735 case TemplateArgument::Null:
736 OS << " null";
737 break;
738 case TemplateArgument::Type:
739 OS << " type";
740 lastChild();
741 dumpType(A.getAsType());
742 break;
743 case TemplateArgument::Declaration:
744 OS << " decl";
745 lastChild();
746 dumpDeclRef(A.getAsDecl());
747 break;
748 case TemplateArgument::NullPtr:
749 OS << " nullptr";
750 break;
751 case TemplateArgument::Integral:
752 OS << " integral " << A.getAsIntegral();
753 break;
754 case TemplateArgument::Template:
755 OS << " template ";
756 A.getAsTemplate().dump(OS);
757 break;
758 case TemplateArgument::TemplateExpansion:
759 OS << " template expansion";
760 A.getAsTemplateOrTemplatePattern().dump(OS);
761 break;
762 case TemplateArgument::Expression:
763 OS << " expr";
764 lastChild();
765 dumpStmt(A.getAsExpr());
766 break;
767 case TemplateArgument::Pack:
768 OS << " pack";
769 for (TemplateArgument::pack_iterator I = A.pack_begin(), E = A.pack_end();
770 I != E; ++I) {
771 if (I + 1 == E)
772 lastChild();
773 dumpTemplateArgument(*I);
774 }
775 break;
776 }
777 }
778
779 //===----------------------------------------------------------------------===//
780 // Decl dumping methods.
781 //===----------------------------------------------------------------------===//
782
dumpDecl(const Decl * D)783 void ASTDumper::dumpDecl(const Decl *D) {
784 IndentScope Indent(*this);
785
786 if (!D) {
787 ColorScope Color(*this, NullColor);
788 OS << "<<<NULL>>>";
789 return;
790 }
791
792 {
793 ColorScope Color(*this, DeclKindNameColor);
794 OS << D->getDeclKindName() << "Decl";
795 }
796 dumpPointer(D);
797 if (D->getLexicalDeclContext() != D->getDeclContext())
798 OS << " parent " << cast<Decl>(D->getDeclContext());
799 dumpPreviousDecl(OS, D);
800 dumpSourceRange(D->getSourceRange());
801 OS << ' ';
802 dumpLocation(D->getLocation());
803 if (Module *M = D->getOwningModule())
804 OS << " in " << M->getFullModuleName();
805 if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
806 if (ND->isHidden())
807 OS << " hidden";
808 if (D->isImplicit())
809 OS << " implicit";
810 if (D->isUsed())
811 OS << " used";
812 else if (D->isReferenced())
813 OS << " referenced";
814 if (D->isInvalidDecl())
815 OS << " invalid";
816
817 bool HasAttrs = D->hasAttrs();
818 const FullComment *Comment =
819 D->getASTContext().getLocalCommentForDeclUncached(D);
820 // Decls within functions are visited by the body
821 bool HasDeclContext = !isa<FunctionDecl>(*D) && !isa<ObjCMethodDecl>(*D) &&
822 hasNodes(dyn_cast<DeclContext>(D));
823
824 setMoreChildren(HasAttrs || Comment || HasDeclContext);
825 ConstDeclVisitor<ASTDumper>::Visit(D);
826
827 setMoreChildren(Comment || HasDeclContext);
828 for (Decl::attr_iterator I = D->attr_begin(), E = D->attr_end();
829 I != E; ++I) {
830 if (I + 1 == E)
831 lastChild();
832 dumpAttr(*I);
833 }
834
835 setMoreChildren(HasDeclContext);
836 lastChild();
837 dumpFullComment(Comment);
838
839 setMoreChildren(false);
840 if (HasDeclContext)
841 dumpDeclContext(cast<DeclContext>(D));
842 }
843
VisitLabelDecl(const LabelDecl * D)844 void ASTDumper::VisitLabelDecl(const LabelDecl *D) {
845 dumpName(D);
846 }
847
VisitTypedefDecl(const TypedefDecl * D)848 void ASTDumper::VisitTypedefDecl(const TypedefDecl *D) {
849 dumpName(D);
850 dumpType(D->getUnderlyingType());
851 if (D->isModulePrivate())
852 OS << " __module_private__";
853 }
854
VisitEnumDecl(const EnumDecl * D)855 void ASTDumper::VisitEnumDecl(const EnumDecl *D) {
856 if (D->isScoped()) {
857 if (D->isScopedUsingClassTag())
858 OS << " class";
859 else
860 OS << " struct";
861 }
862 dumpName(D);
863 if (D->isModulePrivate())
864 OS << " __module_private__";
865 if (D->isFixed())
866 dumpType(D->getIntegerType());
867 }
868
VisitRecordDecl(const RecordDecl * D)869 void ASTDumper::VisitRecordDecl(const RecordDecl *D) {
870 OS << ' ' << D->getKindName();
871 dumpName(D);
872 if (D->isModulePrivate())
873 OS << " __module_private__";
874 if (D->isCompleteDefinition())
875 OS << " definition";
876 }
877
VisitEnumConstantDecl(const EnumConstantDecl * D)878 void ASTDumper::VisitEnumConstantDecl(const EnumConstantDecl *D) {
879 dumpName(D);
880 dumpType(D->getType());
881 if (const Expr *Init = D->getInitExpr()) {
882 lastChild();
883 dumpStmt(Init);
884 }
885 }
886
VisitIndirectFieldDecl(const IndirectFieldDecl * D)887 void ASTDumper::VisitIndirectFieldDecl(const IndirectFieldDecl *D) {
888 dumpName(D);
889 dumpType(D->getType());
890
891 ChildDumper Children(*this);
892 for (auto *Child : D->chain())
893 Children.dumpRef(Child);
894 }
895
VisitFunctionDecl(const FunctionDecl * D)896 void ASTDumper::VisitFunctionDecl(const FunctionDecl *D) {
897 dumpName(D);
898 dumpType(D->getType());
899
900 StorageClass SC = D->getStorageClass();
901 if (SC != SC_None)
902 OS << ' ' << VarDecl::getStorageClassSpecifierString(SC);
903 if (D->isInlineSpecified())
904 OS << " inline";
905 if (D->isVirtualAsWritten())
906 OS << " virtual";
907 if (D->isModulePrivate())
908 OS << " __module_private__";
909
910 if (D->isPure())
911 OS << " pure";
912 else if (D->isDeletedAsWritten())
913 OS << " delete";
914
915 if (const FunctionProtoType *FPT = D->getType()->getAs<FunctionProtoType>()) {
916 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
917 switch (EPI.ExceptionSpecType) {
918 default: break;
919 case EST_Unevaluated:
920 OS << " noexcept-unevaluated " << EPI.ExceptionSpecDecl;
921 break;
922 case EST_Uninstantiated:
923 OS << " noexcept-uninstantiated " << EPI.ExceptionSpecTemplate;
924 break;
925 }
926 }
927
928 bool OldMoreChildren = hasMoreChildren();
929 const FunctionTemplateSpecializationInfo *FTSI =
930 D->getTemplateSpecializationInfo();
931 bool HasTemplateSpecialization = FTSI;
932
933 bool HasNamedDecls = D->getDeclsInPrototypeScope().begin() !=
934 D->getDeclsInPrototypeScope().end();
935
936 bool HasFunctionDecls = D->param_begin() != D->param_end();
937
938 const CXXConstructorDecl *C = dyn_cast<CXXConstructorDecl>(D);
939 bool HasCtorInitializers = C && C->init_begin() != C->init_end();
940
941 bool HasDeclarationBody = D->doesThisDeclarationHaveABody();
942
943 setMoreChildren(OldMoreChildren || HasNamedDecls || HasFunctionDecls ||
944 HasCtorInitializers || HasDeclarationBody);
945 if (HasTemplateSpecialization) {
946 lastChild();
947 dumpTemplateArgumentList(*FTSI->TemplateArguments);
948 }
949
950 setMoreChildren(OldMoreChildren || HasFunctionDecls ||
951 HasCtorInitializers || HasDeclarationBody);
952 for (ArrayRef<NamedDecl *>::iterator
953 I = D->getDeclsInPrototypeScope().begin(),
954 E = D->getDeclsInPrototypeScope().end(); I != E; ++I) {
955 if (I + 1 == E)
956 lastChild();
957 dumpDecl(*I);
958 }
959
960 setMoreChildren(OldMoreChildren || HasCtorInitializers || HasDeclarationBody);
961 for (FunctionDecl::param_const_iterator I = D->param_begin(),
962 E = D->param_end();
963 I != E; ++I) {
964 if (I + 1 == E)
965 lastChild();
966 dumpDecl(*I);
967 }
968
969 setMoreChildren(OldMoreChildren || HasDeclarationBody);
970 if (HasCtorInitializers)
971 for (CXXConstructorDecl::init_const_iterator I = C->init_begin(),
972 E = C->init_end();
973 I != E; ++I) {
974 if (I + 1 == E)
975 lastChild();
976 dumpCXXCtorInitializer(*I);
977 }
978
979 setMoreChildren(OldMoreChildren);
980 if (HasDeclarationBody) {
981 lastChild();
982 dumpStmt(D->getBody());
983 }
984 }
985
VisitFieldDecl(const FieldDecl * D)986 void ASTDumper::VisitFieldDecl(const FieldDecl *D) {
987 dumpName(D);
988 dumpType(D->getType());
989 if (D->isMutable())
990 OS << " mutable";
991 if (D->isModulePrivate())
992 OS << " __module_private__";
993
994 bool OldMoreChildren = hasMoreChildren();
995 bool IsBitField = D->isBitField();
996 Expr *Init = D->getInClassInitializer();
997 bool HasInit = Init;
998
999 setMoreChildren(OldMoreChildren || HasInit);
1000 if (IsBitField) {
1001 lastChild();
1002 dumpStmt(D->getBitWidth());
1003 }
1004 setMoreChildren(OldMoreChildren);
1005 if (HasInit) {
1006 lastChild();
1007 dumpStmt(Init);
1008 }
1009 }
1010
VisitVarDecl(const VarDecl * D)1011 void ASTDumper::VisitVarDecl(const VarDecl *D) {
1012 dumpName(D);
1013 dumpType(D->getType());
1014 StorageClass SC = D->getStorageClass();
1015 if (SC != SC_None)
1016 OS << ' ' << VarDecl::getStorageClassSpecifierString(SC);
1017 switch (D->getTLSKind()) {
1018 case VarDecl::TLS_None: break;
1019 case VarDecl::TLS_Static: OS << " tls"; break;
1020 case VarDecl::TLS_Dynamic: OS << " tls_dynamic"; break;
1021 }
1022 if (D->isModulePrivate())
1023 OS << " __module_private__";
1024 if (D->isNRVOVariable())
1025 OS << " nrvo";
1026 if (D->hasInit()) {
1027 lastChild();
1028 dumpStmt(D->getInit());
1029 }
1030 }
1031
VisitFileScopeAsmDecl(const FileScopeAsmDecl * D)1032 void ASTDumper::VisitFileScopeAsmDecl(const FileScopeAsmDecl *D) {
1033 lastChild();
1034 dumpStmt(D->getAsmString());
1035 }
1036
VisitImportDecl(const ImportDecl * D)1037 void ASTDumper::VisitImportDecl(const ImportDecl *D) {
1038 OS << ' ' << D->getImportedModule()->getFullModuleName();
1039 }
1040
1041 //===----------------------------------------------------------------------===//
1042 // C++ Declarations
1043 //===----------------------------------------------------------------------===//
1044
VisitNamespaceDecl(const NamespaceDecl * D)1045 void ASTDumper::VisitNamespaceDecl(const NamespaceDecl *D) {
1046 dumpName(D);
1047 if (D->isInline())
1048 OS << " inline";
1049 if (!D->isOriginalNamespace())
1050 dumpDeclRef(D->getOriginalNamespace(), "original");
1051 }
1052
VisitUsingDirectiveDecl(const UsingDirectiveDecl * D)1053 void ASTDumper::VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
1054 OS << ' ';
1055 dumpBareDeclRef(D->getNominatedNamespace());
1056 }
1057
VisitNamespaceAliasDecl(const NamespaceAliasDecl * D)1058 void ASTDumper::VisitNamespaceAliasDecl(const NamespaceAliasDecl *D) {
1059 dumpName(D);
1060 dumpDeclRef(D->getAliasedNamespace());
1061 }
1062
VisitTypeAliasDecl(const TypeAliasDecl * D)1063 void ASTDumper::VisitTypeAliasDecl(const TypeAliasDecl *D) {
1064 dumpName(D);
1065 dumpType(D->getUnderlyingType());
1066 }
1067
VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl * D)1068 void ASTDumper::VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D) {
1069 dumpName(D);
1070 dumpTemplateParameters(D->getTemplateParameters());
1071 dumpDecl(D->getTemplatedDecl());
1072 }
1073
VisitCXXRecordDecl(const CXXRecordDecl * D)1074 void ASTDumper::VisitCXXRecordDecl(const CXXRecordDecl *D) {
1075 VisitRecordDecl(D);
1076 if (!D->isCompleteDefinition())
1077 return;
1078
1079 for (const auto &I : D->bases()) {
1080 IndentScope Indent(*this);
1081 if (I.isVirtual())
1082 OS << "virtual ";
1083 dumpAccessSpecifier(I.getAccessSpecifier());
1084 dumpType(I.getType());
1085 if (I.isPackExpansion())
1086 OS << "...";
1087 }
1088 }
1089
VisitStaticAssertDecl(const StaticAssertDecl * D)1090 void ASTDumper::VisitStaticAssertDecl(const StaticAssertDecl *D) {
1091 dumpStmt(D->getAssertExpr());
1092 lastChild();
1093 dumpStmt(D->getMessage());
1094 }
1095
1096 template<typename SpecializationDecl>
VisitTemplateDeclSpecialization(ChildDumper & Children,const SpecializationDecl * D,bool DumpExplicitInst,bool DumpRefOnly)1097 void ASTDumper::VisitTemplateDeclSpecialization(ChildDumper &Children,
1098 const SpecializationDecl *D,
1099 bool DumpExplicitInst,
1100 bool DumpRefOnly) {
1101 bool DumpedAny = false;
1102 for (auto *RedeclWithBadType : D->redecls()) {
1103 // FIXME: The redecls() range sometimes has elements of a less-specific
1104 // type. (In particular, ClassTemplateSpecializationDecl::redecls() gives
1105 // us TagDecls, and should give CXXRecordDecls).
1106 auto *Redecl = dyn_cast<SpecializationDecl>(RedeclWithBadType);
1107 if (!Redecl) {
1108 // Found the injected-class-name for a class template. This will be dumped
1109 // as part of its surrounding class so we don't need to dump it here.
1110 assert(isa<CXXRecordDecl>(RedeclWithBadType) &&
1111 "expected an injected-class-name");
1112 continue;
1113 }
1114
1115 switch (Redecl->getTemplateSpecializationKind()) {
1116 case TSK_ExplicitInstantiationDeclaration:
1117 case TSK_ExplicitInstantiationDefinition:
1118 if (!DumpExplicitInst)
1119 break;
1120 // Fall through.
1121 case TSK_Undeclared:
1122 case TSK_ImplicitInstantiation:
1123 Children.dump(Redecl, DumpRefOnly);
1124 DumpedAny = true;
1125 break;
1126 case TSK_ExplicitSpecialization:
1127 break;
1128 }
1129 }
1130
1131 // Ensure we dump at least one decl for each specialization.
1132 if (!DumpedAny)
1133 Children.dumpRef(D);
1134 }
1135
1136 template<typename TemplateDecl>
VisitTemplateDecl(const TemplateDecl * D,bool DumpExplicitInst)1137 void ASTDumper::VisitTemplateDecl(const TemplateDecl *D,
1138 bool DumpExplicitInst) {
1139 dumpName(D);
1140 dumpTemplateParameters(D->getTemplateParameters());
1141
1142 ChildDumper Children(*this);
1143 Children.dump(D->getTemplatedDecl());
1144
1145 for (auto *Child : D->specializations())
1146 VisitTemplateDeclSpecialization(Children, Child, DumpExplicitInst,
1147 !D->isCanonicalDecl());
1148 }
1149
VisitFunctionTemplateDecl(const FunctionTemplateDecl * D)1150 void ASTDumper::VisitFunctionTemplateDecl(const FunctionTemplateDecl *D) {
1151 // FIXME: We don't add a declaration of a function template specialization
1152 // to its context when it's explicitly instantiated, so dump explicit
1153 // instantiations when we dump the template itself.
1154 VisitTemplateDecl(D, true);
1155 }
1156
VisitClassTemplateDecl(const ClassTemplateDecl * D)1157 void ASTDumper::VisitClassTemplateDecl(const ClassTemplateDecl *D) {
1158 VisitTemplateDecl(D, false);
1159 }
1160
VisitClassTemplateSpecializationDecl(const ClassTemplateSpecializationDecl * D)1161 void ASTDumper::VisitClassTemplateSpecializationDecl(
1162 const ClassTemplateSpecializationDecl *D) {
1163 VisitCXXRecordDecl(D);
1164 dumpTemplateArgumentList(D->getTemplateArgs());
1165 }
1166
VisitClassTemplatePartialSpecializationDecl(const ClassTemplatePartialSpecializationDecl * D)1167 void ASTDumper::VisitClassTemplatePartialSpecializationDecl(
1168 const ClassTemplatePartialSpecializationDecl *D) {
1169 VisitClassTemplateSpecializationDecl(D);
1170 dumpTemplateParameters(D->getTemplateParameters());
1171 }
1172
VisitClassScopeFunctionSpecializationDecl(const ClassScopeFunctionSpecializationDecl * D)1173 void ASTDumper::VisitClassScopeFunctionSpecializationDecl(
1174 const ClassScopeFunctionSpecializationDecl *D) {
1175 dumpDeclRef(D->getSpecialization());
1176 if (D->hasExplicitTemplateArgs())
1177 dumpTemplateArgumentListInfo(D->templateArgs());
1178 }
1179
VisitVarTemplateDecl(const VarTemplateDecl * D)1180 void ASTDumper::VisitVarTemplateDecl(const VarTemplateDecl *D) {
1181 VisitTemplateDecl(D, false);
1182 }
1183
VisitVarTemplateSpecializationDecl(const VarTemplateSpecializationDecl * D)1184 void ASTDumper::VisitVarTemplateSpecializationDecl(
1185 const VarTemplateSpecializationDecl *D) {
1186 dumpTemplateArgumentList(D->getTemplateArgs());
1187 VisitVarDecl(D);
1188 }
1189
VisitVarTemplatePartialSpecializationDecl(const VarTemplatePartialSpecializationDecl * D)1190 void ASTDumper::VisitVarTemplatePartialSpecializationDecl(
1191 const VarTemplatePartialSpecializationDecl *D) {
1192 dumpTemplateParameters(D->getTemplateParameters());
1193 VisitVarTemplateSpecializationDecl(D);
1194 }
1195
VisitTemplateTypeParmDecl(const TemplateTypeParmDecl * D)1196 void ASTDumper::VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) {
1197 if (D->wasDeclaredWithTypename())
1198 OS << " typename";
1199 else
1200 OS << " class";
1201 if (D->isParameterPack())
1202 OS << " ...";
1203 dumpName(D);
1204 if (D->hasDefaultArgument()) {
1205 lastChild();
1206 dumpTemplateArgument(D->getDefaultArgument());
1207 }
1208 }
1209
VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl * D)1210 void ASTDumper::VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) {
1211 dumpType(D->getType());
1212 if (D->isParameterPack())
1213 OS << " ...";
1214 dumpName(D);
1215 if (D->hasDefaultArgument()) {
1216 lastChild();
1217 dumpTemplateArgument(D->getDefaultArgument());
1218 }
1219 }
1220
VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl * D)1221 void ASTDumper::VisitTemplateTemplateParmDecl(
1222 const TemplateTemplateParmDecl *D) {
1223 if (D->isParameterPack())
1224 OS << " ...";
1225 dumpName(D);
1226 dumpTemplateParameters(D->getTemplateParameters());
1227 if (D->hasDefaultArgument()) {
1228 lastChild();
1229 dumpTemplateArgumentLoc(D->getDefaultArgument());
1230 }
1231 }
1232
VisitUsingDecl(const UsingDecl * D)1233 void ASTDumper::VisitUsingDecl(const UsingDecl *D) {
1234 OS << ' ';
1235 D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
1236 OS << D->getNameAsString();
1237 }
1238
VisitUnresolvedUsingTypenameDecl(const UnresolvedUsingTypenameDecl * D)1239 void ASTDumper::VisitUnresolvedUsingTypenameDecl(
1240 const UnresolvedUsingTypenameDecl *D) {
1241 OS << ' ';
1242 D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
1243 OS << D->getNameAsString();
1244 }
1245
VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl * D)1246 void ASTDumper::VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl *D) {
1247 OS << ' ';
1248 D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
1249 OS << D->getNameAsString();
1250 dumpType(D->getType());
1251 }
1252
VisitUsingShadowDecl(const UsingShadowDecl * D)1253 void ASTDumper::VisitUsingShadowDecl(const UsingShadowDecl *D) {
1254 OS << ' ';
1255 dumpBareDeclRef(D->getTargetDecl());
1256 }
1257
VisitLinkageSpecDecl(const LinkageSpecDecl * D)1258 void ASTDumper::VisitLinkageSpecDecl(const LinkageSpecDecl *D) {
1259 switch (D->getLanguage()) {
1260 case LinkageSpecDecl::lang_c: OS << " C"; break;
1261 case LinkageSpecDecl::lang_cxx: OS << " C++"; break;
1262 }
1263 }
1264
VisitAccessSpecDecl(const AccessSpecDecl * D)1265 void ASTDumper::VisitAccessSpecDecl(const AccessSpecDecl *D) {
1266 OS << ' ';
1267 dumpAccessSpecifier(D->getAccess());
1268 }
1269
VisitFriendDecl(const FriendDecl * D)1270 void ASTDumper::VisitFriendDecl(const FriendDecl *D) {
1271 lastChild();
1272 if (TypeSourceInfo *T = D->getFriendType())
1273 dumpType(T->getType());
1274 else
1275 dumpDecl(D->getFriendDecl());
1276 }
1277
1278 //===----------------------------------------------------------------------===//
1279 // Obj-C Declarations
1280 //===----------------------------------------------------------------------===//
1281
VisitObjCIvarDecl(const ObjCIvarDecl * D)1282 void ASTDumper::VisitObjCIvarDecl(const ObjCIvarDecl *D) {
1283 dumpName(D);
1284 dumpType(D->getType());
1285 if (D->getSynthesize())
1286 OS << " synthesize";
1287
1288 switch (D->getAccessControl()) {
1289 case ObjCIvarDecl::None:
1290 OS << " none";
1291 break;
1292 case ObjCIvarDecl::Private:
1293 OS << " private";
1294 break;
1295 case ObjCIvarDecl::Protected:
1296 OS << " protected";
1297 break;
1298 case ObjCIvarDecl::Public:
1299 OS << " public";
1300 break;
1301 case ObjCIvarDecl::Package:
1302 OS << " package";
1303 break;
1304 }
1305 }
1306
VisitObjCMethodDecl(const ObjCMethodDecl * D)1307 void ASTDumper::VisitObjCMethodDecl(const ObjCMethodDecl *D) {
1308 if (D->isInstanceMethod())
1309 OS << " -";
1310 else
1311 OS << " +";
1312 dumpName(D);
1313 dumpType(D->getReturnType());
1314
1315 bool OldMoreChildren = hasMoreChildren();
1316 bool IsVariadic = D->isVariadic();
1317 bool HasBody = D->hasBody();
1318
1319 setMoreChildren(OldMoreChildren || IsVariadic || HasBody);
1320 if (D->isThisDeclarationADefinition()) {
1321 lastChild();
1322 dumpDeclContext(D);
1323 } else {
1324 for (ObjCMethodDecl::param_const_iterator I = D->param_begin(),
1325 E = D->param_end();
1326 I != E; ++I) {
1327 if (I + 1 == E)
1328 lastChild();
1329 dumpDecl(*I);
1330 }
1331 }
1332
1333 setMoreChildren(OldMoreChildren || HasBody);
1334 if (IsVariadic) {
1335 lastChild();
1336 IndentScope Indent(*this);
1337 OS << "...";
1338 }
1339
1340 setMoreChildren(OldMoreChildren);
1341 if (HasBody) {
1342 lastChild();
1343 dumpStmt(D->getBody());
1344 }
1345 }
1346
VisitObjCCategoryDecl(const ObjCCategoryDecl * D)1347 void ASTDumper::VisitObjCCategoryDecl(const ObjCCategoryDecl *D) {
1348 dumpName(D);
1349 dumpDeclRef(D->getClassInterface());
1350 if (D->protocol_begin() == D->protocol_end())
1351 lastChild();
1352 dumpDeclRef(D->getImplementation());
1353 for (ObjCCategoryDecl::protocol_iterator I = D->protocol_begin(),
1354 E = D->protocol_end();
1355 I != E; ++I) {
1356 if (I + 1 == E)
1357 lastChild();
1358 dumpDeclRef(*I);
1359 }
1360 }
1361
VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl * D)1362 void ASTDumper::VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D) {
1363 dumpName(D);
1364 dumpDeclRef(D->getClassInterface());
1365 lastChild();
1366 dumpDeclRef(D->getCategoryDecl());
1367 }
1368
VisitObjCProtocolDecl(const ObjCProtocolDecl * D)1369 void ASTDumper::VisitObjCProtocolDecl(const ObjCProtocolDecl *D) {
1370 dumpName(D);
1371
1372 ChildDumper Children(*this);
1373 for (auto *Child : D->protocols())
1374 Children.dumpRef(Child);
1375 }
1376
VisitObjCInterfaceDecl(const ObjCInterfaceDecl * D)1377 void ASTDumper::VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) {
1378 dumpName(D);
1379 dumpDeclRef(D->getSuperClass(), "super");
1380
1381 ChildDumper Children(*this);
1382 Children.dumpRef(D->getImplementation());
1383 for (auto *Child : D->protocols())
1384 Children.dumpRef(Child);
1385 }
1386
VisitObjCImplementationDecl(const ObjCImplementationDecl * D)1387 void ASTDumper::VisitObjCImplementationDecl(const ObjCImplementationDecl *D) {
1388 dumpName(D);
1389 dumpDeclRef(D->getSuperClass(), "super");
1390 if (D->init_begin() == D->init_end())
1391 lastChild();
1392 dumpDeclRef(D->getClassInterface());
1393 for (ObjCImplementationDecl::init_const_iterator I = D->init_begin(),
1394 E = D->init_end();
1395 I != E; ++I) {
1396 if (I + 1 == E)
1397 lastChild();
1398 dumpCXXCtorInitializer(*I);
1399 }
1400 }
1401
VisitObjCCompatibleAliasDecl(const ObjCCompatibleAliasDecl * D)1402 void ASTDumper::VisitObjCCompatibleAliasDecl(const ObjCCompatibleAliasDecl *D) {
1403 dumpName(D);
1404 lastChild();
1405 dumpDeclRef(D->getClassInterface());
1406 }
1407
VisitObjCPropertyDecl(const ObjCPropertyDecl * D)1408 void ASTDumper::VisitObjCPropertyDecl(const ObjCPropertyDecl *D) {
1409 dumpName(D);
1410 dumpType(D->getType());
1411
1412 if (D->getPropertyImplementation() == ObjCPropertyDecl::Required)
1413 OS << " required";
1414 else if (D->getPropertyImplementation() == ObjCPropertyDecl::Optional)
1415 OS << " optional";
1416
1417 ObjCPropertyDecl::PropertyAttributeKind Attrs = D->getPropertyAttributes();
1418 if (Attrs != ObjCPropertyDecl::OBJC_PR_noattr) {
1419 if (Attrs & ObjCPropertyDecl::OBJC_PR_readonly)
1420 OS << " readonly";
1421 if (Attrs & ObjCPropertyDecl::OBJC_PR_assign)
1422 OS << " assign";
1423 if (Attrs & ObjCPropertyDecl::OBJC_PR_readwrite)
1424 OS << " readwrite";
1425 if (Attrs & ObjCPropertyDecl::OBJC_PR_retain)
1426 OS << " retain";
1427 if (Attrs & ObjCPropertyDecl::OBJC_PR_copy)
1428 OS << " copy";
1429 if (Attrs & ObjCPropertyDecl::OBJC_PR_nonatomic)
1430 OS << " nonatomic";
1431 if (Attrs & ObjCPropertyDecl::OBJC_PR_atomic)
1432 OS << " atomic";
1433 if (Attrs & ObjCPropertyDecl::OBJC_PR_weak)
1434 OS << " weak";
1435 if (Attrs & ObjCPropertyDecl::OBJC_PR_strong)
1436 OS << " strong";
1437 if (Attrs & ObjCPropertyDecl::OBJC_PR_unsafe_unretained)
1438 OS << " unsafe_unretained";
1439 if (Attrs & ObjCPropertyDecl::OBJC_PR_getter) {
1440 if (!(Attrs & ObjCPropertyDecl::OBJC_PR_setter))
1441 lastChild();
1442 dumpDeclRef(D->getGetterMethodDecl(), "getter");
1443 }
1444 if (Attrs & ObjCPropertyDecl::OBJC_PR_setter) {
1445 lastChild();
1446 dumpDeclRef(D->getSetterMethodDecl(), "setter");
1447 }
1448 }
1449 }
1450
VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl * D)1451 void ASTDumper::VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D) {
1452 dumpName(D->getPropertyDecl());
1453 if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize)
1454 OS << " synthesize";
1455 else
1456 OS << " dynamic";
1457 dumpDeclRef(D->getPropertyDecl());
1458 lastChild();
1459 dumpDeclRef(D->getPropertyIvarDecl());
1460 }
1461
VisitBlockDecl(const BlockDecl * D)1462 void ASTDumper::VisitBlockDecl(const BlockDecl *D) {
1463 for (auto I : D->params())
1464 dumpDecl(I);
1465
1466 if (D->isVariadic()) {
1467 IndentScope Indent(*this);
1468 OS << "...";
1469 }
1470
1471 if (D->capturesCXXThis()) {
1472 IndentScope Indent(*this);
1473 OS << "capture this";
1474 }
1475 for (const auto &I : D->captures()) {
1476 IndentScope Indent(*this);
1477 OS << "capture";
1478 if (I.isByRef())
1479 OS << " byref";
1480 if (I.isNested())
1481 OS << " nested";
1482 if (I.getVariable()) {
1483 OS << ' ';
1484 dumpBareDeclRef(I.getVariable());
1485 }
1486 if (I.hasCopyExpr())
1487 dumpStmt(I.getCopyExpr());
1488 }
1489 lastChild();
1490 dumpStmt(D->getBody());
1491 }
1492
1493 //===----------------------------------------------------------------------===//
1494 // Stmt dumping methods.
1495 //===----------------------------------------------------------------------===//
1496
dumpStmt(const Stmt * S)1497 void ASTDumper::dumpStmt(const Stmt *S) {
1498 IndentScope Indent(*this);
1499
1500 if (!S) {
1501 ColorScope Color(*this, NullColor);
1502 OS << "<<<NULL>>>";
1503 return;
1504 }
1505
1506 if (const DeclStmt *DS = dyn_cast<DeclStmt>(S)) {
1507 VisitDeclStmt(DS);
1508 return;
1509 }
1510
1511 setMoreChildren(!S->children().empty());
1512 ConstStmtVisitor<ASTDumper>::Visit(S);
1513 setMoreChildren(false);
1514 for (Stmt::const_child_range CI = S->children(); CI; ++CI) {
1515 Stmt::const_child_range Next = CI;
1516 ++Next;
1517 if (!Next)
1518 lastChild();
1519 dumpStmt(*CI);
1520 }
1521 }
1522
VisitStmt(const Stmt * Node)1523 void ASTDumper::VisitStmt(const Stmt *Node) {
1524 {
1525 ColorScope Color(*this, StmtColor);
1526 OS << Node->getStmtClassName();
1527 }
1528 dumpPointer(Node);
1529 dumpSourceRange(Node->getSourceRange());
1530 }
1531
VisitDeclStmt(const DeclStmt * Node)1532 void ASTDumper::VisitDeclStmt(const DeclStmt *Node) {
1533 VisitStmt(Node);
1534 for (DeclStmt::const_decl_iterator I = Node->decl_begin(),
1535 E = Node->decl_end();
1536 I != E; ++I) {
1537 if (I + 1 == E)
1538 lastChild();
1539 dumpDecl(*I);
1540 }
1541 }
1542
VisitAttributedStmt(const AttributedStmt * Node)1543 void ASTDumper::VisitAttributedStmt(const AttributedStmt *Node) {
1544 VisitStmt(Node);
1545 for (ArrayRef<const Attr *>::iterator I = Node->getAttrs().begin(),
1546 E = Node->getAttrs().end();
1547 I != E; ++I) {
1548 if (I + 1 == E)
1549 lastChild();
1550 dumpAttr(*I);
1551 }
1552 }
1553
VisitLabelStmt(const LabelStmt * Node)1554 void ASTDumper::VisitLabelStmt(const LabelStmt *Node) {
1555 VisitStmt(Node);
1556 OS << " '" << Node->getName() << "'";
1557 }
1558
VisitGotoStmt(const GotoStmt * Node)1559 void ASTDumper::VisitGotoStmt(const GotoStmt *Node) {
1560 VisitStmt(Node);
1561 OS << " '" << Node->getLabel()->getName() << "'";
1562 dumpPointer(Node->getLabel());
1563 }
1564
VisitCXXCatchStmt(const CXXCatchStmt * Node)1565 void ASTDumper::VisitCXXCatchStmt(const CXXCatchStmt *Node) {
1566 VisitStmt(Node);
1567 dumpDecl(Node->getExceptionDecl());
1568 }
1569
1570 //===----------------------------------------------------------------------===//
1571 // Expr dumping methods.
1572 //===----------------------------------------------------------------------===//
1573
VisitExpr(const Expr * Node)1574 void ASTDumper::VisitExpr(const Expr *Node) {
1575 VisitStmt(Node);
1576 dumpType(Node->getType());
1577
1578 {
1579 ColorScope Color(*this, ValueKindColor);
1580 switch (Node->getValueKind()) {
1581 case VK_RValue:
1582 break;
1583 case VK_LValue:
1584 OS << " lvalue";
1585 break;
1586 case VK_XValue:
1587 OS << " xvalue";
1588 break;
1589 }
1590 }
1591
1592 {
1593 ColorScope Color(*this, ObjectKindColor);
1594 switch (Node->getObjectKind()) {
1595 case OK_Ordinary:
1596 break;
1597 case OK_BitField:
1598 OS << " bitfield";
1599 break;
1600 case OK_ObjCProperty:
1601 OS << " objcproperty";
1602 break;
1603 case OK_ObjCSubscript:
1604 OS << " objcsubscript";
1605 break;
1606 case OK_VectorComponent:
1607 OS << " vectorcomponent";
1608 break;
1609 }
1610 }
1611 }
1612
dumpBasePath(raw_ostream & OS,const CastExpr * Node)1613 static void dumpBasePath(raw_ostream &OS, const CastExpr *Node) {
1614 if (Node->path_empty())
1615 return;
1616
1617 OS << " (";
1618 bool First = true;
1619 for (CastExpr::path_const_iterator I = Node->path_begin(),
1620 E = Node->path_end();
1621 I != E; ++I) {
1622 const CXXBaseSpecifier *Base = *I;
1623 if (!First)
1624 OS << " -> ";
1625
1626 const CXXRecordDecl *RD =
1627 cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
1628
1629 if (Base->isVirtual())
1630 OS << "virtual ";
1631 OS << RD->getName();
1632 First = false;
1633 }
1634
1635 OS << ')';
1636 }
1637
VisitCastExpr(const CastExpr * Node)1638 void ASTDumper::VisitCastExpr(const CastExpr *Node) {
1639 VisitExpr(Node);
1640 OS << " <";
1641 {
1642 ColorScope Color(*this, CastColor);
1643 OS << Node->getCastKindName();
1644 }
1645 dumpBasePath(OS, Node);
1646 OS << ">";
1647 }
1648
VisitDeclRefExpr(const DeclRefExpr * Node)1649 void ASTDumper::VisitDeclRefExpr(const DeclRefExpr *Node) {
1650 VisitExpr(Node);
1651
1652 OS << " ";
1653 dumpBareDeclRef(Node->getDecl());
1654 if (Node->getDecl() != Node->getFoundDecl()) {
1655 OS << " (";
1656 dumpBareDeclRef(Node->getFoundDecl());
1657 OS << ")";
1658 }
1659 }
1660
VisitUnresolvedLookupExpr(const UnresolvedLookupExpr * Node)1661 void ASTDumper::VisitUnresolvedLookupExpr(const UnresolvedLookupExpr *Node) {
1662 VisitExpr(Node);
1663 OS << " (";
1664 if (!Node->requiresADL())
1665 OS << "no ";
1666 OS << "ADL) = '" << Node->getName() << '\'';
1667
1668 UnresolvedLookupExpr::decls_iterator
1669 I = Node->decls_begin(), E = Node->decls_end();
1670 if (I == E)
1671 OS << " empty";
1672 for (; I != E; ++I)
1673 dumpPointer(*I);
1674 }
1675
VisitObjCIvarRefExpr(const ObjCIvarRefExpr * Node)1676 void ASTDumper::VisitObjCIvarRefExpr(const ObjCIvarRefExpr *Node) {
1677 VisitExpr(Node);
1678
1679 {
1680 ColorScope Color(*this, DeclKindNameColor);
1681 OS << " " << Node->getDecl()->getDeclKindName() << "Decl";
1682 }
1683 OS << "='" << *Node->getDecl() << "'";
1684 dumpPointer(Node->getDecl());
1685 if (Node->isFreeIvar())
1686 OS << " isFreeIvar";
1687 }
1688
VisitPredefinedExpr(const PredefinedExpr * Node)1689 void ASTDumper::VisitPredefinedExpr(const PredefinedExpr *Node) {
1690 VisitExpr(Node);
1691 switch (Node->getIdentType()) {
1692 default: llvm_unreachable("unknown case");
1693 case PredefinedExpr::Func: OS << " __func__"; break;
1694 case PredefinedExpr::Function: OS << " __FUNCTION__"; break;
1695 case PredefinedExpr::FuncDName: OS << " __FUNCDNAME__"; break;
1696 case PredefinedExpr::LFunction: OS << " L__FUNCTION__"; break;
1697 case PredefinedExpr::PrettyFunction: OS << " __PRETTY_FUNCTION__";break;
1698 case PredefinedExpr::FuncSig: OS << " __FUNCSIG__"; break;
1699 }
1700 }
1701
VisitCharacterLiteral(const CharacterLiteral * Node)1702 void ASTDumper::VisitCharacterLiteral(const CharacterLiteral *Node) {
1703 VisitExpr(Node);
1704 ColorScope Color(*this, ValueColor);
1705 OS << " " << Node->getValue();
1706 }
1707
VisitIntegerLiteral(const IntegerLiteral * Node)1708 void ASTDumper::VisitIntegerLiteral(const IntegerLiteral *Node) {
1709 VisitExpr(Node);
1710
1711 bool isSigned = Node->getType()->isSignedIntegerType();
1712 ColorScope Color(*this, ValueColor);
1713 OS << " " << Node->getValue().toString(10, isSigned);
1714 }
1715
VisitFloatingLiteral(const FloatingLiteral * Node)1716 void ASTDumper::VisitFloatingLiteral(const FloatingLiteral *Node) {
1717 VisitExpr(Node);
1718 ColorScope Color(*this, ValueColor);
1719 OS << " " << Node->getValueAsApproximateDouble();
1720 }
1721
VisitStringLiteral(const StringLiteral * Str)1722 void ASTDumper::VisitStringLiteral(const StringLiteral *Str) {
1723 VisitExpr(Str);
1724 ColorScope Color(*this, ValueColor);
1725 OS << " ";
1726 Str->outputString(OS);
1727 }
1728
VisitInitListExpr(const InitListExpr * ILE)1729 void ASTDumper::VisitInitListExpr(const InitListExpr *ILE) {
1730 VisitExpr(ILE);
1731 if (auto *Filler = ILE->getArrayFiller()) {
1732 if (!ILE->getNumInits())
1733 lastChild();
1734 IndentScope Indent(*this);
1735 OS << "array filler";
1736 lastChild();
1737 dumpStmt(Filler);
1738 }
1739 if (auto *Field = ILE->getInitializedFieldInUnion()) {
1740 OS << " field ";
1741 dumpBareDeclRef(Field);
1742 }
1743 }
1744
VisitUnaryOperator(const UnaryOperator * Node)1745 void ASTDumper::VisitUnaryOperator(const UnaryOperator *Node) {
1746 VisitExpr(Node);
1747 OS << " " << (Node->isPostfix() ? "postfix" : "prefix")
1748 << " '" << UnaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
1749 }
1750
VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr * Node)1751 void ASTDumper::VisitUnaryExprOrTypeTraitExpr(
1752 const UnaryExprOrTypeTraitExpr *Node) {
1753 VisitExpr(Node);
1754 switch(Node->getKind()) {
1755 case UETT_SizeOf:
1756 OS << " sizeof";
1757 break;
1758 case UETT_AlignOf:
1759 OS << " alignof";
1760 break;
1761 case UETT_VecStep:
1762 OS << " vec_step";
1763 break;
1764 }
1765 if (Node->isArgumentType())
1766 dumpType(Node->getArgumentType());
1767 }
1768
VisitMemberExpr(const MemberExpr * Node)1769 void ASTDumper::VisitMemberExpr(const MemberExpr *Node) {
1770 VisitExpr(Node);
1771 OS << " " << (Node->isArrow() ? "->" : ".") << *Node->getMemberDecl();
1772 dumpPointer(Node->getMemberDecl());
1773 }
1774
VisitExtVectorElementExpr(const ExtVectorElementExpr * Node)1775 void ASTDumper::VisitExtVectorElementExpr(const ExtVectorElementExpr *Node) {
1776 VisitExpr(Node);
1777 OS << " " << Node->getAccessor().getNameStart();
1778 }
1779
VisitBinaryOperator(const BinaryOperator * Node)1780 void ASTDumper::VisitBinaryOperator(const BinaryOperator *Node) {
1781 VisitExpr(Node);
1782 OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
1783 }
1784
VisitCompoundAssignOperator(const CompoundAssignOperator * Node)1785 void ASTDumper::VisitCompoundAssignOperator(
1786 const CompoundAssignOperator *Node) {
1787 VisitExpr(Node);
1788 OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode())
1789 << "' ComputeLHSTy=";
1790 dumpBareType(Node->getComputationLHSType());
1791 OS << " ComputeResultTy=";
1792 dumpBareType(Node->getComputationResultType());
1793 }
1794
VisitBlockExpr(const BlockExpr * Node)1795 void ASTDumper::VisitBlockExpr(const BlockExpr *Node) {
1796 VisitExpr(Node);
1797 dumpDecl(Node->getBlockDecl());
1798 }
1799
VisitOpaqueValueExpr(const OpaqueValueExpr * Node)1800 void ASTDumper::VisitOpaqueValueExpr(const OpaqueValueExpr *Node) {
1801 VisitExpr(Node);
1802
1803 if (Expr *Source = Node->getSourceExpr()) {
1804 lastChild();
1805 dumpStmt(Source);
1806 }
1807 }
1808
1809 // GNU extensions.
1810
VisitAddrLabelExpr(const AddrLabelExpr * Node)1811 void ASTDumper::VisitAddrLabelExpr(const AddrLabelExpr *Node) {
1812 VisitExpr(Node);
1813 OS << " " << Node->getLabel()->getName();
1814 dumpPointer(Node->getLabel());
1815 }
1816
1817 //===----------------------------------------------------------------------===//
1818 // C++ Expressions
1819 //===----------------------------------------------------------------------===//
1820
VisitCXXNamedCastExpr(const CXXNamedCastExpr * Node)1821 void ASTDumper::VisitCXXNamedCastExpr(const CXXNamedCastExpr *Node) {
1822 VisitExpr(Node);
1823 OS << " " << Node->getCastName()
1824 << "<" << Node->getTypeAsWritten().getAsString() << ">"
1825 << " <" << Node->getCastKindName();
1826 dumpBasePath(OS, Node);
1827 OS << ">";
1828 }
1829
VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr * Node)1830 void ASTDumper::VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *Node) {
1831 VisitExpr(Node);
1832 OS << " " << (Node->getValue() ? "true" : "false");
1833 }
1834
VisitCXXThisExpr(const CXXThisExpr * Node)1835 void ASTDumper::VisitCXXThisExpr(const CXXThisExpr *Node) {
1836 VisitExpr(Node);
1837 OS << " this";
1838 }
1839
VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr * Node)1840 void ASTDumper::VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *Node) {
1841 VisitExpr(Node);
1842 OS << " functional cast to " << Node->getTypeAsWritten().getAsString()
1843 << " <" << Node->getCastKindName() << ">";
1844 }
1845
VisitCXXConstructExpr(const CXXConstructExpr * Node)1846 void ASTDumper::VisitCXXConstructExpr(const CXXConstructExpr *Node) {
1847 VisitExpr(Node);
1848 CXXConstructorDecl *Ctor = Node->getConstructor();
1849 dumpType(Ctor->getType());
1850 if (Node->isElidable())
1851 OS << " elidable";
1852 if (Node->requiresZeroInitialization())
1853 OS << " zeroing";
1854 }
1855
VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr * Node)1856 void ASTDumper::VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *Node) {
1857 VisitExpr(Node);
1858 OS << " ";
1859 dumpCXXTemporary(Node->getTemporary());
1860 }
1861
1862 void
VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr * Node)1863 ASTDumper::VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *Node) {
1864 VisitExpr(Node);
1865 if (const ValueDecl *VD = Node->getExtendingDecl()) {
1866 OS << " extended by ";
1867 dumpBareDeclRef(VD);
1868 }
1869 }
1870
VisitExprWithCleanups(const ExprWithCleanups * Node)1871 void ASTDumper::VisitExprWithCleanups(const ExprWithCleanups *Node) {
1872 VisitExpr(Node);
1873 for (unsigned i = 0, e = Node->getNumObjects(); i != e; ++i)
1874 dumpDeclRef(Node->getObject(i), "cleanup");
1875 }
1876
dumpCXXTemporary(const CXXTemporary * Temporary)1877 void ASTDumper::dumpCXXTemporary(const CXXTemporary *Temporary) {
1878 OS << "(CXXTemporary";
1879 dumpPointer(Temporary);
1880 OS << ")";
1881 }
1882
1883 //===----------------------------------------------------------------------===//
1884 // Obj-C Expressions
1885 //===----------------------------------------------------------------------===//
1886
VisitObjCMessageExpr(const ObjCMessageExpr * Node)1887 void ASTDumper::VisitObjCMessageExpr(const ObjCMessageExpr *Node) {
1888 VisitExpr(Node);
1889 OS << " selector=";
1890 Node->getSelector().print(OS);
1891 switch (Node->getReceiverKind()) {
1892 case ObjCMessageExpr::Instance:
1893 break;
1894
1895 case ObjCMessageExpr::Class:
1896 OS << " class=";
1897 dumpBareType(Node->getClassReceiver());
1898 break;
1899
1900 case ObjCMessageExpr::SuperInstance:
1901 OS << " super (instance)";
1902 break;
1903
1904 case ObjCMessageExpr::SuperClass:
1905 OS << " super (class)";
1906 break;
1907 }
1908 }
1909
VisitObjCBoxedExpr(const ObjCBoxedExpr * Node)1910 void ASTDumper::VisitObjCBoxedExpr(const ObjCBoxedExpr *Node) {
1911 VisitExpr(Node);
1912 OS << " selector=";
1913 Node->getBoxingMethod()->getSelector().print(OS);
1914 }
1915
VisitObjCAtCatchStmt(const ObjCAtCatchStmt * Node)1916 void ASTDumper::VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node) {
1917 VisitStmt(Node);
1918 if (const VarDecl *CatchParam = Node->getCatchParamDecl())
1919 dumpDecl(CatchParam);
1920 else
1921 OS << " catch all";
1922 }
1923
VisitObjCEncodeExpr(const ObjCEncodeExpr * Node)1924 void ASTDumper::VisitObjCEncodeExpr(const ObjCEncodeExpr *Node) {
1925 VisitExpr(Node);
1926 dumpType(Node->getEncodedType());
1927 }
1928
VisitObjCSelectorExpr(const ObjCSelectorExpr * Node)1929 void ASTDumper::VisitObjCSelectorExpr(const ObjCSelectorExpr *Node) {
1930 VisitExpr(Node);
1931
1932 OS << " ";
1933 Node->getSelector().print(OS);
1934 }
1935
VisitObjCProtocolExpr(const ObjCProtocolExpr * Node)1936 void ASTDumper::VisitObjCProtocolExpr(const ObjCProtocolExpr *Node) {
1937 VisitExpr(Node);
1938
1939 OS << ' ' << *Node->getProtocol();
1940 }
1941
VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr * Node)1942 void ASTDumper::VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *Node) {
1943 VisitExpr(Node);
1944 if (Node->isImplicitProperty()) {
1945 OS << " Kind=MethodRef Getter=\"";
1946 if (Node->getImplicitPropertyGetter())
1947 Node->getImplicitPropertyGetter()->getSelector().print(OS);
1948 else
1949 OS << "(null)";
1950
1951 OS << "\" Setter=\"";
1952 if (ObjCMethodDecl *Setter = Node->getImplicitPropertySetter())
1953 Setter->getSelector().print(OS);
1954 else
1955 OS << "(null)";
1956 OS << "\"";
1957 } else {
1958 OS << " Kind=PropertyRef Property=\"" << *Node->getExplicitProperty() <<'"';
1959 }
1960
1961 if (Node->isSuperReceiver())
1962 OS << " super";
1963
1964 OS << " Messaging=";
1965 if (Node->isMessagingGetter() && Node->isMessagingSetter())
1966 OS << "Getter&Setter";
1967 else if (Node->isMessagingGetter())
1968 OS << "Getter";
1969 else if (Node->isMessagingSetter())
1970 OS << "Setter";
1971 }
1972
VisitObjCSubscriptRefExpr(const ObjCSubscriptRefExpr * Node)1973 void ASTDumper::VisitObjCSubscriptRefExpr(const ObjCSubscriptRefExpr *Node) {
1974 VisitExpr(Node);
1975 if (Node->isArraySubscriptRefExpr())
1976 OS << " Kind=ArraySubscript GetterForArray=\"";
1977 else
1978 OS << " Kind=DictionarySubscript GetterForDictionary=\"";
1979 if (Node->getAtIndexMethodDecl())
1980 Node->getAtIndexMethodDecl()->getSelector().print(OS);
1981 else
1982 OS << "(null)";
1983
1984 if (Node->isArraySubscriptRefExpr())
1985 OS << "\" SetterForArray=\"";
1986 else
1987 OS << "\" SetterForDictionary=\"";
1988 if (Node->setAtIndexMethodDecl())
1989 Node->setAtIndexMethodDecl()->getSelector().print(OS);
1990 else
1991 OS << "(null)";
1992 }
1993
VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr * Node)1994 void ASTDumper::VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *Node) {
1995 VisitExpr(Node);
1996 OS << " " << (Node->getValue() ? "__objc_yes" : "__objc_no");
1997 }
1998
1999 //===----------------------------------------------------------------------===//
2000 // Comments
2001 //===----------------------------------------------------------------------===//
2002
getCommandName(unsigned CommandID)2003 const char *ASTDumper::getCommandName(unsigned CommandID) {
2004 if (Traits)
2005 return Traits->getCommandInfo(CommandID)->Name;
2006 const CommandInfo *Info = CommandTraits::getBuiltinCommandInfo(CommandID);
2007 if (Info)
2008 return Info->Name;
2009 return "<not a builtin command>";
2010 }
2011
dumpFullComment(const FullComment * C)2012 void ASTDumper::dumpFullComment(const FullComment *C) {
2013 if (!C)
2014 return;
2015
2016 FC = C;
2017 dumpComment(C);
2018 FC = nullptr;
2019 }
2020
dumpComment(const Comment * C)2021 void ASTDumper::dumpComment(const Comment *C) {
2022 IndentScope Indent(*this);
2023
2024 if (!C) {
2025 ColorScope Color(*this, NullColor);
2026 OS << "<<<NULL>>>";
2027 return;
2028 }
2029
2030 {
2031 ColorScope Color(*this, CommentColor);
2032 OS << C->getCommentKindName();
2033 }
2034 dumpPointer(C);
2035 dumpSourceRange(C->getSourceRange());
2036 ConstCommentVisitor<ASTDumper>::visit(C);
2037 for (Comment::child_iterator I = C->child_begin(), E = C->child_end();
2038 I != E; ++I) {
2039 if (I + 1 == E)
2040 lastChild();
2041 dumpComment(*I);
2042 }
2043 }
2044
visitTextComment(const TextComment * C)2045 void ASTDumper::visitTextComment(const TextComment *C) {
2046 OS << " Text=\"" << C->getText() << "\"";
2047 }
2048
visitInlineCommandComment(const InlineCommandComment * C)2049 void ASTDumper::visitInlineCommandComment(const InlineCommandComment *C) {
2050 OS << " Name=\"" << getCommandName(C->getCommandID()) << "\"";
2051 switch (C->getRenderKind()) {
2052 case InlineCommandComment::RenderNormal:
2053 OS << " RenderNormal";
2054 break;
2055 case InlineCommandComment::RenderBold:
2056 OS << " RenderBold";
2057 break;
2058 case InlineCommandComment::RenderMonospaced:
2059 OS << " RenderMonospaced";
2060 break;
2061 case InlineCommandComment::RenderEmphasized:
2062 OS << " RenderEmphasized";
2063 break;
2064 }
2065
2066 for (unsigned i = 0, e = C->getNumArgs(); i != e; ++i)
2067 OS << " Arg[" << i << "]=\"" << C->getArgText(i) << "\"";
2068 }
2069
visitHTMLStartTagComment(const HTMLStartTagComment * C)2070 void ASTDumper::visitHTMLStartTagComment(const HTMLStartTagComment *C) {
2071 OS << " Name=\"" << C->getTagName() << "\"";
2072 if (C->getNumAttrs() != 0) {
2073 OS << " Attrs: ";
2074 for (unsigned i = 0, e = C->getNumAttrs(); i != e; ++i) {
2075 const HTMLStartTagComment::Attribute &Attr = C->getAttr(i);
2076 OS << " \"" << Attr.Name << "=\"" << Attr.Value << "\"";
2077 }
2078 }
2079 if (C->isSelfClosing())
2080 OS << " SelfClosing";
2081 }
2082
visitHTMLEndTagComment(const HTMLEndTagComment * C)2083 void ASTDumper::visitHTMLEndTagComment(const HTMLEndTagComment *C) {
2084 OS << " Name=\"" << C->getTagName() << "\"";
2085 }
2086
visitBlockCommandComment(const BlockCommandComment * C)2087 void ASTDumper::visitBlockCommandComment(const BlockCommandComment *C) {
2088 OS << " Name=\"" << getCommandName(C->getCommandID()) << "\"";
2089 for (unsigned i = 0, e = C->getNumArgs(); i != e; ++i)
2090 OS << " Arg[" << i << "]=\"" << C->getArgText(i) << "\"";
2091 }
2092
visitParamCommandComment(const ParamCommandComment * C)2093 void ASTDumper::visitParamCommandComment(const ParamCommandComment *C) {
2094 OS << " " << ParamCommandComment::getDirectionAsString(C->getDirection());
2095
2096 if (C->isDirectionExplicit())
2097 OS << " explicitly";
2098 else
2099 OS << " implicitly";
2100
2101 if (C->hasParamName()) {
2102 if (C->isParamIndexValid())
2103 OS << " Param=\"" << C->getParamName(FC) << "\"";
2104 else
2105 OS << " Param=\"" << C->getParamNameAsWritten() << "\"";
2106 }
2107
2108 if (C->isParamIndexValid() && !C->isVarArgParam())
2109 OS << " ParamIndex=" << C->getParamIndex();
2110 }
2111
visitTParamCommandComment(const TParamCommandComment * C)2112 void ASTDumper::visitTParamCommandComment(const TParamCommandComment *C) {
2113 if (C->hasParamName()) {
2114 if (C->isPositionValid())
2115 OS << " Param=\"" << C->getParamName(FC) << "\"";
2116 else
2117 OS << " Param=\"" << C->getParamNameAsWritten() << "\"";
2118 }
2119
2120 if (C->isPositionValid()) {
2121 OS << " Position=<";
2122 for (unsigned i = 0, e = C->getDepth(); i != e; ++i) {
2123 OS << C->getIndex(i);
2124 if (i != e - 1)
2125 OS << ", ";
2126 }
2127 OS << ">";
2128 }
2129 }
2130
visitVerbatimBlockComment(const VerbatimBlockComment * C)2131 void ASTDumper::visitVerbatimBlockComment(const VerbatimBlockComment *C) {
2132 OS << " Name=\"" << getCommandName(C->getCommandID()) << "\""
2133 " CloseName=\"" << C->getCloseName() << "\"";
2134 }
2135
visitVerbatimBlockLineComment(const VerbatimBlockLineComment * C)2136 void ASTDumper::visitVerbatimBlockLineComment(
2137 const VerbatimBlockLineComment *C) {
2138 OS << " Text=\"" << C->getText() << "\"";
2139 }
2140
visitVerbatimLineComment(const VerbatimLineComment * C)2141 void ASTDumper::visitVerbatimLineComment(const VerbatimLineComment *C) {
2142 OS << " Text=\"" << C->getText() << "\"";
2143 }
2144
2145 //===----------------------------------------------------------------------===//
2146 // Decl method implementations
2147 //===----------------------------------------------------------------------===//
2148
dump() const2149 LLVM_DUMP_METHOD void Decl::dump() const { dump(llvm::errs()); }
2150
dump(raw_ostream & OS) const2151 LLVM_DUMP_METHOD void Decl::dump(raw_ostream &OS) const {
2152 ASTDumper P(OS, &getASTContext().getCommentCommandTraits(),
2153 &getASTContext().getSourceManager());
2154 P.dumpDecl(this);
2155 }
2156
dumpColor() const2157 LLVM_DUMP_METHOD void Decl::dumpColor() const {
2158 ASTDumper P(llvm::errs(), &getASTContext().getCommentCommandTraits(),
2159 &getASTContext().getSourceManager(), /*ShowColors*/true);
2160 P.dumpDecl(this);
2161 }
2162
dumpLookups() const2163 LLVM_DUMP_METHOD void DeclContext::dumpLookups() const {
2164 dumpLookups(llvm::errs());
2165 }
2166
dumpLookups(raw_ostream & OS) const2167 LLVM_DUMP_METHOD void DeclContext::dumpLookups(raw_ostream &OS) const {
2168 const DeclContext *DC = this;
2169 while (!DC->isTranslationUnit())
2170 DC = DC->getParent();
2171 ASTContext &Ctx = cast<TranslationUnitDecl>(DC)->getASTContext();
2172 ASTDumper P(OS, &Ctx.getCommentCommandTraits(), &Ctx.getSourceManager());
2173 P.dumpLookups(this);
2174 }
2175
2176 //===----------------------------------------------------------------------===//
2177 // Stmt method implementations
2178 //===----------------------------------------------------------------------===//
2179
dump(SourceManager & SM) const2180 LLVM_DUMP_METHOD void Stmt::dump(SourceManager &SM) const {
2181 dump(llvm::errs(), SM);
2182 }
2183
dump(raw_ostream & OS,SourceManager & SM) const2184 LLVM_DUMP_METHOD void Stmt::dump(raw_ostream &OS, SourceManager &SM) const {
2185 ASTDumper P(OS, nullptr, &SM);
2186 P.dumpStmt(this);
2187 }
2188
dump() const2189 LLVM_DUMP_METHOD void Stmt::dump() const {
2190 ASTDumper P(llvm::errs(), nullptr, nullptr);
2191 P.dumpStmt(this);
2192 }
2193
dumpColor() const2194 LLVM_DUMP_METHOD void Stmt::dumpColor() const {
2195 ASTDumper P(llvm::errs(), nullptr, nullptr, /*ShowColors*/true);
2196 P.dumpStmt(this);
2197 }
2198
2199 //===----------------------------------------------------------------------===//
2200 // Comment method implementations
2201 //===----------------------------------------------------------------------===//
2202
dump() const2203 LLVM_DUMP_METHOD void Comment::dump() const {
2204 dump(llvm::errs(), nullptr, nullptr);
2205 }
2206
dump(const ASTContext & Context) const2207 LLVM_DUMP_METHOD void Comment::dump(const ASTContext &Context) const {
2208 dump(llvm::errs(), &Context.getCommentCommandTraits(),
2209 &Context.getSourceManager());
2210 }
2211
dump(raw_ostream & OS,const CommandTraits * Traits,const SourceManager * SM) const2212 void Comment::dump(raw_ostream &OS, const CommandTraits *Traits,
2213 const SourceManager *SM) const {
2214 const FullComment *FC = dyn_cast<FullComment>(this);
2215 ASTDumper D(OS, Traits, SM);
2216 D.dumpFullComment(FC);
2217 }
2218
dumpColor() const2219 LLVM_DUMP_METHOD void Comment::dumpColor() const {
2220 const FullComment *FC = dyn_cast<FullComment>(this);
2221 ASTDumper D(llvm::errs(), nullptr, nullptr, /*ShowColors*/true);
2222 D.dumpFullComment(FC);
2223 }
2224