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/CommentVisitor.h"
19 #include "clang/AST/DeclCXX.h"
20 #include "clang/AST/DeclLookups.h"
21 #include "clang/AST/DeclObjC.h"
22 #include "clang/AST/DeclOpenMP.h"
23 #include "clang/AST/DeclVisitor.h"
24 #include "clang/AST/LocInfoType.h"
25 #include "clang/AST/StmtVisitor.h"
26 #include "clang/AST/TextNodeDumper.h"
27 #include "clang/AST/TypeVisitor.h"
28 #include "clang/Basic/Builtins.h"
29 #include "clang/Basic/Module.h"
30 #include "clang/Basic/SourceManager.h"
31 #include "llvm/Support/raw_ostream.h"
32 using namespace clang;
33 using namespace clang::comments;
34 
35 //===----------------------------------------------------------------------===//
36 // ASTDumper Visitor
37 //===----------------------------------------------------------------------===//
38 
39 namespace  {
40 
41   class ASTDumper
42       : public ConstDeclVisitor<ASTDumper>,
43         public ConstStmtVisitor<ASTDumper>,
44         public ConstCommentVisitor<ASTDumper, void, const FullComment *>,
45         public TypeVisitor<ASTDumper> {
46 
47     TextTreeStructure TreeStructure;
48     TextNodeDumper NodeDumper;
49 
50     raw_ostream &OS;
51 
52     /// The policy to use for printing; can be defaulted.
53     PrintingPolicy PrintPolicy;
54 
55     /// Indicates whether we should trigger deserialization of nodes that had
56     /// not already been loaded.
57     bool Deserialize = false;
58 
59     const bool ShowColors;
60 
61     /// Dump a child of the current node.
62     template<typename Fn> void dumpChild(Fn doDumpChild) {
63       TreeStructure.addChild(doDumpChild);
64     }
65 
66   public:
67     ASTDumper(raw_ostream &OS, const CommandTraits *Traits,
68               const SourceManager *SM)
69         : ASTDumper(OS, Traits, SM,
70                     SM && SM->getDiagnostics().getShowColors()) {}
71 
72     ASTDumper(raw_ostream &OS, const CommandTraits *Traits,
73               const SourceManager *SM, bool ShowColors)
74         : ASTDumper(OS, Traits, SM, ShowColors, LangOptions()) {}
75     ASTDumper(raw_ostream &OS, const CommandTraits *Traits,
76               const SourceManager *SM, bool ShowColors,
77               const PrintingPolicy &PrintPolicy)
78         : TreeStructure(OS, ShowColors),
79           NodeDumper(OS, ShowColors, SM, PrintPolicy, Traits), OS(OS),
80           PrintPolicy(PrintPolicy), ShowColors(ShowColors) {}
81 
82     void setDeserialize(bool D) { Deserialize = D; }
83 
84     void dumpDecl(const Decl *D);
85     void dumpStmt(const Stmt *S);
86 
87     // Utilities
88     void dumpType(QualType T) { NodeDumper.dumpType(T); }
89     void dumpTypeAsChild(QualType T);
90     void dumpTypeAsChild(const Type *T);
91     void dumpDeclRef(const Decl *Node, const char *Label = nullptr);
92     void dumpBareDeclRef(const Decl *Node) { NodeDumper.dumpBareDeclRef(Node); }
93     void dumpDeclContext(const DeclContext *DC);
94     void dumpLookups(const DeclContext *DC, bool DumpDecls);
95     void dumpAttr(const Attr *A);
96 
97     // C++ Utilities
98     void dumpCXXCtorInitializer(const CXXCtorInitializer *Init);
99     void dumpTemplateParameters(const TemplateParameterList *TPL);
100     void dumpTemplateArgumentListInfo(const TemplateArgumentListInfo &TALI);
101     void dumpTemplateArgumentLoc(const TemplateArgumentLoc &A,
102                                  const Decl *From = nullptr,
103                                  const char *Label = nullptr);
104     void dumpTemplateArgumentList(const TemplateArgumentList &TAL);
105     void dumpTemplateArgument(const TemplateArgument &A,
106                               SourceRange R = SourceRange(),
107                               const Decl *From = nullptr,
108                               const char *Label = nullptr);
109     template <typename SpecializationDecl>
110     void dumpTemplateDeclSpecialization(const SpecializationDecl *D,
111                                         bool DumpExplicitInst,
112                                         bool DumpRefOnly);
113     template <typename TemplateDecl>
114     void dumpTemplateDecl(const TemplateDecl *D, bool DumpExplicitInst);
115 
116     // Objective-C utilities.
117     void dumpObjCTypeParamList(const ObjCTypeParamList *typeParams);
118 
119     // Types
120     void VisitComplexType(const ComplexType *T) {
121       dumpTypeAsChild(T->getElementType());
122     }
123     void VisitPointerType(const PointerType *T) {
124       dumpTypeAsChild(T->getPointeeType());
125     }
126     void VisitBlockPointerType(const BlockPointerType *T) {
127       dumpTypeAsChild(T->getPointeeType());
128     }
129     void VisitReferenceType(const ReferenceType *T) {
130       dumpTypeAsChild(T->getPointeeType());
131     }
132     void VisitRValueReferenceType(const ReferenceType *T) {
133       if (T->isSpelledAsLValue())
134         OS << " written as lvalue reference";
135       VisitReferenceType(T);
136     }
137     void VisitMemberPointerType(const MemberPointerType *T) {
138       dumpTypeAsChild(T->getClass());
139       dumpTypeAsChild(T->getPointeeType());
140     }
141     void VisitArrayType(const ArrayType *T) {
142       switch (T->getSizeModifier()) {
143         case ArrayType::Normal: break;
144         case ArrayType::Static: OS << " static"; break;
145         case ArrayType::Star: OS << " *"; break;
146       }
147       OS << " " << T->getIndexTypeQualifiers().getAsString();
148       dumpTypeAsChild(T->getElementType());
149     }
150     void VisitConstantArrayType(const ConstantArrayType *T) {
151       OS << " " << T->getSize();
152       VisitArrayType(T);
153     }
154     void VisitVariableArrayType(const VariableArrayType *T) {
155       OS << " ";
156       NodeDumper.dumpSourceRange(T->getBracketsRange());
157       VisitArrayType(T);
158       dumpStmt(T->getSizeExpr());
159     }
160     void VisitDependentSizedArrayType(const DependentSizedArrayType *T) {
161       switch (T->getSizeModifier()) {
162         case ArrayType::Normal: break;
163         case ArrayType::Static: OS << " static"; break;
164         case ArrayType::Star: OS << " *"; break;
165       }
166       OS << " " << T->getIndexTypeQualifiers().getAsString();
167       OS << " ";
168       NodeDumper.dumpSourceRange(T->getBracketsRange());
169       dumpTypeAsChild(T->getElementType());
170       dumpStmt(T->getSizeExpr());
171     }
172     void VisitDependentSizedExtVectorType(
173         const DependentSizedExtVectorType *T) {
174       OS << " ";
175       NodeDumper.dumpLocation(T->getAttributeLoc());
176       dumpTypeAsChild(T->getElementType());
177       dumpStmt(T->getSizeExpr());
178     }
179     void VisitVectorType(const VectorType *T) {
180       switch (T->getVectorKind()) {
181         case VectorType::GenericVector: break;
182         case VectorType::AltiVecVector: OS << " altivec"; break;
183         case VectorType::AltiVecPixel: OS << " altivec pixel"; break;
184         case VectorType::AltiVecBool: OS << " altivec bool"; break;
185         case VectorType::NeonVector: OS << " neon"; break;
186         case VectorType::NeonPolyVector: OS << " neon poly"; break;
187       }
188       OS << " " << T->getNumElements();
189       dumpTypeAsChild(T->getElementType());
190     }
191     void VisitFunctionType(const FunctionType *T) {
192       auto EI = T->getExtInfo();
193       if (EI.getNoReturn()) OS << " noreturn";
194       if (EI.getProducesResult()) OS << " produces_result";
195       if (EI.getHasRegParm()) OS << " regparm " << EI.getRegParm();
196       OS << " " << FunctionType::getNameForCallConv(EI.getCC());
197       dumpTypeAsChild(T->getReturnType());
198     }
199     void VisitFunctionProtoType(const FunctionProtoType *T) {
200       auto EPI = T->getExtProtoInfo();
201       if (EPI.HasTrailingReturn) OS << " trailing_return";
202       if (T->isConst()) OS << " const";
203       if (T->isVolatile()) OS << " volatile";
204       if (T->isRestrict()) OS << " restrict";
205       switch (EPI.RefQualifier) {
206         case RQ_None: break;
207         case RQ_LValue: OS << " &"; break;
208         case RQ_RValue: OS << " &&"; break;
209       }
210       // FIXME: Exception specification.
211       // FIXME: Consumed parameters.
212       VisitFunctionType(T);
213       for (QualType PT : T->getParamTypes())
214         dumpTypeAsChild(PT);
215       if (EPI.Variadic)
216         dumpChild([=] { OS << "..."; });
217     }
218     void VisitUnresolvedUsingType(const UnresolvedUsingType *T) {
219       dumpDeclRef(T->getDecl());
220     }
221     void VisitTypedefType(const TypedefType *T) {
222       dumpDeclRef(T->getDecl());
223     }
224     void VisitTypeOfExprType(const TypeOfExprType *T) {
225       dumpStmt(T->getUnderlyingExpr());
226     }
227     void VisitDecltypeType(const DecltypeType *T) {
228       dumpStmt(T->getUnderlyingExpr());
229     }
230     void VisitUnaryTransformType(const UnaryTransformType *T) {
231       switch (T->getUTTKind()) {
232       case UnaryTransformType::EnumUnderlyingType:
233         OS << " underlying_type";
234         break;
235       }
236       dumpTypeAsChild(T->getBaseType());
237     }
238     void VisitTagType(const TagType *T) {
239       dumpDeclRef(T->getDecl());
240     }
241     void VisitAttributedType(const AttributedType *T) {
242       // FIXME: AttrKind
243       dumpTypeAsChild(T->getModifiedType());
244     }
245     void VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
246       OS << " depth " << T->getDepth() << " index " << T->getIndex();
247       if (T->isParameterPack()) OS << " pack";
248       dumpDeclRef(T->getDecl());
249     }
250     void VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) {
251       dumpTypeAsChild(T->getReplacedParameter());
252     }
253     void VisitSubstTemplateTypeParmPackType(
254         const SubstTemplateTypeParmPackType *T) {
255       dumpTypeAsChild(T->getReplacedParameter());
256       dumpTemplateArgument(T->getArgumentPack());
257     }
258     void VisitAutoType(const AutoType *T) {
259       if (T->isDecltypeAuto()) OS << " decltype(auto)";
260       if (!T->isDeduced())
261         OS << " undeduced";
262     }
263     void VisitTemplateSpecializationType(const TemplateSpecializationType *T) {
264       if (T->isTypeAlias()) OS << " alias";
265       OS << " "; T->getTemplateName().dump(OS);
266       for (auto &Arg : *T)
267         dumpTemplateArgument(Arg);
268       if (T->isTypeAlias())
269         dumpTypeAsChild(T->getAliasedType());
270     }
271     void VisitInjectedClassNameType(const InjectedClassNameType *T) {
272       dumpDeclRef(T->getDecl());
273     }
274     void VisitObjCInterfaceType(const ObjCInterfaceType *T) {
275       dumpDeclRef(T->getDecl());
276     }
277     void VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
278       dumpTypeAsChild(T->getPointeeType());
279     }
280     void VisitAtomicType(const AtomicType *T) {
281       dumpTypeAsChild(T->getValueType());
282     }
283     void VisitPipeType(const PipeType *T) {
284       dumpTypeAsChild(T->getElementType());
285     }
286     void VisitAdjustedType(const AdjustedType *T) {
287       dumpTypeAsChild(T->getOriginalType());
288     }
289     void VisitPackExpansionType(const PackExpansionType *T) {
290       if (auto N = T->getNumExpansions()) OS << " expansions " << *N;
291       if (!T->isSugared())
292         dumpTypeAsChild(T->getPattern());
293     }
294     // FIXME: ElaboratedType, DependentNameType,
295     // DependentTemplateSpecializationType, ObjCObjectType
296 
297     // Decls
298     void VisitLabelDecl(const LabelDecl *D);
299     void VisitTypedefDecl(const TypedefDecl *D);
300     void VisitEnumDecl(const EnumDecl *D);
301     void VisitRecordDecl(const RecordDecl *D);
302     void VisitEnumConstantDecl(const EnumConstantDecl *D);
303     void VisitIndirectFieldDecl(const IndirectFieldDecl *D);
304     void VisitFunctionDecl(const FunctionDecl *D);
305     void VisitFieldDecl(const FieldDecl *D);
306     void VisitVarDecl(const VarDecl *D);
307     void VisitDecompositionDecl(const DecompositionDecl *D);
308     void VisitBindingDecl(const BindingDecl *D);
309     void VisitFileScopeAsmDecl(const FileScopeAsmDecl *D);
310     void VisitImportDecl(const ImportDecl *D);
311     void VisitPragmaCommentDecl(const PragmaCommentDecl *D);
312     void VisitPragmaDetectMismatchDecl(const PragmaDetectMismatchDecl *D);
313     void VisitCapturedDecl(const CapturedDecl *D);
314 
315     // OpenMP decls
316     void VisitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D);
317     void VisitOMPDeclareReductionDecl(const OMPDeclareReductionDecl *D);
318     void VisitOMPRequiresDecl(const OMPRequiresDecl *D);
319     void VisitOMPCapturedExprDecl(const OMPCapturedExprDecl *D);
320 
321     // C++ Decls
322     void VisitNamespaceDecl(const NamespaceDecl *D);
323     void VisitUsingDirectiveDecl(const UsingDirectiveDecl *D);
324     void VisitNamespaceAliasDecl(const NamespaceAliasDecl *D);
325     void VisitTypeAliasDecl(const TypeAliasDecl *D);
326     void VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D);
327     void VisitCXXRecordDecl(const CXXRecordDecl *D);
328     void VisitStaticAssertDecl(const StaticAssertDecl *D);
329     void VisitFunctionTemplateDecl(const FunctionTemplateDecl *D);
330     void VisitClassTemplateDecl(const ClassTemplateDecl *D);
331     void VisitClassTemplateSpecializationDecl(
332         const ClassTemplateSpecializationDecl *D);
333     void VisitClassTemplatePartialSpecializationDecl(
334         const ClassTemplatePartialSpecializationDecl *D);
335     void VisitClassScopeFunctionSpecializationDecl(
336         const ClassScopeFunctionSpecializationDecl *D);
337     void VisitBuiltinTemplateDecl(const BuiltinTemplateDecl *D);
338     void VisitVarTemplateDecl(const VarTemplateDecl *D);
339     void VisitVarTemplateSpecializationDecl(
340         const VarTemplateSpecializationDecl *D);
341     void VisitVarTemplatePartialSpecializationDecl(
342         const VarTemplatePartialSpecializationDecl *D);
343     void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D);
344     void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D);
345     void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D);
346     void VisitUsingDecl(const UsingDecl *D);
347     void VisitUnresolvedUsingTypenameDecl(const UnresolvedUsingTypenameDecl *D);
348     void VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl *D);
349     void VisitUsingShadowDecl(const UsingShadowDecl *D);
350     void VisitConstructorUsingShadowDecl(const ConstructorUsingShadowDecl *D);
351     void VisitLinkageSpecDecl(const LinkageSpecDecl *D);
352     void VisitAccessSpecDecl(const AccessSpecDecl *D);
353     void VisitFriendDecl(const FriendDecl *D);
354 
355     // ObjC Decls
356     void VisitObjCIvarDecl(const ObjCIvarDecl *D);
357     void VisitObjCMethodDecl(const ObjCMethodDecl *D);
358     void VisitObjCTypeParamDecl(const ObjCTypeParamDecl *D);
359     void VisitObjCCategoryDecl(const ObjCCategoryDecl *D);
360     void VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D);
361     void VisitObjCProtocolDecl(const ObjCProtocolDecl *D);
362     void VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D);
363     void VisitObjCImplementationDecl(const ObjCImplementationDecl *D);
364     void VisitObjCCompatibleAliasDecl(const ObjCCompatibleAliasDecl *D);
365     void VisitObjCPropertyDecl(const ObjCPropertyDecl *D);
366     void VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D);
367     void VisitBlockDecl(const BlockDecl *D);
368 
369     // Stmts.
370     void VisitDeclStmt(const DeclStmt *Node);
371     void VisitAttributedStmt(const AttributedStmt *Node);
372     void VisitIfStmt(const IfStmt *Node);
373     void VisitSwitchStmt(const SwitchStmt *Node);
374     void VisitWhileStmt(const WhileStmt *Node);
375     void VisitLabelStmt(const LabelStmt *Node);
376     void VisitGotoStmt(const GotoStmt *Node);
377     void VisitCXXCatchStmt(const CXXCatchStmt *Node);
378     void VisitCaseStmt(const CaseStmt *Node);
379     void VisitCapturedStmt(const CapturedStmt *Node);
380 
381     // OpenMP
382     void VisitOMPExecutableDirective(const OMPExecutableDirective *Node);
383 
384     // Exprs
385     void VisitCallExpr(const CallExpr *Node);
386     void VisitCastExpr(const CastExpr *Node);
387     void VisitImplicitCastExpr(const ImplicitCastExpr *Node);
388     void VisitDeclRefExpr(const DeclRefExpr *Node);
389     void VisitPredefinedExpr(const PredefinedExpr *Node);
390     void VisitCharacterLiteral(const CharacterLiteral *Node);
391     void VisitIntegerLiteral(const IntegerLiteral *Node);
392     void VisitFixedPointLiteral(const FixedPointLiteral *Node);
393     void VisitFloatingLiteral(const FloatingLiteral *Node);
394     void VisitStringLiteral(const StringLiteral *Str);
395     void VisitInitListExpr(const InitListExpr *ILE);
396     void VisitUnaryOperator(const UnaryOperator *Node);
397     void VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *Node);
398     void VisitMemberExpr(const MemberExpr *Node);
399     void VisitExtVectorElementExpr(const ExtVectorElementExpr *Node);
400     void VisitBinaryOperator(const BinaryOperator *Node);
401     void VisitCompoundAssignOperator(const CompoundAssignOperator *Node);
402     void VisitAddrLabelExpr(const AddrLabelExpr *Node);
403     void VisitBlockExpr(const BlockExpr *Node);
404     void VisitOpaqueValueExpr(const OpaqueValueExpr *Node);
405     void VisitGenericSelectionExpr(const GenericSelectionExpr *E);
406 
407     // C++
408     void VisitCXXNamedCastExpr(const CXXNamedCastExpr *Node);
409     void VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *Node);
410     void VisitCXXThisExpr(const CXXThisExpr *Node);
411     void VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *Node);
412     void VisitCXXUnresolvedConstructExpr(const CXXUnresolvedConstructExpr *Node);
413     void VisitCXXConstructExpr(const CXXConstructExpr *Node);
414     void VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *Node);
415     void VisitCXXNewExpr(const CXXNewExpr *Node);
416     void VisitCXXDeleteExpr(const CXXDeleteExpr *Node);
417     void VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *Node);
418     void VisitExprWithCleanups(const ExprWithCleanups *Node);
419     void VisitUnresolvedLookupExpr(const UnresolvedLookupExpr *Node);
420     void VisitLambdaExpr(const LambdaExpr *Node) {
421       dumpDecl(Node->getLambdaClass());
422     }
423     void VisitSizeOfPackExpr(const SizeOfPackExpr *Node);
424     void
425     VisitCXXDependentScopeMemberExpr(const CXXDependentScopeMemberExpr *Node);
426 
427     // ObjC
428     void VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node);
429     void VisitObjCEncodeExpr(const ObjCEncodeExpr *Node);
430     void VisitObjCMessageExpr(const ObjCMessageExpr *Node);
431     void VisitObjCBoxedExpr(const ObjCBoxedExpr *Node);
432     void VisitObjCSelectorExpr(const ObjCSelectorExpr *Node);
433     void VisitObjCProtocolExpr(const ObjCProtocolExpr *Node);
434     void VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *Node);
435     void VisitObjCSubscriptRefExpr(const ObjCSubscriptRefExpr *Node);
436     void VisitObjCIvarRefExpr(const ObjCIvarRefExpr *Node);
437     void VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *Node);
438 
439     // Comments.
440     void dumpComment(const Comment *C, const FullComment *FC);
441   };
442 }
443 
444 //===----------------------------------------------------------------------===//
445 //  Utilities
446 //===----------------------------------------------------------------------===//
447 
448 void ASTDumper::dumpTypeAsChild(QualType T) {
449   SplitQualType SQT = T.split();
450   if (!SQT.Quals.hasQualifiers())
451     return dumpTypeAsChild(SQT.Ty);
452 
453   dumpChild([=] {
454     OS << "QualType";
455     NodeDumper.dumpPointer(T.getAsOpaquePtr());
456     OS << " ";
457     NodeDumper.dumpBareType(T, false);
458     OS << " " << T.split().Quals.getAsString();
459     dumpTypeAsChild(T.split().Ty);
460   });
461 }
462 
463 void ASTDumper::dumpTypeAsChild(const Type *T) {
464   dumpChild([=] {
465     if (!T) {
466       ColorScope Color(OS, ShowColors, NullColor);
467       OS << "<<<NULL>>>";
468       return;
469     }
470     if (const LocInfoType *LIT = llvm::dyn_cast<LocInfoType>(T)) {
471       {
472         ColorScope Color(OS, ShowColors, TypeColor);
473         OS << "LocInfo Type";
474       }
475       NodeDumper.dumpPointer(T);
476       dumpTypeAsChild(LIT->getTypeSourceInfo()->getType());
477       return;
478     }
479 
480     {
481       ColorScope Color(OS, ShowColors, TypeColor);
482       OS << T->getTypeClassName() << "Type";
483     }
484     NodeDumper.dumpPointer(T);
485     OS << " ";
486     NodeDumper.dumpBareType(QualType(T, 0), false);
487 
488     QualType SingleStepDesugar =
489         T->getLocallyUnqualifiedSingleStepDesugaredType();
490     if (SingleStepDesugar != QualType(T, 0))
491       OS << " sugar";
492     if (T->isDependentType())
493       OS << " dependent";
494     else if (T->isInstantiationDependentType())
495       OS << " instantiation_dependent";
496     if (T->isVariablyModifiedType())
497       OS << " variably_modified";
498     if (T->containsUnexpandedParameterPack())
499       OS << " contains_unexpanded_pack";
500     if (T->isFromAST())
501       OS << " imported";
502 
503     TypeVisitor<ASTDumper>::Visit(T);
504 
505     if (SingleStepDesugar != QualType(T, 0))
506       dumpTypeAsChild(SingleStepDesugar);
507   });
508 }
509 
510 void ASTDumper::dumpDeclRef(const Decl *D, const char *Label) {
511   if (!D)
512     return;
513 
514   dumpChild([=]{
515     if (Label)
516       OS << Label << ' ';
517     dumpBareDeclRef(D);
518   });
519 }
520 
521 void ASTDumper::dumpDeclContext(const DeclContext *DC) {
522   if (!DC)
523     return;
524 
525   for (auto *D : (Deserialize ? DC->decls() : DC->noload_decls()))
526     dumpDecl(D);
527 
528   if (DC->hasExternalLexicalStorage()) {
529     dumpChild([=] {
530       ColorScope Color(OS, ShowColors, UndeserializedColor);
531       OS << "<undeserialized declarations>";
532     });
533   }
534 }
535 
536 void ASTDumper::dumpLookups(const DeclContext *DC, bool DumpDecls) {
537   dumpChild([=] {
538     OS << "StoredDeclsMap ";
539     NodeDumper.dumpBareDeclRef(cast<Decl>(DC));
540 
541     const DeclContext *Primary = DC->getPrimaryContext();
542     if (Primary != DC) {
543       OS << " primary";
544       NodeDumper.dumpPointer(cast<Decl>(Primary));
545     }
546 
547     bool HasUndeserializedLookups = Primary->hasExternalVisibleStorage();
548 
549     auto Range = Deserialize
550                      ? Primary->lookups()
551                      : Primary->noload_lookups(/*PreserveInternalState=*/true);
552     for (auto I = Range.begin(), E = Range.end(); I != E; ++I) {
553       DeclarationName Name = I.getLookupName();
554       DeclContextLookupResult R = *I;
555 
556       dumpChild([=] {
557         OS << "DeclarationName ";
558         {
559           ColorScope Color(OS, ShowColors, DeclNameColor);
560           OS << '\'' << Name << '\'';
561         }
562 
563         for (DeclContextLookupResult::iterator RI = R.begin(), RE = R.end();
564              RI != RE; ++RI) {
565           dumpChild([=] {
566             NodeDumper.dumpBareDeclRef(*RI);
567 
568             if ((*RI)->isHidden())
569               OS << " hidden";
570 
571             // If requested, dump the redecl chain for this lookup.
572             if (DumpDecls) {
573               // Dump earliest decl first.
574               std::function<void(Decl *)> DumpWithPrev = [&](Decl *D) {
575                 if (Decl *Prev = D->getPreviousDecl())
576                   DumpWithPrev(Prev);
577                 dumpDecl(D);
578               };
579               DumpWithPrev(*RI);
580             }
581           });
582         }
583       });
584     }
585 
586     if (HasUndeserializedLookups) {
587       dumpChild([=] {
588         ColorScope Color(OS, ShowColors, UndeserializedColor);
589         OS << "<undeserialized lookups>";
590       });
591     }
592   });
593 }
594 
595 void ASTDumper::dumpAttr(const Attr *A) {
596   dumpChild([=] {
597     {
598       ColorScope Color(OS, ShowColors, AttrColor);
599 
600       switch (A->getKind()) {
601 #define ATTR(X) case attr::X: OS << #X; break;
602 #include "clang/Basic/AttrList.inc"
603       }
604       OS << "Attr";
605     }
606     NodeDumper.dumpPointer(A);
607     NodeDumper.dumpSourceRange(A->getRange());
608     if (A->isInherited())
609       OS << " Inherited";
610     if (A->isImplicit())
611       OS << " Implicit";
612 #include "clang/AST/AttrDump.inc"
613   });
614 }
615 
616 static void dumpPreviousDeclImpl(raw_ostream &OS, ...) {}
617 
618 template<typename T>
619 static void dumpPreviousDeclImpl(raw_ostream &OS, const Mergeable<T> *D) {
620   const T *First = D->getFirstDecl();
621   if (First != D)
622     OS << " first " << First;
623 }
624 
625 template<typename T>
626 static void dumpPreviousDeclImpl(raw_ostream &OS, const Redeclarable<T> *D) {
627   const T *Prev = D->getPreviousDecl();
628   if (Prev)
629     OS << " prev " << Prev;
630 }
631 
632 /// Dump the previous declaration in the redeclaration chain for a declaration,
633 /// if any.
634 static void dumpPreviousDecl(raw_ostream &OS, const Decl *D) {
635   switch (D->getKind()) {
636 #define DECL(DERIVED, BASE) \
637   case Decl::DERIVED: \
638     return dumpPreviousDeclImpl(OS, cast<DERIVED##Decl>(D));
639 #define ABSTRACT_DECL(DECL)
640 #include "clang/AST/DeclNodes.inc"
641   }
642   llvm_unreachable("Decl that isn't part of DeclNodes.inc!");
643 }
644 
645 //===----------------------------------------------------------------------===//
646 //  C++ Utilities
647 //===----------------------------------------------------------------------===//
648 
649 void ASTDumper::dumpCXXCtorInitializer(const CXXCtorInitializer *Init) {
650   dumpChild([=] {
651     OS << "CXXCtorInitializer";
652     if (Init->isAnyMemberInitializer()) {
653       OS << ' ';
654       NodeDumper.dumpBareDeclRef(Init->getAnyMember());
655     } else if (Init->isBaseInitializer()) {
656       NodeDumper.dumpType(QualType(Init->getBaseClass(), 0));
657     } else if (Init->isDelegatingInitializer()) {
658       NodeDumper.dumpType(Init->getTypeSourceInfo()->getType());
659     } else {
660       llvm_unreachable("Unknown initializer type");
661     }
662     dumpStmt(Init->getInit());
663   });
664 }
665 
666 void ASTDumper::dumpTemplateParameters(const TemplateParameterList *TPL) {
667   if (!TPL)
668     return;
669 
670   for (TemplateParameterList::const_iterator I = TPL->begin(), E = TPL->end();
671        I != E; ++I)
672     dumpDecl(*I);
673 }
674 
675 void ASTDumper::dumpTemplateArgumentListInfo(
676     const TemplateArgumentListInfo &TALI) {
677   for (unsigned i = 0, e = TALI.size(); i < e; ++i)
678     dumpTemplateArgumentLoc(TALI[i]);
679 }
680 
681 void ASTDumper::dumpTemplateArgumentLoc(const TemplateArgumentLoc &A,
682                                         const Decl *From, const char *Label) {
683   dumpTemplateArgument(A.getArgument(), A.getSourceRange(), From, Label);
684 }
685 
686 void ASTDumper::dumpTemplateArgumentList(const TemplateArgumentList &TAL) {
687   for (unsigned i = 0, e = TAL.size(); i < e; ++i)
688     dumpTemplateArgument(TAL[i]);
689 }
690 
691 void ASTDumper::dumpTemplateArgument(const TemplateArgument &A, SourceRange R,
692                                      const Decl *From, const char *Label) {
693   dumpChild([=] {
694     OS << "TemplateArgument";
695     if (R.isValid())
696       NodeDumper.dumpSourceRange(R);
697 
698     if (From)
699       dumpDeclRef(From, Label);
700 
701     switch (A.getKind()) {
702     case TemplateArgument::Null:
703       OS << " null";
704       break;
705     case TemplateArgument::Type:
706       OS << " type";
707       NodeDumper.dumpType(A.getAsType());
708       break;
709     case TemplateArgument::Declaration:
710       OS << " decl";
711       dumpDeclRef(A.getAsDecl());
712       break;
713     case TemplateArgument::NullPtr:
714       OS << " nullptr";
715       break;
716     case TemplateArgument::Integral:
717       OS << " integral " << A.getAsIntegral();
718       break;
719     case TemplateArgument::Template:
720       OS << " template ";
721       A.getAsTemplate().dump(OS);
722       break;
723     case TemplateArgument::TemplateExpansion:
724       OS << " template expansion ";
725       A.getAsTemplateOrTemplatePattern().dump(OS);
726       break;
727     case TemplateArgument::Expression:
728       OS << " expr";
729       dumpStmt(A.getAsExpr());
730       break;
731     case TemplateArgument::Pack:
732       OS << " pack";
733       for (TemplateArgument::pack_iterator I = A.pack_begin(), E = A.pack_end();
734            I != E; ++I)
735         dumpTemplateArgument(*I);
736       break;
737     }
738   });
739 }
740 
741 //===----------------------------------------------------------------------===//
742 //  Objective-C Utilities
743 //===----------------------------------------------------------------------===//
744 void ASTDumper::dumpObjCTypeParamList(const ObjCTypeParamList *typeParams) {
745   if (!typeParams)
746     return;
747 
748   for (auto typeParam : *typeParams) {
749     dumpDecl(typeParam);
750   }
751 }
752 
753 //===----------------------------------------------------------------------===//
754 //  Decl dumping methods.
755 //===----------------------------------------------------------------------===//
756 
757 void ASTDumper::dumpDecl(const Decl *D) {
758   dumpChild([=] {
759     if (!D) {
760       ColorScope Color(OS, ShowColors, NullColor);
761       OS << "<<<NULL>>>";
762       return;
763     }
764 
765     {
766       ColorScope Color(OS, ShowColors, DeclKindNameColor);
767       OS << D->getDeclKindName() << "Decl";
768     }
769     NodeDumper.dumpPointer(D);
770     if (D->getLexicalDeclContext() != D->getDeclContext())
771       OS << " parent " << cast<Decl>(D->getDeclContext());
772     dumpPreviousDecl(OS, D);
773     NodeDumper.dumpSourceRange(D->getSourceRange());
774     OS << ' ';
775     NodeDumper.dumpLocation(D->getLocation());
776     if (D->isFromASTFile())
777       OS << " imported";
778     if (Module *M = D->getOwningModule())
779       OS << " in " << M->getFullModuleName();
780     if (auto *ND = dyn_cast<NamedDecl>(D))
781       for (Module *M : D->getASTContext().getModulesWithMergedDefinition(
782                const_cast<NamedDecl *>(ND)))
783         dumpChild([=] { OS << "also in " << M->getFullModuleName(); });
784     if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
785       if (ND->isHidden())
786         OS << " hidden";
787     if (D->isImplicit())
788       OS << " implicit";
789     if (D->isUsed())
790       OS << " used";
791     else if (D->isThisDeclarationReferenced())
792       OS << " referenced";
793     if (D->isInvalidDecl())
794       OS << " invalid";
795     if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
796       if (FD->isConstexpr())
797         OS << " constexpr";
798 
799 
800     ConstDeclVisitor<ASTDumper>::Visit(D);
801 
802     for (Decl::attr_iterator I = D->attr_begin(), E = D->attr_end(); I != E;
803          ++I)
804       dumpAttr(*I);
805 
806     if (const FullComment *Comment =
807             D->getASTContext().getLocalCommentForDeclUncached(D))
808       dumpComment(Comment, Comment);
809 
810     // Decls within functions are visited by the body.
811     if (!isa<FunctionDecl>(*D) && !isa<ObjCMethodDecl>(*D)) {
812       auto DC = dyn_cast<DeclContext>(D);
813       if (DC &&
814           (DC->hasExternalLexicalStorage() ||
815            (Deserialize ? DC->decls_begin() != DC->decls_end()
816                         : DC->noload_decls_begin() != DC->noload_decls_end())))
817         dumpDeclContext(DC);
818     }
819   });
820 }
821 
822 void ASTDumper::VisitLabelDecl(const LabelDecl *D) { NodeDumper.dumpName(D); }
823 
824 void ASTDumper::VisitTypedefDecl(const TypedefDecl *D) {
825   NodeDumper.dumpName(D);
826   NodeDumper.dumpType(D->getUnderlyingType());
827   if (D->isModulePrivate())
828     OS << " __module_private__";
829   dumpTypeAsChild(D->getUnderlyingType());
830 }
831 
832 void ASTDumper::VisitEnumDecl(const EnumDecl *D) {
833   if (D->isScoped()) {
834     if (D->isScopedUsingClassTag())
835       OS << " class";
836     else
837       OS << " struct";
838   }
839   NodeDumper.dumpName(D);
840   if (D->isModulePrivate())
841     OS << " __module_private__";
842   if (D->isFixed())
843     NodeDumper.dumpType(D->getIntegerType());
844 }
845 
846 void ASTDumper::VisitRecordDecl(const RecordDecl *D) {
847   OS << ' ' << D->getKindName();
848   NodeDumper.dumpName(D);
849   if (D->isModulePrivate())
850     OS << " __module_private__";
851   if (D->isCompleteDefinition())
852     OS << " definition";
853 }
854 
855 void ASTDumper::VisitEnumConstantDecl(const EnumConstantDecl *D) {
856   NodeDumper.dumpName(D);
857   NodeDumper.dumpType(D->getType());
858   if (const Expr *Init = D->getInitExpr())
859     dumpStmt(Init);
860 }
861 
862 void ASTDumper::VisitIndirectFieldDecl(const IndirectFieldDecl *D) {
863   NodeDumper.dumpName(D);
864   NodeDumper.dumpType(D->getType());
865 
866   for (auto *Child : D->chain())
867     dumpDeclRef(Child);
868 }
869 
870 void ASTDumper::VisitFunctionDecl(const FunctionDecl *D) {
871   NodeDumper.dumpName(D);
872   NodeDumper.dumpType(D->getType());
873 
874   StorageClass SC = D->getStorageClass();
875   if (SC != SC_None)
876     OS << ' ' << VarDecl::getStorageClassSpecifierString(SC);
877   if (D->isInlineSpecified())
878     OS << " inline";
879   if (D->isVirtualAsWritten())
880     OS << " virtual";
881   if (D->isModulePrivate())
882     OS << " __module_private__";
883 
884   if (D->isPure())
885     OS << " pure";
886   if (D->isDefaulted()) {
887     OS << " default";
888     if (D->isDeleted())
889       OS << "_delete";
890   }
891   if (D->isDeletedAsWritten())
892     OS << " delete";
893   if (D->isTrivial())
894     OS << " trivial";
895 
896   if (const FunctionProtoType *FPT = D->getType()->getAs<FunctionProtoType>()) {
897     FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
898     switch (EPI.ExceptionSpec.Type) {
899     default: break;
900     case EST_Unevaluated:
901       OS << " noexcept-unevaluated " << EPI.ExceptionSpec.SourceDecl;
902       break;
903     case EST_Uninstantiated:
904       OS << " noexcept-uninstantiated " << EPI.ExceptionSpec.SourceTemplate;
905       break;
906     }
907   }
908 
909   if (const FunctionTemplateSpecializationInfo *FTSI =
910           D->getTemplateSpecializationInfo())
911     dumpTemplateArgumentList(*FTSI->TemplateArguments);
912 
913   if (!D->param_begin() && D->getNumParams())
914     dumpChild([=] { OS << "<<NULL params x " << D->getNumParams() << ">>"; });
915   else
916     for (const ParmVarDecl *Parameter : D->parameters())
917       dumpDecl(Parameter);
918 
919   if (const CXXConstructorDecl *C = dyn_cast<CXXConstructorDecl>(D))
920     for (CXXConstructorDecl::init_const_iterator I = C->init_begin(),
921                                                  E = C->init_end();
922          I != E; ++I)
923       dumpCXXCtorInitializer(*I);
924 
925   if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
926     if (MD->size_overridden_methods() != 0) {
927       auto dumpOverride = [=](const CXXMethodDecl *D) {
928         SplitQualType T_split = D->getType().split();
929         OS << D << " " << D->getParent()->getName()
930            << "::" << D->getNameAsString() << " '"
931            << QualType::getAsString(T_split, PrintPolicy) << "'";
932       };
933 
934       dumpChild([=] {
935         auto Overrides = MD->overridden_methods();
936         OS << "Overrides: [ ";
937         dumpOverride(*Overrides.begin());
938         for (const auto *Override :
939              llvm::make_range(Overrides.begin() + 1, Overrides.end())) {
940           OS << ", ";
941           dumpOverride(Override);
942         }
943         OS << " ]";
944       });
945     }
946   }
947 
948   if (D->doesThisDeclarationHaveABody())
949     dumpStmt(D->getBody());
950 }
951 
952 void ASTDumper::VisitFieldDecl(const FieldDecl *D) {
953   NodeDumper.dumpName(D);
954   NodeDumper.dumpType(D->getType());
955   if (D->isMutable())
956     OS << " mutable";
957   if (D->isModulePrivate())
958     OS << " __module_private__";
959 
960   if (D->isBitField())
961     dumpStmt(D->getBitWidth());
962   if (Expr *Init = D->getInClassInitializer())
963     dumpStmt(Init);
964 }
965 
966 void ASTDumper::VisitVarDecl(const VarDecl *D) {
967   NodeDumper.dumpName(D);
968   NodeDumper.dumpType(D->getType());
969   StorageClass SC = D->getStorageClass();
970   if (SC != SC_None)
971     OS << ' ' << VarDecl::getStorageClassSpecifierString(SC);
972   switch (D->getTLSKind()) {
973   case VarDecl::TLS_None: break;
974   case VarDecl::TLS_Static: OS << " tls"; break;
975   case VarDecl::TLS_Dynamic: OS << " tls_dynamic"; break;
976   }
977   if (D->isModulePrivate())
978     OS << " __module_private__";
979   if (D->isNRVOVariable())
980     OS << " nrvo";
981   if (D->isInline())
982     OS << " inline";
983   if (D->isConstexpr())
984     OS << " constexpr";
985   if (D->hasInit()) {
986     switch (D->getInitStyle()) {
987     case VarDecl::CInit: OS << " cinit"; break;
988     case VarDecl::CallInit: OS << " callinit"; break;
989     case VarDecl::ListInit: OS << " listinit"; break;
990     }
991     dumpStmt(D->getInit());
992   }
993 }
994 
995 void ASTDumper::VisitDecompositionDecl(const DecompositionDecl *D) {
996   VisitVarDecl(D);
997   for (auto *B : D->bindings())
998     dumpDecl(B);
999 }
1000 
1001 void ASTDumper::VisitBindingDecl(const BindingDecl *D) {
1002   NodeDumper.dumpName(D);
1003   NodeDumper.dumpType(D->getType());
1004   if (auto *E = D->getBinding())
1005     dumpStmt(E);
1006 }
1007 
1008 void ASTDumper::VisitFileScopeAsmDecl(const FileScopeAsmDecl *D) {
1009   dumpStmt(D->getAsmString());
1010 }
1011 
1012 void ASTDumper::VisitImportDecl(const ImportDecl *D) {
1013   OS << ' ' << D->getImportedModule()->getFullModuleName();
1014 }
1015 
1016 void ASTDumper::VisitPragmaCommentDecl(const PragmaCommentDecl *D) {
1017   OS << ' ';
1018   switch (D->getCommentKind()) {
1019   case PCK_Unknown:  llvm_unreachable("unexpected pragma comment kind");
1020   case PCK_Compiler: OS << "compiler"; break;
1021   case PCK_ExeStr:   OS << "exestr"; break;
1022   case PCK_Lib:      OS << "lib"; break;
1023   case PCK_Linker:   OS << "linker"; break;
1024   case PCK_User:     OS << "user"; break;
1025   }
1026   StringRef Arg = D->getArg();
1027   if (!Arg.empty())
1028     OS << " \"" << Arg << "\"";
1029 }
1030 
1031 void ASTDumper::VisitPragmaDetectMismatchDecl(
1032     const PragmaDetectMismatchDecl *D) {
1033   OS << " \"" << D->getName() << "\" \"" << D->getValue() << "\"";
1034 }
1035 
1036 void ASTDumper::VisitCapturedDecl(const CapturedDecl *D) {
1037   dumpStmt(D->getBody());
1038 }
1039 
1040 //===----------------------------------------------------------------------===//
1041 // OpenMP Declarations
1042 //===----------------------------------------------------------------------===//
1043 
1044 void ASTDumper::VisitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D) {
1045   for (auto *E : D->varlists())
1046     dumpStmt(E);
1047 }
1048 
1049 void ASTDumper::VisitOMPDeclareReductionDecl(const OMPDeclareReductionDecl *D) {
1050   NodeDumper.dumpName(D);
1051   NodeDumper.dumpType(D->getType());
1052   OS << " combiner";
1053   NodeDumper.dumpPointer(D->getCombiner());
1054   if (const auto *Initializer = D->getInitializer()) {
1055     OS << " initializer";
1056     NodeDumper.dumpPointer(Initializer);
1057     switch (D->getInitializerKind()) {
1058     case OMPDeclareReductionDecl::DirectInit:
1059       OS << " omp_priv = ";
1060       break;
1061     case OMPDeclareReductionDecl::CopyInit:
1062       OS << " omp_priv ()";
1063       break;
1064     case OMPDeclareReductionDecl::CallInit:
1065       break;
1066     }
1067   }
1068 
1069   dumpStmt(D->getCombiner());
1070   if (const auto *Initializer = D->getInitializer())
1071     dumpStmt(Initializer);
1072 }
1073 
1074 void ASTDumper::VisitOMPRequiresDecl(const OMPRequiresDecl *D) {
1075   for (auto *C : D->clauselists()) {
1076     dumpChild([=] {
1077       if (!C) {
1078         ColorScope Color(OS, ShowColors, NullColor);
1079         OS << "<<<NULL>>> OMPClause";
1080         return;
1081       }
1082       {
1083         ColorScope Color(OS, ShowColors, AttrColor);
1084         StringRef ClauseName(getOpenMPClauseName(C->getClauseKind()));
1085         OS << "OMP" << ClauseName.substr(/*Start=*/0, /*N=*/1).upper()
1086            << ClauseName.drop_front() << "Clause";
1087       }
1088       NodeDumper.dumpPointer(C);
1089       NodeDumper.dumpSourceRange(SourceRange(C->getBeginLoc(), C->getEndLoc()));
1090     });
1091   }
1092 }
1093 
1094 void ASTDumper::VisitOMPCapturedExprDecl(const OMPCapturedExprDecl *D) {
1095   NodeDumper.dumpName(D);
1096   NodeDumper.dumpType(D->getType());
1097   dumpStmt(D->getInit());
1098 }
1099 
1100 //===----------------------------------------------------------------------===//
1101 // C++ Declarations
1102 //===----------------------------------------------------------------------===//
1103 
1104 void ASTDumper::VisitNamespaceDecl(const NamespaceDecl *D) {
1105   NodeDumper.dumpName(D);
1106   if (D->isInline())
1107     OS << " inline";
1108   if (!D->isOriginalNamespace())
1109     dumpDeclRef(D->getOriginalNamespace(), "original");
1110 }
1111 
1112 void ASTDumper::VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
1113   OS << ' ';
1114   NodeDumper.dumpBareDeclRef(D->getNominatedNamespace());
1115 }
1116 
1117 void ASTDumper::VisitNamespaceAliasDecl(const NamespaceAliasDecl *D) {
1118   NodeDumper.dumpName(D);
1119   dumpDeclRef(D->getAliasedNamespace());
1120 }
1121 
1122 void ASTDumper::VisitTypeAliasDecl(const TypeAliasDecl *D) {
1123   NodeDumper.dumpName(D);
1124   NodeDumper.dumpType(D->getUnderlyingType());
1125   dumpTypeAsChild(D->getUnderlyingType());
1126 }
1127 
1128 void ASTDumper::VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D) {
1129   NodeDumper.dumpName(D);
1130   dumpTemplateParameters(D->getTemplateParameters());
1131   dumpDecl(D->getTemplatedDecl());
1132 }
1133 
1134 void ASTDumper::VisitCXXRecordDecl(const CXXRecordDecl *D) {
1135   VisitRecordDecl(D);
1136   if (!D->isCompleteDefinition())
1137     return;
1138 
1139   dumpChild([=] {
1140     {
1141       ColorScope Color(OS, ShowColors, DeclKindNameColor);
1142       OS << "DefinitionData";
1143     }
1144 #define FLAG(fn, name) if (D->fn()) OS << " " #name;
1145     FLAG(isParsingBaseSpecifiers, parsing_base_specifiers);
1146 
1147     FLAG(isGenericLambda, generic);
1148     FLAG(isLambda, lambda);
1149 
1150     FLAG(canPassInRegisters, pass_in_registers);
1151     FLAG(isEmpty, empty);
1152     FLAG(isAggregate, aggregate);
1153     FLAG(isStandardLayout, standard_layout);
1154     FLAG(isTriviallyCopyable, trivially_copyable);
1155     FLAG(isPOD, pod);
1156     FLAG(isTrivial, trivial);
1157     FLAG(isPolymorphic, polymorphic);
1158     FLAG(isAbstract, abstract);
1159     FLAG(isLiteral, literal);
1160 
1161     FLAG(hasUserDeclaredConstructor, has_user_declared_ctor);
1162     FLAG(hasConstexprNonCopyMoveConstructor, has_constexpr_non_copy_move_ctor);
1163     FLAG(hasMutableFields, has_mutable_fields);
1164     FLAG(hasVariantMembers, has_variant_members);
1165     FLAG(allowConstDefaultInit, can_const_default_init);
1166 
1167     dumpChild([=] {
1168       {
1169         ColorScope Color(OS, ShowColors, DeclKindNameColor);
1170         OS << "DefaultConstructor";
1171       }
1172       FLAG(hasDefaultConstructor, exists);
1173       FLAG(hasTrivialDefaultConstructor, trivial);
1174       FLAG(hasNonTrivialDefaultConstructor, non_trivial);
1175       FLAG(hasUserProvidedDefaultConstructor, user_provided);
1176       FLAG(hasConstexprDefaultConstructor, constexpr);
1177       FLAG(needsImplicitDefaultConstructor, needs_implicit);
1178       FLAG(defaultedDefaultConstructorIsConstexpr, defaulted_is_constexpr);
1179     });
1180 
1181     dumpChild([=] {
1182       {
1183         ColorScope Color(OS, ShowColors, DeclKindNameColor);
1184         OS << "CopyConstructor";
1185       }
1186       FLAG(hasSimpleCopyConstructor, simple);
1187       FLAG(hasTrivialCopyConstructor, trivial);
1188       FLAG(hasNonTrivialCopyConstructor, non_trivial);
1189       FLAG(hasUserDeclaredCopyConstructor, user_declared);
1190       FLAG(hasCopyConstructorWithConstParam, has_const_param);
1191       FLAG(needsImplicitCopyConstructor, needs_implicit);
1192       FLAG(needsOverloadResolutionForCopyConstructor,
1193            needs_overload_resolution);
1194       if (!D->needsOverloadResolutionForCopyConstructor())
1195         FLAG(defaultedCopyConstructorIsDeleted, defaulted_is_deleted);
1196       FLAG(implicitCopyConstructorHasConstParam, implicit_has_const_param);
1197     });
1198 
1199     dumpChild([=] {
1200       {
1201         ColorScope Color(OS, ShowColors, DeclKindNameColor);
1202         OS << "MoveConstructor";
1203       }
1204       FLAG(hasMoveConstructor, exists);
1205       FLAG(hasSimpleMoveConstructor, simple);
1206       FLAG(hasTrivialMoveConstructor, trivial);
1207       FLAG(hasNonTrivialMoveConstructor, non_trivial);
1208       FLAG(hasUserDeclaredMoveConstructor, user_declared);
1209       FLAG(needsImplicitMoveConstructor, needs_implicit);
1210       FLAG(needsOverloadResolutionForMoveConstructor,
1211            needs_overload_resolution);
1212       if (!D->needsOverloadResolutionForMoveConstructor())
1213         FLAG(defaultedMoveConstructorIsDeleted, defaulted_is_deleted);
1214     });
1215 
1216     dumpChild([=] {
1217       {
1218         ColorScope Color(OS, ShowColors, DeclKindNameColor);
1219         OS << "CopyAssignment";
1220       }
1221       FLAG(hasTrivialCopyAssignment, trivial);
1222       FLAG(hasNonTrivialCopyAssignment, non_trivial);
1223       FLAG(hasCopyAssignmentWithConstParam, has_const_param);
1224       FLAG(hasUserDeclaredCopyAssignment, user_declared);
1225       FLAG(needsImplicitCopyAssignment, needs_implicit);
1226       FLAG(needsOverloadResolutionForCopyAssignment, needs_overload_resolution);
1227       FLAG(implicitCopyAssignmentHasConstParam, implicit_has_const_param);
1228     });
1229 
1230     dumpChild([=] {
1231       {
1232         ColorScope Color(OS, ShowColors, DeclKindNameColor);
1233         OS << "MoveAssignment";
1234       }
1235       FLAG(hasMoveAssignment, exists);
1236       FLAG(hasSimpleMoveAssignment, simple);
1237       FLAG(hasTrivialMoveAssignment, trivial);
1238       FLAG(hasNonTrivialMoveAssignment, non_trivial);
1239       FLAG(hasUserDeclaredMoveAssignment, user_declared);
1240       FLAG(needsImplicitMoveAssignment, needs_implicit);
1241       FLAG(needsOverloadResolutionForMoveAssignment, needs_overload_resolution);
1242     });
1243 
1244     dumpChild([=] {
1245       {
1246         ColorScope Color(OS, ShowColors, DeclKindNameColor);
1247         OS << "Destructor";
1248       }
1249       FLAG(hasSimpleDestructor, simple);
1250       FLAG(hasIrrelevantDestructor, irrelevant);
1251       FLAG(hasTrivialDestructor, trivial);
1252       FLAG(hasNonTrivialDestructor, non_trivial);
1253       FLAG(hasUserDeclaredDestructor, user_declared);
1254       FLAG(needsImplicitDestructor, needs_implicit);
1255       FLAG(needsOverloadResolutionForDestructor, needs_overload_resolution);
1256       if (!D->needsOverloadResolutionForDestructor())
1257         FLAG(defaultedDestructorIsDeleted, defaulted_is_deleted);
1258     });
1259   });
1260 
1261   for (const auto &I : D->bases()) {
1262     dumpChild([=] {
1263       if (I.isVirtual())
1264         OS << "virtual ";
1265       NodeDumper.dumpAccessSpecifier(I.getAccessSpecifier());
1266       NodeDumper.dumpType(I.getType());
1267       if (I.isPackExpansion())
1268         OS << "...";
1269     });
1270   }
1271 }
1272 
1273 void ASTDumper::VisitStaticAssertDecl(const StaticAssertDecl *D) {
1274   dumpStmt(D->getAssertExpr());
1275   dumpStmt(D->getMessage());
1276 }
1277 
1278 template <typename SpecializationDecl>
1279 void ASTDumper::dumpTemplateDeclSpecialization(const SpecializationDecl *D,
1280                                                bool DumpExplicitInst,
1281                                                bool DumpRefOnly) {
1282   bool DumpedAny = false;
1283   for (auto *RedeclWithBadType : D->redecls()) {
1284     // FIXME: The redecls() range sometimes has elements of a less-specific
1285     // type. (In particular, ClassTemplateSpecializationDecl::redecls() gives
1286     // us TagDecls, and should give CXXRecordDecls).
1287     auto *Redecl = dyn_cast<SpecializationDecl>(RedeclWithBadType);
1288     if (!Redecl) {
1289       // Found the injected-class-name for a class template. This will be dumped
1290       // as part of its surrounding class so we don't need to dump it here.
1291       assert(isa<CXXRecordDecl>(RedeclWithBadType) &&
1292              "expected an injected-class-name");
1293       continue;
1294     }
1295 
1296     switch (Redecl->getTemplateSpecializationKind()) {
1297     case TSK_ExplicitInstantiationDeclaration:
1298     case TSK_ExplicitInstantiationDefinition:
1299       if (!DumpExplicitInst)
1300         break;
1301       LLVM_FALLTHROUGH;
1302     case TSK_Undeclared:
1303     case TSK_ImplicitInstantiation:
1304       if (DumpRefOnly)
1305         dumpDeclRef(Redecl);
1306       else
1307         dumpDecl(Redecl);
1308       DumpedAny = true;
1309       break;
1310     case TSK_ExplicitSpecialization:
1311       break;
1312     }
1313   }
1314 
1315   // Ensure we dump at least one decl for each specialization.
1316   if (!DumpedAny)
1317     dumpDeclRef(D);
1318 }
1319 
1320 template <typename TemplateDecl>
1321 void ASTDumper::dumpTemplateDecl(const TemplateDecl *D, bool DumpExplicitInst) {
1322   NodeDumper.dumpName(D);
1323   dumpTemplateParameters(D->getTemplateParameters());
1324 
1325   dumpDecl(D->getTemplatedDecl());
1326 
1327   for (auto *Child : D->specializations())
1328     dumpTemplateDeclSpecialization(Child, DumpExplicitInst,
1329                                    !D->isCanonicalDecl());
1330 }
1331 
1332 void ASTDumper::VisitFunctionTemplateDecl(const FunctionTemplateDecl *D) {
1333   // FIXME: We don't add a declaration of a function template specialization
1334   // to its context when it's explicitly instantiated, so dump explicit
1335   // instantiations when we dump the template itself.
1336   dumpTemplateDecl(D, true);
1337 }
1338 
1339 void ASTDumper::VisitClassTemplateDecl(const ClassTemplateDecl *D) {
1340   dumpTemplateDecl(D, false);
1341 }
1342 
1343 void ASTDumper::VisitClassTemplateSpecializationDecl(
1344     const ClassTemplateSpecializationDecl *D) {
1345   VisitCXXRecordDecl(D);
1346   dumpTemplateArgumentList(D->getTemplateArgs());
1347 }
1348 
1349 void ASTDumper::VisitClassTemplatePartialSpecializationDecl(
1350     const ClassTemplatePartialSpecializationDecl *D) {
1351   VisitClassTemplateSpecializationDecl(D);
1352   dumpTemplateParameters(D->getTemplateParameters());
1353 }
1354 
1355 void ASTDumper::VisitClassScopeFunctionSpecializationDecl(
1356     const ClassScopeFunctionSpecializationDecl *D) {
1357   dumpDecl(D->getSpecialization());
1358   if (D->hasExplicitTemplateArgs())
1359     dumpTemplateArgumentListInfo(D->templateArgs());
1360 }
1361 
1362 void ASTDumper::VisitVarTemplateDecl(const VarTemplateDecl *D) {
1363   dumpTemplateDecl(D, false);
1364 }
1365 
1366 void ASTDumper::VisitBuiltinTemplateDecl(const BuiltinTemplateDecl *D) {
1367   NodeDumper.dumpName(D);
1368   dumpTemplateParameters(D->getTemplateParameters());
1369 }
1370 
1371 void ASTDumper::VisitVarTemplateSpecializationDecl(
1372     const VarTemplateSpecializationDecl *D) {
1373   dumpTemplateArgumentList(D->getTemplateArgs());
1374   VisitVarDecl(D);
1375 }
1376 
1377 void ASTDumper::VisitVarTemplatePartialSpecializationDecl(
1378     const VarTemplatePartialSpecializationDecl *D) {
1379   dumpTemplateParameters(D->getTemplateParameters());
1380   VisitVarTemplateSpecializationDecl(D);
1381 }
1382 
1383 void ASTDumper::VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) {
1384   if (D->wasDeclaredWithTypename())
1385     OS << " typename";
1386   else
1387     OS << " class";
1388   OS << " depth " << D->getDepth() << " index " << D->getIndex();
1389   if (D->isParameterPack())
1390     OS << " ...";
1391   NodeDumper.dumpName(D);
1392   if (D->hasDefaultArgument())
1393     dumpTemplateArgument(D->getDefaultArgument(), SourceRange(),
1394                          D->getDefaultArgStorage().getInheritedFrom(),
1395                          D->defaultArgumentWasInherited() ? "inherited from"
1396                                                           : "previous");
1397 }
1398 
1399 void ASTDumper::VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) {
1400   NodeDumper.dumpType(D->getType());
1401   OS << " depth " << D->getDepth() << " index " << D->getIndex();
1402   if (D->isParameterPack())
1403     OS << " ...";
1404   NodeDumper.dumpName(D);
1405   if (D->hasDefaultArgument())
1406     dumpTemplateArgument(D->getDefaultArgument(), SourceRange(),
1407                          D->getDefaultArgStorage().getInheritedFrom(),
1408                          D->defaultArgumentWasInherited() ? "inherited from"
1409                                                           : "previous");
1410 }
1411 
1412 void ASTDumper::VisitTemplateTemplateParmDecl(
1413     const TemplateTemplateParmDecl *D) {
1414   OS << " depth " << D->getDepth() << " index " << D->getIndex();
1415   if (D->isParameterPack())
1416     OS << " ...";
1417   NodeDumper.dumpName(D);
1418   dumpTemplateParameters(D->getTemplateParameters());
1419   if (D->hasDefaultArgument())
1420     dumpTemplateArgumentLoc(
1421         D->getDefaultArgument(), D->getDefaultArgStorage().getInheritedFrom(),
1422         D->defaultArgumentWasInherited() ? "inherited from" : "previous");
1423 }
1424 
1425 void ASTDumper::VisitUsingDecl(const UsingDecl *D) {
1426   OS << ' ';
1427   if (D->getQualifier())
1428     D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
1429   OS << D->getNameAsString();
1430 }
1431 
1432 void ASTDumper::VisitUnresolvedUsingTypenameDecl(
1433     const UnresolvedUsingTypenameDecl *D) {
1434   OS << ' ';
1435   if (D->getQualifier())
1436     D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
1437   OS << D->getNameAsString();
1438 }
1439 
1440 void ASTDumper::VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl *D) {
1441   OS << ' ';
1442   if (D->getQualifier())
1443     D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
1444   OS << D->getNameAsString();
1445   NodeDumper.dumpType(D->getType());
1446 }
1447 
1448 void ASTDumper::VisitUsingShadowDecl(const UsingShadowDecl *D) {
1449   OS << ' ';
1450   NodeDumper.dumpBareDeclRef(D->getTargetDecl());
1451   if (auto *TD = dyn_cast<TypeDecl>(D->getUnderlyingDecl()))
1452     dumpTypeAsChild(TD->getTypeForDecl());
1453 }
1454 
1455 void ASTDumper::VisitConstructorUsingShadowDecl(
1456     const ConstructorUsingShadowDecl *D) {
1457   if (D->constructsVirtualBase())
1458     OS << " virtual";
1459 
1460   dumpChild([=] {
1461     OS << "target ";
1462     NodeDumper.dumpBareDeclRef(D->getTargetDecl());
1463   });
1464 
1465   dumpChild([=] {
1466     OS << "nominated ";
1467     NodeDumper.dumpBareDeclRef(D->getNominatedBaseClass());
1468     OS << ' ';
1469     NodeDumper.dumpBareDeclRef(D->getNominatedBaseClassShadowDecl());
1470   });
1471 
1472   dumpChild([=] {
1473     OS << "constructed ";
1474     NodeDumper.dumpBareDeclRef(D->getConstructedBaseClass());
1475     OS << ' ';
1476     NodeDumper.dumpBareDeclRef(D->getConstructedBaseClassShadowDecl());
1477   });
1478 }
1479 
1480 void ASTDumper::VisitLinkageSpecDecl(const LinkageSpecDecl *D) {
1481   switch (D->getLanguage()) {
1482   case LinkageSpecDecl::lang_c: OS << " C"; break;
1483   case LinkageSpecDecl::lang_cxx: OS << " C++"; break;
1484   }
1485 }
1486 
1487 void ASTDumper::VisitAccessSpecDecl(const AccessSpecDecl *D) {
1488   OS << ' ';
1489   NodeDumper.dumpAccessSpecifier(D->getAccess());
1490 }
1491 
1492 void ASTDumper::VisitFriendDecl(const FriendDecl *D) {
1493   if (TypeSourceInfo *T = D->getFriendType())
1494     NodeDumper.dumpType(T->getType());
1495   else
1496     dumpDecl(D->getFriendDecl());
1497 }
1498 
1499 //===----------------------------------------------------------------------===//
1500 // Obj-C Declarations
1501 //===----------------------------------------------------------------------===//
1502 
1503 void ASTDumper::VisitObjCIvarDecl(const ObjCIvarDecl *D) {
1504   NodeDumper.dumpName(D);
1505   NodeDumper.dumpType(D->getType());
1506   if (D->getSynthesize())
1507     OS << " synthesize";
1508 
1509   switch (D->getAccessControl()) {
1510   case ObjCIvarDecl::None:
1511     OS << " none";
1512     break;
1513   case ObjCIvarDecl::Private:
1514     OS << " private";
1515     break;
1516   case ObjCIvarDecl::Protected:
1517     OS << " protected";
1518     break;
1519   case ObjCIvarDecl::Public:
1520     OS << " public";
1521     break;
1522   case ObjCIvarDecl::Package:
1523     OS << " package";
1524     break;
1525   }
1526 }
1527 
1528 void ASTDumper::VisitObjCMethodDecl(const ObjCMethodDecl *D) {
1529   if (D->isInstanceMethod())
1530     OS << " -";
1531   else
1532     OS << " +";
1533   NodeDumper.dumpName(D);
1534   NodeDumper.dumpType(D->getReturnType());
1535 
1536   if (D->isThisDeclarationADefinition()) {
1537     dumpDeclContext(D);
1538   } else {
1539     for (const ParmVarDecl *Parameter : D->parameters())
1540       dumpDecl(Parameter);
1541   }
1542 
1543   if (D->isVariadic())
1544     dumpChild([=] { OS << "..."; });
1545 
1546   if (D->hasBody())
1547     dumpStmt(D->getBody());
1548 }
1549 
1550 void ASTDumper::VisitObjCTypeParamDecl(const ObjCTypeParamDecl *D) {
1551   NodeDumper.dumpName(D);
1552   switch (D->getVariance()) {
1553   case ObjCTypeParamVariance::Invariant:
1554     break;
1555 
1556   case ObjCTypeParamVariance::Covariant:
1557     OS << " covariant";
1558     break;
1559 
1560   case ObjCTypeParamVariance::Contravariant:
1561     OS << " contravariant";
1562     break;
1563   }
1564 
1565   if (D->hasExplicitBound())
1566     OS << " bounded";
1567   NodeDumper.dumpType(D->getUnderlyingType());
1568 }
1569 
1570 void ASTDumper::VisitObjCCategoryDecl(const ObjCCategoryDecl *D) {
1571   NodeDumper.dumpName(D);
1572   dumpDeclRef(D->getClassInterface());
1573   dumpObjCTypeParamList(D->getTypeParamList());
1574   dumpDeclRef(D->getImplementation());
1575   for (ObjCCategoryDecl::protocol_iterator I = D->protocol_begin(),
1576                                            E = D->protocol_end();
1577        I != E; ++I)
1578     dumpDeclRef(*I);
1579 }
1580 
1581 void ASTDumper::VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D) {
1582   NodeDumper.dumpName(D);
1583   dumpDeclRef(D->getClassInterface());
1584   dumpDeclRef(D->getCategoryDecl());
1585 }
1586 
1587 void ASTDumper::VisitObjCProtocolDecl(const ObjCProtocolDecl *D) {
1588   NodeDumper.dumpName(D);
1589 
1590   for (auto *Child : D->protocols())
1591     dumpDeclRef(Child);
1592 }
1593 
1594 void ASTDumper::VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) {
1595   NodeDumper.dumpName(D);
1596   dumpObjCTypeParamList(D->getTypeParamListAsWritten());
1597   dumpDeclRef(D->getSuperClass(), "super");
1598 
1599   dumpDeclRef(D->getImplementation());
1600   for (auto *Child : D->protocols())
1601     dumpDeclRef(Child);
1602 }
1603 
1604 void ASTDumper::VisitObjCImplementationDecl(const ObjCImplementationDecl *D) {
1605   NodeDumper.dumpName(D);
1606   dumpDeclRef(D->getSuperClass(), "super");
1607   dumpDeclRef(D->getClassInterface());
1608   for (ObjCImplementationDecl::init_const_iterator I = D->init_begin(),
1609                                                    E = D->init_end();
1610        I != E; ++I)
1611     dumpCXXCtorInitializer(*I);
1612 }
1613 
1614 void ASTDumper::VisitObjCCompatibleAliasDecl(const ObjCCompatibleAliasDecl *D) {
1615   NodeDumper.dumpName(D);
1616   dumpDeclRef(D->getClassInterface());
1617 }
1618 
1619 void ASTDumper::VisitObjCPropertyDecl(const ObjCPropertyDecl *D) {
1620   NodeDumper.dumpName(D);
1621   NodeDumper.dumpType(D->getType());
1622 
1623   if (D->getPropertyImplementation() == ObjCPropertyDecl::Required)
1624     OS << " required";
1625   else if (D->getPropertyImplementation() == ObjCPropertyDecl::Optional)
1626     OS << " optional";
1627 
1628   ObjCPropertyDecl::PropertyAttributeKind Attrs = D->getPropertyAttributes();
1629   if (Attrs != ObjCPropertyDecl::OBJC_PR_noattr) {
1630     if (Attrs & ObjCPropertyDecl::OBJC_PR_readonly)
1631       OS << " readonly";
1632     if (Attrs & ObjCPropertyDecl::OBJC_PR_assign)
1633       OS << " assign";
1634     if (Attrs & ObjCPropertyDecl::OBJC_PR_readwrite)
1635       OS << " readwrite";
1636     if (Attrs & ObjCPropertyDecl::OBJC_PR_retain)
1637       OS << " retain";
1638     if (Attrs & ObjCPropertyDecl::OBJC_PR_copy)
1639       OS << " copy";
1640     if (Attrs & ObjCPropertyDecl::OBJC_PR_nonatomic)
1641       OS << " nonatomic";
1642     if (Attrs & ObjCPropertyDecl::OBJC_PR_atomic)
1643       OS << " atomic";
1644     if (Attrs & ObjCPropertyDecl::OBJC_PR_weak)
1645       OS << " weak";
1646     if (Attrs & ObjCPropertyDecl::OBJC_PR_strong)
1647       OS << " strong";
1648     if (Attrs & ObjCPropertyDecl::OBJC_PR_unsafe_unretained)
1649       OS << " unsafe_unretained";
1650     if (Attrs & ObjCPropertyDecl::OBJC_PR_class)
1651       OS << " class";
1652     if (Attrs & ObjCPropertyDecl::OBJC_PR_getter)
1653       dumpDeclRef(D->getGetterMethodDecl(), "getter");
1654     if (Attrs & ObjCPropertyDecl::OBJC_PR_setter)
1655       dumpDeclRef(D->getSetterMethodDecl(), "setter");
1656   }
1657 }
1658 
1659 void ASTDumper::VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D) {
1660   NodeDumper.dumpName(D->getPropertyDecl());
1661   if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize)
1662     OS << " synthesize";
1663   else
1664     OS << " dynamic";
1665   dumpDeclRef(D->getPropertyDecl());
1666   dumpDeclRef(D->getPropertyIvarDecl());
1667 }
1668 
1669 void ASTDumper::VisitBlockDecl(const BlockDecl *D) {
1670   for (auto I : D->parameters())
1671     dumpDecl(I);
1672 
1673   if (D->isVariadic())
1674     dumpChild([=]{ OS << "..."; });
1675 
1676   if (D->capturesCXXThis())
1677     dumpChild([=]{ OS << "capture this"; });
1678 
1679   for (const auto &I : D->captures()) {
1680     dumpChild([=] {
1681       OS << "capture";
1682       if (I.isByRef())
1683         OS << " byref";
1684       if (I.isNested())
1685         OS << " nested";
1686       if (I.getVariable()) {
1687         OS << ' ';
1688         NodeDumper.dumpBareDeclRef(I.getVariable());
1689       }
1690       if (I.hasCopyExpr())
1691         dumpStmt(I.getCopyExpr());
1692     });
1693   }
1694   dumpStmt(D->getBody());
1695 }
1696 
1697 //===----------------------------------------------------------------------===//
1698 //  Stmt dumping methods.
1699 //===----------------------------------------------------------------------===//
1700 
1701 void ASTDumper::dumpStmt(const Stmt *S) {
1702   dumpChild([=] {
1703     if (!S) {
1704       ColorScope Color(OS, ShowColors, NullColor);
1705       OS << "<<<NULL>>>";
1706       return;
1707     }
1708     {
1709       ColorScope Color(OS, ShowColors, StmtColor);
1710       OS << S->getStmtClassName();
1711     }
1712     NodeDumper.dumpPointer(S);
1713     NodeDumper.dumpSourceRange(S->getSourceRange());
1714 
1715     if (const auto *E = dyn_cast<Expr>(S)) {
1716       NodeDumper.dumpType(E->getType());
1717 
1718       {
1719         ColorScope Color(OS, ShowColors, ValueKindColor);
1720         switch (E->getValueKind()) {
1721         case VK_RValue:
1722           break;
1723         case VK_LValue:
1724           OS << " lvalue";
1725           break;
1726         case VK_XValue:
1727           OS << " xvalue";
1728           break;
1729         }
1730       }
1731 
1732       {
1733         ColorScope Color(OS, ShowColors, ObjectKindColor);
1734         switch (E->getObjectKind()) {
1735         case OK_Ordinary:
1736           break;
1737         case OK_BitField:
1738           OS << " bitfield";
1739           break;
1740         case OK_ObjCProperty:
1741           OS << " objcproperty";
1742           break;
1743         case OK_ObjCSubscript:
1744           OS << " objcsubscript";
1745           break;
1746         case OK_VectorComponent:
1747           OS << " vectorcomponent";
1748           break;
1749         }
1750       }
1751     }
1752 
1753     ConstStmtVisitor<ASTDumper>::Visit(S);
1754 
1755     // Some statements have custom mechanisms for dumping their children.
1756     if (isa<DeclStmt>(S) || isa<GenericSelectionExpr>(S)) {
1757       return;
1758     }
1759 
1760     for (const Stmt *SubStmt : S->children())
1761       dumpStmt(SubStmt);
1762   });
1763 }
1764 
1765 void ASTDumper::VisitDeclStmt(const DeclStmt *Node) {
1766   for (DeclStmt::const_decl_iterator I = Node->decl_begin(),
1767                                      E = Node->decl_end();
1768        I != E; ++I)
1769     dumpDecl(*I);
1770 }
1771 
1772 void ASTDumper::VisitAttributedStmt(const AttributedStmt *Node) {
1773   for (ArrayRef<const Attr *>::iterator I = Node->getAttrs().begin(),
1774                                         E = Node->getAttrs().end();
1775        I != E; ++I)
1776     dumpAttr(*I);
1777 }
1778 
1779 void ASTDumper::VisitIfStmt(const IfStmt *Node) {
1780   if (Node->hasInitStorage())
1781     OS << " has_init";
1782   if (Node->hasVarStorage())
1783     OS << " has_var";
1784   if (Node->hasElseStorage())
1785     OS << " has_else";
1786 }
1787 
1788 void ASTDumper::VisitSwitchStmt(const SwitchStmt *Node) {
1789   if (Node->hasInitStorage())
1790     OS << " has_init";
1791   if (Node->hasVarStorage())
1792     OS << " has_var";
1793 }
1794 
1795 void ASTDumper::VisitWhileStmt(const WhileStmt *Node) {
1796   if (Node->hasVarStorage())
1797     OS << " has_var";
1798 }
1799 
1800 void ASTDumper::VisitLabelStmt(const LabelStmt *Node) {
1801   OS << " '" << Node->getName() << "'";
1802 }
1803 
1804 void ASTDumper::VisitGotoStmt(const GotoStmt *Node) {
1805   OS << " '" << Node->getLabel()->getName() << "'";
1806   NodeDumper.dumpPointer(Node->getLabel());
1807 }
1808 
1809 void ASTDumper::VisitCXXCatchStmt(const CXXCatchStmt *Node) {
1810   dumpDecl(Node->getExceptionDecl());
1811 }
1812 
1813 void ASTDumper::VisitCaseStmt(const CaseStmt *Node) {
1814   if (Node->caseStmtIsGNURange())
1815     OS << " gnu_range";
1816 }
1817 
1818 void ASTDumper::VisitCapturedStmt(const CapturedStmt *Node) {
1819   dumpDecl(Node->getCapturedDecl());
1820 }
1821 
1822 //===----------------------------------------------------------------------===//
1823 //  OpenMP dumping methods.
1824 //===----------------------------------------------------------------------===//
1825 
1826 void ASTDumper::VisitOMPExecutableDirective(
1827     const OMPExecutableDirective *Node) {
1828   for (auto *C : Node->clauses()) {
1829     dumpChild([=] {
1830       if (!C) {
1831         ColorScope Color(OS, ShowColors, NullColor);
1832         OS << "<<<NULL>>> OMPClause";
1833         return;
1834       }
1835       {
1836         ColorScope Color(OS, ShowColors, AttrColor);
1837         StringRef ClauseName(getOpenMPClauseName(C->getClauseKind()));
1838         OS << "OMP" << ClauseName.substr(/*Start=*/0, /*N=*/1).upper()
1839            << ClauseName.drop_front() << "Clause";
1840       }
1841       NodeDumper.dumpPointer(C);
1842       NodeDumper.dumpSourceRange(SourceRange(C->getBeginLoc(), C->getEndLoc()));
1843       if (C->isImplicit())
1844         OS << " <implicit>";
1845       for (auto *S : C->children())
1846         dumpStmt(S);
1847     });
1848   }
1849 }
1850 
1851 //===----------------------------------------------------------------------===//
1852 //  Expr dumping methods.
1853 //===----------------------------------------------------------------------===//
1854 
1855 static void dumpBasePath(raw_ostream &OS, const CastExpr *Node) {
1856   if (Node->path_empty())
1857     return;
1858 
1859   OS << " (";
1860   bool First = true;
1861   for (CastExpr::path_const_iterator I = Node->path_begin(),
1862                                      E = Node->path_end();
1863        I != E; ++I) {
1864     const CXXBaseSpecifier *Base = *I;
1865     if (!First)
1866       OS << " -> ";
1867 
1868     const CXXRecordDecl *RD =
1869     cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
1870 
1871     if (Base->isVirtual())
1872       OS << "virtual ";
1873     OS << RD->getName();
1874     First = false;
1875   }
1876 
1877   OS << ')';
1878 }
1879 
1880 void ASTDumper::VisitCallExpr(const CallExpr *Node) {
1881   if (Node->usesADL())
1882     OS << " adl";
1883 }
1884 
1885 void ASTDumper::VisitCastExpr(const CastExpr *Node) {
1886   OS << " <";
1887   {
1888     ColorScope Color(OS, ShowColors, CastColor);
1889     OS << Node->getCastKindName();
1890   }
1891   dumpBasePath(OS, Node);
1892   OS << ">";
1893 }
1894 
1895 void ASTDumper::VisitImplicitCastExpr(const ImplicitCastExpr *Node) {
1896   VisitCastExpr(Node);
1897   if (Node->isPartOfExplicitCast())
1898     OS << " part_of_explicit_cast";
1899 }
1900 
1901 void ASTDumper::VisitDeclRefExpr(const DeclRefExpr *Node) {
1902   OS << " ";
1903   NodeDumper.dumpBareDeclRef(Node->getDecl());
1904   if (Node->getDecl() != Node->getFoundDecl()) {
1905     OS << " (";
1906     NodeDumper.dumpBareDeclRef(Node->getFoundDecl());
1907     OS << ")";
1908   }
1909 }
1910 
1911 void ASTDumper::VisitUnresolvedLookupExpr(const UnresolvedLookupExpr *Node) {
1912   OS << " (";
1913   if (!Node->requiresADL())
1914     OS << "no ";
1915   OS << "ADL) = '" << Node->getName() << '\'';
1916 
1917   UnresolvedLookupExpr::decls_iterator
1918     I = Node->decls_begin(), E = Node->decls_end();
1919   if (I == E)
1920     OS << " empty";
1921   for (; I != E; ++I)
1922     NodeDumper.dumpPointer(*I);
1923 }
1924 
1925 void ASTDumper::VisitObjCIvarRefExpr(const ObjCIvarRefExpr *Node) {
1926   {
1927     ColorScope Color(OS, ShowColors, DeclKindNameColor);
1928     OS << " " << Node->getDecl()->getDeclKindName() << "Decl";
1929   }
1930   OS << "='" << *Node->getDecl() << "'";
1931   NodeDumper.dumpPointer(Node->getDecl());
1932   if (Node->isFreeIvar())
1933     OS << " isFreeIvar";
1934 }
1935 
1936 void ASTDumper::VisitPredefinedExpr(const PredefinedExpr *Node) {
1937   OS << " " << PredefinedExpr::getIdentKindName(Node->getIdentKind());
1938 }
1939 
1940 void ASTDumper::VisitCharacterLiteral(const CharacterLiteral *Node) {
1941   ColorScope Color(OS, ShowColors, ValueColor);
1942   OS << " " << Node->getValue();
1943 }
1944 
1945 void ASTDumper::VisitIntegerLiteral(const IntegerLiteral *Node) {
1946   bool isSigned = Node->getType()->isSignedIntegerType();
1947   ColorScope Color(OS, ShowColors, ValueColor);
1948   OS << " " << Node->getValue().toString(10, isSigned);
1949 }
1950 
1951 void ASTDumper::VisitFixedPointLiteral(const FixedPointLiteral *Node) {
1952   ColorScope Color(OS, ShowColors, ValueColor);
1953   OS << " " << Node->getValueAsString(/*Radix=*/10);
1954 }
1955 
1956 void ASTDumper::VisitFloatingLiteral(const FloatingLiteral *Node) {
1957   ColorScope Color(OS, ShowColors, ValueColor);
1958   OS << " " << Node->getValueAsApproximateDouble();
1959 }
1960 
1961 void ASTDumper::VisitStringLiteral(const StringLiteral *Str) {
1962   ColorScope Color(OS, ShowColors, ValueColor);
1963   OS << " ";
1964   Str->outputString(OS);
1965 }
1966 
1967 void ASTDumper::VisitInitListExpr(const InitListExpr *ILE) {
1968   if (auto *Field = ILE->getInitializedFieldInUnion()) {
1969     OS << " field ";
1970     NodeDumper.dumpBareDeclRef(Field);
1971   }
1972   if (auto *Filler = ILE->getArrayFiller()) {
1973     dumpChild([=] {
1974       OS << "array filler";
1975       dumpStmt(Filler);
1976     });
1977   }
1978 }
1979 
1980 void ASTDumper::VisitUnaryOperator(const UnaryOperator *Node) {
1981   OS << " " << (Node->isPostfix() ? "postfix" : "prefix")
1982      << " '" << UnaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
1983   if (!Node->canOverflow())
1984     OS << " cannot overflow";
1985 }
1986 
1987 void ASTDumper::VisitUnaryExprOrTypeTraitExpr(
1988     const UnaryExprOrTypeTraitExpr *Node) {
1989   switch(Node->getKind()) {
1990   case UETT_SizeOf:
1991     OS << " sizeof";
1992     break;
1993   case UETT_AlignOf:
1994     OS << " alignof";
1995     break;
1996   case UETT_VecStep:
1997     OS << " vec_step";
1998     break;
1999   case UETT_OpenMPRequiredSimdAlign:
2000     OS << " __builtin_omp_required_simd_align";
2001     break;
2002   case UETT_PreferredAlignOf:
2003     OS << " __alignof";
2004     break;
2005   }
2006   if (Node->isArgumentType())
2007     NodeDumper.dumpType(Node->getArgumentType());
2008 }
2009 
2010 void ASTDumper::VisitMemberExpr(const MemberExpr *Node) {
2011   OS << " " << (Node->isArrow() ? "->" : ".") << *Node->getMemberDecl();
2012   NodeDumper.dumpPointer(Node->getMemberDecl());
2013 }
2014 
2015 void ASTDumper::VisitExtVectorElementExpr(const ExtVectorElementExpr *Node) {
2016   OS << " " << Node->getAccessor().getNameStart();
2017 }
2018 
2019 void ASTDumper::VisitBinaryOperator(const BinaryOperator *Node) {
2020   OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
2021 }
2022 
2023 void ASTDumper::VisitCompoundAssignOperator(
2024     const CompoundAssignOperator *Node) {
2025   OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode())
2026      << "' ComputeLHSTy=";
2027   NodeDumper.dumpBareType(Node->getComputationLHSType());
2028   OS << " ComputeResultTy=";
2029   NodeDumper.dumpBareType(Node->getComputationResultType());
2030 }
2031 
2032 void ASTDumper::VisitBlockExpr(const BlockExpr *Node) {
2033   dumpDecl(Node->getBlockDecl());
2034 }
2035 
2036 void ASTDumper::VisitOpaqueValueExpr(const OpaqueValueExpr *Node) {
2037   if (Expr *Source = Node->getSourceExpr())
2038     dumpStmt(Source);
2039 }
2040 
2041 void ASTDumper::VisitGenericSelectionExpr(const GenericSelectionExpr *E) {
2042   if (E->isResultDependent())
2043     OS << " result_dependent";
2044   dumpStmt(E->getControllingExpr());
2045   dumpTypeAsChild(E->getControllingExpr()->getType()); // FIXME: remove
2046 
2047   for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {
2048     dumpChild([=] {
2049       if (const TypeSourceInfo *TSI = E->getAssocTypeSourceInfo(I)) {
2050         OS << "case ";
2051         NodeDumper.dumpType(TSI->getType());
2052       } else {
2053         OS << "default";
2054       }
2055 
2056       if (!E->isResultDependent() && E->getResultIndex() == I)
2057         OS << " selected";
2058 
2059       if (const TypeSourceInfo *TSI = E->getAssocTypeSourceInfo(I))
2060         dumpTypeAsChild(TSI->getType());
2061       dumpStmt(E->getAssocExpr(I));
2062     });
2063   }
2064 }
2065 
2066 // GNU extensions.
2067 
2068 void ASTDumper::VisitAddrLabelExpr(const AddrLabelExpr *Node) {
2069   OS << " " << Node->getLabel()->getName();
2070   NodeDumper.dumpPointer(Node->getLabel());
2071 }
2072 
2073 //===----------------------------------------------------------------------===//
2074 // C++ Expressions
2075 //===----------------------------------------------------------------------===//
2076 
2077 void ASTDumper::VisitCXXNamedCastExpr(const CXXNamedCastExpr *Node) {
2078   OS << " " << Node->getCastName()
2079      << "<" << Node->getTypeAsWritten().getAsString() << ">"
2080      << " <" << Node->getCastKindName();
2081   dumpBasePath(OS, Node);
2082   OS << ">";
2083 }
2084 
2085 void ASTDumper::VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *Node) {
2086   OS << " " << (Node->getValue() ? "true" : "false");
2087 }
2088 
2089 void ASTDumper::VisitCXXThisExpr(const CXXThisExpr *Node) {
2090   OS << " this";
2091 }
2092 
2093 void ASTDumper::VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *Node) {
2094   OS << " functional cast to " << Node->getTypeAsWritten().getAsString()
2095      << " <" << Node->getCastKindName() << ">";
2096 }
2097 
2098 void ASTDumper::VisitCXXUnresolvedConstructExpr(
2099     const CXXUnresolvedConstructExpr *Node) {
2100   NodeDumper.dumpType(Node->getTypeAsWritten());
2101   if (Node->isListInitialization())
2102     OS << " list";
2103 }
2104 
2105 void ASTDumper::VisitCXXConstructExpr(const CXXConstructExpr *Node) {
2106   CXXConstructorDecl *Ctor = Node->getConstructor();
2107   NodeDumper.dumpType(Ctor->getType());
2108   if (Node->isElidable())
2109     OS << " elidable";
2110   if (Node->isListInitialization())
2111     OS << " list";
2112   if (Node->isStdInitListInitialization())
2113     OS << " std::initializer_list";
2114   if (Node->requiresZeroInitialization())
2115     OS << " zeroing";
2116 }
2117 
2118 void ASTDumper::VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *Node) {
2119   OS << " ";
2120   NodeDumper.dumpCXXTemporary(Node->getTemporary());
2121 }
2122 
2123 void ASTDumper::VisitCXXNewExpr(const CXXNewExpr *Node) {
2124   if (Node->isGlobalNew())
2125     OS << " global";
2126   if (Node->isArray())
2127     OS << " array";
2128   if (Node->getOperatorNew()) {
2129     OS << ' ';
2130     NodeDumper.dumpBareDeclRef(Node->getOperatorNew());
2131   }
2132   // We could dump the deallocation function used in case of error, but it's
2133   // usually not that interesting.
2134 }
2135 
2136 void ASTDumper::VisitCXXDeleteExpr(const CXXDeleteExpr *Node) {
2137   if (Node->isGlobalDelete())
2138     OS << " global";
2139   if (Node->isArrayForm())
2140     OS << " array";
2141   if (Node->getOperatorDelete()) {
2142     OS << ' ';
2143     NodeDumper.dumpBareDeclRef(Node->getOperatorDelete());
2144   }
2145 }
2146 
2147 void
2148 ASTDumper::VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *Node) {
2149   if (const ValueDecl *VD = Node->getExtendingDecl()) {
2150     OS << " extended by ";
2151     NodeDumper.dumpBareDeclRef(VD);
2152   }
2153 }
2154 
2155 void ASTDumper::VisitExprWithCleanups(const ExprWithCleanups *Node) {
2156   for (unsigned i = 0, e = Node->getNumObjects(); i != e; ++i)
2157     dumpDeclRef(Node->getObject(i), "cleanup");
2158 }
2159 
2160 void ASTDumper::VisitSizeOfPackExpr(const SizeOfPackExpr *Node) {
2161   NodeDumper.dumpPointer(Node->getPack());
2162   NodeDumper.dumpName(Node->getPack());
2163   if (Node->isPartiallySubstituted())
2164     for (const auto &A : Node->getPartialArguments())
2165       dumpTemplateArgument(A);
2166 }
2167 
2168 void ASTDumper::VisitCXXDependentScopeMemberExpr(
2169     const CXXDependentScopeMemberExpr *Node) {
2170   OS << " " << (Node->isArrow() ? "->" : ".") << Node->getMember();
2171 }
2172 
2173 //===----------------------------------------------------------------------===//
2174 // Obj-C Expressions
2175 //===----------------------------------------------------------------------===//
2176 
2177 void ASTDumper::VisitObjCMessageExpr(const ObjCMessageExpr *Node) {
2178   OS << " selector=";
2179   Node->getSelector().print(OS);
2180   switch (Node->getReceiverKind()) {
2181   case ObjCMessageExpr::Instance:
2182     break;
2183 
2184   case ObjCMessageExpr::Class:
2185     OS << " class=";
2186     NodeDumper.dumpBareType(Node->getClassReceiver());
2187     break;
2188 
2189   case ObjCMessageExpr::SuperInstance:
2190     OS << " super (instance)";
2191     break;
2192 
2193   case ObjCMessageExpr::SuperClass:
2194     OS << " super (class)";
2195     break;
2196   }
2197 }
2198 
2199 void ASTDumper::VisitObjCBoxedExpr(const ObjCBoxedExpr *Node) {
2200   if (auto *BoxingMethod = Node->getBoxingMethod()) {
2201     OS << " selector=";
2202     BoxingMethod->getSelector().print(OS);
2203   }
2204 }
2205 
2206 void ASTDumper::VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node) {
2207   if (const VarDecl *CatchParam = Node->getCatchParamDecl())
2208     dumpDecl(CatchParam);
2209   else
2210     OS << " catch all";
2211 }
2212 
2213 void ASTDumper::VisitObjCEncodeExpr(const ObjCEncodeExpr *Node) {
2214   NodeDumper.dumpType(Node->getEncodedType());
2215 }
2216 
2217 void ASTDumper::VisitObjCSelectorExpr(const ObjCSelectorExpr *Node) {
2218   OS << " ";
2219   Node->getSelector().print(OS);
2220 }
2221 
2222 void ASTDumper::VisitObjCProtocolExpr(const ObjCProtocolExpr *Node) {
2223   OS << ' ' << *Node->getProtocol();
2224 }
2225 
2226 void ASTDumper::VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *Node) {
2227   if (Node->isImplicitProperty()) {
2228     OS << " Kind=MethodRef Getter=\"";
2229     if (Node->getImplicitPropertyGetter())
2230       Node->getImplicitPropertyGetter()->getSelector().print(OS);
2231     else
2232       OS << "(null)";
2233 
2234     OS << "\" Setter=\"";
2235     if (ObjCMethodDecl *Setter = Node->getImplicitPropertySetter())
2236       Setter->getSelector().print(OS);
2237     else
2238       OS << "(null)";
2239     OS << "\"";
2240   } else {
2241     OS << " Kind=PropertyRef Property=\"" << *Node->getExplicitProperty() <<'"';
2242   }
2243 
2244   if (Node->isSuperReceiver())
2245     OS << " super";
2246 
2247   OS << " Messaging=";
2248   if (Node->isMessagingGetter() && Node->isMessagingSetter())
2249     OS << "Getter&Setter";
2250   else if (Node->isMessagingGetter())
2251     OS << "Getter";
2252   else if (Node->isMessagingSetter())
2253     OS << "Setter";
2254 }
2255 
2256 void ASTDumper::VisitObjCSubscriptRefExpr(const ObjCSubscriptRefExpr *Node) {
2257   if (Node->isArraySubscriptRefExpr())
2258     OS << " Kind=ArraySubscript GetterForArray=\"";
2259   else
2260     OS << " Kind=DictionarySubscript GetterForDictionary=\"";
2261   if (Node->getAtIndexMethodDecl())
2262     Node->getAtIndexMethodDecl()->getSelector().print(OS);
2263   else
2264     OS << "(null)";
2265 
2266   if (Node->isArraySubscriptRefExpr())
2267     OS << "\" SetterForArray=\"";
2268   else
2269     OS << "\" SetterForDictionary=\"";
2270   if (Node->setAtIndexMethodDecl())
2271     Node->setAtIndexMethodDecl()->getSelector().print(OS);
2272   else
2273     OS << "(null)";
2274 }
2275 
2276 void ASTDumper::VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *Node) {
2277   OS << " " << (Node->getValue() ? "__objc_yes" : "__objc_no");
2278 }
2279 
2280 //===----------------------------------------------------------------------===//
2281 // Comments
2282 //===----------------------------------------------------------------------===//
2283 
2284 void ASTDumper::dumpComment(const Comment *C, const FullComment *FC) {
2285   dumpChild([=] {
2286     NodeDumper.Visit(C, FC);
2287     if (!C) {
2288       return;
2289     }
2290     ConstCommentVisitor<ASTDumper, void, const FullComment *>::visit(C, FC);
2291     for (Comment::child_iterator I = C->child_begin(), E = C->child_end();
2292          I != E; ++I)
2293       dumpComment(*I, FC);
2294   });
2295 }
2296 
2297 //===----------------------------------------------------------------------===//
2298 // Type method implementations
2299 //===----------------------------------------------------------------------===//
2300 
2301 void QualType::dump(const char *msg) const {
2302   if (msg)
2303     llvm::errs() << msg << ": ";
2304   dump();
2305 }
2306 
2307 LLVM_DUMP_METHOD void QualType::dump() const { dump(llvm::errs()); }
2308 
2309 LLVM_DUMP_METHOD void QualType::dump(llvm::raw_ostream &OS) const {
2310   ASTDumper Dumper(OS, nullptr, nullptr);
2311   Dumper.dumpTypeAsChild(*this);
2312 }
2313 
2314 LLVM_DUMP_METHOD void Type::dump() const { dump(llvm::errs()); }
2315 
2316 LLVM_DUMP_METHOD void Type::dump(llvm::raw_ostream &OS) const {
2317   QualType(this, 0).dump(OS);
2318 }
2319 
2320 //===----------------------------------------------------------------------===//
2321 // Decl method implementations
2322 //===----------------------------------------------------------------------===//
2323 
2324 LLVM_DUMP_METHOD void Decl::dump() const { dump(llvm::errs()); }
2325 
2326 LLVM_DUMP_METHOD void Decl::dump(raw_ostream &OS, bool Deserialize) const {
2327   const ASTContext &Ctx = getASTContext();
2328   const SourceManager &SM = Ctx.getSourceManager();
2329   ASTDumper P(OS, &Ctx.getCommentCommandTraits(), &SM,
2330               SM.getDiagnostics().getShowColors(), Ctx.getPrintingPolicy());
2331   P.setDeserialize(Deserialize);
2332   P.dumpDecl(this);
2333 }
2334 
2335 LLVM_DUMP_METHOD void Decl::dumpColor() const {
2336   const ASTContext &Ctx = getASTContext();
2337   ASTDumper P(llvm::errs(), &Ctx.getCommentCommandTraits(),
2338               &Ctx.getSourceManager(), /*ShowColors*/ true,
2339               Ctx.getPrintingPolicy());
2340   P.dumpDecl(this);
2341 }
2342 
2343 LLVM_DUMP_METHOD void DeclContext::dumpLookups() const {
2344   dumpLookups(llvm::errs());
2345 }
2346 
2347 LLVM_DUMP_METHOD void DeclContext::dumpLookups(raw_ostream &OS,
2348                                                bool DumpDecls,
2349                                                bool Deserialize) const {
2350   const DeclContext *DC = this;
2351   while (!DC->isTranslationUnit())
2352     DC = DC->getParent();
2353   ASTContext &Ctx = cast<TranslationUnitDecl>(DC)->getASTContext();
2354   const SourceManager &SM = Ctx.getSourceManager();
2355   ASTDumper P(OS, &Ctx.getCommentCommandTraits(), &Ctx.getSourceManager(),
2356               SM.getDiagnostics().getShowColors(), Ctx.getPrintingPolicy());
2357   P.setDeserialize(Deserialize);
2358   P.dumpLookups(this, DumpDecls);
2359 }
2360 
2361 //===----------------------------------------------------------------------===//
2362 // Stmt method implementations
2363 //===----------------------------------------------------------------------===//
2364 
2365 LLVM_DUMP_METHOD void Stmt::dump(SourceManager &SM) const {
2366   dump(llvm::errs(), SM);
2367 }
2368 
2369 LLVM_DUMP_METHOD void Stmt::dump(raw_ostream &OS, SourceManager &SM) const {
2370   ASTDumper P(OS, nullptr, &SM);
2371   P.dumpStmt(this);
2372 }
2373 
2374 LLVM_DUMP_METHOD void Stmt::dump(raw_ostream &OS) const {
2375   ASTDumper P(OS, nullptr, nullptr);
2376   P.dumpStmt(this);
2377 }
2378 
2379 LLVM_DUMP_METHOD void Stmt::dump() const {
2380   ASTDumper P(llvm::errs(), nullptr, nullptr);
2381   P.dumpStmt(this);
2382 }
2383 
2384 LLVM_DUMP_METHOD void Stmt::dumpColor() const {
2385   ASTDumper P(llvm::errs(), nullptr, nullptr, /*ShowColors*/true);
2386   P.dumpStmt(this);
2387 }
2388 
2389 //===----------------------------------------------------------------------===//
2390 // Comment method implementations
2391 //===----------------------------------------------------------------------===//
2392 
2393 LLVM_DUMP_METHOD void Comment::dump() const {
2394   dump(llvm::errs(), nullptr, nullptr);
2395 }
2396 
2397 LLVM_DUMP_METHOD void Comment::dump(const ASTContext &Context) const {
2398   dump(llvm::errs(), &Context.getCommentCommandTraits(),
2399        &Context.getSourceManager());
2400 }
2401 
2402 void Comment::dump(raw_ostream &OS, const CommandTraits *Traits,
2403                    const SourceManager *SM) const {
2404   const FullComment *FC = dyn_cast<FullComment>(this);
2405   if (!FC)
2406     return;
2407   ASTDumper D(OS, Traits, SM);
2408   D.dumpComment(FC, FC);
2409 }
2410 
2411 LLVM_DUMP_METHOD void Comment::dumpColor() const {
2412   const FullComment *FC = dyn_cast<FullComment>(this);
2413   if (!FC)
2414     return;
2415   ASTDumper D(llvm::errs(), nullptr, nullptr, /*ShowColors*/true);
2416   D.dumpComment(FC, FC);
2417 }
2418