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