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/ASTDumperUtils.h"
17 #include "clang/AST/Attr.h"
18 #include "clang/AST/AttrVisitor.h"
19 #include "clang/AST/CommentVisitor.h"
20 #include "clang/AST/DeclCXX.h"
21 #include "clang/AST/DeclLookups.h"
22 #include "clang/AST/DeclObjC.h"
23 #include "clang/AST/DeclOpenMP.h"
24 #include "clang/AST/DeclVisitor.h"
25 #include "clang/AST/LocInfoType.h"
26 #include "clang/AST/StmtVisitor.h"
27 #include "clang/AST/TemplateArgumentVisitor.h"
28 #include "clang/AST/TextNodeDumper.h"
29 #include "clang/AST/TypeVisitor.h"
30 #include "clang/Basic/Builtins.h"
31 #include "clang/Basic/Module.h"
32 #include "clang/Basic/SourceManager.h"
33 #include "llvm/Support/raw_ostream.h"
34 using namespace clang;
35 using namespace clang::comments;
36 
37 //===----------------------------------------------------------------------===//
38 // ASTDumper Visitor
39 //===----------------------------------------------------------------------===//
40 
41 namespace  {
42 
43   class ASTDumper
44       : public ConstDeclVisitor<ASTDumper>,
45         public ConstStmtVisitor<ASTDumper>,
46         public ConstCommentVisitor<ASTDumper, void, const FullComment *>,
47         public TypeVisitor<ASTDumper>,
48         public ConstAttrVisitor<ASTDumper>,
49         public ConstTemplateArgumentVisitor<ASTDumper> {
50 
51     TextNodeDumper NodeDumper;
52 
53     raw_ostream &OS;
54 
55     /// The policy to use for printing; can be defaulted.
56     PrintingPolicy PrintPolicy;
57 
58     /// Indicates whether we should trigger deserialization of nodes that had
59     /// not already been loaded.
60     bool Deserialize = false;
61 
62     const bool ShowColors;
63 
64     /// Dump a child of the current node.
dumpChild(Fn DoDumpChild)65     template<typename Fn> void dumpChild(Fn DoDumpChild) {
66       NodeDumper.AddChild(DoDumpChild);
67     }
dumpChild(StringRef Label,Fn DoDumpChild)68     template <typename Fn> void dumpChild(StringRef Label, Fn DoDumpChild) {
69       NodeDumper.AddChild(Label, DoDumpChild);
70     }
71 
72   public:
ASTDumper(raw_ostream & OS,const CommandTraits * Traits,const SourceManager * SM)73     ASTDumper(raw_ostream &OS, const CommandTraits *Traits,
74               const SourceManager *SM)
75         : ASTDumper(OS, Traits, SM,
76                     SM && SM->getDiagnostics().getShowColors()) {}
77 
ASTDumper(raw_ostream & OS,const CommandTraits * Traits,const SourceManager * SM,bool ShowColors)78     ASTDumper(raw_ostream &OS, const CommandTraits *Traits,
79               const SourceManager *SM, bool ShowColors)
80         : ASTDumper(OS, Traits, SM, ShowColors, LangOptions()) {}
ASTDumper(raw_ostream & OS,const CommandTraits * Traits,const SourceManager * SM,bool ShowColors,const PrintingPolicy & PrintPolicy)81     ASTDumper(raw_ostream &OS, const CommandTraits *Traits,
82               const SourceManager *SM, bool ShowColors,
83               const PrintingPolicy &PrintPolicy)
84         : NodeDumper(OS, ShowColors, SM, PrintPolicy, Traits), OS(OS),
85           PrintPolicy(PrintPolicy), ShowColors(ShowColors) {}
86 
setDeserialize(bool D)87     void setDeserialize(bool D) { Deserialize = D; }
88 
89     void dumpDecl(const Decl *D);
90     void dumpStmt(const Stmt *S, StringRef Label = {});
91 
92     // Utilities
93     void dumpTypeAsChild(QualType T);
94     void dumpTypeAsChild(const Type *T);
95     void dumpDeclContext(const DeclContext *DC);
96     void dumpLookups(const DeclContext *DC, bool DumpDecls);
97     void dumpAttr(const Attr *A);
98 
99     // C++ Utilities
100     void dumpCXXCtorInitializer(const CXXCtorInitializer *Init);
101     void dumpTemplateParameters(const TemplateParameterList *TPL);
102     void dumpTemplateArgumentListInfo(const TemplateArgumentListInfo &TALI);
103     void dumpTemplateArgumentLoc(const TemplateArgumentLoc &A,
104                                  const Decl *From = nullptr,
105                                  const char *Label = nullptr);
106     void dumpTemplateArgumentList(const TemplateArgumentList &TAL);
107     void dumpTemplateArgument(const TemplateArgument &A,
108                               SourceRange R = SourceRange(),
109                               const Decl *From = nullptr,
110                               const char *Label = nullptr);
111     template <typename SpecializationDecl>
112     void dumpTemplateDeclSpecialization(const SpecializationDecl *D,
113                                         bool DumpExplicitInst,
114                                         bool DumpRefOnly);
115     template <typename TemplateDecl>
116     void dumpTemplateDecl(const TemplateDecl *D, bool DumpExplicitInst);
117 
118     // Objective-C utilities.
119     void dumpObjCTypeParamList(const ObjCTypeParamList *typeParams);
120 
121     // Types
VisitComplexType(const ComplexType * T)122     void VisitComplexType(const ComplexType *T) {
123       dumpTypeAsChild(T->getElementType());
124     }
VisitLocInfoType(const LocInfoType * T)125     void VisitLocInfoType(const LocInfoType *T) {
126       dumpTypeAsChild(T->getTypeSourceInfo()->getType());
127     }
VisitPointerType(const PointerType * T)128     void VisitPointerType(const PointerType *T) {
129       dumpTypeAsChild(T->getPointeeType());
130     }
VisitBlockPointerType(const BlockPointerType * T)131     void VisitBlockPointerType(const BlockPointerType *T) {
132       dumpTypeAsChild(T->getPointeeType());
133     }
VisitReferenceType(const ReferenceType * T)134     void VisitReferenceType(const ReferenceType *T) {
135       dumpTypeAsChild(T->getPointeeType());
136     }
VisitMemberPointerType(const MemberPointerType * T)137     void VisitMemberPointerType(const MemberPointerType *T) {
138       dumpTypeAsChild(T->getClass());
139       dumpTypeAsChild(T->getPointeeType());
140     }
VisitArrayType(const ArrayType * T)141     void VisitArrayType(const ArrayType *T) {
142       dumpTypeAsChild(T->getElementType());
143     }
VisitVariableArrayType(const VariableArrayType * T)144     void VisitVariableArrayType(const VariableArrayType *T) {
145       VisitArrayType(T);
146       dumpStmt(T->getSizeExpr());
147     }
VisitDependentSizedArrayType(const DependentSizedArrayType * T)148     void VisitDependentSizedArrayType(const DependentSizedArrayType *T) {
149       dumpTypeAsChild(T->getElementType());
150       dumpStmt(T->getSizeExpr());
151     }
VisitDependentSizedExtVectorType(const DependentSizedExtVectorType * T)152     void VisitDependentSizedExtVectorType(
153         const DependentSizedExtVectorType *T) {
154       dumpTypeAsChild(T->getElementType());
155       dumpStmt(T->getSizeExpr());
156     }
VisitVectorType(const VectorType * T)157     void VisitVectorType(const VectorType *T) {
158       dumpTypeAsChild(T->getElementType());
159     }
VisitFunctionType(const FunctionType * T)160     void VisitFunctionType(const FunctionType *T) {
161       dumpTypeAsChild(T->getReturnType());
162     }
VisitFunctionProtoType(const FunctionProtoType * T)163     void VisitFunctionProtoType(const FunctionProtoType *T) {
164       VisitFunctionType(T);
165       for (QualType PT : T->getParamTypes())
166         dumpTypeAsChild(PT);
167       if (T->getExtProtoInfo().Variadic)
168         dumpChild([=] { OS << "..."; });
169     }
VisitTypeOfExprType(const TypeOfExprType * T)170     void VisitTypeOfExprType(const TypeOfExprType *T) {
171       dumpStmt(T->getUnderlyingExpr());
172     }
VisitDecltypeType(const DecltypeType * T)173     void VisitDecltypeType(const DecltypeType *T) {
174       dumpStmt(T->getUnderlyingExpr());
175     }
VisitUnaryTransformType(const UnaryTransformType * T)176     void VisitUnaryTransformType(const UnaryTransformType *T) {
177       dumpTypeAsChild(T->getBaseType());
178     }
VisitAttributedType(const AttributedType * T)179     void VisitAttributedType(const AttributedType *T) {
180       // FIXME: AttrKind
181       dumpTypeAsChild(T->getModifiedType());
182     }
VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType * T)183     void VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) {
184       dumpTypeAsChild(T->getReplacedParameter());
185     }
VisitSubstTemplateTypeParmPackType(const SubstTemplateTypeParmPackType * T)186     void VisitSubstTemplateTypeParmPackType(
187         const SubstTemplateTypeParmPackType *T) {
188       dumpTypeAsChild(T->getReplacedParameter());
189       dumpTemplateArgument(T->getArgumentPack());
190     }
VisitTemplateSpecializationType(const TemplateSpecializationType * T)191     void VisitTemplateSpecializationType(const TemplateSpecializationType *T) {
192       for (auto &Arg : *T)
193         dumpTemplateArgument(Arg);
194       if (T->isTypeAlias())
195         dumpTypeAsChild(T->getAliasedType());
196     }
VisitObjCObjectPointerType(const ObjCObjectPointerType * T)197     void VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
198       dumpTypeAsChild(T->getPointeeType());
199     }
VisitAtomicType(const AtomicType * T)200     void VisitAtomicType(const AtomicType *T) {
201       dumpTypeAsChild(T->getValueType());
202     }
VisitPipeType(const PipeType * T)203     void VisitPipeType(const PipeType *T) {
204       dumpTypeAsChild(T->getElementType());
205     }
VisitAdjustedType(const AdjustedType * T)206     void VisitAdjustedType(const AdjustedType *T) {
207       dumpTypeAsChild(T->getOriginalType());
208     }
VisitPackExpansionType(const PackExpansionType * T)209     void VisitPackExpansionType(const PackExpansionType *T) {
210       if (!T->isSugared())
211         dumpTypeAsChild(T->getPattern());
212     }
213     // FIXME: ElaboratedType, DependentNameType,
214     // DependentTemplateSpecializationType, ObjCObjectType
215 
216     // Decls
217     void VisitLabelDecl(const LabelDecl *D);
218     void VisitTypedefDecl(const TypedefDecl *D);
219     void VisitEnumDecl(const EnumDecl *D);
220     void VisitRecordDecl(const RecordDecl *D);
221     void VisitEnumConstantDecl(const EnumConstantDecl *D);
222     void VisitIndirectFieldDecl(const IndirectFieldDecl *D);
223     void VisitFunctionDecl(const FunctionDecl *D);
224     void VisitFieldDecl(const FieldDecl *D);
225     void VisitVarDecl(const VarDecl *D);
226     void VisitDecompositionDecl(const DecompositionDecl *D);
227     void VisitBindingDecl(const BindingDecl *D);
228     void VisitFileScopeAsmDecl(const FileScopeAsmDecl *D);
229     void VisitImportDecl(const ImportDecl *D);
230     void VisitPragmaCommentDecl(const PragmaCommentDecl *D);
231     void VisitPragmaDetectMismatchDecl(const PragmaDetectMismatchDecl *D);
232     void VisitCapturedDecl(const CapturedDecl *D);
233 
234     // OpenMP decls
235     void VisitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D);
236     void VisitOMPDeclareReductionDecl(const OMPDeclareReductionDecl *D);
237     void VisitOMPRequiresDecl(const OMPRequiresDecl *D);
238     void VisitOMPCapturedExprDecl(const OMPCapturedExprDecl *D);
239 
240     // C++ Decls
241     void VisitNamespaceDecl(const NamespaceDecl *D);
242     void VisitUsingDirectiveDecl(const UsingDirectiveDecl *D);
243     void VisitNamespaceAliasDecl(const NamespaceAliasDecl *D);
244     void VisitTypeAliasDecl(const TypeAliasDecl *D);
245     void VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D);
246     void VisitCXXRecordDecl(const CXXRecordDecl *D);
247     void VisitStaticAssertDecl(const StaticAssertDecl *D);
248     void VisitFunctionTemplateDecl(const FunctionTemplateDecl *D);
249     void VisitClassTemplateDecl(const ClassTemplateDecl *D);
250     void VisitClassTemplateSpecializationDecl(
251         const ClassTemplateSpecializationDecl *D);
252     void VisitClassTemplatePartialSpecializationDecl(
253         const ClassTemplatePartialSpecializationDecl *D);
254     void VisitClassScopeFunctionSpecializationDecl(
255         const ClassScopeFunctionSpecializationDecl *D);
256     void VisitBuiltinTemplateDecl(const BuiltinTemplateDecl *D);
257     void VisitVarTemplateDecl(const VarTemplateDecl *D);
258     void VisitVarTemplateSpecializationDecl(
259         const VarTemplateSpecializationDecl *D);
260     void VisitVarTemplatePartialSpecializationDecl(
261         const VarTemplatePartialSpecializationDecl *D);
262     void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D);
263     void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D);
264     void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D);
265     void VisitUsingDecl(const UsingDecl *D);
266     void VisitUnresolvedUsingTypenameDecl(const UnresolvedUsingTypenameDecl *D);
267     void VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl *D);
268     void VisitUsingShadowDecl(const UsingShadowDecl *D);
269     void VisitConstructorUsingShadowDecl(const ConstructorUsingShadowDecl *D);
270     void VisitLinkageSpecDecl(const LinkageSpecDecl *D);
271     void VisitAccessSpecDecl(const AccessSpecDecl *D);
272     void VisitFriendDecl(const FriendDecl *D);
273 
274     // ObjC Decls
275     void VisitObjCIvarDecl(const ObjCIvarDecl *D);
276     void VisitObjCMethodDecl(const ObjCMethodDecl *D);
277     void VisitObjCTypeParamDecl(const ObjCTypeParamDecl *D);
278     void VisitObjCCategoryDecl(const ObjCCategoryDecl *D);
279     void VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D);
280     void VisitObjCProtocolDecl(const ObjCProtocolDecl *D);
281     void VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D);
282     void VisitObjCImplementationDecl(const ObjCImplementationDecl *D);
283     void VisitObjCCompatibleAliasDecl(const ObjCCompatibleAliasDecl *D);
284     void VisitObjCPropertyDecl(const ObjCPropertyDecl *D);
285     void VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D);
286     void Visit(const BlockDecl::Capture &C);
287     void VisitBlockDecl(const BlockDecl *D);
288 
289     // Stmts.
290     void VisitDeclStmt(const DeclStmt *Node);
291     void VisitAttributedStmt(const AttributedStmt *Node);
292     void VisitCXXCatchStmt(const CXXCatchStmt *Node);
293     void VisitCapturedStmt(const CapturedStmt *Node);
294 
295     // OpenMP
296     void Visit(const OMPClause *C);
297     void VisitOMPExecutableDirective(const OMPExecutableDirective *Node);
298 
299     // Exprs
300     void VisitInitListExpr(const InitListExpr *ILE);
301     void VisitBlockExpr(const BlockExpr *Node);
302     void VisitOpaqueValueExpr(const OpaqueValueExpr *Node);
303     void VisitGenericSelectionExpr(const GenericSelectionExpr *E);
304 
305     // C++
VisitLambdaExpr(const LambdaExpr * Node)306     void VisitLambdaExpr(const LambdaExpr *Node) {
307       dumpDecl(Node->getLambdaClass());
308     }
309     void VisitSizeOfPackExpr(const SizeOfPackExpr *Node);
310 
311     // ObjC
312     void VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node);
313 
314     // Comments.
315     void dumpComment(const Comment *C, const FullComment *FC);
316 
VisitExpressionTemplateArgument(const TemplateArgument & TA)317     void VisitExpressionTemplateArgument(const TemplateArgument &TA) {
318       dumpStmt(TA.getAsExpr());
319     }
VisitPackTemplateArgument(const TemplateArgument & TA)320     void VisitPackTemplateArgument(const TemplateArgument &TA) {
321       for (const auto &TArg : TA.pack_elements())
322         dumpTemplateArgument(TArg);
323     }
324 
325 // Implements Visit methods for Attrs.
326 #include "clang/AST/AttrNodeTraverse.inc"
327   };
328 }
329 
330 //===----------------------------------------------------------------------===//
331 //  Utilities
332 //===----------------------------------------------------------------------===//
333 
dumpTypeAsChild(QualType T)334 void ASTDumper::dumpTypeAsChild(QualType T) {
335   SplitQualType SQT = T.split();
336   if (!SQT.Quals.hasQualifiers())
337     return dumpTypeAsChild(SQT.Ty);
338 
339   dumpChild([=] {
340     NodeDumper.Visit(T);
341     dumpTypeAsChild(T.split().Ty);
342   });
343 }
344 
dumpTypeAsChild(const Type * T)345 void ASTDumper::dumpTypeAsChild(const Type *T) {
346   dumpChild([=] {
347     NodeDumper.Visit(T);
348     if (!T)
349       return;
350     TypeVisitor<ASTDumper>::Visit(T);
351 
352     QualType SingleStepDesugar =
353         T->getLocallyUnqualifiedSingleStepDesugaredType();
354     if (SingleStepDesugar != QualType(T, 0))
355       dumpTypeAsChild(SingleStepDesugar);
356   });
357 }
358 
dumpDeclContext(const DeclContext * DC)359 void ASTDumper::dumpDeclContext(const DeclContext *DC) {
360   if (!DC)
361     return;
362 
363   for (auto *D : (Deserialize ? DC->decls() : DC->noload_decls()))
364     dumpDecl(D);
365 
366   if (DC->hasExternalLexicalStorage()) {
367     dumpChild([=] {
368       ColorScope Color(OS, ShowColors, UndeserializedColor);
369       OS << "<undeserialized declarations>";
370     });
371   }
372 }
373 
dumpLookups(const DeclContext * DC,bool DumpDecls)374 void ASTDumper::dumpLookups(const DeclContext *DC, bool DumpDecls) {
375   dumpChild([=] {
376     OS << "StoredDeclsMap ";
377     NodeDumper.dumpBareDeclRef(cast<Decl>(DC));
378 
379     const DeclContext *Primary = DC->getPrimaryContext();
380     if (Primary != DC) {
381       OS << " primary";
382       NodeDumper.dumpPointer(cast<Decl>(Primary));
383     }
384 
385     bool HasUndeserializedLookups = Primary->hasExternalVisibleStorage();
386 
387     auto Range = Deserialize
388                      ? Primary->lookups()
389                      : Primary->noload_lookups(/*PreserveInternalState=*/true);
390     for (auto I = Range.begin(), E = Range.end(); I != E; ++I) {
391       DeclarationName Name = I.getLookupName();
392       DeclContextLookupResult R = *I;
393 
394       dumpChild([=] {
395         OS << "DeclarationName ";
396         {
397           ColorScope Color(OS, ShowColors, DeclNameColor);
398           OS << '\'' << Name << '\'';
399         }
400 
401         for (DeclContextLookupResult::iterator RI = R.begin(), RE = R.end();
402              RI != RE; ++RI) {
403           dumpChild([=] {
404             NodeDumper.dumpBareDeclRef(*RI);
405 
406             if ((*RI)->isHidden())
407               OS << " hidden";
408 
409             // If requested, dump the redecl chain for this lookup.
410             if (DumpDecls) {
411               // Dump earliest decl first.
412               std::function<void(Decl *)> DumpWithPrev = [&](Decl *D) {
413                 if (Decl *Prev = D->getPreviousDecl())
414                   DumpWithPrev(Prev);
415                 dumpDecl(D);
416               };
417               DumpWithPrev(*RI);
418             }
419           });
420         }
421       });
422     }
423 
424     if (HasUndeserializedLookups) {
425       dumpChild([=] {
426         ColorScope Color(OS, ShowColors, UndeserializedColor);
427         OS << "<undeserialized lookups>";
428       });
429     }
430   });
431 }
432 
dumpAttr(const Attr * A)433 void ASTDumper::dumpAttr(const Attr *A) {
434   dumpChild([=] {
435     NodeDumper.Visit(A);
436     ConstAttrVisitor<ASTDumper>::Visit(A);
437   });
438 }
439 
440 //===----------------------------------------------------------------------===//
441 //  C++ Utilities
442 //===----------------------------------------------------------------------===//
443 
dumpCXXCtorInitializer(const CXXCtorInitializer * Init)444 void ASTDumper::dumpCXXCtorInitializer(const CXXCtorInitializer *Init) {
445   dumpChild([=] {
446     NodeDumper.Visit(Init);
447     dumpStmt(Init->getInit());
448   });
449 }
450 
dumpTemplateParameters(const TemplateParameterList * TPL)451 void ASTDumper::dumpTemplateParameters(const TemplateParameterList *TPL) {
452   if (!TPL)
453     return;
454 
455   for (TemplateParameterList::const_iterator I = TPL->begin(), E = TPL->end();
456        I != E; ++I)
457     dumpDecl(*I);
458 }
459 
dumpTemplateArgumentListInfo(const TemplateArgumentListInfo & TALI)460 void ASTDumper::dumpTemplateArgumentListInfo(
461     const TemplateArgumentListInfo &TALI) {
462   for (unsigned i = 0, e = TALI.size(); i < e; ++i)
463     dumpTemplateArgumentLoc(TALI[i]);
464 }
465 
dumpTemplateArgumentLoc(const TemplateArgumentLoc & A,const Decl * From,const char * Label)466 void ASTDumper::dumpTemplateArgumentLoc(const TemplateArgumentLoc &A,
467                                         const Decl *From, const char *Label) {
468   dumpTemplateArgument(A.getArgument(), A.getSourceRange(), From, Label);
469 }
470 
dumpTemplateArgumentList(const TemplateArgumentList & TAL)471 void ASTDumper::dumpTemplateArgumentList(const TemplateArgumentList &TAL) {
472   for (unsigned i = 0, e = TAL.size(); i < e; ++i)
473     dumpTemplateArgument(TAL[i]);
474 }
475 
dumpTemplateArgument(const TemplateArgument & A,SourceRange R,const Decl * From,const char * Label)476 void ASTDumper::dumpTemplateArgument(const TemplateArgument &A, SourceRange R,
477                                      const Decl *From, const char *Label) {
478   dumpChild([=] {
479     NodeDumper.Visit(A, R, From, Label);
480     ConstTemplateArgumentVisitor<ASTDumper>::Visit(A);
481   });
482 }
483 
484 //===----------------------------------------------------------------------===//
485 //  Objective-C Utilities
486 //===----------------------------------------------------------------------===//
dumpObjCTypeParamList(const ObjCTypeParamList * typeParams)487 void ASTDumper::dumpObjCTypeParamList(const ObjCTypeParamList *typeParams) {
488   if (!typeParams)
489     return;
490 
491   for (auto typeParam : *typeParams) {
492     dumpDecl(typeParam);
493   }
494 }
495 
496 //===----------------------------------------------------------------------===//
497 //  Decl dumping methods.
498 //===----------------------------------------------------------------------===//
499 
dumpDecl(const Decl * D)500 void ASTDumper::dumpDecl(const Decl *D) {
501   dumpChild([=] {
502     NodeDumper.Visit(D);
503     if (!D)
504       return;
505 
506     ConstDeclVisitor<ASTDumper>::Visit(D);
507 
508     for (Decl::attr_iterator I = D->attr_begin(), E = D->attr_end(); I != E;
509          ++I)
510       dumpAttr(*I);
511 
512     if (const FullComment *Comment =
513             D->getASTContext().getLocalCommentForDeclUncached(D))
514       dumpComment(Comment, Comment);
515 
516     // Decls within functions are visited by the body.
517     if (!isa<FunctionDecl>(*D) && !isa<ObjCMethodDecl>(*D)) {
518       auto DC = dyn_cast<DeclContext>(D);
519       if (DC &&
520           (DC->hasExternalLexicalStorage() ||
521            (Deserialize ? DC->decls_begin() != DC->decls_end()
522                         : DC->noload_decls_begin() != DC->noload_decls_end())))
523         dumpDeclContext(DC);
524     }
525   });
526 }
527 
VisitLabelDecl(const LabelDecl * D)528 void ASTDumper::VisitLabelDecl(const LabelDecl *D) { NodeDumper.dumpName(D); }
529 
VisitTypedefDecl(const TypedefDecl * D)530 void ASTDumper::VisitTypedefDecl(const TypedefDecl *D) {
531   NodeDumper.dumpName(D);
532   NodeDumper.dumpType(D->getUnderlyingType());
533   if (D->isModulePrivate())
534     OS << " __module_private__";
535   dumpTypeAsChild(D->getUnderlyingType());
536 }
537 
VisitEnumDecl(const EnumDecl * D)538 void ASTDumper::VisitEnumDecl(const EnumDecl *D) {
539   if (D->isScoped()) {
540     if (D->isScopedUsingClassTag())
541       OS << " class";
542     else
543       OS << " struct";
544   }
545   NodeDumper.dumpName(D);
546   if (D->isModulePrivate())
547     OS << " __module_private__";
548   if (D->isFixed())
549     NodeDumper.dumpType(D->getIntegerType());
550 }
551 
VisitRecordDecl(const RecordDecl * D)552 void ASTDumper::VisitRecordDecl(const RecordDecl *D) {
553   OS << ' ' << D->getKindName();
554   NodeDumper.dumpName(D);
555   if (D->isModulePrivate())
556     OS << " __module_private__";
557   if (D->isCompleteDefinition())
558     OS << " definition";
559 }
560 
VisitEnumConstantDecl(const EnumConstantDecl * D)561 void ASTDumper::VisitEnumConstantDecl(const EnumConstantDecl *D) {
562   NodeDumper.dumpName(D);
563   NodeDumper.dumpType(D->getType());
564   if (const Expr *Init = D->getInitExpr())
565     dumpStmt(Init);
566 }
567 
VisitIndirectFieldDecl(const IndirectFieldDecl * D)568 void ASTDumper::VisitIndirectFieldDecl(const IndirectFieldDecl *D) {
569   NodeDumper.dumpName(D);
570   NodeDumper.dumpType(D->getType());
571 
572   for (auto *Child : D->chain())
573     NodeDumper.dumpDeclRef(Child);
574 }
575 
VisitFunctionDecl(const FunctionDecl * D)576 void ASTDumper::VisitFunctionDecl(const FunctionDecl *D) {
577   NodeDumper.dumpName(D);
578   NodeDumper.dumpType(D->getType());
579 
580   StorageClass SC = D->getStorageClass();
581   if (SC != SC_None)
582     OS << ' ' << VarDecl::getStorageClassSpecifierString(SC);
583   if (D->isInlineSpecified())
584     OS << " inline";
585   if (D->isVirtualAsWritten())
586     OS << " virtual";
587   if (D->isModulePrivate())
588     OS << " __module_private__";
589 
590   if (D->isPure())
591     OS << " pure";
592   if (D->isDefaulted()) {
593     OS << " default";
594     if (D->isDeleted())
595       OS << "_delete";
596   }
597   if (D->isDeletedAsWritten())
598     OS << " delete";
599   if (D->isTrivial())
600     OS << " trivial";
601 
602   if (const auto *FPT = D->getType()->getAs<FunctionProtoType>()) {
603     FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
604     switch (EPI.ExceptionSpec.Type) {
605     default: break;
606     case EST_Unevaluated:
607       OS << " noexcept-unevaluated " << EPI.ExceptionSpec.SourceDecl;
608       break;
609     case EST_Uninstantiated:
610       OS << " noexcept-uninstantiated " << EPI.ExceptionSpec.SourceTemplate;
611       break;
612     }
613   }
614 
615   if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
616     if (MD->size_overridden_methods() != 0) {
617       auto dumpOverride = [=](const CXXMethodDecl *D) {
618         SplitQualType T_split = D->getType().split();
619         OS << D << " " << D->getParent()->getName()
620            << "::" << D->getNameAsString() << " '"
621            << QualType::getAsString(T_split, PrintPolicy) << "'";
622       };
623 
624       dumpChild([=] {
625         auto Overrides = MD->overridden_methods();
626         OS << "Overrides: [ ";
627         dumpOverride(*Overrides.begin());
628         for (const auto *Override :
629              llvm::make_range(Overrides.begin() + 1, Overrides.end())) {
630           OS << ", ";
631           dumpOverride(Override);
632         }
633         OS << " ]";
634       });
635     }
636   }
637 
638   if (const auto *FTSI = D->getTemplateSpecializationInfo())
639     dumpTemplateArgumentList(*FTSI->TemplateArguments);
640 
641   if (!D->param_begin() && D->getNumParams())
642     dumpChild([=] { OS << "<<NULL params x " << D->getNumParams() << ">>"; });
643   else
644     for (const ParmVarDecl *Parameter : D->parameters())
645       dumpDecl(Parameter);
646 
647   if (const auto *C = dyn_cast<CXXConstructorDecl>(D))
648     for (const auto *I : C->inits())
649       dumpCXXCtorInitializer(I);
650 
651   if (D->doesThisDeclarationHaveABody())
652     dumpStmt(D->getBody());
653 }
654 
VisitFieldDecl(const FieldDecl * D)655 void ASTDumper::VisitFieldDecl(const FieldDecl *D) {
656   NodeDumper.dumpName(D);
657   NodeDumper.dumpType(D->getType());
658   if (D->isMutable())
659     OS << " mutable";
660   if (D->isModulePrivate())
661     OS << " __module_private__";
662 
663   if (D->isBitField())
664     dumpStmt(D->getBitWidth());
665   if (Expr *Init = D->getInClassInitializer())
666     dumpStmt(Init);
667 }
668 
VisitVarDecl(const VarDecl * D)669 void ASTDumper::VisitVarDecl(const VarDecl *D) {
670   NodeDumper.dumpName(D);
671   NodeDumper.dumpType(D->getType());
672   StorageClass SC = D->getStorageClass();
673   if (SC != SC_None)
674     OS << ' ' << VarDecl::getStorageClassSpecifierString(SC);
675   switch (D->getTLSKind()) {
676   case VarDecl::TLS_None: break;
677   case VarDecl::TLS_Static: OS << " tls"; break;
678   case VarDecl::TLS_Dynamic: OS << " tls_dynamic"; break;
679   }
680   if (D->isModulePrivate())
681     OS << " __module_private__";
682   if (D->isNRVOVariable())
683     OS << " nrvo";
684   if (D->isInline())
685     OS << " inline";
686   if (D->isConstexpr())
687     OS << " constexpr";
688   if (D->hasInit()) {
689     switch (D->getInitStyle()) {
690     case VarDecl::CInit: OS << " cinit"; break;
691     case VarDecl::CallInit: OS << " callinit"; break;
692     case VarDecl::ListInit: OS << " listinit"; break;
693     }
694     dumpStmt(D->getInit());
695   }
696 }
697 
VisitDecompositionDecl(const DecompositionDecl * D)698 void ASTDumper::VisitDecompositionDecl(const DecompositionDecl *D) {
699   VisitVarDecl(D);
700   for (auto *B : D->bindings())
701     dumpDecl(B);
702 }
703 
VisitBindingDecl(const BindingDecl * D)704 void ASTDumper::VisitBindingDecl(const BindingDecl *D) {
705   NodeDumper.dumpName(D);
706   NodeDumper.dumpType(D->getType());
707   if (auto *E = D->getBinding())
708     dumpStmt(E);
709 }
710 
VisitFileScopeAsmDecl(const FileScopeAsmDecl * D)711 void ASTDumper::VisitFileScopeAsmDecl(const FileScopeAsmDecl *D) {
712   dumpStmt(D->getAsmString());
713 }
714 
VisitImportDecl(const ImportDecl * D)715 void ASTDumper::VisitImportDecl(const ImportDecl *D) {
716   OS << ' ' << D->getImportedModule()->getFullModuleName();
717 }
718 
VisitPragmaCommentDecl(const PragmaCommentDecl * D)719 void ASTDumper::VisitPragmaCommentDecl(const PragmaCommentDecl *D) {
720   OS << ' ';
721   switch (D->getCommentKind()) {
722   case PCK_Unknown:  llvm_unreachable("unexpected pragma comment kind");
723   case PCK_Compiler: OS << "compiler"; break;
724   case PCK_ExeStr:   OS << "exestr"; break;
725   case PCK_Lib:      OS << "lib"; break;
726   case PCK_Linker:   OS << "linker"; break;
727   case PCK_User:     OS << "user"; break;
728   }
729   StringRef Arg = D->getArg();
730   if (!Arg.empty())
731     OS << " \"" << Arg << "\"";
732 }
733 
VisitPragmaDetectMismatchDecl(const PragmaDetectMismatchDecl * D)734 void ASTDumper::VisitPragmaDetectMismatchDecl(
735     const PragmaDetectMismatchDecl *D) {
736   OS << " \"" << D->getName() << "\" \"" << D->getValue() << "\"";
737 }
738 
VisitCapturedDecl(const CapturedDecl * D)739 void ASTDumper::VisitCapturedDecl(const CapturedDecl *D) {
740   dumpStmt(D->getBody());
741 }
742 
743 //===----------------------------------------------------------------------===//
744 // OpenMP Declarations
745 //===----------------------------------------------------------------------===//
746 
VisitOMPThreadPrivateDecl(const OMPThreadPrivateDecl * D)747 void ASTDumper::VisitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D) {
748   for (auto *E : D->varlists())
749     dumpStmt(E);
750 }
751 
VisitOMPDeclareReductionDecl(const OMPDeclareReductionDecl * D)752 void ASTDumper::VisitOMPDeclareReductionDecl(const OMPDeclareReductionDecl *D) {
753   NodeDumper.dumpName(D);
754   NodeDumper.dumpType(D->getType());
755   OS << " combiner";
756   NodeDumper.dumpPointer(D->getCombiner());
757   if (const auto *Initializer = D->getInitializer()) {
758     OS << " initializer";
759     NodeDumper.dumpPointer(Initializer);
760     switch (D->getInitializerKind()) {
761     case OMPDeclareReductionDecl::DirectInit:
762       OS << " omp_priv = ";
763       break;
764     case OMPDeclareReductionDecl::CopyInit:
765       OS << " omp_priv ()";
766       break;
767     case OMPDeclareReductionDecl::CallInit:
768       break;
769     }
770   }
771 
772   dumpStmt(D->getCombiner());
773   if (const auto *Initializer = D->getInitializer())
774     dumpStmt(Initializer);
775 }
776 
VisitOMPRequiresDecl(const OMPRequiresDecl * D)777 void ASTDumper::VisitOMPRequiresDecl(const OMPRequiresDecl *D) {
778   for (auto *C : D->clauselists()) {
779     dumpChild([=] {
780       if (!C) {
781         ColorScope Color(OS, ShowColors, NullColor);
782         OS << "<<<NULL>>> OMPClause";
783         return;
784       }
785       {
786         ColorScope Color(OS, ShowColors, AttrColor);
787         StringRef ClauseName(getOpenMPClauseName(C->getClauseKind()));
788         OS << "OMP" << ClauseName.substr(/*Start=*/0, /*N=*/1).upper()
789            << ClauseName.drop_front() << "Clause";
790       }
791       NodeDumper.dumpPointer(C);
792       NodeDumper.dumpSourceRange(SourceRange(C->getBeginLoc(), C->getEndLoc()));
793     });
794   }
795 }
796 
VisitOMPCapturedExprDecl(const OMPCapturedExprDecl * D)797 void ASTDumper::VisitOMPCapturedExprDecl(const OMPCapturedExprDecl *D) {
798   NodeDumper.dumpName(D);
799   NodeDumper.dumpType(D->getType());
800   dumpStmt(D->getInit());
801 }
802 
803 //===----------------------------------------------------------------------===//
804 // C++ Declarations
805 //===----------------------------------------------------------------------===//
806 
VisitNamespaceDecl(const NamespaceDecl * D)807 void ASTDumper::VisitNamespaceDecl(const NamespaceDecl *D) {
808   NodeDumper.dumpName(D);
809   if (D->isInline())
810     OS << " inline";
811   if (!D->isOriginalNamespace())
812     NodeDumper.dumpDeclRef(D->getOriginalNamespace(), "original");
813 }
814 
VisitUsingDirectiveDecl(const UsingDirectiveDecl * D)815 void ASTDumper::VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
816   OS << ' ';
817   NodeDumper.dumpBareDeclRef(D->getNominatedNamespace());
818 }
819 
VisitNamespaceAliasDecl(const NamespaceAliasDecl * D)820 void ASTDumper::VisitNamespaceAliasDecl(const NamespaceAliasDecl *D) {
821   NodeDumper.dumpName(D);
822   NodeDumper.dumpDeclRef(D->getAliasedNamespace());
823 }
824 
VisitTypeAliasDecl(const TypeAliasDecl * D)825 void ASTDumper::VisitTypeAliasDecl(const TypeAliasDecl *D) {
826   NodeDumper.dumpName(D);
827   NodeDumper.dumpType(D->getUnderlyingType());
828   dumpTypeAsChild(D->getUnderlyingType());
829 }
830 
VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl * D)831 void ASTDumper::VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D) {
832   NodeDumper.dumpName(D);
833   dumpTemplateParameters(D->getTemplateParameters());
834   dumpDecl(D->getTemplatedDecl());
835 }
836 
VisitCXXRecordDecl(const CXXRecordDecl * D)837 void ASTDumper::VisitCXXRecordDecl(const CXXRecordDecl *D) {
838   VisitRecordDecl(D);
839   if (!D->isCompleteDefinition())
840     return;
841 
842   dumpChild([=] {
843     {
844       ColorScope Color(OS, ShowColors, DeclKindNameColor);
845       OS << "DefinitionData";
846     }
847 #define FLAG(fn, name) if (D->fn()) OS << " " #name;
848     FLAG(isParsingBaseSpecifiers, parsing_base_specifiers);
849 
850     FLAG(isGenericLambda, generic);
851     FLAG(isLambda, lambda);
852 
853     FLAG(canPassInRegisters, pass_in_registers);
854     FLAG(isEmpty, empty);
855     FLAG(isAggregate, aggregate);
856     FLAG(isStandardLayout, standard_layout);
857     FLAG(isTriviallyCopyable, trivially_copyable);
858     FLAG(isPOD, pod);
859     FLAG(isTrivial, trivial);
860     FLAG(isPolymorphic, polymorphic);
861     FLAG(isAbstract, abstract);
862     FLAG(isLiteral, literal);
863 
864     FLAG(hasUserDeclaredConstructor, has_user_declared_ctor);
865     FLAG(hasConstexprNonCopyMoveConstructor, has_constexpr_non_copy_move_ctor);
866     FLAG(hasMutableFields, has_mutable_fields);
867     FLAG(hasVariantMembers, has_variant_members);
868     FLAG(allowConstDefaultInit, can_const_default_init);
869 
870     dumpChild([=] {
871       {
872         ColorScope Color(OS, ShowColors, DeclKindNameColor);
873         OS << "DefaultConstructor";
874       }
875       FLAG(hasDefaultConstructor, exists);
876       FLAG(hasTrivialDefaultConstructor, trivial);
877       FLAG(hasNonTrivialDefaultConstructor, non_trivial);
878       FLAG(hasUserProvidedDefaultConstructor, user_provided);
879       FLAG(hasConstexprDefaultConstructor, constexpr);
880       FLAG(needsImplicitDefaultConstructor, needs_implicit);
881       FLAG(defaultedDefaultConstructorIsConstexpr, defaulted_is_constexpr);
882     });
883 
884     dumpChild([=] {
885       {
886         ColorScope Color(OS, ShowColors, DeclKindNameColor);
887         OS << "CopyConstructor";
888       }
889       FLAG(hasSimpleCopyConstructor, simple);
890       FLAG(hasTrivialCopyConstructor, trivial);
891       FLAG(hasNonTrivialCopyConstructor, non_trivial);
892       FLAG(hasUserDeclaredCopyConstructor, user_declared);
893       FLAG(hasCopyConstructorWithConstParam, has_const_param);
894       FLAG(needsImplicitCopyConstructor, needs_implicit);
895       FLAG(needsOverloadResolutionForCopyConstructor,
896            needs_overload_resolution);
897       if (!D->needsOverloadResolutionForCopyConstructor())
898         FLAG(defaultedCopyConstructorIsDeleted, defaulted_is_deleted);
899       FLAG(implicitCopyConstructorHasConstParam, implicit_has_const_param);
900     });
901 
902     dumpChild([=] {
903       {
904         ColorScope Color(OS, ShowColors, DeclKindNameColor);
905         OS << "MoveConstructor";
906       }
907       FLAG(hasMoveConstructor, exists);
908       FLAG(hasSimpleMoveConstructor, simple);
909       FLAG(hasTrivialMoveConstructor, trivial);
910       FLAG(hasNonTrivialMoveConstructor, non_trivial);
911       FLAG(hasUserDeclaredMoveConstructor, user_declared);
912       FLAG(needsImplicitMoveConstructor, needs_implicit);
913       FLAG(needsOverloadResolutionForMoveConstructor,
914            needs_overload_resolution);
915       if (!D->needsOverloadResolutionForMoveConstructor())
916         FLAG(defaultedMoveConstructorIsDeleted, defaulted_is_deleted);
917     });
918 
919     dumpChild([=] {
920       {
921         ColorScope Color(OS, ShowColors, DeclKindNameColor);
922         OS << "CopyAssignment";
923       }
924       FLAG(hasTrivialCopyAssignment, trivial);
925       FLAG(hasNonTrivialCopyAssignment, non_trivial);
926       FLAG(hasCopyAssignmentWithConstParam, has_const_param);
927       FLAG(hasUserDeclaredCopyAssignment, user_declared);
928       FLAG(needsImplicitCopyAssignment, needs_implicit);
929       FLAG(needsOverloadResolutionForCopyAssignment, needs_overload_resolution);
930       FLAG(implicitCopyAssignmentHasConstParam, implicit_has_const_param);
931     });
932 
933     dumpChild([=] {
934       {
935         ColorScope Color(OS, ShowColors, DeclKindNameColor);
936         OS << "MoveAssignment";
937       }
938       FLAG(hasMoveAssignment, exists);
939       FLAG(hasSimpleMoveAssignment, simple);
940       FLAG(hasTrivialMoveAssignment, trivial);
941       FLAG(hasNonTrivialMoveAssignment, non_trivial);
942       FLAG(hasUserDeclaredMoveAssignment, user_declared);
943       FLAG(needsImplicitMoveAssignment, needs_implicit);
944       FLAG(needsOverloadResolutionForMoveAssignment, needs_overload_resolution);
945     });
946 
947     dumpChild([=] {
948       {
949         ColorScope Color(OS, ShowColors, DeclKindNameColor);
950         OS << "Destructor";
951       }
952       FLAG(hasSimpleDestructor, simple);
953       FLAG(hasIrrelevantDestructor, irrelevant);
954       FLAG(hasTrivialDestructor, trivial);
955       FLAG(hasNonTrivialDestructor, non_trivial);
956       FLAG(hasUserDeclaredDestructor, user_declared);
957       FLAG(needsImplicitDestructor, needs_implicit);
958       FLAG(needsOverloadResolutionForDestructor, needs_overload_resolution);
959       if (!D->needsOverloadResolutionForDestructor())
960         FLAG(defaultedDestructorIsDeleted, defaulted_is_deleted);
961     });
962   });
963 
964   for (const auto &I : D->bases()) {
965     dumpChild([=] {
966       if (I.isVirtual())
967         OS << "virtual ";
968       NodeDumper.dumpAccessSpecifier(I.getAccessSpecifier());
969       NodeDumper.dumpType(I.getType());
970       if (I.isPackExpansion())
971         OS << "...";
972     });
973   }
974 }
975 
VisitStaticAssertDecl(const StaticAssertDecl * D)976 void ASTDumper::VisitStaticAssertDecl(const StaticAssertDecl *D) {
977   dumpStmt(D->getAssertExpr());
978   dumpStmt(D->getMessage());
979 }
980 
981 template <typename SpecializationDecl>
dumpTemplateDeclSpecialization(const SpecializationDecl * D,bool DumpExplicitInst,bool DumpRefOnly)982 void ASTDumper::dumpTemplateDeclSpecialization(const SpecializationDecl *D,
983                                                bool DumpExplicitInst,
984                                                bool DumpRefOnly) {
985   bool DumpedAny = false;
986   for (auto *RedeclWithBadType : D->redecls()) {
987     // FIXME: The redecls() range sometimes has elements of a less-specific
988     // type. (In particular, ClassTemplateSpecializationDecl::redecls() gives
989     // us TagDecls, and should give CXXRecordDecls).
990     auto *Redecl = dyn_cast<SpecializationDecl>(RedeclWithBadType);
991     if (!Redecl) {
992       // Found the injected-class-name for a class template. This will be dumped
993       // as part of its surrounding class so we don't need to dump it here.
994       assert(isa<CXXRecordDecl>(RedeclWithBadType) &&
995              "expected an injected-class-name");
996       continue;
997     }
998 
999     switch (Redecl->getTemplateSpecializationKind()) {
1000     case TSK_ExplicitInstantiationDeclaration:
1001     case TSK_ExplicitInstantiationDefinition:
1002       if (!DumpExplicitInst)
1003         break;
1004       LLVM_FALLTHROUGH;
1005     case TSK_Undeclared:
1006     case TSK_ImplicitInstantiation:
1007       if (DumpRefOnly)
1008         NodeDumper.dumpDeclRef(Redecl);
1009       else
1010         dumpDecl(Redecl);
1011       DumpedAny = true;
1012       break;
1013     case TSK_ExplicitSpecialization:
1014       break;
1015     }
1016   }
1017 
1018   // Ensure we dump at least one decl for each specialization.
1019   if (!DumpedAny)
1020     NodeDumper.dumpDeclRef(D);
1021 }
1022 
1023 template <typename TemplateDecl>
dumpTemplateDecl(const TemplateDecl * D,bool DumpExplicitInst)1024 void ASTDumper::dumpTemplateDecl(const TemplateDecl *D, bool DumpExplicitInst) {
1025   NodeDumper.dumpName(D);
1026   dumpTemplateParameters(D->getTemplateParameters());
1027 
1028   dumpDecl(D->getTemplatedDecl());
1029 
1030   for (auto *Child : D->specializations())
1031     dumpTemplateDeclSpecialization(Child, DumpExplicitInst,
1032                                    !D->isCanonicalDecl());
1033 }
1034 
VisitFunctionTemplateDecl(const FunctionTemplateDecl * D)1035 void ASTDumper::VisitFunctionTemplateDecl(const FunctionTemplateDecl *D) {
1036   // FIXME: We don't add a declaration of a function template specialization
1037   // to its context when it's explicitly instantiated, so dump explicit
1038   // instantiations when we dump the template itself.
1039   dumpTemplateDecl(D, true);
1040 }
1041 
VisitClassTemplateDecl(const ClassTemplateDecl * D)1042 void ASTDumper::VisitClassTemplateDecl(const ClassTemplateDecl *D) {
1043   dumpTemplateDecl(D, false);
1044 }
1045 
VisitClassTemplateSpecializationDecl(const ClassTemplateSpecializationDecl * D)1046 void ASTDumper::VisitClassTemplateSpecializationDecl(
1047     const ClassTemplateSpecializationDecl *D) {
1048   VisitCXXRecordDecl(D);
1049   dumpTemplateArgumentList(D->getTemplateArgs());
1050 }
1051 
VisitClassTemplatePartialSpecializationDecl(const ClassTemplatePartialSpecializationDecl * D)1052 void ASTDumper::VisitClassTemplatePartialSpecializationDecl(
1053     const ClassTemplatePartialSpecializationDecl *D) {
1054   VisitClassTemplateSpecializationDecl(D);
1055   dumpTemplateParameters(D->getTemplateParameters());
1056 }
1057 
VisitClassScopeFunctionSpecializationDecl(const ClassScopeFunctionSpecializationDecl * D)1058 void ASTDumper::VisitClassScopeFunctionSpecializationDecl(
1059     const ClassScopeFunctionSpecializationDecl *D) {
1060   dumpDecl(D->getSpecialization());
1061   if (D->hasExplicitTemplateArgs())
1062     dumpTemplateArgumentListInfo(D->templateArgs());
1063 }
1064 
VisitVarTemplateDecl(const VarTemplateDecl * D)1065 void ASTDumper::VisitVarTemplateDecl(const VarTemplateDecl *D) {
1066   dumpTemplateDecl(D, false);
1067 }
1068 
VisitBuiltinTemplateDecl(const BuiltinTemplateDecl * D)1069 void ASTDumper::VisitBuiltinTemplateDecl(const BuiltinTemplateDecl *D) {
1070   NodeDumper.dumpName(D);
1071   dumpTemplateParameters(D->getTemplateParameters());
1072 }
1073 
VisitVarTemplateSpecializationDecl(const VarTemplateSpecializationDecl * D)1074 void ASTDumper::VisitVarTemplateSpecializationDecl(
1075     const VarTemplateSpecializationDecl *D) {
1076   dumpTemplateArgumentList(D->getTemplateArgs());
1077   VisitVarDecl(D);
1078 }
1079 
VisitVarTemplatePartialSpecializationDecl(const VarTemplatePartialSpecializationDecl * D)1080 void ASTDumper::VisitVarTemplatePartialSpecializationDecl(
1081     const VarTemplatePartialSpecializationDecl *D) {
1082   dumpTemplateParameters(D->getTemplateParameters());
1083   VisitVarTemplateSpecializationDecl(D);
1084 }
1085 
VisitTemplateTypeParmDecl(const TemplateTypeParmDecl * D)1086 void ASTDumper::VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) {
1087   if (D->wasDeclaredWithTypename())
1088     OS << " typename";
1089   else
1090     OS << " class";
1091   OS << " depth " << D->getDepth() << " index " << D->getIndex();
1092   if (D->isParameterPack())
1093     OS << " ...";
1094   NodeDumper.dumpName(D);
1095   if (D->hasDefaultArgument())
1096     dumpTemplateArgument(D->getDefaultArgument(), SourceRange(),
1097                          D->getDefaultArgStorage().getInheritedFrom(),
1098                          D->defaultArgumentWasInherited() ? "inherited from"
1099                                                           : "previous");
1100 }
1101 
VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl * D)1102 void ASTDumper::VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) {
1103   NodeDumper.dumpType(D->getType());
1104   OS << " depth " << D->getDepth() << " index " << D->getIndex();
1105   if (D->isParameterPack())
1106     OS << " ...";
1107   NodeDumper.dumpName(D);
1108   if (D->hasDefaultArgument())
1109     dumpTemplateArgument(D->getDefaultArgument(), SourceRange(),
1110                          D->getDefaultArgStorage().getInheritedFrom(),
1111                          D->defaultArgumentWasInherited() ? "inherited from"
1112                                                           : "previous");
1113 }
1114 
VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl * D)1115 void ASTDumper::VisitTemplateTemplateParmDecl(
1116     const TemplateTemplateParmDecl *D) {
1117   OS << " depth " << D->getDepth() << " index " << D->getIndex();
1118   if (D->isParameterPack())
1119     OS << " ...";
1120   NodeDumper.dumpName(D);
1121   dumpTemplateParameters(D->getTemplateParameters());
1122   if (D->hasDefaultArgument())
1123     dumpTemplateArgumentLoc(
1124         D->getDefaultArgument(), D->getDefaultArgStorage().getInheritedFrom(),
1125         D->defaultArgumentWasInherited() ? "inherited from" : "previous");
1126 }
1127 
VisitUsingDecl(const UsingDecl * D)1128 void ASTDumper::VisitUsingDecl(const UsingDecl *D) {
1129   OS << ' ';
1130   if (D->getQualifier())
1131     D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
1132   OS << D->getNameAsString();
1133 }
1134 
VisitUnresolvedUsingTypenameDecl(const UnresolvedUsingTypenameDecl * D)1135 void ASTDumper::VisitUnresolvedUsingTypenameDecl(
1136     const UnresolvedUsingTypenameDecl *D) {
1137   OS << ' ';
1138   if (D->getQualifier())
1139     D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
1140   OS << D->getNameAsString();
1141 }
1142 
VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl * D)1143 void ASTDumper::VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl *D) {
1144   OS << ' ';
1145   if (D->getQualifier())
1146     D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
1147   OS << D->getNameAsString();
1148   NodeDumper.dumpType(D->getType());
1149 }
1150 
VisitUsingShadowDecl(const UsingShadowDecl * D)1151 void ASTDumper::VisitUsingShadowDecl(const UsingShadowDecl *D) {
1152   OS << ' ';
1153   NodeDumper.dumpBareDeclRef(D->getTargetDecl());
1154   if (auto *TD = dyn_cast<TypeDecl>(D->getUnderlyingDecl()))
1155     dumpTypeAsChild(TD->getTypeForDecl());
1156 }
1157 
VisitConstructorUsingShadowDecl(const ConstructorUsingShadowDecl * D)1158 void ASTDumper::VisitConstructorUsingShadowDecl(
1159     const ConstructorUsingShadowDecl *D) {
1160   if (D->constructsVirtualBase())
1161     OS << " virtual";
1162 
1163   dumpChild([=] {
1164     OS << "target ";
1165     NodeDumper.dumpBareDeclRef(D->getTargetDecl());
1166   });
1167 
1168   dumpChild([=] {
1169     OS << "nominated ";
1170     NodeDumper.dumpBareDeclRef(D->getNominatedBaseClass());
1171     OS << ' ';
1172     NodeDumper.dumpBareDeclRef(D->getNominatedBaseClassShadowDecl());
1173   });
1174 
1175   dumpChild([=] {
1176     OS << "constructed ";
1177     NodeDumper.dumpBareDeclRef(D->getConstructedBaseClass());
1178     OS << ' ';
1179     NodeDumper.dumpBareDeclRef(D->getConstructedBaseClassShadowDecl());
1180   });
1181 }
1182 
VisitLinkageSpecDecl(const LinkageSpecDecl * D)1183 void ASTDumper::VisitLinkageSpecDecl(const LinkageSpecDecl *D) {
1184   switch (D->getLanguage()) {
1185   case LinkageSpecDecl::lang_c: OS << " C"; break;
1186   case LinkageSpecDecl::lang_cxx: OS << " C++"; break;
1187   }
1188 }
1189 
VisitAccessSpecDecl(const AccessSpecDecl * D)1190 void ASTDumper::VisitAccessSpecDecl(const AccessSpecDecl *D) {
1191   OS << ' ';
1192   NodeDumper.dumpAccessSpecifier(D->getAccess());
1193 }
1194 
VisitFriendDecl(const FriendDecl * D)1195 void ASTDumper::VisitFriendDecl(const FriendDecl *D) {
1196   if (TypeSourceInfo *T = D->getFriendType())
1197     NodeDumper.dumpType(T->getType());
1198   else
1199     dumpDecl(D->getFriendDecl());
1200 }
1201 
1202 //===----------------------------------------------------------------------===//
1203 // Obj-C Declarations
1204 //===----------------------------------------------------------------------===//
1205 
VisitObjCIvarDecl(const ObjCIvarDecl * D)1206 void ASTDumper::VisitObjCIvarDecl(const ObjCIvarDecl *D) {
1207   NodeDumper.dumpName(D);
1208   NodeDumper.dumpType(D->getType());
1209   if (D->getSynthesize())
1210     OS << " synthesize";
1211 
1212   switch (D->getAccessControl()) {
1213   case ObjCIvarDecl::None:
1214     OS << " none";
1215     break;
1216   case ObjCIvarDecl::Private:
1217     OS << " private";
1218     break;
1219   case ObjCIvarDecl::Protected:
1220     OS << " protected";
1221     break;
1222   case ObjCIvarDecl::Public:
1223     OS << " public";
1224     break;
1225   case ObjCIvarDecl::Package:
1226     OS << " package";
1227     break;
1228   }
1229 }
1230 
VisitObjCMethodDecl(const ObjCMethodDecl * D)1231 void ASTDumper::VisitObjCMethodDecl(const ObjCMethodDecl *D) {
1232   if (D->isInstanceMethod())
1233     OS << " -";
1234   else
1235     OS << " +";
1236   NodeDumper.dumpName(D);
1237   NodeDumper.dumpType(D->getReturnType());
1238 
1239   if (D->isThisDeclarationADefinition()) {
1240     dumpDeclContext(D);
1241   } else {
1242     for (const ParmVarDecl *Parameter : D->parameters())
1243       dumpDecl(Parameter);
1244   }
1245 
1246   if (D->isVariadic())
1247     dumpChild([=] { OS << "..."; });
1248 
1249   if (D->hasBody())
1250     dumpStmt(D->getBody());
1251 }
1252 
VisitObjCTypeParamDecl(const ObjCTypeParamDecl * D)1253 void ASTDumper::VisitObjCTypeParamDecl(const ObjCTypeParamDecl *D) {
1254   NodeDumper.dumpName(D);
1255   switch (D->getVariance()) {
1256   case ObjCTypeParamVariance::Invariant:
1257     break;
1258 
1259   case ObjCTypeParamVariance::Covariant:
1260     OS << " covariant";
1261     break;
1262 
1263   case ObjCTypeParamVariance::Contravariant:
1264     OS << " contravariant";
1265     break;
1266   }
1267 
1268   if (D->hasExplicitBound())
1269     OS << " bounded";
1270   NodeDumper.dumpType(D->getUnderlyingType());
1271 }
1272 
VisitObjCCategoryDecl(const ObjCCategoryDecl * D)1273 void ASTDumper::VisitObjCCategoryDecl(const ObjCCategoryDecl *D) {
1274   NodeDumper.dumpName(D);
1275   NodeDumper.dumpDeclRef(D->getClassInterface());
1276   NodeDumper.dumpDeclRef(D->getImplementation());
1277   for (ObjCCategoryDecl::protocol_iterator I = D->protocol_begin(),
1278                                            E = D->protocol_end();
1279        I != E; ++I)
1280     NodeDumper.dumpDeclRef(*I);
1281   dumpObjCTypeParamList(D->getTypeParamList());
1282 }
1283 
VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl * D)1284 void ASTDumper::VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D) {
1285   NodeDumper.dumpName(D);
1286   NodeDumper.dumpDeclRef(D->getClassInterface());
1287   NodeDumper.dumpDeclRef(D->getCategoryDecl());
1288 }
1289 
VisitObjCProtocolDecl(const ObjCProtocolDecl * D)1290 void ASTDumper::VisitObjCProtocolDecl(const ObjCProtocolDecl *D) {
1291   NodeDumper.dumpName(D);
1292 
1293   for (auto *Child : D->protocols())
1294     NodeDumper.dumpDeclRef(Child);
1295 }
1296 
VisitObjCInterfaceDecl(const ObjCInterfaceDecl * D)1297 void ASTDumper::VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) {
1298   NodeDumper.dumpName(D);
1299   NodeDumper.dumpDeclRef(D->getSuperClass(), "super");
1300 
1301   NodeDumper.dumpDeclRef(D->getImplementation());
1302   for (auto *Child : D->protocols())
1303     NodeDumper.dumpDeclRef(Child);
1304   dumpObjCTypeParamList(D->getTypeParamListAsWritten());
1305 }
1306 
VisitObjCImplementationDecl(const ObjCImplementationDecl * D)1307 void ASTDumper::VisitObjCImplementationDecl(const ObjCImplementationDecl *D) {
1308   NodeDumper.dumpName(D);
1309   NodeDumper.dumpDeclRef(D->getSuperClass(), "super");
1310   NodeDumper.dumpDeclRef(D->getClassInterface());
1311   for (ObjCImplementationDecl::init_const_iterator I = D->init_begin(),
1312                                                    E = D->init_end();
1313        I != E; ++I)
1314     dumpCXXCtorInitializer(*I);
1315 }
1316 
VisitObjCCompatibleAliasDecl(const ObjCCompatibleAliasDecl * D)1317 void ASTDumper::VisitObjCCompatibleAliasDecl(const ObjCCompatibleAliasDecl *D) {
1318   NodeDumper.dumpName(D);
1319   NodeDumper.dumpDeclRef(D->getClassInterface());
1320 }
1321 
VisitObjCPropertyDecl(const ObjCPropertyDecl * D)1322 void ASTDumper::VisitObjCPropertyDecl(const ObjCPropertyDecl *D) {
1323   NodeDumper.dumpName(D);
1324   NodeDumper.dumpType(D->getType());
1325 
1326   if (D->getPropertyImplementation() == ObjCPropertyDecl::Required)
1327     OS << " required";
1328   else if (D->getPropertyImplementation() == ObjCPropertyDecl::Optional)
1329     OS << " optional";
1330 
1331   ObjCPropertyDecl::PropertyAttributeKind Attrs = D->getPropertyAttributes();
1332   if (Attrs != ObjCPropertyDecl::OBJC_PR_noattr) {
1333     if (Attrs & ObjCPropertyDecl::OBJC_PR_readonly)
1334       OS << " readonly";
1335     if (Attrs & ObjCPropertyDecl::OBJC_PR_assign)
1336       OS << " assign";
1337     if (Attrs & ObjCPropertyDecl::OBJC_PR_readwrite)
1338       OS << " readwrite";
1339     if (Attrs & ObjCPropertyDecl::OBJC_PR_retain)
1340       OS << " retain";
1341     if (Attrs & ObjCPropertyDecl::OBJC_PR_copy)
1342       OS << " copy";
1343     if (Attrs & ObjCPropertyDecl::OBJC_PR_nonatomic)
1344       OS << " nonatomic";
1345     if (Attrs & ObjCPropertyDecl::OBJC_PR_atomic)
1346       OS << " atomic";
1347     if (Attrs & ObjCPropertyDecl::OBJC_PR_weak)
1348       OS << " weak";
1349     if (Attrs & ObjCPropertyDecl::OBJC_PR_strong)
1350       OS << " strong";
1351     if (Attrs & ObjCPropertyDecl::OBJC_PR_unsafe_unretained)
1352       OS << " unsafe_unretained";
1353     if (Attrs & ObjCPropertyDecl::OBJC_PR_class)
1354       OS << " class";
1355     if (Attrs & ObjCPropertyDecl::OBJC_PR_getter)
1356       NodeDumper.dumpDeclRef(D->getGetterMethodDecl(), "getter");
1357     if (Attrs & ObjCPropertyDecl::OBJC_PR_setter)
1358       NodeDumper.dumpDeclRef(D->getSetterMethodDecl(), "setter");
1359   }
1360 }
1361 
VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl * D)1362 void ASTDumper::VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D) {
1363   NodeDumper.dumpName(D->getPropertyDecl());
1364   if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize)
1365     OS << " synthesize";
1366   else
1367     OS << " dynamic";
1368   NodeDumper.dumpDeclRef(D->getPropertyDecl());
1369   NodeDumper.dumpDeclRef(D->getPropertyIvarDecl());
1370 }
1371 
Visit(const BlockDecl::Capture & C)1372 void ASTDumper::Visit(const BlockDecl::Capture &C) {
1373   dumpChild([=] {
1374     NodeDumper.Visit(C);
1375     if (C.hasCopyExpr())
1376       dumpStmt(C.getCopyExpr());
1377   });
1378 }
1379 
VisitBlockDecl(const BlockDecl * D)1380 void ASTDumper::VisitBlockDecl(const BlockDecl *D) {
1381   for (auto I : D->parameters())
1382     dumpDecl(I);
1383 
1384   if (D->isVariadic())
1385     dumpChild([=]{ OS << "..."; });
1386 
1387   if (D->capturesCXXThis())
1388     dumpChild([=]{ OS << "capture this"; });
1389 
1390   for (const auto &I : D->captures())
1391     Visit(I);
1392   dumpStmt(D->getBody());
1393 }
1394 
1395 //===----------------------------------------------------------------------===//
1396 //  Stmt dumping methods.
1397 //===----------------------------------------------------------------------===//
1398 
dumpStmt(const Stmt * S,StringRef Label)1399 void ASTDumper::dumpStmt(const Stmt *S, StringRef Label) {
1400   dumpChild(Label, [=] {
1401     NodeDumper.Visit(S);
1402 
1403     if (!S) {
1404       return;
1405     }
1406 
1407     ConstStmtVisitor<ASTDumper>::Visit(S);
1408 
1409     // Some statements have custom mechanisms for dumping their children.
1410     if (isa<DeclStmt>(S) || isa<GenericSelectionExpr>(S)) {
1411       return;
1412     }
1413 
1414     for (const Stmt *SubStmt : S->children())
1415       dumpStmt(SubStmt);
1416   });
1417 }
1418 
VisitDeclStmt(const DeclStmt * Node)1419 void ASTDumper::VisitDeclStmt(const DeclStmt *Node) {
1420   for (DeclStmt::const_decl_iterator I = Node->decl_begin(),
1421                                      E = Node->decl_end();
1422        I != E; ++I)
1423     dumpDecl(*I);
1424 }
1425 
VisitAttributedStmt(const AttributedStmt * Node)1426 void ASTDumper::VisitAttributedStmt(const AttributedStmt *Node) {
1427   for (ArrayRef<const Attr *>::iterator I = Node->getAttrs().begin(),
1428                                         E = Node->getAttrs().end();
1429        I != E; ++I)
1430     dumpAttr(*I);
1431 }
1432 
VisitCXXCatchStmt(const CXXCatchStmt * Node)1433 void ASTDumper::VisitCXXCatchStmt(const CXXCatchStmt *Node) {
1434   dumpDecl(Node->getExceptionDecl());
1435 }
1436 
VisitCapturedStmt(const CapturedStmt * Node)1437 void ASTDumper::VisitCapturedStmt(const CapturedStmt *Node) {
1438   dumpDecl(Node->getCapturedDecl());
1439 }
1440 
1441 //===----------------------------------------------------------------------===//
1442 //  OpenMP dumping methods.
1443 //===----------------------------------------------------------------------===//
1444 
Visit(const OMPClause * C)1445 void ASTDumper::Visit(const OMPClause *C) {
1446   dumpChild([=] {
1447     NodeDumper.Visit(C);
1448     for (auto *S : C->children())
1449       dumpStmt(S);
1450   });
1451 }
1452 
VisitOMPExecutableDirective(const OMPExecutableDirective * Node)1453 void ASTDumper::VisitOMPExecutableDirective(
1454     const OMPExecutableDirective *Node) {
1455   for (const auto *C : Node->clauses())
1456     Visit(C);
1457 }
1458 
1459 //===----------------------------------------------------------------------===//
1460 //  Expr dumping methods.
1461 //===----------------------------------------------------------------------===//
1462 
1463 
VisitInitListExpr(const InitListExpr * ILE)1464 void ASTDumper::VisitInitListExpr(const InitListExpr *ILE) {
1465   if (auto *Filler = ILE->getArrayFiller()) {
1466     dumpStmt(Filler, "array_filler");
1467   }
1468 }
1469 
VisitBlockExpr(const BlockExpr * Node)1470 void ASTDumper::VisitBlockExpr(const BlockExpr *Node) {
1471   dumpDecl(Node->getBlockDecl());
1472 }
1473 
VisitOpaqueValueExpr(const OpaqueValueExpr * Node)1474 void ASTDumper::VisitOpaqueValueExpr(const OpaqueValueExpr *Node) {
1475   if (Expr *Source = Node->getSourceExpr())
1476     dumpStmt(Source);
1477 }
1478 
VisitGenericSelectionExpr(const GenericSelectionExpr * E)1479 void ASTDumper::VisitGenericSelectionExpr(const GenericSelectionExpr *E) {
1480   if (E->isResultDependent())
1481     OS << " result_dependent";
1482   dumpStmt(E->getControllingExpr());
1483   dumpTypeAsChild(E->getControllingExpr()->getType()); // FIXME: remove
1484 
1485   for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {
1486     dumpChild([=] {
1487       if (const TypeSourceInfo *TSI = E->getAssocTypeSourceInfo(I)) {
1488         OS << "case ";
1489         NodeDumper.dumpType(TSI->getType());
1490       } else {
1491         OS << "default";
1492       }
1493 
1494       if (!E->isResultDependent() && E->getResultIndex() == I)
1495         OS << " selected";
1496 
1497       if (const TypeSourceInfo *TSI = E->getAssocTypeSourceInfo(I))
1498         dumpTypeAsChild(TSI->getType());
1499       dumpStmt(E->getAssocExpr(I));
1500     });
1501   }
1502 }
1503 
1504 //===----------------------------------------------------------------------===//
1505 // C++ Expressions
1506 //===----------------------------------------------------------------------===//
1507 
VisitSizeOfPackExpr(const SizeOfPackExpr * Node)1508 void ASTDumper::VisitSizeOfPackExpr(const SizeOfPackExpr *Node) {
1509   if (Node->isPartiallySubstituted())
1510     for (const auto &A : Node->getPartialArguments())
1511       dumpTemplateArgument(A);
1512 }
1513 
1514 //===----------------------------------------------------------------------===//
1515 // Obj-C Expressions
1516 //===----------------------------------------------------------------------===//
1517 
VisitObjCAtCatchStmt(const ObjCAtCatchStmt * Node)1518 void ASTDumper::VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node) {
1519   if (const VarDecl *CatchParam = Node->getCatchParamDecl())
1520     dumpDecl(CatchParam);
1521 }
1522 
1523 //===----------------------------------------------------------------------===//
1524 // Comments
1525 //===----------------------------------------------------------------------===//
1526 
dumpComment(const Comment * C,const FullComment * FC)1527 void ASTDumper::dumpComment(const Comment *C, const FullComment *FC) {
1528   dumpChild([=] {
1529     NodeDumper.Visit(C, FC);
1530     if (!C) {
1531       return;
1532     }
1533     ConstCommentVisitor<ASTDumper, void, const FullComment *>::visit(C, FC);
1534     for (Comment::child_iterator I = C->child_begin(), E = C->child_end();
1535          I != E; ++I)
1536       dumpComment(*I, FC);
1537   });
1538 }
1539 
1540 //===----------------------------------------------------------------------===//
1541 // Type method implementations
1542 //===----------------------------------------------------------------------===//
1543 
dump(const char * msg) const1544 void QualType::dump(const char *msg) const {
1545   if (msg)
1546     llvm::errs() << msg << ": ";
1547   dump();
1548 }
1549 
dump() const1550 LLVM_DUMP_METHOD void QualType::dump() const { dump(llvm::errs()); }
1551 
dump(llvm::raw_ostream & OS) const1552 LLVM_DUMP_METHOD void QualType::dump(llvm::raw_ostream &OS) const {
1553   ASTDumper Dumper(OS, nullptr, nullptr);
1554   Dumper.dumpTypeAsChild(*this);
1555 }
1556 
dump() const1557 LLVM_DUMP_METHOD void Type::dump() const { dump(llvm::errs()); }
1558 
dump(llvm::raw_ostream & OS) const1559 LLVM_DUMP_METHOD void Type::dump(llvm::raw_ostream &OS) const {
1560   QualType(this, 0).dump(OS);
1561 }
1562 
1563 //===----------------------------------------------------------------------===//
1564 // Decl method implementations
1565 //===----------------------------------------------------------------------===//
1566 
dump() const1567 LLVM_DUMP_METHOD void Decl::dump() const { dump(llvm::errs()); }
1568 
dump(raw_ostream & OS,bool Deserialize) const1569 LLVM_DUMP_METHOD void Decl::dump(raw_ostream &OS, bool Deserialize) const {
1570   const ASTContext &Ctx = getASTContext();
1571   const SourceManager &SM = Ctx.getSourceManager();
1572   ASTDumper P(OS, &Ctx.getCommentCommandTraits(), &SM,
1573               SM.getDiagnostics().getShowColors(), Ctx.getPrintingPolicy());
1574   P.setDeserialize(Deserialize);
1575   P.dumpDecl(this);
1576 }
1577 
dumpColor() const1578 LLVM_DUMP_METHOD void Decl::dumpColor() const {
1579   const ASTContext &Ctx = getASTContext();
1580   ASTDumper P(llvm::errs(), &Ctx.getCommentCommandTraits(),
1581               &Ctx.getSourceManager(), /*ShowColors*/ true,
1582               Ctx.getPrintingPolicy());
1583   P.dumpDecl(this);
1584 }
1585 
dumpLookups() const1586 LLVM_DUMP_METHOD void DeclContext::dumpLookups() const {
1587   dumpLookups(llvm::errs());
1588 }
1589 
dumpLookups(raw_ostream & OS,bool DumpDecls,bool Deserialize) const1590 LLVM_DUMP_METHOD void DeclContext::dumpLookups(raw_ostream &OS,
1591                                                bool DumpDecls,
1592                                                bool Deserialize) const {
1593   const DeclContext *DC = this;
1594   while (!DC->isTranslationUnit())
1595     DC = DC->getParent();
1596   ASTContext &Ctx = cast<TranslationUnitDecl>(DC)->getASTContext();
1597   const SourceManager &SM = Ctx.getSourceManager();
1598   ASTDumper P(OS, &Ctx.getCommentCommandTraits(), &Ctx.getSourceManager(),
1599               SM.getDiagnostics().getShowColors(), Ctx.getPrintingPolicy());
1600   P.setDeserialize(Deserialize);
1601   P.dumpLookups(this, DumpDecls);
1602 }
1603 
1604 //===----------------------------------------------------------------------===//
1605 // Stmt method implementations
1606 //===----------------------------------------------------------------------===//
1607 
dump(SourceManager & SM) const1608 LLVM_DUMP_METHOD void Stmt::dump(SourceManager &SM) const {
1609   dump(llvm::errs(), SM);
1610 }
1611 
dump(raw_ostream & OS,SourceManager & SM) const1612 LLVM_DUMP_METHOD void Stmt::dump(raw_ostream &OS, SourceManager &SM) const {
1613   ASTDumper P(OS, nullptr, &SM);
1614   P.dumpStmt(this);
1615 }
1616 
dump(raw_ostream & OS) const1617 LLVM_DUMP_METHOD void Stmt::dump(raw_ostream &OS) const {
1618   ASTDumper P(OS, nullptr, nullptr);
1619   P.dumpStmt(this);
1620 }
1621 
dump() const1622 LLVM_DUMP_METHOD void Stmt::dump() const {
1623   ASTDumper P(llvm::errs(), nullptr, nullptr);
1624   P.dumpStmt(this);
1625 }
1626 
dumpColor() const1627 LLVM_DUMP_METHOD void Stmt::dumpColor() const {
1628   ASTDumper P(llvm::errs(), nullptr, nullptr, /*ShowColors*/true);
1629   P.dumpStmt(this);
1630 }
1631 
1632 //===----------------------------------------------------------------------===//
1633 // Comment method implementations
1634 //===----------------------------------------------------------------------===//
1635 
dump() const1636 LLVM_DUMP_METHOD void Comment::dump() const {
1637   dump(llvm::errs(), nullptr, nullptr);
1638 }
1639 
dump(const ASTContext & Context) const1640 LLVM_DUMP_METHOD void Comment::dump(const ASTContext &Context) const {
1641   dump(llvm::errs(), &Context.getCommentCommandTraits(),
1642        &Context.getSourceManager());
1643 }
1644 
dump(raw_ostream & OS,const CommandTraits * Traits,const SourceManager * SM) const1645 void Comment::dump(raw_ostream &OS, const CommandTraits *Traits,
1646                    const SourceManager *SM) const {
1647   const FullComment *FC = dyn_cast<FullComment>(this);
1648   if (!FC)
1649     return;
1650   ASTDumper D(OS, Traits, SM);
1651   D.dumpComment(FC, FC);
1652 }
1653 
dumpColor() const1654 LLVM_DUMP_METHOD void Comment::dumpColor() const {
1655   const FullComment *FC = dyn_cast<FullComment>(this);
1656   if (!FC)
1657     return;
1658   ASTDumper D(llvm::errs(), nullptr, nullptr, /*ShowColors*/true);
1659   D.dumpComment(FC, FC);
1660 }
1661