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

   1 //===--- DumpXML.cpp - Detailed XML dumping ---------------------*- C++ -*-===//
   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 defines the Decl::dumpXML() method, a debugging tool to
  11 //  print a detailed graph of an AST in an unspecified XML format.
  12 //
  13 //  There is no guarantee of stability for this format.
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 // Only pay for this in code size in assertions-enabled builds.
  18
  19 #include "clang/AST/ASTContext.h"
  20 #include "clang/AST/Decl.h"
  21 #include "clang/AST/DeclCXX.h"
  22 #include "clang/AST/DeclFriend.h"
  23 #include "clang/AST/DeclObjC.h"
  24 #include "clang/AST/DeclTemplate.h"
  25 #include "clang/AST/DeclVisitor.h"
  26 #include "clang/AST/Expr.h"
  27 #include "clang/AST/ExprCXX.h"
  28 #include "clang/AST/ExprObjC.h"
  29 #include "clang/AST/NestedNameSpecifier.h"
  30 #include "clang/AST/Stmt.h"
  31 #include "clang/AST/StmtCXX.h"
  32 #include "clang/AST/StmtObjC.h"
  33 #include "clang/AST/StmtVisitor.h"
  34 #include "clang/AST/TemplateBase.h"
  35 #include "clang/AST/TemplateName.h"
  36 #include "clang/AST/Type.h"
  37 #include "clang/AST/TypeLoc.h"
  38 #include "clang/AST/TypeLocVisitor.h"
  39 #include "clang/AST/TypeVisitor.h"
  40 #include "clang/AST/Expr.h"
  41 #include "clang/AST/ExprCXX.h"
  42 #include "llvm/ADT/SmallString.h"
  43
  44 using namespace clang;
  45
  46 #ifndef NDEBUG
  47
  48 namespace {
  49
  50 enum NodeState {
  51   NS_Attrs, NS_LazyChildren, NS_Children
  52 };
  53
  54 struct Node {
  55   StringRef Name;
  56   NodeState State;
  57   Node(StringRef name) : Name(name), State(NS_Attrs) {}
  58
  59   bool isDoneWithAttrs() const { return State != NS_Attrs; }
  60 };
  61
  62 template <class Impl> struct XMLDeclVisitor {
  63 #define DISPATCH(NAME, CLASS) \
  64   static_cast<Impl*>(this)->NAME(static_cast<CLASS*>(D))
  65
  66   void dispatch(Decl *D) {
  67     switch (D->getKind()) {
  68 #define DECL(DERIVED, BASE) \
  69       case Decl::DERIVED: \
  70         DISPATCH(dispatch##DERIVED##DeclAttrs, DERIVED##Decl); \
  71         static_cast<Impl*>(this)->completeAttrs(); \
  72         DISPATCH(dispatch##DERIVED##DeclChildren, DERIVED##Decl); \
  73         DISPATCH(dispatch##DERIVED##DeclAsContext, DERIVED##Decl); \
  74         break;
  75 #define ABSTRACT_DECL(DECL)
  76 #include "clang/AST/DeclNodes.inc"
  77     }
  78   }
  79
  80 #define DECL(DERIVED, BASE) \
  81   void dispatch##DERIVED##DeclAttrs(DERIVED##Decl *D) { \
  82     DISPATCH(dispatch##BASE##Attrs, BASE); \
  83     DISPATCH(visit##DERIVED##DeclAttrs, DERIVED##Decl); \
  84   } \
  85   void visit##DERIVED##DeclAttrs(DERIVED##Decl *D) {} \
  86   void dispatch##DERIVED##DeclChildren(DERIVED##Decl *D) { \
  87     DISPATCH(dispatch##BASE##Children, BASE); \
  88     DISPATCH(visit##DERIVED##DeclChildren, DERIVED##Decl); \
  89   } \
  90   void visit##DERIVED##DeclChildren(DERIVED##Decl *D) {} \
  91   void dispatch##DERIVED##DeclAsContext(DERIVED##Decl *D) { \
  92     DISPATCH(dispatch##BASE##AsContext, BASE); \
  93     DISPATCH(visit##DERIVED##DeclAsContext, DERIVED##Decl); \
  94   } \
  95   void visit##DERIVED##DeclAsContext(DERIVED##Decl *D) {}
  96 #include "clang/AST/DeclNodes.inc"
  97
  98   void dispatchDeclAttrs(Decl *D) {
  99     DISPATCH(visitDeclAttrs, Decl);
 100   }
 101   void visitDeclAttrs(Decl *D) {}
 102
 103   void dispatchDeclChildren(Decl *D) {
 104     DISPATCH(visitDeclChildren, Decl);
 105   }
 106   void visitDeclChildren(Decl *D) {}
 107
 108   void dispatchDeclAsContext(Decl *D) {
 109     DISPATCH(visitDeclAsContext, Decl);
 110   }
 111   void visitDeclAsContext(Decl *D) {}
 112
 113 #undef DISPATCH
 114 };
 115
 116 template <class Impl> struct XMLTypeVisitor {
 117 #define DISPATCH(NAME, CLASS) \
 118   static_cast<Impl*>(this)->NAME(static_cast<CLASS*>(T))
 119
 120   void dispatch(Type *T) {
 121     switch (T->getTypeClass()) {
 122 #define TYPE(DERIVED, BASE) \
 123       case Type::DERIVED: \
 124         DISPATCH(dispatch##DERIVED##TypeAttrs, DERIVED##Type); \
 125         static_cast<Impl*>(this)->completeAttrs(); \
 126         DISPATCH(dispatch##DERIVED##TypeChildren, DERIVED##Type); \
 127         break;
 128 #define ABSTRACT_TYPE(DERIVED, BASE)
 129 #include "clang/AST/TypeNodes.def"
 130     }
 131   }
 132
 133 #define TYPE(DERIVED, BASE) \
 134   void dispatch##DERIVED##TypeAttrs(DERIVED##Type *T) { \
 135     DISPATCH(dispatch##BASE##Attrs, BASE); \
 136     DISPATCH(visit##DERIVED##TypeAttrs, DERIVED##Type); \
 137   } \
 138   void visit##DERIVED##TypeAttrs(DERIVED##Type *T) {} \
 139   void dispatch##DERIVED##TypeChildren(DERIVED##Type *T) { \
 140     DISPATCH(dispatch##BASE##Children, BASE); \
 141     DISPATCH(visit##DERIVED##TypeChildren, DERIVED##Type); \
 142   } \
 143   void visit##DERIVED##TypeChildren(DERIVED##Type *T) {}
 144 #include "clang/AST/TypeNodes.def"
 145
 146   void dispatchTypeAttrs(Type *T) {
 147     DISPATCH(visitTypeAttrs, Type);
 148   }
 149   void visitTypeAttrs(Type *T) {}
 150
 151   void dispatchTypeChildren(Type *T) {
 152     DISPATCH(visitTypeChildren, Type);
 153   }
 154   void visitTypeChildren(Type *T) {}
 155
 156 #undef DISPATCH
 157 };
 158
 159 static StringRef getTypeKindName(Type *T) {
 160   switch (T->getTypeClass()) {
 161 #define TYPE(DERIVED, BASE) case Type::DERIVED: return #DERIVED "Type";
 162 #define ABSTRACT_TYPE(DERIVED, BASE)
 163 #include "clang/AST/TypeNodes.def"
 164   }
 165
 166   llvm_unreachable("unknown type kind!");
 167 }
 168
 169 struct XMLDumper : public XMLDeclVisitor<XMLDumper>,
 170                    public XMLTypeVisitor<XMLDumper> {
 171   raw_ostream &out;
 172   ASTContext &Context;
 173   SmallVector<Node, 16> Stack;
 174   unsigned Indent;
 175   explicit XMLDumper(raw_ostream &OS, ASTContext &context)
 176     : out(OS), Context(context), Indent(0) {}
 177
 178   void indent() {
 179     for (unsigned I = Indent; I; --I)
 180       out << ' ';
 181   }
 182
 183   /// Push a new node on the stack.
 184   void push(StringRef name) {
 185     if (!Stack.empty()) {
 186       assert(Stack.back().isDoneWithAttrs());
 187       if (Stack.back().State == NS_LazyChildren) {
 188         Stack.back().State = NS_Children;
 189         out << ">\n";
 190       }
 191       Indent++;
 192       indent();
 193     }
 194     Stack.push_back(Node(name));
 195     out << '<' << name;
 196   }
 197
 198   /// Set the given attribute to the given value.
 199   void set(StringRef attr, StringRef value) {
 200     assert(!Stack.empty() && !Stack.back().isDoneWithAttrs());
 201     out << ' ' << attr << '=' << '"' << value << '"'; // TODO: quotation
 202   }
 203
 204   /// Finish attributes.
 205   void completeAttrs() {
 206     assert(!Stack.empty() && !Stack.back().isDoneWithAttrs());
 207     Stack.back().State = NS_LazyChildren;
 208   }
 209
 210   /// Pop a node.
 211   void pop() {
 212     assert(!Stack.empty() && Stack.back().isDoneWithAttrs());
 213     if (Stack.back().State == NS_LazyChildren) {
 214       out << "/>\n";
 215     } else {
 216       indent();
 217       out << "</" << Stack.back().Name << ">\n";
 218     }
 219     if (Stack.size() > 1) Indent--;
 220     Stack.pop_back();
 221   }
 222
 223   //---- General utilities -------------------------------------------//
 224
 225   void setPointer(StringRef prop, const void *p) {
 226     SmallString<10> buffer;
 227     llvm::raw_svector_ostream os(buffer);
 228     os << p;
 229     os.flush();
 230     set(prop, buffer);
 231   }
 232
 233   void setPointer(void *p) {
 234     setPointer("ptr", p);
 235   }
 236
 237   void setInteger(StringRef prop, const llvm::APSInt &v) {
 238     set(prop, v.toString(10));
 239   }
 240
 241   void setInteger(StringRef prop, unsigned n) {
 242     SmallString<10> buffer;
 243     llvm::raw_svector_ostream os(buffer);
 244     os << n;
 245     os.flush();
 246     set(prop, buffer);
 247   }
 248
 249   void setFlag(StringRef prop, bool flag) {
 250     if (flag) set(prop, "true");
 251   }
 252
 253   void setName(DeclarationName Name) {
 254     if (!Name)
 255       return set("name", "");
 256
 257     // Common case.
 258     if (Name.isIdentifier())
 259       return set("name", Name.getAsIdentifierInfo()->getName());
 260
 261     set("name", Name.getAsString());
 262   }
 263
 264   class TemporaryContainer {
 265     XMLDumper &Dumper;
 266   public:
 267     TemporaryContainer(XMLDumper &dumper, StringRef name)
 268       : Dumper(dumper) {
 269       Dumper.push(name);
 270       Dumper.completeAttrs();
 271     }
 272
 273     ~TemporaryContainer() {
 274       Dumper.pop();
 275     }
 276   };
 277
 278   void visitTemplateParameters(TemplateParameterList *L) {
 279     push("template_parameters");
 280     completeAttrs();
 281     for (TemplateParameterList::iterator
 282            I = L->begin(), E = L->end(); I != E; ++I)
 283       dispatch(*I);
 284     pop();
 285   }
 286
 287   void visitTemplateArguments(const TemplateArgumentList &L) {
 288     push("template_arguments");
 289     completeAttrs();
 290     for (unsigned I = 0, E = L.size(); I != E; ++I)
 291       dispatch(L[I]);
 292     pop();
 293   }
 294
 295   /// Visits a reference to the given declaration.
 296   void visitDeclRef(Decl *D) {
 297     push(D->getDeclKindName());
 298     setPointer("ref", D);
 299     completeAttrs();
 300     pop();
 301   }
 302   void visitDeclRef(StringRef Name, Decl *D) {
 303     TemporaryContainer C(*this, Name);
 304     if (D) visitDeclRef(D);
 305   }
 306
 307   void dispatch(const TemplateArgument &A) {
 308     switch (A.getKind()) {
 309     case TemplateArgument::Null: {
 310       TemporaryContainer C(*this, "null");
 311       break;
 312     }
 313     case TemplateArgument::Type: {
 314       dispatch(A.getAsType());
 315       break;
 316     }
 317     case TemplateArgument::Template:
 318     case TemplateArgument::TemplateExpansion:
 319       // FIXME: Implement!
 320       break;
 321
 322     case TemplateArgument::Declaration: {
 323       if (Decl *D = A.getAsDecl())
 324         visitDeclRef(D);
 325       break;
 326     }
 327     case TemplateArgument::Integral: {
 328       push("integer");
 329       setInteger("value", *A.getAsIntegral());
 330       completeAttrs();
 331       pop();
 332       break;
 333     }
 334     case TemplateArgument::Expression: {
 335       dispatch(A.getAsExpr());
 336       break;
 337     }
 338     case TemplateArgument::Pack: {
 339       for (TemplateArgument::pack_iterator P = A.pack_begin(),
 340                                         PEnd = A.pack_end();
 341            P != PEnd; ++P)
 342         dispatch(*P);
 343       break;
 344     }
 345     }
 346   }
 347
 348   void dispatch(const TemplateArgumentLoc &A) {
 349     dispatch(A.getArgument());
 350   }
 351
 352   //---- Declarations ------------------------------------------------//
 353   // Calls are made in this order:
 354   //   # Enter a new node.
 355   //   push("FieldDecl")
 356   //
 357   //   # In this phase, attributes are set on the node.
 358   //   visitDeclAttrs(D)
 359   //   visitNamedDeclAttrs(D)
 360   //   ...
 361   //   visitFieldDeclAttrs(D)
 362   //
 363   //   # No more attributes after this point.
 364   //   completeAttrs()
 365   //
 366   //   # Create "header" child nodes, i.e. those which logically
 367   //   # belong to the declaration itself.
 368   //   visitDeclChildren(D)
 369   //   visitNamedDeclChildren(D)
 370   //   ...
 371   //   visitFieldDeclChildren(D)
 372   //
 373   //   # Create nodes for the lexical children.
 374   //   visitDeclAsContext(D)
 375   //   visitNamedDeclAsContext(D)
 376   //   ...
 377   //   visitFieldDeclAsContext(D)
 378   //
 379   //   # Finish the node.
 380   //   pop();
 381   void dispatch(Decl *D) {
 382     push(D->getDeclKindName());
 383     XMLDeclVisitor<XMLDumper>::dispatch(D);
 384     pop();
 385   }
 386   void visitDeclAttrs(Decl *D) {
 387     setPointer(D);
 388   }
 389
 390   /// Visit all the lexical decls in the given context.
 391   void visitDeclContext(DeclContext *DC) {
 392     for (DeclContext::decl_iterator
 393            I = DC->decls_begin(), E = DC->decls_end(); I != E; ++I)
 394       dispatch(*I);
 395
 396     // FIXME: point out visible declarations not in lexical context?
 397   }
 398
 399   /// Set the "access" attribute on the current node according to the
 400   /// given specifier.
 401   void setAccess(AccessSpecifier AS) {
 402     switch (AS) {
 403     case AS_public: return set("access", "public");
 404     case AS_protected: return set("access", "protected");
 405     case AS_private: return set("access", "private");
 406     case AS_none: llvm_unreachable("explicit forbidden access");
 407     }
 408   }
 409
 410   template <class T> void visitRedeclarableAttrs(T *D) {
 411     if (T *Prev = D->getPreviousDecl())
 412       setPointer("previous", Prev);
 413   }
 414
 415
 416   // TranslationUnitDecl
 417   void visitTranslationUnitDeclAsContext(TranslationUnitDecl *D) {
 418     visitDeclContext(D);
 419   }
 420
 421   // LinkageSpecDecl
 422   void visitLinkageSpecDeclAttrs(LinkageSpecDecl *D) {
 423     StringRef lang = "";
 424     switch (D->getLanguage()) {
 425     case LinkageSpecDecl::lang_c: lang = "C"; break;
 426     case LinkageSpecDecl::lang_cxx: lang = "C++"; break;
 427     }
 428     set("lang", lang);
 429   }
 430   void visitLinkageSpecDeclAsContext(LinkageSpecDecl *D) {
 431     visitDeclContext(D);
 432   }
 433
 434   // NamespaceDecl
 435   void visitNamespaceDeclAttrs(NamespaceDecl *D) {
 436     setFlag("inline", D->isInline());
 437     if (!D->isOriginalNamespace())
 438       setPointer("original", D->getOriginalNamespace());
 439   }
 440   void visitNamespaceDeclAsContext(NamespaceDecl *D) {
 441     visitDeclContext(D);
 442   }
 443
 444   // NamedDecl
 445   void visitNamedDeclAttrs(NamedDecl *D) {
 446     setName(D->getDeclName());
 447   }
 448
 449   // ValueDecl
 450   void visitValueDeclChildren(ValueDecl *D) {
 451     dispatch(D->getType());
 452   }
 453
 454   // DeclaratorDecl
 455   void visitDeclaratorDeclChildren(DeclaratorDecl *D) {
 456     //dispatch(D->getTypeSourceInfo()->getTypeLoc());
 457   }
 458
 459   // VarDecl
 460   void visitVarDeclAttrs(VarDecl *D) {
 461     visitRedeclarableAttrs(D);
 462     if (D->getStorageClass() != SC_None)
 463       set("storage",
 464           VarDecl::getStorageClassSpecifierString(D->getStorageClass()));
 465     StringRef initStyle = "";
 466     switch (D->getInitStyle()) {
 467     case VarDecl::CInit: initStyle = "c"; break;
 468     case VarDecl::CallInit: initStyle = "call"; break;
 469     case VarDecl::ListInit: initStyle = "list"; break;
 470     }
 471     set("initstyle", initStyle);
 472     setFlag("nrvo", D->isNRVOVariable());
 473     // TODO: instantiation, etc.
 474   }
 475   void visitVarDeclChildren(VarDecl *D) {
 476     if (D->hasInit()) dispatch(D->getInit());
 477   }
 478
 479   // ParmVarDecl?
 480
 481   // FunctionDecl
 482   void visitFunctionDeclAttrs(FunctionDecl *D) {
 483     visitRedeclarableAttrs(D);
 484     setFlag("pure", D->isPure());
 485     setFlag("trivial", D->isTrivial());
 486     setFlag("returnzero", D->hasImplicitReturnZero());
 487     setFlag("prototype", D->hasWrittenPrototype());
 488     setFlag("deleted", D->isDeletedAsWritten());
 489     if (D->getStorageClass() != SC_None)
 490       set("storage",
 491           VarDecl::getStorageClassSpecifierString(D->getStorageClass()));
 492     setFlag("inline", D->isInlineSpecified());
 493     if (const AsmLabelAttr *ALA = D->getAttr<AsmLabelAttr>())
 494       set("asmlabel", ALA->getLabel());
 495     // TODO: instantiation, etc.
 496   }
 497   void visitFunctionDeclChildren(FunctionDecl *D) {
 498     for (FunctionDecl::param_iterator
 499            I = D->param_begin(), E = D->param_end(); I != E; ++I)
 500       dispatch(*I);
 501     for (llvm::ArrayRef<NamedDecl*>::iterator
 502            I = D->getDeclsInPrototypeScope().begin(), E = D->getDeclsInPrototypeScope().end();
 503          I != E; ++I)
 504       dispatch(*I);
 505     if (D->doesThisDeclarationHaveABody())
 506       dispatch(D->getBody());
 507   }
 508
 509   // CXXMethodDecl ?
 510   // CXXConstructorDecl ?
 511   // CXXDestructorDecl ?
 512   // CXXConversionDecl ?
 513
 514   void dispatch(CXXCtorInitializer *Init) {
 515     // TODO
 516   }
 517
 518   // FieldDecl
 519   void visitFieldDeclAttrs(FieldDecl *D) {
 520     setFlag("mutable", D->isMutable());
 521   }
 522   void visitFieldDeclChildren(FieldDecl *D) {
 523     if (D->isBitField()) {
 524       TemporaryContainer C(*this, "bitwidth");
 525       dispatch(D->getBitWidth());
 526     }
 527     // TODO: C++0x member initializer
 528   }
 529
 530   // EnumConstantDecl
 531   void visitEnumConstantDeclChildren(EnumConstantDecl *D) {
 532     // value in any case?
 533     if (D->getInitExpr()) dispatch(D->getInitExpr());
 534   }
 535
 536   // IndirectFieldDecl
 537   void visitIndirectFieldDeclChildren(IndirectFieldDecl *D) {
 538     for (IndirectFieldDecl::chain_iterator
 539            I = D->chain_begin(), E = D->chain_end(); I != E; ++I) {
 540       NamedDecl *VD = const_cast<NamedDecl*>(*I);
 541       push(isa<VarDecl>(VD) ? "variable" : "field");
 542       setPointer("ptr", VD);
 543       completeAttrs();
 544       pop();
 545     }
 546   }
 547
 548   // TypeDecl
 549   void visitTypeDeclAttrs(TypeDecl *D) {
 550     setPointer("typeptr", D->getTypeForDecl());
 551   }
 552
 553   // TypedefDecl
 554   void visitTypedefDeclAttrs(TypedefDecl *D) {
 555     visitRedeclarableAttrs<TypedefNameDecl>(D);
 556   }
 557   void visitTypedefDeclChildren(TypedefDecl *D) {
 558     dispatch(D->getTypeSourceInfo()->getTypeLoc());
 559   }
 560
 561   // TypeAliasDecl
 562   void visitTypeAliasDeclAttrs(TypeAliasDecl *D) {
 563     visitRedeclarableAttrs<TypedefNameDecl>(D);
 564   }
 565   void visitTypeAliasDeclChildren(TypeAliasDecl *D) {
 566     dispatch(D->getTypeSourceInfo()->getTypeLoc());
 567   }
 568
 569   // TagDecl
 570   void visitTagDeclAttrs(TagDecl *D) {
 571     visitRedeclarableAttrs(D);
 572   }
 573   void visitTagDeclAsContext(TagDecl *D) {
 574     visitDeclContext(D);
 575   }
 576
 577   // EnumDecl
 578   void visitEnumDeclAttrs(EnumDecl *D) {
 579     setFlag("scoped", D->isScoped());
 580     setFlag("fixed", D->isFixed());
 581   }
 582   void visitEnumDeclChildren(EnumDecl *D) {
 583     {
 584       TemporaryContainer C(*this, "promotion_type");
 585       dispatch(D->getPromotionType());
 586     }
 587     {
 588       TemporaryContainer C(*this, "integer_type");
 589       dispatch(D->getIntegerType());
 590     }
 591   }
 592
 593   // RecordDecl ?
 594
 595   void visitCXXRecordDeclChildren(CXXRecordDecl *D) {
 596     if (!D->isThisDeclarationADefinition()) return;
 597
 598     for (CXXRecordDecl::base_class_iterator
 599            I = D->bases_begin(), E = D->bases_end(); I != E; ++I) {
 600       push("base");
 601       setAccess(I->getAccessSpecifier());
 602       completeAttrs();
 603       dispatch(I->getTypeSourceInfo()->getTypeLoc());
 604       pop();
 605     }
 606   }
 607
 608   // ClassTemplateSpecializationDecl ?
 609
 610   // FileScopeAsmDecl ?
 611
 612   // BlockDecl
 613   void visitBlockDeclAttrs(BlockDecl *D) {
 614     setFlag("variadic", D->isVariadic());
 615   }
 616   void visitBlockDeclChildren(BlockDecl *D) {
 617     for (FunctionDecl::param_iterator
 618            I = D->param_begin(), E = D->param_end(); I != E; ++I)
 619       dispatch(*I);
 620     dispatch(D->getBody());
 621   }
 622
 623   // AccessSpecDecl
 624   void visitAccessSpecDeclAttrs(AccessSpecDecl *D) {
 625     setAccess(D->getAccess());
 626   }
 627
 628   // TemplateDecl
 629   void visitTemplateDeclChildren(TemplateDecl *D) {
 630     visitTemplateParameters(D->getTemplateParameters());
 631     if (D->getTemplatedDecl())
 632       dispatch(D->getTemplatedDecl());
 633   }
 634
 635   // FunctionTemplateDecl
 636   void visitFunctionTemplateDeclAttrs(FunctionTemplateDecl *D) {
 637     visitRedeclarableAttrs(D);
 638   }
 639   void visitFunctionTemplateDeclChildren(FunctionTemplateDecl *D) {
 640     // Mention all the specializations which don't have explicit
 641     // declarations elsewhere.
 642     for (FunctionTemplateDecl::spec_iterator
 643            I = D->spec_begin(), E = D->spec_end(); I != E; ++I) {
 644       FunctionTemplateSpecializationInfo *Info
 645         = I->getTemplateSpecializationInfo();
 646
 647       bool Unknown = false;
 648       switch (Info->getTemplateSpecializationKind()) {
 649       case TSK_ImplicitInstantiation: Unknown = false; break;
 650       case TSK_Undeclared: Unknown = true; break;
 651
 652       // These will be covered at their respective sites.
 653       case TSK_ExplicitSpecialization: continue;
 654       case TSK_ExplicitInstantiationDeclaration: continue;
 655       case TSK_ExplicitInstantiationDefinition: continue;
 656       }
 657
 658       TemporaryContainer C(*this,
 659                            Unknown ? "uninstantiated" : "instantiation");
 660       visitTemplateArguments(*Info->TemplateArguments);
 661       dispatch(Info->Function);
 662     }
 663   }
 664
 665   // ClasTemplateDecl
 666   void visitClassTemplateDeclAttrs(ClassTemplateDecl *D) {
 667     visitRedeclarableAttrs(D);
 668   }
 669   void visitClassTemplateDeclChildren(ClassTemplateDecl *D) {
 670     // Mention all the specializations which don't have explicit
 671     // declarations elsewhere.
 672     for (ClassTemplateDecl::spec_iterator
 673            I = D->spec_begin(), E = D->spec_end(); I != E; ++I) {
 674
 675       bool Unknown = false;
 676       switch (I->getTemplateSpecializationKind()) {
 677       case TSK_ImplicitInstantiation: Unknown = false; break;
 678       case TSK_Undeclared: Unknown = true; break;
 679
 680       // These will be covered at their respective sites.
 681       case TSK_ExplicitSpecialization: continue;
 682       case TSK_ExplicitInstantiationDeclaration: continue;
 683       case TSK_ExplicitInstantiationDefinition: continue;
 684       }
 685
 686       TemporaryContainer C(*this,
 687                            Unknown ? "uninstantiated" : "instantiation");
 688       visitTemplateArguments(I->getTemplateArgs());
 689       dispatch(*I);
 690     }
 691   }
 692
 693   // TemplateTypeParmDecl
 694   void visitTemplateTypeParmDeclAttrs(TemplateTypeParmDecl *D) {
 695     setInteger("depth", D->getDepth());
 696     setInteger("index", D->getIndex());
 697   }
 698   void visitTemplateTypeParmDeclChildren(TemplateTypeParmDecl *D) {
 699     if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
 700       dispatch(D->getDefaultArgumentInfo()->getTypeLoc());
 701     // parameter pack?
 702   }
 703
 704   // NonTypeTemplateParmDecl
 705   void visitNonTypeTemplateParmDeclAttrs(NonTypeTemplateParmDecl *D) {
 706     setInteger("depth", D->getDepth());
 707     setInteger("index", D->getIndex());
 708   }
 709   void visitNonTypeTemplateParmDeclChildren(NonTypeTemplateParmDecl *D) {
 710     if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
 711       dispatch(D->getDefaultArgument());
 712     // parameter pack?
 713   }
 714
 715   // TemplateTemplateParmDecl
 716   void visitTemplateTemplateParmDeclAttrs(TemplateTemplateParmDecl *D) {
 717     setInteger("depth", D->getDepth());
 718     setInteger("index", D->getIndex());
 719   }
 720   void visitTemplateTemplateParmDeclChildren(TemplateTemplateParmDecl *D) {
 721     if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
 722       dispatch(D->getDefaultArgument());
 723     // parameter pack?
 724   }
 725
 726   // FriendDecl
 727   void visitFriendDeclChildren(FriendDecl *D) {
 728     if (TypeSourceInfo *T = D->getFriendType())
 729       dispatch(T->getTypeLoc());
 730     else
 731       dispatch(D->getFriendDecl());
 732   }
 733
 734   // UsingDirectiveDecl ?
 735   // UsingDecl ?
 736   // UsingShadowDecl ?
 737   // NamespaceAliasDecl ?
 738   // UnresolvedUsingValueDecl ?
 739   // UnresolvedUsingTypenameDecl ?
 740   // StaticAssertDecl ?
 741
 742   // ObjCImplDecl
 743   void visitObjCImplDeclChildren(ObjCImplDecl *D) {
 744     visitDeclRef(D->getClassInterface());
 745   }
 746   void visitObjCImplDeclAsContext(ObjCImplDecl *D) {
 747     visitDeclContext(D);
 748   }
 749
 750   // ObjCInterfaceDecl
 751   void visitCategoryList(ObjCCategoryDecl *D) {
 752     if (!D) return;
 753
 754     TemporaryContainer C(*this, "categories");
 755     for (; D; D = D->getNextClassCategory())
 756       visitDeclRef(D);
 757   }
 758   void visitObjCInterfaceDeclAttrs(ObjCInterfaceDecl *D) {
 759     setPointer("typeptr", D->getTypeForDecl());
 760     setFlag("forward_decl", !D->isThisDeclarationADefinition());
 761     setFlag("implicit_interface", D->isImplicitInterfaceDecl());
 762   }
 763   void visitObjCInterfaceDeclChildren(ObjCInterfaceDecl *D) {
 764     visitDeclRef("super", D->getSuperClass());
 765     visitDeclRef("implementation", D->getImplementation());
 766     if (D->protocol_begin() != D->protocol_end()) {
 767       TemporaryContainer C(*this, "protocols");
 768       for (ObjCInterfaceDecl::protocol_iterator
 769              I = D->protocol_begin(), E = D->protocol_end(); I != E; ++I)
 770         visitDeclRef(*I);
 771     }
 772     visitCategoryList(D->getCategoryList());
 773   }
 774   void visitObjCInterfaceDeclAsContext(ObjCInterfaceDecl *D) {
 775     visitDeclContext(D);
 776   }
 777
 778   // ObjCCategoryDecl
 779   void visitObjCCategoryDeclAttrs(ObjCCategoryDecl *D) {
 780     setFlag("extension", D->IsClassExtension());
 781     setFlag("synth_bitfield", D->hasSynthBitfield());
 782   }
 783   void visitObjCCategoryDeclChildren(ObjCCategoryDecl *D) {
 784     visitDeclRef("interface", D->getClassInterface());
 785     visitDeclRef("implementation", D->getImplementation());
 786     if (D->protocol_begin() != D->protocol_end()) {
 787       TemporaryContainer C(*this, "protocols");
 788       for (ObjCCategoryDecl::protocol_iterator
 789              I = D->protocol_begin(), E = D->protocol_end(); I != E; ++I)
 790         visitDeclRef(*I);
 791     }
 792   }
 793   void visitObjCCategoryDeclAsContext(ObjCCategoryDecl *D) {
 794     visitDeclContext(D);
 795   }
 796
 797   // ObjCCategoryImplDecl
 798   void visitObjCCategoryImplDeclAttrs(ObjCCategoryImplDecl *D) {
 799     set("identifier", D->getName());
 800   }
 801   void visitObjCCategoryImplDeclChildren(ObjCCategoryImplDecl *D) {
 802     visitDeclRef(D->getCategoryDecl());
 803   }
 804
 805   // ObjCImplementationDecl
 806   void visitObjCImplementationDeclAttrs(ObjCImplementationDecl *D) {
 807     setFlag("synth_bitfield", D->hasSynthBitfield());
 808     set("identifier", D->getName());
 809   }
 810   void visitObjCImplementationDeclChildren(ObjCImplementationDecl *D) {
 811     visitDeclRef("super", D->getSuperClass());
 812     if (D->init_begin() != D->init_end()) {
 813       TemporaryContainer C(*this, "initializers");
 814       for (ObjCImplementationDecl::init_iterator
 815              I = D->init_begin(), E = D->init_end(); I != E; ++I)
 816         dispatch(*I);
 817     }
 818   }
 819
 820   // ObjCProtocolDecl
 821   void visitObjCProtocolDeclChildren(ObjCProtocolDecl *D) {
 822     if (!D->isThisDeclarationADefinition())
 823       return;
 824
 825     if (D->protocol_begin() != D->protocol_end()) {
 826       TemporaryContainer C(*this, "protocols");
 827       for (ObjCInterfaceDecl::protocol_iterator
 828              I = D->protocol_begin(), E = D->protocol_end(); I != E; ++I)
 829         visitDeclRef(*I);
 830     }
 831   }
 832   void visitObjCProtocolDeclAsContext(ObjCProtocolDecl *D) {
 833     if (!D->isThisDeclarationADefinition())
 834       return;
 835
 836     visitDeclContext(D);
 837   }
 838
 839   // ObjCMethodDecl
 840   void visitObjCMethodDeclAttrs(ObjCMethodDecl *D) {
 841     // decl qualifier?
 842     // implementation control?
 843
 844     setFlag("instance", D->isInstanceMethod());
 845     setFlag("variadic", D->isVariadic());
 846     setFlag("synthesized", D->isSynthesized());
 847     setFlag("defined", D->isDefined());
 848     setFlag("related_result_type", D->hasRelatedResultType());
 849   }
 850   void visitObjCMethodDeclChildren(ObjCMethodDecl *D) {
 851     dispatch(D->getResultType());
 852     for (ObjCMethodDecl::param_iterator
 853            I = D->param_begin(), E = D->param_end(); I != E; ++I)
 854       dispatch(*I);
 855     if (D->isThisDeclarationADefinition())
 856       dispatch(D->getBody());
 857   }
 858
 859   // ObjCIvarDecl
 860   void setAccessControl(StringRef prop, ObjCIvarDecl::AccessControl AC) {
 861     switch (AC) {
 862     case ObjCIvarDecl::None: return set(prop, "none");
 863     case ObjCIvarDecl::Private: return set(prop, "private");
 864     case ObjCIvarDecl::Protected: return set(prop, "protected");
 865     case ObjCIvarDecl::Public: return set(prop, "public");
 866     case ObjCIvarDecl::Package: return set(prop, "package");
 867     }
 868   }
 869   void visitObjCIvarDeclAttrs(ObjCIvarDecl *D) {
 870     setFlag("synthesize", D->getSynthesize());
 871     setAccessControl("access", D->getAccessControl());
 872   }
 873
 874   // ObjCCompatibleAliasDecl
 875   void visitObjCCompatibleAliasDeclChildren(ObjCCompatibleAliasDecl *D) {
 876     visitDeclRef(D->getClassInterface());
 877   }
 878
 879   // FIXME: ObjCPropertyDecl
 880   // FIXME: ObjCPropertyImplDecl
 881
 882   //---- Types -----------------------------------------------------//
 883   void dispatch(TypeLoc TL) {
 884     dispatch(TL.getType()); // for now
 885   }
 886
 887   void dispatch(QualType T) {
 888     if (T.hasLocalQualifiers()) {
 889       push("QualType");
 890       Qualifiers Qs = T.getLocalQualifiers();
 891       setFlag("const", Qs.hasConst());
 892       setFlag("volatile", Qs.hasVolatile());
 893       setFlag("restrict", Qs.hasRestrict());
 894       if (Qs.hasAddressSpace()) setInteger("addrspace", Qs.getAddressSpace());
 895       if (Qs.hasObjCGCAttr()) {
 896         switch (Qs.getObjCGCAttr()) {
 897         case Qualifiers::Weak: set("gc", "weak"); break;
 898         case Qualifiers::Strong: set("gc", "strong"); break;
 899         case Qualifiers::GCNone: llvm_unreachable("explicit none");
 900         }
 901       }
 902
 903       completeAttrs();
 904       dispatch(QualType(T.getTypePtr(), 0));
 905       pop();
 906       return;
 907     }
 908
 909     Type *Ty = const_cast<Type*>(T.getTypePtr());
 910     push(getTypeKindName(Ty));
 911     XMLTypeVisitor<XMLDumper>::dispatch(const_cast<Type*>(T.getTypePtr()));
 912     pop();
 913   }
 914
 915   void setCallingConv(CallingConv CC) {
 916     switch (CC) {
 917     case CC_Default: return;
 918     case CC_C: return set("cc", "cdecl");
 919     case CC_X86FastCall: return set("cc", "x86_fastcall");
 920     case CC_X86StdCall: return set("cc", "x86_stdcall");
 921     case CC_X86ThisCall: return set("cc", "x86_thiscall");
 922     case CC_X86Pascal: return set("cc", "x86_pascal");
 923     case CC_AAPCS: return set("cc", "aapcs");
 924     case CC_AAPCS_VFP: return set("cc", "aapcs_vfp");
 925     }
 926   }
 927
 928   void visitTypeAttrs(Type *D) {
 929     setPointer(D);
 930     setFlag("dependent", D->isDependentType());
 931     setFlag("variably_modified", D->isVariablyModifiedType());
 932
 933     setPointer("canonical", D->getCanonicalTypeInternal().getAsOpaquePtr());
 934   }
 935
 936   void visitPointerTypeChildren(PointerType *T) {
 937     dispatch(T->getPointeeType());
 938   }
 939   void visitReferenceTypeChildren(ReferenceType *T) {
 940     dispatch(T->getPointeeType());
 941   }
 942   void visitObjCObjectPointerTypeChildren(ObjCObjectPointerType *T) {
 943     dispatch(T->getPointeeType());
 944   }
 945   void visitBlockPointerTypeChildren(BlockPointerType *T) {
 946     dispatch(T->getPointeeType());
 947   }
 948
 949   // Types that just wrap declarations.
 950   void visitTagTypeChildren(TagType *T) {
 951     visitDeclRef(T->getDecl());
 952   }
 953   void visitTypedefTypeChildren(TypedefType *T) {
 954     visitDeclRef(T->getDecl());
 955   }
 956   void visitObjCInterfaceTypeChildren(ObjCInterfaceType *T) {
 957     visitDeclRef(T->getDecl());
 958   }
 959   void visitUnresolvedUsingTypeChildren(UnresolvedUsingType *T) {
 960     visitDeclRef(T->getDecl());
 961   }
 962   void visitInjectedClassNameTypeChildren(InjectedClassNameType *T) {
 963     visitDeclRef(T->getDecl());
 964   }
 965
 966   void visitFunctionTypeAttrs(FunctionType *T) {
 967     setFlag("noreturn", T->getNoReturnAttr());
 968     setCallingConv(T->getCallConv());
 969     if (T->getHasRegParm()) setInteger("regparm", T->getRegParmType());
 970   }
 971   void visitFunctionTypeChildren(FunctionType *T) {
 972     dispatch(T->getResultType());
 973   }
 974
 975   void visitFunctionProtoTypeAttrs(FunctionProtoType *T) {
 976     setFlag("const", T->getTypeQuals() & Qualifiers::Const);
 977     setFlag("volatile", T->getTypeQuals() & Qualifiers::Volatile);
 978     setFlag("restrict", T->getTypeQuals() & Qualifiers::Restrict);
 979   }
 980   void visitFunctionProtoTypeChildren(FunctionProtoType *T) {
 981     push("parameters");
 982     setFlag("variadic", T->isVariadic());
 983     completeAttrs();
 984     for (FunctionProtoType::arg_type_iterator
 985            I = T->arg_type_begin(), E = T->arg_type_end(); I != E; ++I)
 986       dispatch(*I);
 987     pop();
 988
 989     if (T->hasDynamicExceptionSpec()) {
 990       push("exception_specifiers");
 991       setFlag("any", T->getExceptionSpecType() == EST_MSAny);
 992       completeAttrs();
 993       for (FunctionProtoType::exception_iterator
 994              I = T->exception_begin(), E = T->exception_end(); I != E; ++I)
 995         dispatch(*I);
 996       pop();
 997     }
 998     // FIXME: noexcept specifier
 999   }
1000
1001   void visitTemplateSpecializationTypeChildren(TemplateSpecializationType *T) {
1002     if (const RecordType *RT = T->getAs<RecordType>())
1003       visitDeclRef(RT->getDecl());
1004
1005     // TODO: TemplateName
1006
1007     push("template_arguments");
1008     completeAttrs();
1009     for (unsigned I = 0, E = T->getNumArgs(); I != E; ++I)
1010       dispatch(T->getArg(I));
1011     pop();
1012   }
1013
1014   //---- Statements ------------------------------------------------//
1015   void dispatch(Stmt *S) {
1016     // FIXME: this is not really XML at all
1017     push("Stmt");
1018     out << ">\n";
1019     Stack.back().State = NS_Children; // explicitly become non-lazy
1020     S->dump(out, Context.getSourceManager());
1021     out << '\n';
1022     pop();
1023   }
1024 };
1025 }
1026
1027 void Decl::dumpXML() const {
1028   dumpXML(llvm::errs());
1029 }
1030
1031 void Decl::dumpXML(raw_ostream &out) const {
1032   XMLDumper(out, getASTContext()).dispatch(const_cast<Decl*>(this));
1033 }
1034
1035 #else /* ifndef NDEBUG */
1036
1037 void Decl::dumpXML() const {}
1038 void Decl::dumpXML(raw_ostream &out) const {}
1039
1040 #endif