Home | History | Annotate | Download | only in AST 
      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/DeclObjC.h"
     20 #include "clang/AST/DeclVisitor.h"
     21 #include "clang/AST/StmtVisitor.h"
     22 #include "clang/Basic/Module.h"
     23 #include "clang/Basic/SourceManager.h"
     24 #include "llvm/Support/raw_ostream.h"
     25 using namespace clang;
     26 using namespace clang::comments;
     27 
     28 //===----------------------------------------------------------------------===//
     29 // ASTDumper Visitor
     30 //===----------------------------------------------------------------------===//
     31 
     32 namespace  {
     33   // Colors used for various parts of the AST dump
     34 
     35   struct TerminalColor {
     36     raw_ostream::Colors Color;
     37     bool Bold;
     38   };
     39 
     40   // Decl kind names (VarDecl, FunctionDecl, etc)
     41   static const TerminalColor DeclKindNameColor = { raw_ostream::GREEN, true };
     42   // Attr names (CleanupAttr, GuardedByAttr, etc)
     43   static const TerminalColor AttrColor = { raw_ostream::BLUE, true };
     44   // Statement names (DeclStmt, ImplicitCastExpr, etc)
     45   static const TerminalColor StmtColor = { raw_ostream::MAGENTA, true };
     46   // Comment names (FullComment, ParagraphComment, TextComment, etc)
     47   static const TerminalColor CommentColor = { raw_ostream::YELLOW, true };
     48 
     49   // Type names (int, float, etc, plus user defined types)
     50   static const TerminalColor TypeColor = { raw_ostream::GREEN, false };
     51 
     52   // Pointer address
     53   static const TerminalColor AddressColor = { raw_ostream::YELLOW, false };
     54   // Source locations
     55   static const TerminalColor LocationColor = { raw_ostream::YELLOW, false };
     56 
     57   // lvalue/xvalue
     58   static const TerminalColor ValueKindColor = { raw_ostream::CYAN, false };
     59   // bitfield/objcproperty/objcsubscript/vectorcomponent
     60   static const TerminalColor ObjectKindColor = { raw_ostream::CYAN, false };
     61 
     62   // Null statements
     63   static const TerminalColor NullColor = { raw_ostream::BLUE, false };
     64 
     65   // CastKind from CastExpr's
     66   static const TerminalColor CastColor = { raw_ostream::RED, false };
     67 
     68   // Value of the statement
     69   static const TerminalColor ValueColor = { raw_ostream::CYAN, true };
     70   // Decl names
     71   static const TerminalColor DeclNameColor = { raw_ostream::CYAN, true };
     72 
     73   // Indents ( `, -. | )
     74   static const TerminalColor IndentColor = { raw_ostream::BLUE, false };
     75 
     76   class ASTDumper
     77       : public ConstDeclVisitor<ASTDumper>, public ConstStmtVisitor<ASTDumper>,
     78         public ConstCommentVisitor<ASTDumper> {
     79     raw_ostream &OS;
     80     const CommandTraits *Traits;
     81     const SourceManager *SM;
     82     bool IsFirstLine;
     83 
     84     // Indicates whether more child are expected at the current tree depth
     85     enum IndentType { IT_Child, IT_LastChild };
     86 
     87     /// Indents[i] indicates if another child exists at level i.
     88     /// Used by Indent() to print the tree structure.
     89     llvm::SmallVector<IndentType, 32> Indents;
     90 
     91     /// Indicates that more children will be needed at this indent level.
     92     /// If true, prevents lastChild() from marking the node as the last child.
     93     /// This is used when there are multiple collections of children to be
     94     /// dumped as well as during conditional node dumping.
     95     bool MoreChildren;
     96 
     97     /// Keep track of the last location we print out so that we can
     98     /// print out deltas from then on out.
     99     const char *LastLocFilename;
    100     unsigned LastLocLine;
    101 
    102     /// The \c FullComment parent of the comment being dumped.
    103     const FullComment *FC;
    104 
    105     bool ShowColors;
    106 
    107     class IndentScope {
    108       ASTDumper &Dumper;
    109       // Preserve the Dumper's MoreChildren value from the previous IndentScope
    110       bool MoreChildren;
    111     public:
    112       IndentScope(ASTDumper &Dumper) : Dumper(Dumper) {
    113         MoreChildren = Dumper.hasMoreChildren();
    114         Dumper.setMoreChildren(false);
    115         Dumper.indent();
    116       }
    117       ~IndentScope() {
    118         Dumper.setMoreChildren(MoreChildren);
    119         Dumper.unindent();
    120       }
    121     };
    122 
    123     class ColorScope {
    124       ASTDumper &Dumper;
    125     public:
    126       ColorScope(ASTDumper &Dumper, TerminalColor Color)
    127         : Dumper(Dumper) {
    128         if (Dumper.ShowColors)
    129           Dumper.OS.changeColor(Color.Color, Color.Bold);
    130       }
    131       ~ColorScope() {
    132         if (Dumper.ShowColors)
    133           Dumper.OS.resetColor();
    134       }
    135     };
    136 
    137   public:
    138     ASTDumper(raw_ostream &OS, const CommandTraits *Traits,
    139               const SourceManager *SM)
    140       : OS(OS), Traits(Traits), SM(SM), IsFirstLine(true), MoreChildren(false),
    141         LastLocFilename(""), LastLocLine(~0U), FC(0),
    142         ShowColors(SM && SM->getDiagnostics().getShowColors()) { }
    143 
    144     ASTDumper(raw_ostream &OS, const CommandTraits *Traits,
    145               const SourceManager *SM, bool ShowColors)
    146       : OS(OS), Traits(Traits), SM(SM), IsFirstLine(true), MoreChildren(false),
    147         LastLocFilename(""), LastLocLine(~0U),
    148         ShowColors(ShowColors) { }
    149 
    150     ~ASTDumper() {
    151       OS << "\n";
    152     }
    153 
    154     void dumpDecl(const Decl *D);
    155     void dumpStmt(const Stmt *S);
    156     void dumpFullComment(const FullComment *C);
    157 
    158     // Formatting
    159     void indent();
    160     void unindent();
    161     void lastChild();
    162     bool hasMoreChildren();
    163     void setMoreChildren(bool Value);
    164 
    165     // Utilities
    166     void dumpPointer(const void *Ptr);
    167     void dumpSourceRange(SourceRange R);
    168     void dumpLocation(SourceLocation Loc);
    169     void dumpBareType(QualType T);
    170     void dumpType(QualType T);
    171     void dumpBareDeclRef(const Decl *Node);
    172     void dumpDeclRef(const Decl *Node, const char *Label = 0);
    173     void dumpName(const NamedDecl *D);
    174     bool hasNodes(const DeclContext *DC);
    175     void dumpDeclContext(const DeclContext *DC);
    176     void dumpAttr(const Attr *A);
    177 
    178     // C++ Utilities
    179     void dumpAccessSpecifier(AccessSpecifier AS);
    180     void dumpCXXCtorInitializer(const CXXCtorInitializer *Init);
    181     void dumpTemplateParameters(const TemplateParameterList *TPL);
    182     void dumpTemplateArgumentListInfo(const TemplateArgumentListInfo &TALI);
    183     void dumpTemplateArgumentLoc(const TemplateArgumentLoc &A);
    184     void dumpTemplateArgumentList(const TemplateArgumentList &TAL);
    185     void dumpTemplateArgument(const TemplateArgument &A,
    186                               SourceRange R = SourceRange());
    187 
    188     // Decls
    189     void VisitLabelDecl(const LabelDecl *D);
    190     void VisitTypedefDecl(const TypedefDecl *D);
    191     void VisitEnumDecl(const EnumDecl *D);
    192     void VisitRecordDecl(const RecordDecl *D);
    193     void VisitEnumConstantDecl(const EnumConstantDecl *D);
    194     void VisitIndirectFieldDecl(const IndirectFieldDecl *D);
    195     void VisitFunctionDecl(const FunctionDecl *D);
    196     void VisitFieldDecl(const FieldDecl *D);
    197     void VisitVarDecl(const VarDecl *D);
    198     void VisitFileScopeAsmDecl(const FileScopeAsmDecl *D);
    199     void VisitImportDecl(const ImportDecl *D);
    200 
    201     // C++ Decls
    202     void VisitNamespaceDecl(const NamespaceDecl *D);
    203     void VisitUsingDirectiveDecl(const UsingDirectiveDecl *D);
    204     void VisitNamespaceAliasDecl(const NamespaceAliasDecl *D);
    205     void VisitTypeAliasDecl(const TypeAliasDecl *D);
    206     void VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D);
    207     void VisitCXXRecordDecl(const CXXRecordDecl *D);
    208     void VisitStaticAssertDecl(const StaticAssertDecl *D);
    209     void VisitFunctionTemplateDecl(const FunctionTemplateDecl *D);
    210     void VisitClassTemplateDecl(const ClassTemplateDecl *D);
    211     void VisitClassTemplateSpecializationDecl(
    212         const ClassTemplateSpecializationDecl *D);
    213     void VisitClassTemplatePartialSpecializationDecl(
    214         const ClassTemplatePartialSpecializationDecl *D);
    215     void VisitClassScopeFunctionSpecializationDecl(
    216         const ClassScopeFunctionSpecializationDecl *D);
    217     void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D);
    218     void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D);
    219     void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D);
    220     void VisitUsingDecl(const UsingDecl *D);
    221     void VisitUnresolvedUsingTypenameDecl(const UnresolvedUsingTypenameDecl *D);
    222     void VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl *D);
    223     void VisitUsingShadowDecl(const UsingShadowDecl *D);
    224     void VisitLinkageSpecDecl(const LinkageSpecDecl *D);
    225     void VisitAccessSpecDecl(const AccessSpecDecl *D);
    226     void VisitFriendDecl(const FriendDecl *D);
    227 
    228     // ObjC Decls
    229     void VisitObjCIvarDecl(const ObjCIvarDecl *D);
    230     void VisitObjCMethodDecl(const ObjCMethodDecl *D);
    231     void VisitObjCCategoryDecl(const ObjCCategoryDecl *D);
    232     void VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D);
    233     void VisitObjCProtocolDecl(const ObjCProtocolDecl *D);
    234     void VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D);
    235     void VisitObjCImplementationDecl(const ObjCImplementationDecl *D);
    236     void VisitObjCCompatibleAliasDecl(const ObjCCompatibleAliasDecl *D);
    237     void VisitObjCPropertyDecl(const ObjCPropertyDecl *D);
    238     void VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D);
    239     void VisitBlockDecl(const BlockDecl *D);
    240 
    241     // Stmts.
    242     void VisitStmt(const Stmt *Node);
    243     void VisitDeclStmt(const DeclStmt *Node);
    244     void VisitAttributedStmt(const AttributedStmt *Node);
    245     void VisitLabelStmt(const LabelStmt *Node);
    246     void VisitGotoStmt(const GotoStmt *Node);
    247 
    248     // Exprs
    249     void VisitExpr(const Expr *Node);
    250     void VisitCastExpr(const CastExpr *Node);
    251     void VisitDeclRefExpr(const DeclRefExpr *Node);
    252     void VisitPredefinedExpr(const PredefinedExpr *Node);
    253     void VisitCharacterLiteral(const CharacterLiteral *Node);
    254     void VisitIntegerLiteral(const IntegerLiteral *Node);
    255     void VisitFloatingLiteral(const FloatingLiteral *Node);
    256     void VisitStringLiteral(const StringLiteral *Str);
    257     void VisitUnaryOperator(const UnaryOperator *Node);
    258     void VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *Node);
    259     void VisitMemberExpr(const MemberExpr *Node);
    260     void VisitExtVectorElementExpr(const ExtVectorElementExpr *Node);
    261     void VisitBinaryOperator(const BinaryOperator *Node);
    262     void VisitCompoundAssignOperator(const CompoundAssignOperator *Node);
    263     void VisitAddrLabelExpr(const AddrLabelExpr *Node);
    264     void VisitBlockExpr(const BlockExpr *Node);
    265     void VisitOpaqueValueExpr(const OpaqueValueExpr *Node);
    266 
    267     // C++
    268     void VisitCXXNamedCastExpr(const CXXNamedCastExpr *Node);
    269     void VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *Node);
    270     void VisitCXXThisExpr(const CXXThisExpr *Node);
    271     void VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *Node);
    272     void VisitCXXConstructExpr(const CXXConstructExpr *Node);
    273     void VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *Node);
    274     void VisitExprWithCleanups(const ExprWithCleanups *Node);
    275     void VisitUnresolvedLookupExpr(const UnresolvedLookupExpr *Node);
    276     void dumpCXXTemporary(const CXXTemporary *Temporary);
    277 
    278     // ObjC
    279     void VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node);
    280     void VisitObjCEncodeExpr(const ObjCEncodeExpr *Node);
    281     void VisitObjCMessageExpr(const ObjCMessageExpr *Node);
    282     void VisitObjCBoxedExpr(const ObjCBoxedExpr *Node);
    283     void VisitObjCSelectorExpr(const ObjCSelectorExpr *Node);
    284     void VisitObjCProtocolExpr(const ObjCProtocolExpr *Node);
    285     void VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *Node);
    286     void VisitObjCSubscriptRefExpr(const ObjCSubscriptRefExpr *Node);
    287     void VisitObjCIvarRefExpr(const ObjCIvarRefExpr *Node);
    288     void VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *Node);
    289 
    290     // Comments.
    291     const char *getCommandName(unsigned CommandID);
    292     void dumpComment(const Comment *C);
    293 
    294     // Inline comments.
    295     void visitTextComment(const TextComment *C);
    296     void visitInlineCommandComment(const InlineCommandComment *C);
    297     void visitHTMLStartTagComment(const HTMLStartTagComment *C);
    298     void visitHTMLEndTagComment(const HTMLEndTagComment *C);
    299 
    300     // Block comments.
    301     void visitBlockCommandComment(const BlockCommandComment *C);
    302     void visitParamCommandComment(const ParamCommandComment *C);
    303     void visitTParamCommandComment(const TParamCommandComment *C);
    304     void visitVerbatimBlockComment(const VerbatimBlockComment *C);
    305     void visitVerbatimBlockLineComment(const VerbatimBlockLineComment *C);
    306     void visitVerbatimLineComment(const VerbatimLineComment *C);
    307   };
    308 }
    309 
    310 //===----------------------------------------------------------------------===//
    311 //  Utilities
    312 //===----------------------------------------------------------------------===//
    313 
    314 // Print out the appropriate tree structure using the Indents vector.
    315 // Example of tree and the Indents vector at each level.
    316 // A        { }
    317 // |-B      { IT_Child }
    318 // | `-C    { IT_Child,     IT_LastChild }
    319 // `-D      { IT_LastChild }
    320 //   |-E    { IT_LastChild, IT_Child }
    321 //   `-F    { IT_LastChild, IT_LastChild }
    322 // Type            non-last element, last element
    323 // IT_Child        "| "              "|-"
    324 // IT_LastChild    "  "              "`-"
    325 void ASTDumper::indent() {
    326   if (IsFirstLine)
    327     IsFirstLine = false;
    328   else
    329     OS << "\n";
    330 
    331   ColorScope Color(*this, IndentColor);
    332   for (llvm::SmallVector<IndentType, 32>::const_iterator I = Indents.begin(),
    333                                                          E = Indents.end();
    334        I != E; ++I) {
    335     switch (*I) {
    336     case IT_Child:
    337       if (I == E - 1)
    338         OS << "|-";
    339       else
    340         OS << "| ";
    341       continue;
    342     case IT_LastChild:
    343       if (I == E - 1)
    344         OS << "`-";
    345       else
    346         OS << "  ";
    347       continue;
    348     }
    349     llvm_unreachable("Invalid IndentType");
    350   }
    351   Indents.push_back(IT_Child);
    352 }
    353 
    354 void ASTDumper::unindent() {
    355   Indents.pop_back();
    356 }
    357 
    358 // Call before each potential last child node is to be dumped.  If MoreChildren
    359 // is false, then this is the last child, otherwise treat as a regular node.
    360 void ASTDumper::lastChild() {
    361   if (!hasMoreChildren())
    362     Indents.back() = IT_LastChild;
    363 }
    364 
    365 // MoreChildren should be set before calling another function that may print
    366 // additional nodes to prevent conflicting final child nodes.
    367 bool ASTDumper::hasMoreChildren() {
    368   return MoreChildren;
    369 }
    370 
    371 void ASTDumper::setMoreChildren(bool Value) {
    372   MoreChildren = Value;
    373 }
    374 
    375 void ASTDumper::dumpPointer(const void *Ptr) {
    376   ColorScope Color(*this, AddressColor);
    377   OS << ' ' << Ptr;
    378 }
    379 
    380 void ASTDumper::dumpLocation(SourceLocation Loc) {
    381   ColorScope Color(*this, LocationColor);
    382   SourceLocation SpellingLoc = SM->getSpellingLoc(Loc);
    383 
    384   // The general format we print out is filename:line:col, but we drop pieces
    385   // that haven't changed since the last loc printed.
    386   PresumedLoc PLoc = SM->getPresumedLoc(SpellingLoc);
    387 
    388   if (PLoc.isInvalid()) {
    389     OS << "<invalid sloc>";
    390     return;
    391   }
    392 
    393   if (strcmp(PLoc.getFilename(), LastLocFilename) != 0) {
    394     OS << PLoc.getFilename() << ':' << PLoc.getLine()
    395        << ':' << PLoc.getColumn();
    396     LastLocFilename = PLoc.getFilename();
    397     LastLocLine = PLoc.getLine();
    398   } else if (PLoc.getLine() != LastLocLine) {
    399     OS << "line" << ':' << PLoc.getLine()
    400        << ':' << PLoc.getColumn();
    401     LastLocLine = PLoc.getLine();
    402   } else {
    403     OS << "col" << ':' << PLoc.getColumn();
    404   }
    405 }
    406 
    407 void ASTDumper::dumpSourceRange(SourceRange R) {
    408   // Can't translate locations if a SourceManager isn't available.
    409   if (!SM)
    410     return;
    411 
    412   OS << " <";
    413   dumpLocation(R.getBegin());
    414   if (R.getBegin() != R.getEnd()) {
    415     OS << ", ";
    416     dumpLocation(R.getEnd());
    417   }
    418   OS << ">";
    419 
    420   // <t2.c:123:421[blah], t2.c:412:321>
    421 
    422 }
    423 
    424 void ASTDumper::dumpBareType(QualType T) {
    425   ColorScope Color(*this, TypeColor);
    426 
    427   SplitQualType T_split = T.split();
    428   OS << "'" << QualType::getAsString(T_split) << "'";
    429 
    430   if (!T.isNull()) {
    431     // If the type is sugared, also dump a (shallow) desugared type.
    432     SplitQualType D_split = T.getSplitDesugaredType();
    433     if (T_split != D_split)
    434       OS << ":'" << QualType::getAsString(D_split) << "'";
    435   }
    436 }
    437 
    438 void ASTDumper::dumpType(QualType T) {
    439   OS << ' ';
    440   dumpBareType(T);
    441 }
    442 
    443 void ASTDumper::dumpBareDeclRef(const Decl *D) {
    444   {
    445     ColorScope Color(*this, DeclKindNameColor);
    446     OS << D->getDeclKindName();
    447   }
    448   dumpPointer(D);
    449 
    450   if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
    451     ColorScope Color(*this, DeclNameColor);
    452     OS << " '";
    453     ND->getDeclName().printName(OS);
    454     OS << "'";
    455   }
    456 
    457   if (const ValueDecl *VD = dyn_cast<ValueDecl>(D))
    458     dumpType(VD->getType());
    459 }
    460 
    461 void ASTDumper::dumpDeclRef(const Decl *D, const char *Label) {
    462   if (!D)
    463     return;
    464 
    465   IndentScope Indent(*this);
    466   if (Label)
    467     OS << Label << ' ';
    468   dumpBareDeclRef(D);
    469 }
    470 
    471 void ASTDumper::dumpName(const NamedDecl *ND) {
    472   if (ND->getDeclName()) {
    473     ColorScope Color(*this, DeclNameColor);
    474     OS << ' ' << ND->getNameAsString();
    475   }
    476 }
    477 
    478 bool ASTDumper::hasNodes(const DeclContext *DC) {
    479   if (!DC)
    480     return false;
    481 
    482   return DC->decls_begin() != DC->decls_end();
    483 }
    484 
    485 void ASTDumper::dumpDeclContext(const DeclContext *DC) {
    486   if (!DC)
    487     return;
    488   for (DeclContext::decl_iterator I = DC->decls_begin(), E = DC->decls_end();
    489        I != E; ++I) {
    490     DeclContext::decl_iterator Next = I;
    491     ++Next;
    492     if (Next == E)
    493       lastChild();
    494     dumpDecl(*I);
    495   }
    496 }
    497 
    498 void ASTDumper::dumpAttr(const Attr *A) {
    499   IndentScope Indent(*this);
    500   {
    501     ColorScope Color(*this, AttrColor);
    502     switch (A->getKind()) {
    503 #define ATTR(X) case attr::X: OS << #X; break;
    504 #include "clang/Basic/AttrList.inc"
    505     default: llvm_unreachable("unexpected attribute kind");
    506     }
    507     OS << "Attr";
    508   }
    509   dumpPointer(A);
    510   dumpSourceRange(A->getRange());
    511 #include "clang/AST/AttrDump.inc"
    512 }
    513 
    514 static Decl *getPreviousDeclImpl(...) {
    515   return 0;
    516 }
    517 
    518 template<typename T>
    519 static const Decl *getPreviousDeclImpl(const Redeclarable<T> *D) {
    520   return D->getPreviousDecl();
    521 }
    522 
    523 /// Get the previous declaration in the redeclaration chain for a declaration.
    524 static const Decl *getPreviousDecl(const Decl *D) {
    525   switch (D->getKind()) {
    526 #define DECL(DERIVED, BASE) \
    527   case Decl::DERIVED: \
    528     return getPreviousDeclImpl(cast<DERIVED##Decl>(D));
    529 #define ABSTRACT_DECL(DECL)
    530 #include "clang/AST/DeclNodes.inc"
    531   }
    532   llvm_unreachable("Decl that isn't part of DeclNodes.inc!");
    533 }
    534 
    535 //===----------------------------------------------------------------------===//
    536 //  C++ Utilities
    537 //===----------------------------------------------------------------------===//
    538 
    539 void ASTDumper::dumpAccessSpecifier(AccessSpecifier AS) {
    540   switch (AS) {
    541   case AS_none:
    542     break;
    543   case AS_public:
    544     OS << "public";
    545     break;
    546   case AS_protected:
    547     OS << "protected";
    548     break;
    549   case AS_private:
    550     OS << "private";
    551     break;
    552   }
    553 }
    554 
    555 void ASTDumper::dumpCXXCtorInitializer(const CXXCtorInitializer *Init) {
    556   IndentScope Indent(*this);
    557   OS << "CXXCtorInitializer";
    558   if (Init->isAnyMemberInitializer()) {
    559     OS << ' ';
    560     dumpBareDeclRef(Init->getAnyMember());
    561   } else {
    562     dumpType(QualType(Init->getBaseClass(), 0));
    563   }
    564   dumpStmt(Init->getInit());
    565 }
    566 
    567 void ASTDumper::dumpTemplateParameters(const TemplateParameterList *TPL) {
    568   if (!TPL)
    569     return;
    570 
    571   for (TemplateParameterList::const_iterator I = TPL->begin(), E = TPL->end();
    572        I != E; ++I)
    573     dumpDecl(*I);
    574 }
    575 
    576 void ASTDumper::dumpTemplateArgumentListInfo(
    577     const TemplateArgumentListInfo &TALI) {
    578   for (unsigned i = 0, e = TALI.size(); i < e; ++i) {
    579     if (i + 1 == e)
    580       lastChild();
    581     dumpTemplateArgumentLoc(TALI[i]);
    582   }
    583 }
    584 
    585 void ASTDumper::dumpTemplateArgumentLoc(const TemplateArgumentLoc &A) {
    586   dumpTemplateArgument(A.getArgument(), A.getSourceRange());
    587 }
    588 
    589 void ASTDumper::dumpTemplateArgumentList(const TemplateArgumentList &TAL) {
    590   for (unsigned i = 0, e = TAL.size(); i < e; ++i)
    591     dumpTemplateArgument(TAL[i]);
    592 }
    593 
    594 void ASTDumper::dumpTemplateArgument(const TemplateArgument &A, SourceRange R) {
    595   IndentScope Indent(*this);
    596   OS << "TemplateArgument";
    597   if (R.isValid())
    598     dumpSourceRange(R);
    599 
    600   switch (A.getKind()) {
    601   case TemplateArgument::Null:
    602     OS << " null";
    603     break;
    604   case TemplateArgument::Type:
    605     OS << " type";
    606     lastChild();
    607     dumpType(A.getAsType());
    608     break;
    609   case TemplateArgument::Declaration:
    610     OS << " decl";
    611     lastChild();
    612     dumpDeclRef(A.getAsDecl());
    613     break;
    614   case TemplateArgument::NullPtr:
    615     OS << " nullptr";
    616     break;
    617   case TemplateArgument::Integral:
    618     OS << " integral " << A.getAsIntegral();
    619     break;
    620   case TemplateArgument::Template:
    621     OS << " template ";
    622     A.getAsTemplate().dump(OS);
    623     break;
    624   case TemplateArgument::TemplateExpansion:
    625     OS << " template expansion";
    626     A.getAsTemplateOrTemplatePattern().dump(OS);
    627     break;
    628   case TemplateArgument::Expression:
    629     OS << " expr";
    630     lastChild();
    631     dumpStmt(A.getAsExpr());
    632     break;
    633   case TemplateArgument::Pack:
    634     OS << " pack";
    635     for (TemplateArgument::pack_iterator I = A.pack_begin(), E = A.pack_end();
    636          I != E; ++I) {
    637       if (I + 1 == E)
    638         lastChild();
    639       dumpTemplateArgument(*I);
    640     }
    641     break;
    642   }
    643 }
    644 
    645 //===----------------------------------------------------------------------===//
    646 //  Decl dumping methods.
    647 //===----------------------------------------------------------------------===//
    648 
    649 void ASTDumper::dumpDecl(const Decl *D) {
    650   IndentScope Indent(*this);
    651 
    652   if (!D) {
    653     ColorScope Color(*this, NullColor);
    654     OS << "<<<NULL>>>";
    655     return;
    656   }
    657 
    658   {
    659     ColorScope Color(*this, DeclKindNameColor);
    660     OS << D->getDeclKindName() << "Decl";
    661   }
    662   dumpPointer(D);
    663   if (D->getLexicalDeclContext() != D->getDeclContext())
    664     OS << " parent " << cast<Decl>(D->getDeclContext());
    665   if (const Decl *Prev = getPreviousDecl(D))
    666     OS << " prev " << Prev;
    667   dumpSourceRange(D->getSourceRange());
    668 
    669   bool HasAttrs = D->attr_begin() != D->attr_end();
    670   bool HasComment = D->getASTContext().getCommentForDecl(D, 0);
    671   // Decls within functions are visited by the body
    672   bool HasDeclContext = !isa<FunctionDecl>(*D) && !isa<ObjCMethodDecl>(*D) &&
    673                          hasNodes(dyn_cast<DeclContext>(D));
    674 
    675   setMoreChildren(HasAttrs || HasComment || HasDeclContext);
    676   ConstDeclVisitor<ASTDumper>::Visit(D);
    677 
    678   setMoreChildren(HasComment || HasDeclContext);
    679   for (Decl::attr_iterator I = D->attr_begin(), E = D->attr_end();
    680        I != E; ++I) {
    681     if (I + 1 == E)
    682       lastChild();
    683     dumpAttr(*I);
    684   }
    685 
    686   setMoreChildren(HasDeclContext);
    687   lastChild();
    688   dumpFullComment(D->getASTContext().getCommentForDecl(D, 0));
    689 
    690   setMoreChildren(false);
    691   if (HasDeclContext)
    692     dumpDeclContext(cast<DeclContext>(D));
    693 }
    694 
    695 void ASTDumper::VisitLabelDecl(const LabelDecl *D) {
    696   dumpName(D);
    697 }
    698 
    699 void ASTDumper::VisitTypedefDecl(const TypedefDecl *D) {
    700   dumpName(D);
    701   dumpType(D->getUnderlyingType());
    702   if (D->isModulePrivate())
    703     OS << " __module_private__";
    704 }
    705 
    706 void ASTDumper::VisitEnumDecl(const EnumDecl *D) {
    707   if (D->isScoped()) {
    708     if (D->isScopedUsingClassTag())
    709       OS << " class";
    710     else
    711       OS << " struct";
    712   }
    713   dumpName(D);
    714   if (D->isModulePrivate())
    715     OS << " __module_private__";
    716   if (D->isFixed())
    717     dumpType(D->getIntegerType());
    718 }
    719 
    720 void ASTDumper::VisitRecordDecl(const RecordDecl *D) {
    721   OS << ' ' << D->getKindName();
    722   dumpName(D);
    723   if (D->isModulePrivate())
    724     OS << " __module_private__";
    725 }
    726 
    727 void ASTDumper::VisitEnumConstantDecl(const EnumConstantDecl *D) {
    728   dumpName(D);
    729   dumpType(D->getType());
    730   if (const Expr *Init = D->getInitExpr()) {
    731     lastChild();
    732     dumpStmt(Init);
    733   }
    734 }
    735 
    736 void ASTDumper::VisitIndirectFieldDecl(const IndirectFieldDecl *D) {
    737   dumpName(D);
    738   dumpType(D->getType());
    739   for (IndirectFieldDecl::chain_iterator I = D->chain_begin(),
    740                                          E = D->chain_end();
    741        I != E; ++I) {
    742     if (I + 1 == E)
    743       lastChild();
    744     dumpDeclRef(*I);
    745   }
    746 }
    747 
    748 void ASTDumper::VisitFunctionDecl(const FunctionDecl *D) {
    749   dumpName(D);
    750   dumpType(D->getType());
    751 
    752   StorageClass SC = D->getStorageClassAsWritten();
    753   if (SC != SC_None)
    754     OS << ' ' << VarDecl::getStorageClassSpecifierString(SC);
    755   if (D->isInlineSpecified())
    756     OS << " inline";
    757   if (D->isVirtualAsWritten())
    758     OS << " virtual";
    759   if (D->isModulePrivate())
    760     OS << " __module_private__";
    761 
    762   if (D->isPure())
    763     OS << " pure";
    764   else if (D->isDeletedAsWritten())
    765     OS << " delete";
    766 
    767   bool OldMoreChildren = hasMoreChildren();
    768   const FunctionTemplateSpecializationInfo *FTSI =
    769       D->getTemplateSpecializationInfo();
    770   bool HasTemplateSpecialization = FTSI;
    771 
    772   bool HasNamedDecls = D->getDeclsInPrototypeScope().begin() !=
    773                        D->getDeclsInPrototypeScope().end();
    774 
    775   bool HasFunctionDecls = D->param_begin() != D->param_end();
    776 
    777   const CXXConstructorDecl *C = dyn_cast<CXXConstructorDecl>(D);
    778   bool HasCtorInitializers = C && C->init_begin() != C->init_end();
    779 
    780   bool HasDeclarationBody = D->doesThisDeclarationHaveABody();
    781 
    782   setMoreChildren(OldMoreChildren || HasNamedDecls || HasFunctionDecls ||
    783                   HasCtorInitializers || HasDeclarationBody);
    784   if (HasTemplateSpecialization) {
    785     lastChild();
    786     dumpTemplateArgumentList(*FTSI->TemplateArguments);
    787   }
    788 
    789   setMoreChildren(OldMoreChildren || HasFunctionDecls ||
    790                   HasCtorInitializers || HasDeclarationBody);
    791   for (ArrayRef<NamedDecl *>::iterator
    792        I = D->getDeclsInPrototypeScope().begin(),
    793        E = D->getDeclsInPrototypeScope().end(); I != E; ++I) {
    794     if (I + 1 == E)
    795       lastChild();
    796     dumpDecl(*I);
    797   }
    798 
    799   setMoreChildren(OldMoreChildren || HasCtorInitializers || HasDeclarationBody);
    800   for (FunctionDecl::param_const_iterator I = D->param_begin(),
    801                                           E = D->param_end();
    802        I != E; ++I) {
    803     if (I + 1 == E)
    804       lastChild();
    805     dumpDecl(*I);
    806   }
    807 
    808   setMoreChildren(OldMoreChildren || HasDeclarationBody);
    809   if (HasCtorInitializers)
    810     for (CXXConstructorDecl::init_const_iterator I = C->init_begin(),
    811                                                  E = C->init_end();
    812          I != E; ++I) {
    813       if (I + 1 == E)
    814         lastChild();
    815       dumpCXXCtorInitializer(*I);
    816   }
    817 
    818   setMoreChildren(OldMoreChildren);
    819   if (HasDeclarationBody) {
    820     lastChild();
    821     dumpStmt(D->getBody());
    822   }
    823 }
    824 
    825 void ASTDumper::VisitFieldDecl(const FieldDecl *D) {
    826   dumpName(D);
    827   dumpType(D->getType());
    828   if (D->isMutable())
    829     OS << " mutable";
    830   if (D->isModulePrivate())
    831     OS << " __module_private__";
    832 
    833   bool OldMoreChildren = hasMoreChildren();
    834   bool IsBitField = D->isBitField();
    835   Expr *Init = D->getInClassInitializer();
    836   bool HasInit = Init;
    837 
    838   setMoreChildren(OldMoreChildren || HasInit);
    839   if (IsBitField) {
    840     lastChild();
    841     dumpStmt(D->getBitWidth());
    842   }
    843   setMoreChildren(OldMoreChildren);
    844   if (HasInit) {
    845     lastChild();
    846     dumpStmt(Init);
    847   }
    848 }
    849 
    850 void ASTDumper::VisitVarDecl(const VarDecl *D) {
    851   dumpName(D);
    852   dumpType(D->getType());
    853   StorageClass SC = D->getStorageClassAsWritten();
    854   if (SC != SC_None)
    855     OS << ' ' << VarDecl::getStorageClassSpecifierString(SC);
    856   if (D->isThreadSpecified())
    857     OS << " __thread";
    858   if (D->isModulePrivate())
    859     OS << " __module_private__";
    860   if (D->isNRVOVariable())
    861     OS << " nrvo";
    862   if (D->hasInit()) {
    863     lastChild();
    864     dumpStmt(D->getInit());
    865   }
    866 }
    867 
    868 void ASTDumper::VisitFileScopeAsmDecl(const FileScopeAsmDecl *D) {
    869   lastChild();
    870   dumpStmt(D->getAsmString());
    871 }
    872 
    873 void ASTDumper::VisitImportDecl(const ImportDecl *D) {
    874   OS << ' ' << D->getImportedModule()->getFullModuleName();
    875 }
    876 
    877 //===----------------------------------------------------------------------===//
    878 // C++ Declarations
    879 //===----------------------------------------------------------------------===//
    880 
    881 void ASTDumper::VisitNamespaceDecl(const NamespaceDecl *D) {
    882   dumpName(D);
    883   if (D->isInline())
    884     OS << " inline";
    885   if (!D->isOriginalNamespace())
    886     dumpDeclRef(D->getOriginalNamespace(), "original");
    887 }
    888 
    889 void ASTDumper::VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
    890   OS << ' ';
    891   dumpBareDeclRef(D->getNominatedNamespace());
    892 }
    893 
    894 void ASTDumper::VisitNamespaceAliasDecl(const NamespaceAliasDecl *D) {
    895   dumpName(D);
    896   dumpDeclRef(D->getAliasedNamespace());
    897 }
    898 
    899 void ASTDumper::VisitTypeAliasDecl(const TypeAliasDecl *D) {
    900   dumpName(D);
    901   dumpType(D->getUnderlyingType());
    902 }
    903 
    904 void ASTDumper::VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D) {
    905   dumpName(D);
    906   dumpTemplateParameters(D->getTemplateParameters());
    907   dumpDecl(D->getTemplatedDecl());
    908 }
    909 
    910 void ASTDumper::VisitCXXRecordDecl(const CXXRecordDecl *D) {
    911   VisitRecordDecl(D);
    912   if (!D->isCompleteDefinition())
    913     return;
    914 
    915   for (CXXRecordDecl::base_class_const_iterator I = D->bases_begin(),
    916                                                 E = D->bases_end();
    917        I != E; ++I) {
    918     IndentScope Indent(*this);
    919     if (I->isVirtual())
    920       OS << "virtual ";
    921     dumpAccessSpecifier(I->getAccessSpecifier());
    922     dumpType(I->getType());
    923     if (I->isPackExpansion())
    924       OS << "...";
    925   }
    926 }
    927 
    928 void ASTDumper::VisitStaticAssertDecl(const StaticAssertDecl *D) {
    929   dumpStmt(D->getAssertExpr());
    930   lastChild();
    931   dumpStmt(D->getMessage());
    932 }
    933 
    934 void ASTDumper::VisitFunctionTemplateDecl(const FunctionTemplateDecl *D) {
    935   dumpName(D);
    936   dumpTemplateParameters(D->getTemplateParameters());
    937   dumpDecl(D->getTemplatedDecl());
    938   for (FunctionTemplateDecl::spec_iterator I = D->spec_begin(),
    939                                            E = D->spec_end();
    940        I != E; ++I) {
    941     FunctionTemplateDecl::spec_iterator Next = I;
    942     ++Next;
    943     if (Next == E)
    944       lastChild();
    945     switch (I->getTemplateSpecializationKind()) {
    946     case TSK_Undeclared:
    947     case TSK_ImplicitInstantiation:
    948     case TSK_ExplicitInstantiationDeclaration:
    949     case TSK_ExplicitInstantiationDefinition:
    950       if (D == D->getCanonicalDecl())
    951         dumpDecl(*I);
    952       else
    953         dumpDeclRef(*I);
    954       break;
    955     case TSK_ExplicitSpecialization:
    956       dumpDeclRef(*I);
    957       break;
    958     }
    959   }
    960 }
    961 
    962 void ASTDumper::VisitClassTemplateDecl(const ClassTemplateDecl *D) {
    963   dumpName(D);
    964   dumpTemplateParameters(D->getTemplateParameters());
    965 
    966   ClassTemplateDecl::spec_iterator I = D->spec_begin();
    967   ClassTemplateDecl::spec_iterator E = D->spec_end();
    968   if (I == E)
    969     lastChild();
    970   dumpDecl(D->getTemplatedDecl());
    971   for (; I != E; ++I) {
    972     ClassTemplateDecl::spec_iterator Next = I;
    973     ++Next;
    974     if (Next == E)
    975       lastChild();
    976     switch (I->getTemplateSpecializationKind()) {
    977     case TSK_Undeclared:
    978     case TSK_ImplicitInstantiation:
    979       if (D == D->getCanonicalDecl())
    980         dumpDecl(*I);
    981       else
    982         dumpDeclRef(*I);
    983       break;
    984     case TSK_ExplicitSpecialization:
    985     case TSK_ExplicitInstantiationDeclaration:
    986     case TSK_ExplicitInstantiationDefinition:
    987       dumpDeclRef(*I);
    988       break;
    989     }
    990   }
    991 }
    992 
    993 void ASTDumper::VisitClassTemplateSpecializationDecl(
    994     const ClassTemplateSpecializationDecl *D) {
    995   VisitCXXRecordDecl(D);
    996   dumpTemplateArgumentList(D->getTemplateArgs());
    997 }
    998 
    999 void ASTDumper::VisitClassTemplatePartialSpecializationDecl(
   1000     const ClassTemplatePartialSpecializationDecl *D) {
   1001   VisitClassTemplateSpecializationDecl(D);
   1002   dumpTemplateParameters(D->getTemplateParameters());
   1003 }
   1004 
   1005 void ASTDumper::VisitClassScopeFunctionSpecializationDecl(
   1006     const ClassScopeFunctionSpecializationDecl *D) {
   1007   dumpDeclRef(D->getSpecialization());
   1008   if (D->hasExplicitTemplateArgs())
   1009     dumpTemplateArgumentListInfo(D->templateArgs());
   1010 }
   1011 
   1012 void ASTDumper::VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) {
   1013   if (D->wasDeclaredWithTypename())
   1014     OS << " typename";
   1015   else
   1016     OS << " class";
   1017   if (D->isParameterPack())
   1018     OS << " ...";
   1019   dumpName(D);
   1020   if (D->hasDefaultArgument())
   1021     dumpType(D->getDefaultArgument());
   1022 }
   1023 
   1024 void ASTDumper::VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) {
   1025   dumpType(D->getType());
   1026   if (D->isParameterPack())
   1027     OS << " ...";
   1028   dumpName(D);
   1029   if (D->hasDefaultArgument())
   1030     dumpStmt(D->getDefaultArgument());
   1031 }
   1032 
   1033 void ASTDumper::VisitTemplateTemplateParmDecl(
   1034     const TemplateTemplateParmDecl *D) {
   1035   if (D->isParameterPack())
   1036     OS << " ...";
   1037   dumpName(D);
   1038   dumpTemplateParameters(D->getTemplateParameters());
   1039   if (D->hasDefaultArgument())
   1040     dumpTemplateArgumentLoc(D->getDefaultArgument());
   1041 }
   1042 
   1043 void ASTDumper::VisitUsingDecl(const UsingDecl *D) {
   1044   OS << ' ';
   1045   D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
   1046   OS << D->getNameAsString();
   1047 }
   1048 
   1049 void ASTDumper::VisitUnresolvedUsingTypenameDecl(
   1050     const UnresolvedUsingTypenameDecl *D) {
   1051   OS << ' ';
   1052   D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
   1053   OS << D->getNameAsString();
   1054 }
   1055 
   1056 void ASTDumper::VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl *D) {
   1057   OS << ' ';
   1058   D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
   1059   OS << D->getNameAsString();
   1060   dumpType(D->getType());
   1061 }
   1062 
   1063 void ASTDumper::VisitUsingShadowDecl(const UsingShadowDecl *D) {
   1064   OS << ' ';
   1065   dumpBareDeclRef(D->getTargetDecl());
   1066 }
   1067 
   1068 void ASTDumper::VisitLinkageSpecDecl(const LinkageSpecDecl *D) {
   1069   switch (D->getLanguage()) {
   1070   case LinkageSpecDecl::lang_c: OS << " C"; break;
   1071   case LinkageSpecDecl::lang_cxx: OS << " C++"; break;
   1072   }
   1073 }
   1074 
   1075 void ASTDumper::VisitAccessSpecDecl(const AccessSpecDecl *D) {
   1076   OS << ' ';
   1077   dumpAccessSpecifier(D->getAccess());
   1078 }
   1079 
   1080 void ASTDumper::VisitFriendDecl(const FriendDecl *D) {
   1081   lastChild();
   1082   if (TypeSourceInfo *T = D->getFriendType())
   1083     dumpType(T->getType());
   1084   else
   1085     dumpDecl(D->getFriendDecl());
   1086 }
   1087 
   1088 //===----------------------------------------------------------------------===//
   1089 // Obj-C Declarations
   1090 //===----------------------------------------------------------------------===//
   1091 
   1092 void ASTDumper::VisitObjCIvarDecl(const ObjCIvarDecl *D) {
   1093   dumpName(D);
   1094   dumpType(D->getType());
   1095   if (D->getSynthesize())
   1096     OS << " synthesize";
   1097 
   1098   switch (D->getAccessControl()) {
   1099   case ObjCIvarDecl::None:
   1100     OS << " none";
   1101     break;
   1102   case ObjCIvarDecl::Private:
   1103     OS << " private";
   1104     break;
   1105   case ObjCIvarDecl::Protected:
   1106     OS << " protected";
   1107     break;
   1108   case ObjCIvarDecl::Public:
   1109     OS << " public";
   1110     break;
   1111   case ObjCIvarDecl::Package:
   1112     OS << " package";
   1113     break;
   1114   }
   1115 }
   1116 
   1117 void ASTDumper::VisitObjCMethodDecl(const ObjCMethodDecl *D) {
   1118   if (D->isInstanceMethod())
   1119     OS << " -";
   1120   else
   1121     OS << " +";
   1122   dumpName(D);
   1123   dumpType(D->getResultType());
   1124 
   1125   bool OldMoreChildren = hasMoreChildren();
   1126   bool IsVariadic = D->isVariadic();
   1127   bool HasBody = D->hasBody();
   1128 
   1129   setMoreChildren(OldMoreChildren || IsVariadic || HasBody);
   1130   if (D->isThisDeclarationADefinition()) {
   1131     lastChild();
   1132     dumpDeclContext(D);
   1133   } else {
   1134     for (ObjCMethodDecl::param_const_iterator I = D->param_begin(),
   1135                                               E = D->param_end();
   1136          I != E; ++I) {
   1137       if (I + 1 == E)
   1138         lastChild();
   1139       dumpDecl(*I);
   1140     }
   1141   }
   1142 
   1143   setMoreChildren(OldMoreChildren || HasBody);
   1144   if (IsVariadic) {
   1145     lastChild();
   1146     IndentScope Indent(*this);
   1147     OS << "...";
   1148   }
   1149 
   1150   setMoreChildren(OldMoreChildren);
   1151   if (HasBody) {
   1152     lastChild();
   1153     dumpStmt(D->getBody());
   1154   }
   1155 }
   1156 
   1157 void ASTDumper::VisitObjCCategoryDecl(const ObjCCategoryDecl *D) {
   1158   dumpName(D);
   1159   dumpDeclRef(D->getClassInterface());
   1160   if (D->protocol_begin() == D->protocol_end())
   1161     lastChild();
   1162   dumpDeclRef(D->getImplementation());
   1163   for (ObjCCategoryDecl::protocol_iterator I = D->protocol_begin(),
   1164                                            E = D->protocol_end();
   1165        I != E; ++I) {
   1166     if (I + 1 == E)
   1167       lastChild();
   1168     dumpDeclRef(*I);
   1169   }
   1170 }
   1171 
   1172 void ASTDumper::VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D) {
   1173   dumpName(D);
   1174   dumpDeclRef(D->getClassInterface());
   1175   lastChild();
   1176   dumpDeclRef(D->getCategoryDecl());
   1177 }
   1178 
   1179 void ASTDumper::VisitObjCProtocolDecl(const ObjCProtocolDecl *D) {
   1180   dumpName(D);
   1181   for (ObjCProtocolDecl::protocol_iterator I = D->protocol_begin(),
   1182                                            E = D->protocol_end();
   1183        I != E; ++I) {
   1184     if (I + 1 == E)
   1185       lastChild();
   1186     dumpDeclRef(*I);
   1187   }
   1188 }
   1189 
   1190 void ASTDumper::VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) {
   1191   dumpName(D);
   1192   dumpDeclRef(D->getSuperClass(), "super");
   1193   if (D->protocol_begin() == D->protocol_end())
   1194     lastChild();
   1195   dumpDeclRef(D->getImplementation());
   1196   for (ObjCInterfaceDecl::protocol_iterator I = D->protocol_begin(),
   1197                                             E = D->protocol_end();
   1198        I != E; ++I) {
   1199     if (I + 1 == E)
   1200       lastChild();
   1201     dumpDeclRef(*I);
   1202   }
   1203 }
   1204 
   1205 void ASTDumper::VisitObjCImplementationDecl(const ObjCImplementationDecl *D) {
   1206   dumpName(D);
   1207   dumpDeclRef(D->getSuperClass(), "super");
   1208   if (D->init_begin() == D->init_end())
   1209     lastChild();
   1210   dumpDeclRef(D->getClassInterface());
   1211   for (ObjCImplementationDecl::init_const_iterator I = D->init_begin(),
   1212                                                    E = D->init_end();
   1213        I != E; ++I) {
   1214     if (I + 1 == E)
   1215       lastChild();
   1216     dumpCXXCtorInitializer(*I);
   1217   }
   1218 }
   1219 
   1220 void ASTDumper::VisitObjCCompatibleAliasDecl(const ObjCCompatibleAliasDecl *D) {
   1221   dumpName(D);
   1222   lastChild();
   1223   dumpDeclRef(D->getClassInterface());
   1224 }
   1225 
   1226 void ASTDumper::VisitObjCPropertyDecl(const ObjCPropertyDecl *D) {
   1227   dumpName(D);
   1228   dumpType(D->getType());
   1229 
   1230   if (D->getPropertyImplementation() == ObjCPropertyDecl::Required)
   1231     OS << " required";
   1232   else if (D->getPropertyImplementation() == ObjCPropertyDecl::Optional)
   1233     OS << " optional";
   1234 
   1235   ObjCPropertyDecl::PropertyAttributeKind Attrs = D->getPropertyAttributes();
   1236   if (Attrs != ObjCPropertyDecl::OBJC_PR_noattr) {
   1237     if (Attrs & ObjCPropertyDecl::OBJC_PR_readonly)
   1238       OS << " readonly";
   1239     if (Attrs & ObjCPropertyDecl::OBJC_PR_assign)
   1240       OS << " assign";
   1241     if (Attrs & ObjCPropertyDecl::OBJC_PR_readwrite)
   1242       OS << " readwrite";
   1243     if (Attrs & ObjCPropertyDecl::OBJC_PR_retain)
   1244       OS << " retain";
   1245     if (Attrs & ObjCPropertyDecl::OBJC_PR_copy)
   1246       OS << " copy";
   1247     if (Attrs & ObjCPropertyDecl::OBJC_PR_nonatomic)
   1248       OS << " nonatomic";
   1249     if (Attrs & ObjCPropertyDecl::OBJC_PR_atomic)
   1250       OS << " atomic";
   1251     if (Attrs & ObjCPropertyDecl::OBJC_PR_weak)
   1252       OS << " weak";
   1253     if (Attrs & ObjCPropertyDecl::OBJC_PR_strong)
   1254       OS << " strong";
   1255     if (Attrs & ObjCPropertyDecl::OBJC_PR_unsafe_unretained)
   1256       OS << " unsafe_unretained";
   1257     if (Attrs & ObjCPropertyDecl::OBJC_PR_getter) {
   1258       if (!(Attrs & ObjCPropertyDecl::OBJC_PR_setter))
   1259         lastChild();
   1260       dumpDeclRef(D->getGetterMethodDecl(), "getter");
   1261     }
   1262     if (Attrs & ObjCPropertyDecl::OBJC_PR_setter) {
   1263       lastChild();
   1264       dumpDeclRef(D->getSetterMethodDecl(), "setter");
   1265     }
   1266   }
   1267 }
   1268 
   1269 void ASTDumper::VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D) {
   1270   dumpName(D->getPropertyDecl());
   1271   if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize)
   1272     OS << " synthesize";
   1273   else
   1274     OS << " dynamic";
   1275   dumpDeclRef(D->getPropertyDecl());
   1276   lastChild();
   1277   dumpDeclRef(D->getPropertyIvarDecl());
   1278 }
   1279 
   1280 void ASTDumper::VisitBlockDecl(const BlockDecl *D) {
   1281   for (BlockDecl::param_const_iterator I = D->param_begin(), E = D->param_end();
   1282        I != E; ++I)
   1283     dumpDecl(*I);
   1284 
   1285   if (D->isVariadic()) {
   1286     IndentScope Indent(*this);
   1287     OS << "...";
   1288   }
   1289 
   1290   if (D->capturesCXXThis()) {
   1291     IndentScope Indent(*this);
   1292     OS << "capture this";
   1293   }
   1294   for (BlockDecl::capture_iterator I = D->capture_begin(), E = D->capture_end();
   1295        I != E; ++I) {
   1296     IndentScope Indent(*this);
   1297     OS << "capture";
   1298     if (I->isByRef())
   1299       OS << " byref";
   1300     if (I->isNested())
   1301       OS << " nested";
   1302     if (I->getVariable()) {
   1303       OS << ' ';
   1304       dumpBareDeclRef(I->getVariable());
   1305     }
   1306     if (I->hasCopyExpr())
   1307       dumpStmt(I->getCopyExpr());
   1308   }
   1309   lastChild();
   1310   dumpStmt(D->getBody());
   1311 }
   1312 
   1313 //===----------------------------------------------------------------------===//
   1314 //  Stmt dumping methods.
   1315 //===----------------------------------------------------------------------===//
   1316 
   1317 void ASTDumper::dumpStmt(const Stmt *S) {
   1318   IndentScope Indent(*this);
   1319 
   1320   if (!S) {
   1321     ColorScope Color(*this, NullColor);
   1322     OS << "<<<NULL>>>";
   1323     return;
   1324   }
   1325 
   1326   if (const DeclStmt *DS = dyn_cast<DeclStmt>(S)) {
   1327     VisitDeclStmt(DS);
   1328     return;
   1329   }
   1330 
   1331   setMoreChildren(S->children());
   1332   ConstStmtVisitor<ASTDumper>::Visit(S);
   1333   setMoreChildren(false);
   1334   for (Stmt::const_child_range CI = S->children(); CI; ++CI) {
   1335     Stmt::const_child_range Next = CI;
   1336     ++Next;
   1337     if (!Next)
   1338       lastChild();
   1339     dumpStmt(*CI);
   1340   }
   1341 }
   1342 
   1343 void ASTDumper::VisitStmt(const Stmt *Node) {
   1344   {
   1345     ColorScope Color(*this, StmtColor);
   1346     OS << Node->getStmtClassName();
   1347   }
   1348   dumpPointer(Node);
   1349   dumpSourceRange(Node->getSourceRange());
   1350 }
   1351 
   1352 void ASTDumper::VisitDeclStmt(const DeclStmt *Node) {
   1353   VisitStmt(Node);
   1354   for (DeclStmt::const_decl_iterator I = Node->decl_begin(),
   1355                                      E = Node->decl_end();
   1356        I != E; ++I) {
   1357     if (I + 1 == E)
   1358       lastChild();
   1359     dumpDecl(*I);
   1360   }
   1361 }
   1362 
   1363 void ASTDumper::VisitAttributedStmt(const AttributedStmt *Node) {
   1364   VisitStmt(Node);
   1365   for (ArrayRef<const Attr *>::iterator I = Node->getAttrs().begin(),
   1366                                         E = Node->getAttrs().end();
   1367        I != E; ++I) {
   1368     if (I + 1 == E)
   1369       lastChild();
   1370     dumpAttr(*I);
   1371   }
   1372 }
   1373 
   1374 void ASTDumper::VisitLabelStmt(const LabelStmt *Node) {
   1375   VisitStmt(Node);
   1376   OS << " '" << Node->getName() << "'";
   1377 }
   1378 
   1379 void ASTDumper::VisitGotoStmt(const GotoStmt *Node) {
   1380   VisitStmt(Node);
   1381   OS << " '" << Node->getLabel()->getName() << "'";
   1382   dumpPointer(Node->getLabel());
   1383 }
   1384 
   1385 //===----------------------------------------------------------------------===//
   1386 //  Expr dumping methods.
   1387 //===----------------------------------------------------------------------===//
   1388 
   1389 void ASTDumper::VisitExpr(const Expr *Node) {
   1390   VisitStmt(Node);
   1391   dumpType(Node->getType());
   1392 
   1393   {
   1394     ColorScope Color(*this, ValueKindColor);
   1395     switch (Node->getValueKind()) {
   1396     case VK_RValue:
   1397       break;
   1398     case VK_LValue:
   1399       OS << " lvalue";
   1400       break;
   1401     case VK_XValue:
   1402       OS << " xvalue";
   1403       break;
   1404     }
   1405   }
   1406 
   1407   {
   1408     ColorScope Color(*this, ObjectKindColor);
   1409     switch (Node->getObjectKind()) {
   1410     case OK_Ordinary:
   1411       break;
   1412     case OK_BitField:
   1413       OS << " bitfield";
   1414       break;
   1415     case OK_ObjCProperty:
   1416       OS << " objcproperty";
   1417       break;
   1418     case OK_ObjCSubscript:
   1419       OS << " objcsubscript";
   1420       break;
   1421     case OK_VectorComponent:
   1422       OS << " vectorcomponent";
   1423       break;
   1424     }
   1425   }
   1426 }
   1427 
   1428 static void dumpBasePath(raw_ostream &OS, const CastExpr *Node) {
   1429   if (Node->path_empty())
   1430     return;
   1431 
   1432   OS << " (";
   1433   bool First = true;
   1434   for (CastExpr::path_const_iterator I = Node->path_begin(),
   1435                                      E = Node->path_end();
   1436        I != E; ++I) {
   1437     const CXXBaseSpecifier *Base = *I;
   1438     if (!First)
   1439       OS << " -> ";
   1440 
   1441     const CXXRecordDecl *RD =
   1442     cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
   1443 
   1444     if (Base->isVirtual())
   1445       OS << "virtual ";
   1446     OS << RD->getName();
   1447     First = false;
   1448   }
   1449 
   1450   OS << ')';
   1451 }
   1452 
   1453 void ASTDumper::VisitCastExpr(const CastExpr *Node) {
   1454   VisitExpr(Node);
   1455   OS << " <";
   1456   {
   1457     ColorScope Color(*this, CastColor);
   1458     OS << Node->getCastKindName();
   1459   }
   1460   dumpBasePath(OS, Node);
   1461   OS << ">";
   1462 }
   1463 
   1464 void ASTDumper::VisitDeclRefExpr(const DeclRefExpr *Node) {
   1465   VisitExpr(Node);
   1466 
   1467   OS << " ";
   1468   dumpBareDeclRef(Node->getDecl());
   1469   if (Node->getDecl() != Node->getFoundDecl()) {
   1470     OS << " (";
   1471     dumpBareDeclRef(Node->getFoundDecl());
   1472     OS << ")";
   1473   }
   1474 }
   1475 
   1476 void ASTDumper::VisitUnresolvedLookupExpr(const UnresolvedLookupExpr *Node) {
   1477   VisitExpr(Node);
   1478   OS << " (";
   1479   if (!Node->requiresADL())
   1480     OS << "no ";
   1481   OS << "ADL) = '" << Node->getName() << '\'';
   1482 
   1483   UnresolvedLookupExpr::decls_iterator
   1484     I = Node->decls_begin(), E = Node->decls_end();
   1485   if (I == E)
   1486     OS << " empty";
   1487   for (; I != E; ++I)
   1488     dumpPointer(*I);
   1489 }
   1490 
   1491 void ASTDumper::VisitObjCIvarRefExpr(const ObjCIvarRefExpr *Node) {
   1492   VisitExpr(Node);
   1493 
   1494   {
   1495     ColorScope Color(*this, DeclKindNameColor);
   1496     OS << " " << Node->getDecl()->getDeclKindName() << "Decl";
   1497   }
   1498   OS << "='" << *Node->getDecl() << "'";
   1499   dumpPointer(Node->getDecl());
   1500   if (Node->isFreeIvar())
   1501     OS << " isFreeIvar";
   1502 }
   1503 
   1504 void ASTDumper::VisitPredefinedExpr(const PredefinedExpr *Node) {
   1505   VisitExpr(Node);
   1506   switch (Node->getIdentType()) {
   1507   default: llvm_unreachable("unknown case");
   1508   case PredefinedExpr::Func:           OS <<  " __func__"; break;
   1509   case PredefinedExpr::Function:       OS <<  " __FUNCTION__"; break;
   1510   case PredefinedExpr::LFunction:      OS <<  " L__FUNCTION__"; break;
   1511   case PredefinedExpr::PrettyFunction: OS <<  " __PRETTY_FUNCTION__";break;
   1512   }
   1513 }
   1514 
   1515 void ASTDumper::VisitCharacterLiteral(const CharacterLiteral *Node) {
   1516   VisitExpr(Node);
   1517   ColorScope Color(*this, ValueColor);
   1518   OS << " " << Node->getValue();
   1519 }
   1520 
   1521 void ASTDumper::VisitIntegerLiteral(const IntegerLiteral *Node) {
   1522   VisitExpr(Node);
   1523 
   1524   bool isSigned = Node->getType()->isSignedIntegerType();
   1525   ColorScope Color(*this, ValueColor);
   1526   OS << " " << Node->getValue().toString(10, isSigned);
   1527 }
   1528 
   1529 void ASTDumper::VisitFloatingLiteral(const FloatingLiteral *Node) {
   1530   VisitExpr(Node);
   1531   ColorScope Color(*this, ValueColor);
   1532   OS << " " << Node->getValueAsApproximateDouble();
   1533 }
   1534 
   1535 void ASTDumper::VisitStringLiteral(const StringLiteral *Str) {
   1536   VisitExpr(Str);
   1537   ColorScope Color(*this, ValueColor);
   1538   OS << " ";
   1539   Str->outputString(OS);
   1540 }
   1541 
   1542 void ASTDumper::VisitUnaryOperator(const UnaryOperator *Node) {
   1543   VisitExpr(Node);
   1544   OS << " " << (Node->isPostfix() ? "postfix" : "prefix")
   1545      << " '" << UnaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
   1546 }
   1547 
   1548 void ASTDumper::VisitUnaryExprOrTypeTraitExpr(
   1549     const UnaryExprOrTypeTraitExpr *Node) {
   1550   VisitExpr(Node);
   1551   switch(Node->getKind()) {
   1552   case UETT_SizeOf:
   1553     OS << " sizeof";
   1554     break;
   1555   case UETT_AlignOf:
   1556     OS << " alignof";
   1557     break;
   1558   case UETT_VecStep:
   1559     OS << " vec_step";
   1560     break;
   1561   }
   1562   if (Node->isArgumentType())
   1563     dumpType(Node->getArgumentType());
   1564 }
   1565 
   1566 void ASTDumper::VisitMemberExpr(const MemberExpr *Node) {
   1567   VisitExpr(Node);
   1568   OS << " " << (Node->isArrow() ? "->" : ".") << *Node->getMemberDecl();
   1569   dumpPointer(Node->getMemberDecl());
   1570 }
   1571 
   1572 void ASTDumper::VisitExtVectorElementExpr(const ExtVectorElementExpr *Node) {
   1573   VisitExpr(Node);
   1574   OS << " " << Node->getAccessor().getNameStart();
   1575 }
   1576 
   1577 void ASTDumper::VisitBinaryOperator(const BinaryOperator *Node) {
   1578   VisitExpr(Node);
   1579   OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
   1580 }
   1581 
   1582 void ASTDumper::VisitCompoundAssignOperator(
   1583     const CompoundAssignOperator *Node) {
   1584   VisitExpr(Node);
   1585   OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode())
   1586      << "' ComputeLHSTy=";
   1587   dumpBareType(Node->getComputationLHSType());
   1588   OS << " ComputeResultTy=";
   1589   dumpBareType(Node->getComputationResultType());
   1590 }
   1591 
   1592 void ASTDumper::VisitBlockExpr(const BlockExpr *Node) {
   1593   VisitExpr(Node);
   1594   dumpDecl(Node->getBlockDecl());
   1595 }
   1596 
   1597 void ASTDumper::VisitOpaqueValueExpr(const OpaqueValueExpr *Node) {
   1598   VisitExpr(Node);
   1599 
   1600   if (Expr *Source = Node->getSourceExpr()) {
   1601     lastChild();
   1602     dumpStmt(Source);
   1603   }
   1604 }
   1605 
   1606 // GNU extensions.
   1607 
   1608 void ASTDumper::VisitAddrLabelExpr(const AddrLabelExpr *Node) {
   1609   VisitExpr(Node);
   1610   OS << " " << Node->getLabel()->getName();
   1611   dumpPointer(Node->getLabel());
   1612 }
   1613 
   1614 //===----------------------------------------------------------------------===//
   1615 // C++ Expressions
   1616 //===----------------------------------------------------------------------===//
   1617 
   1618 void ASTDumper::VisitCXXNamedCastExpr(const CXXNamedCastExpr *Node) {
   1619   VisitExpr(Node);
   1620   OS << " " << Node->getCastName()
   1621      << "<" << Node->getTypeAsWritten().getAsString() << ">"
   1622      << " <" << Node->getCastKindName();
   1623   dumpBasePath(OS, Node);
   1624   OS << ">";
   1625 }
   1626 
   1627 void ASTDumper::VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *Node) {
   1628   VisitExpr(Node);
   1629   OS << " " << (Node->getValue() ? "true" : "false");
   1630 }
   1631 
   1632 void ASTDumper::VisitCXXThisExpr(const CXXThisExpr *Node) {
   1633   VisitExpr(Node);
   1634   OS << " this";
   1635 }
   1636 
   1637 void ASTDumper::VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *Node) {
   1638   VisitExpr(Node);
   1639   OS << " functional cast to " << Node->getTypeAsWritten().getAsString()
   1640      << " <" << Node->getCastKindName() << ">";
   1641 }
   1642 
   1643 void ASTDumper::VisitCXXConstructExpr(const CXXConstructExpr *Node) {
   1644   VisitExpr(Node);
   1645   CXXConstructorDecl *Ctor = Node->getConstructor();
   1646   dumpType(Ctor->getType());
   1647   if (Node->isElidable())
   1648     OS << " elidable";
   1649   if (Node->requiresZeroInitialization())
   1650     OS << " zeroing";
   1651 }
   1652 
   1653 void ASTDumper::VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *Node) {
   1654   VisitExpr(Node);
   1655   OS << " ";
   1656   dumpCXXTemporary(Node->getTemporary());
   1657 }
   1658 
   1659 void ASTDumper::VisitExprWithCleanups(const ExprWithCleanups *Node) {
   1660   VisitExpr(Node);
   1661   for (unsigned i = 0, e = Node->getNumObjects(); i != e; ++i)
   1662     dumpDeclRef(Node->getObject(i), "cleanup");
   1663 }
   1664 
   1665 void ASTDumper::dumpCXXTemporary(const CXXTemporary *Temporary) {
   1666   OS << "(CXXTemporary";
   1667   dumpPointer(Temporary);
   1668   OS << ")";
   1669 }
   1670 
   1671 //===----------------------------------------------------------------------===//
   1672 // Obj-C Expressions
   1673 //===----------------------------------------------------------------------===//
   1674 
   1675 void ASTDumper::VisitObjCMessageExpr(const ObjCMessageExpr *Node) {
   1676   VisitExpr(Node);
   1677   OS << " selector=" << Node->getSelector().getAsString();
   1678   switch (Node->getReceiverKind()) {
   1679   case ObjCMessageExpr::Instance:
   1680     break;
   1681 
   1682   case ObjCMessageExpr::Class:
   1683     OS << " class=";
   1684     dumpBareType(Node->getClassReceiver());
   1685     break;
   1686 
   1687   case ObjCMessageExpr::SuperInstance:
   1688     OS << " super (instance)";
   1689     break;
   1690 
   1691   case ObjCMessageExpr::SuperClass:
   1692     OS << " super (class)";
   1693     break;
   1694   }
   1695 }
   1696 
   1697 void ASTDumper::VisitObjCBoxedExpr(const ObjCBoxedExpr *Node) {
   1698   VisitExpr(Node);
   1699   OS << " selector=" << Node->getBoxingMethod()->getSelector().getAsString();
   1700 }
   1701 
   1702 void ASTDumper::VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node) {
   1703   VisitStmt(Node);
   1704   if (const VarDecl *CatchParam = Node->getCatchParamDecl())
   1705     dumpDecl(CatchParam);
   1706   else
   1707     OS << " catch all";
   1708 }
   1709 
   1710 void ASTDumper::VisitObjCEncodeExpr(const ObjCEncodeExpr *Node) {
   1711   VisitExpr(Node);
   1712   dumpType(Node->getEncodedType());
   1713 }
   1714 
   1715 void ASTDumper::VisitObjCSelectorExpr(const ObjCSelectorExpr *Node) {
   1716   VisitExpr(Node);
   1717 
   1718   OS << " " << Node->getSelector().getAsString();
   1719 }
   1720 
   1721 void ASTDumper::VisitObjCProtocolExpr(const ObjCProtocolExpr *Node) {
   1722   VisitExpr(Node);
   1723 
   1724   OS << ' ' << *Node->getProtocol();
   1725 }
   1726 
   1727 void ASTDumper::VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *Node) {
   1728   VisitExpr(Node);
   1729   if (Node->isImplicitProperty()) {
   1730     OS << " Kind=MethodRef Getter=\"";
   1731     if (Node->getImplicitPropertyGetter())
   1732       OS << Node->getImplicitPropertyGetter()->getSelector().getAsString();
   1733     else
   1734       OS << "(null)";
   1735 
   1736     OS << "\" Setter=\"";
   1737     if (ObjCMethodDecl *Setter = Node->getImplicitPropertySetter())
   1738       OS << Setter->getSelector().getAsString();
   1739     else
   1740       OS << "(null)";
   1741     OS << "\"";
   1742   } else {
   1743     OS << " Kind=PropertyRef Property=\"" << *Node->getExplicitProperty() <<'"';
   1744   }
   1745 
   1746   if (Node->isSuperReceiver())
   1747     OS << " super";
   1748 
   1749   OS << " Messaging=";
   1750   if (Node->isMessagingGetter() && Node->isMessagingSetter())
   1751     OS << "Getter&Setter";
   1752   else if (Node->isMessagingGetter())
   1753     OS << "Getter";
   1754   else if (Node->isMessagingSetter())
   1755     OS << "Setter";
   1756 }
   1757 
   1758 void ASTDumper::VisitObjCSubscriptRefExpr(const ObjCSubscriptRefExpr *Node) {
   1759   VisitExpr(Node);
   1760   if (Node->isArraySubscriptRefExpr())
   1761     OS << " Kind=ArraySubscript GetterForArray=\"";
   1762   else
   1763     OS << " Kind=DictionarySubscript GetterForDictionary=\"";
   1764   if (Node->getAtIndexMethodDecl())
   1765     OS << Node->getAtIndexMethodDecl()->getSelector().getAsString();
   1766   else
   1767     OS << "(null)";
   1768 
   1769   if (Node->isArraySubscriptRefExpr())
   1770     OS << "\" SetterForArray=\"";
   1771   else
   1772     OS << "\" SetterForDictionary=\"";
   1773   if (Node->setAtIndexMethodDecl())
   1774     OS << Node->setAtIndexMethodDecl()->getSelector().getAsString();
   1775   else
   1776     OS << "(null)";
   1777 }
   1778 
   1779 void ASTDumper::VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *Node) {
   1780   VisitExpr(Node);
   1781   OS << " " << (Node->getValue() ? "__objc_yes" : "__objc_no");
   1782 }
   1783 
   1784 //===----------------------------------------------------------------------===//
   1785 // Comments
   1786 //===----------------------------------------------------------------------===//
   1787 
   1788 const char *ASTDumper::getCommandName(unsigned CommandID) {
   1789   if (Traits)
   1790     return Traits->getCommandInfo(CommandID)->Name;
   1791   const CommandInfo *Info = CommandTraits::getBuiltinCommandInfo(CommandID);
   1792   if (Info)
   1793     return Info->Name;
   1794   return "<not a builtin command>";
   1795 }
   1796 
   1797 void ASTDumper::dumpFullComment(const FullComment *C) {
   1798   if (!C)
   1799     return;
   1800 
   1801   FC = C;
   1802   dumpComment(C);
   1803   FC = 0;
   1804 }
   1805 
   1806 void ASTDumper::dumpComment(const Comment *C) {
   1807   IndentScope Indent(*this);
   1808 
   1809   if (!C) {
   1810     ColorScope Color(*this, NullColor);
   1811     OS << "<<<NULL>>>";
   1812     return;
   1813   }
   1814 
   1815   {
   1816     ColorScope Color(*this, CommentColor);
   1817     OS << C->getCommentKindName();
   1818   }
   1819   dumpPointer(C);
   1820   dumpSourceRange(C->getSourceRange());
   1821   ConstCommentVisitor<ASTDumper>::visit(C);
   1822   for (Comment::child_iterator I = C->child_begin(), E = C->child_end();
   1823        I != E; ++I) {
   1824     if (I + 1 == E)
   1825       lastChild();
   1826     dumpComment(*I);
   1827   }
   1828 }
   1829 
   1830 void ASTDumper::visitTextComment(const TextComment *C) {
   1831   OS << " Text=\"" << C->getText() << "\"";
   1832 }
   1833 
   1834 void ASTDumper::visitInlineCommandComment(const InlineCommandComment *C) {
   1835   OS << " Name=\"" << getCommandName(C->getCommandID()) << "\"";
   1836   switch (C->getRenderKind()) {
   1837   case InlineCommandComment::RenderNormal:
   1838     OS << " RenderNormal";
   1839     break;
   1840   case InlineCommandComment::RenderBold:
   1841     OS << " RenderBold";
   1842     break;
   1843   case InlineCommandComment::RenderMonospaced:
   1844     OS << " RenderMonospaced";
   1845     break;
   1846   case InlineCommandComment::RenderEmphasized:
   1847     OS << " RenderEmphasized";
   1848     break;
   1849   }
   1850 
   1851   for (unsigned i = 0, e = C->getNumArgs(); i != e; ++i)
   1852     OS << " Arg[" << i << "]=\"" << C->getArgText(i) << "\"";
   1853 }
   1854 
   1855 void ASTDumper::visitHTMLStartTagComment(const HTMLStartTagComment *C) {
   1856   OS << " Name=\"" << C->getTagName() << "\"";
   1857   if (C->getNumAttrs() != 0) {
   1858     OS << " Attrs: ";
   1859     for (unsigned i = 0, e = C->getNumAttrs(); i != e; ++i) {
   1860       const HTMLStartTagComment::Attribute &Attr = C->getAttr(i);
   1861       OS << " \"" << Attr.Name << "=\"" << Attr.Value << "\"";
   1862     }
   1863   }
   1864   if (C->isSelfClosing())
   1865     OS << " SelfClosing";
   1866 }
   1867 
   1868 void ASTDumper::visitHTMLEndTagComment(const HTMLEndTagComment *C) {
   1869   OS << " Name=\"" << C->getTagName() << "\"";
   1870 }
   1871 
   1872 void ASTDumper::visitBlockCommandComment(const BlockCommandComment *C) {
   1873   OS << " Name=\"" << getCommandName(C->getCommandID()) << "\"";
   1874   for (unsigned i = 0, e = C->getNumArgs(); i != e; ++i)
   1875     OS << " Arg[" << i << "]=\"" << C->getArgText(i) << "\"";
   1876 }
   1877 
   1878 void ASTDumper::visitParamCommandComment(const ParamCommandComment *C) {
   1879   OS << " " << ParamCommandComment::getDirectionAsString(C->getDirection());
   1880 
   1881   if (C->isDirectionExplicit())
   1882     OS << " explicitly";
   1883   else
   1884     OS << " implicitly";
   1885 
   1886   if (C->hasParamName()) {
   1887     if (C->isParamIndexValid())
   1888       OS << " Param=\"" << C->getParamName(FC) << "\"";
   1889     else
   1890       OS << " Param=\"" << C->getParamNameAsWritten() << "\"";
   1891   }
   1892 
   1893   if (C->isParamIndexValid())
   1894     OS << " ParamIndex=" << C->getParamIndex();
   1895 }
   1896 
   1897 void ASTDumper::visitTParamCommandComment(const TParamCommandComment *C) {
   1898   if (C->hasParamName()) {
   1899     if (C->isPositionValid())
   1900       OS << " Param=\"" << C->getParamName(FC) << "\"";
   1901     else
   1902       OS << " Param=\"" << C->getParamNameAsWritten() << "\"";
   1903   }
   1904 
   1905   if (C->isPositionValid()) {
   1906     OS << " Position=<";
   1907     for (unsigned i = 0, e = C->getDepth(); i != e; ++i) {
   1908       OS << C->getIndex(i);
   1909       if (i != e - 1)
   1910         OS << ", ";
   1911     }
   1912     OS << ">";
   1913   }
   1914 }
   1915 
   1916 void ASTDumper::visitVerbatimBlockComment(const VerbatimBlockComment *C) {
   1917   OS << " Name=\"" << getCommandName(C->getCommandID()) << "\""
   1918         " CloseName=\"" << C->getCloseName() << "\"";
   1919 }
   1920 
   1921 void ASTDumper::visitVerbatimBlockLineComment(
   1922     const VerbatimBlockLineComment *C) {
   1923   OS << " Text=\"" << C->getText() << "\"";
   1924 }
   1925 
   1926 void ASTDumper::visitVerbatimLineComment(const VerbatimLineComment *C) {
   1927   OS << " Text=\"" << C->getText() << "\"";
   1928 }
   1929 
   1930 //===----------------------------------------------------------------------===//
   1931 // Decl method implementations
   1932 //===----------------------------------------------------------------------===//
   1933 
   1934 void Decl::dump() const {
   1935   dump(llvm::errs());
   1936 }
   1937 
   1938 void Decl::dump(raw_ostream &OS) const {
   1939   ASTDumper P(OS, &getASTContext().getCommentCommandTraits(),
   1940               &getASTContext().getSourceManager());
   1941   P.dumpDecl(this);
   1942 }
   1943 
   1944 void Decl::dumpColor() const {
   1945   ASTDumper P(llvm::errs(), &getASTContext().getCommentCommandTraits(),
   1946               &getASTContext().getSourceManager(), /*ShowColors*/true);
   1947   P.dumpDecl(this);
   1948 }
   1949 //===----------------------------------------------------------------------===//
   1950 // Stmt method implementations
   1951 //===----------------------------------------------------------------------===//
   1952 
   1953 void Stmt::dump(SourceManager &SM) const {
   1954   dump(llvm::errs(), SM);
   1955 }
   1956 
   1957 void Stmt::dump(raw_ostream &OS, SourceManager &SM) const {
   1958   ASTDumper P(OS, 0, &SM);
   1959   P.dumpStmt(this);
   1960 }
   1961 
   1962 void Stmt::dump() const {
   1963   ASTDumper P(llvm::errs(), 0, 0);
   1964   P.dumpStmt(this);
   1965 }
   1966 
   1967 void Stmt::dumpColor() const {
   1968   ASTDumper P(llvm::errs(), 0, 0, /*ShowColors*/true);
   1969   P.dumpStmt(this);
   1970 }
   1971 
   1972 //===----------------------------------------------------------------------===//
   1973 // Comment method implementations
   1974 //===----------------------------------------------------------------------===//
   1975 
   1976 void Comment::dump() const {
   1977   dump(llvm::errs(), 0, 0);
   1978 }
   1979 
   1980 void Comment::dump(const ASTContext &Context) const {
   1981   dump(llvm::errs(), &Context.getCommentCommandTraits(),
   1982        &Context.getSourceManager());
   1983 }
   1984 
   1985 void Comment::dump(raw_ostream &OS, const CommandTraits *Traits,
   1986                    const SourceManager *SM) const {
   1987   const FullComment *FC = dyn_cast<FullComment>(this);
   1988   ASTDumper D(OS, Traits, SM);
   1989   D.dumpFullComment(FC);
   1990 }
   1991 
   1992 void Comment::dumpColor() const {
   1993   const FullComment *FC = dyn_cast<FullComment>(this);
   1994   ASTDumper D(llvm::errs(), 0, 0, /*ShowColors*/true);
   1995   D.dumpFullComment(FC);
   1996 }
   1997