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