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