contrib/llvm/tools/clang/lib/AST/ASTDumper.cpp

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