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