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   StringRef Name;
  57   NodeState State;
  58   Node(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 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   raw_ostream &out;
 176   ASTContext &Context;
 177   SmallVector<Node, 16> Stack;
 178   unsigned Indent;
 179   explicit XMLDumper(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(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(StringRef attr, 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(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(StringRef prop, const llvm::APSInt &v) {
 242     set(prop, v.toString(10));
 243   }
 244
 245   void setInteger(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(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, 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(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     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->isDeletedAsWritten());
 486     if (D->getStorageClass() != SC_None)
 487       set("storage",
 488           VarDecl::getStorageClassSpecifierString(D->getStorageClass()));
 489     setFlag("inline", D->isInlineSpecified());
 490     if (const AsmLabelAttr *ALA = D->getAttr<AsmLabelAttr>())
 491       set("asmlabel", ALA->getLabel());
 492     // TODO: instantiation, etc.
 493   }
 494   void visitFunctionDeclChildren(FunctionDecl *D) {
 495     for (FunctionDecl::param_iterator
 496            I = D->param_begin(), E = D->param_end(); I != E; ++I)
 497       dispatch(*I);
 498     if (D->doesThisDeclarationHaveABody())
 499       dispatch(D->getBody());
 500   }
 501
 502   // CXXMethodDecl ?
 503   // CXXConstructorDecl ?
 504   // CXXDestructorDecl ?
 505   // CXXConversionDecl ?
 506
 507   void dispatch(CXXCtorInitializer *Init) {
 508     // TODO
 509   }
 510
 511   // FieldDecl
 512   void visitFieldDeclAttrs(FieldDecl *D) {
 513     setFlag("mutable", D->isMutable());
 514   }
 515   void visitFieldDeclChildren(FieldDecl *D) {
 516     if (D->isBitField()) {
 517       TemporaryContainer C(*this, "bitwidth");
 518       dispatch(D->getBitWidth());
 519     }
 520     // TODO: C++0x member initializer
 521   }
 522
 523   // EnumConstantDecl
 524   void visitEnumConstantDeclChildren(EnumConstantDecl *D) {
 525     // value in any case?
 526     if (D->getInitExpr()) dispatch(D->getInitExpr());
 527   }
 528
 529   // IndirectFieldDecl
 530   void visitIndirectFieldDeclChildren(IndirectFieldDecl *D) {
 531     for (IndirectFieldDecl::chain_iterator
 532            I = D->chain_begin(), E = D->chain_end(); I != E; ++I) {
 533       NamedDecl *VD = const_cast<NamedDecl*>(*I);
 534       push(isa<VarDecl>(VD) ? "variable" : "field");
 535       setPointer("ptr", VD);
 536       completeAttrs();
 537       pop();
 538     }
 539   }
 540
 541   // TypeDecl
 542   void visitTypeDeclAttrs(TypeDecl *D) {
 543     setPointer("typeptr", D->getTypeForDecl());
 544   }
 545
 546   // TypedefDecl
 547   void visitTypedefDeclAttrs(TypedefDecl *D) {
 548     visitRedeclarableAttrs<TypedefNameDecl>(D);
 549   }
 550   void visitTypedefDeclChildren(TypedefDecl *D) {
 551     dispatch(D->getTypeSourceInfo()->getTypeLoc());
 552   }
 553
 554   // TypeAliasDecl
 555   void visitTypeAliasDeclAttrs(TypeAliasDecl *D) {
 556     visitRedeclarableAttrs<TypedefNameDecl>(D);
 557   }
 558   void visitTypeAliasDeclChildren(TypeAliasDecl *D) {
 559     dispatch(D->getTypeSourceInfo()->getTypeLoc());
 560   }
 561
 562   // TagDecl
 563   void visitTagDeclAttrs(TagDecl *D) {
 564     visitRedeclarableAttrs(D);
 565   }
 566   void visitTagDeclAsContext(TagDecl *D) {
 567     visitDeclContext(D);
 568   }
 569
 570   // EnumDecl
 571   void visitEnumDeclAttrs(EnumDecl *D) {
 572     setFlag("scoped", D->isScoped());
 573     setFlag("fixed", D->isFixed());
 574   }
 575   void visitEnumDeclChildren(EnumDecl *D) {
 576     {
 577       TemporaryContainer C(*this, "promotion_type");
 578       dispatch(D->getPromotionType());
 579     }
 580     {
 581       TemporaryContainer C(*this, "integer_type");
 582       dispatch(D->getIntegerType());
 583     }
 584   }
 585
 586   // RecordDecl ?
 587
 588   void visitCXXRecordDeclChildren(CXXRecordDecl *D) {
 589     if (!D->isThisDeclarationADefinition()) return;
 590
 591     for (CXXRecordDecl::base_class_iterator
 592            I = D->bases_begin(), E = D->bases_end(); I != E; ++I) {
 593       push("base");
 594       setAccess(I->getAccessSpecifier());
 595       completeAttrs();
 596       dispatch(I->getTypeSourceInfo()->getTypeLoc());
 597       pop();
 598     }
 599   }
 600
 601   // ClassTemplateSpecializationDecl ?
 602
 603   // FileScopeAsmDecl ?
 604
 605   // BlockDecl
 606   void visitBlockDeclAttrs(BlockDecl *D) {
 607     setFlag("variadic", D->isVariadic());
 608   }
 609   void visitBlockDeclChildren(BlockDecl *D) {
 610     for (FunctionDecl::param_iterator
 611            I = D->param_begin(), E = D->param_end(); I != E; ++I)
 612       dispatch(*I);
 613     dispatch(D->getBody());
 614   }
 615
 616   // AccessSpecDecl
 617   void visitAccessSpecDeclAttrs(AccessSpecDecl *D) {
 618     setAccess(D->getAccess());
 619   }
 620
 621   // TemplateDecl
 622   void visitTemplateDeclChildren(TemplateDecl *D) {
 623     visitTemplateParameters(D->getTemplateParameters());
 624     if (D->getTemplatedDecl())
 625       dispatch(D->getTemplatedDecl());
 626   }
 627
 628   // FunctionTemplateDecl
 629   void visitFunctionTemplateDeclAttrs(FunctionTemplateDecl *D) {
 630     visitRedeclarableAttrs(D);
 631   }
 632   void visitFunctionTemplateDeclChildren(FunctionTemplateDecl *D) {
 633     // Mention all the specializations which don't have explicit
 634     // declarations elsewhere.
 635     for (FunctionTemplateDecl::spec_iterator
 636            I = D->spec_begin(), E = D->spec_end(); I != E; ++I) {
 637       FunctionTemplateSpecializationInfo *Info
 638         = I->getTemplateSpecializationInfo();
 639
 640       bool Unknown = false;
 641       switch (Info->getTemplateSpecializationKind()) {
 642       case TSK_ImplicitInstantiation: Unknown = false; break;
 643       case TSK_Undeclared: Unknown = true; break;
 644
 645       // These will be covered at their respective sites.
 646       case TSK_ExplicitSpecialization: continue;
 647       case TSK_ExplicitInstantiationDeclaration: continue;
 648       case TSK_ExplicitInstantiationDefinition: continue;
 649       }
 650
 651       TemporaryContainer C(*this,
 652                            Unknown ? "uninstantiated" : "instantiation");
 653       visitTemplateArguments(*Info->TemplateArguments);
 654       dispatch(Info->Function);
 655     }
 656   }
 657
 658   // ClasTemplateDecl
 659   void visitClassTemplateDeclAttrs(ClassTemplateDecl *D) {
 660     visitRedeclarableAttrs(D);
 661   }
 662   void visitClassTemplateDeclChildren(ClassTemplateDecl *D) {
 663     // Mention all the specializations which don't have explicit
 664     // declarations elsewhere.
 665     for (ClassTemplateDecl::spec_iterator
 666            I = D->spec_begin(), E = D->spec_end(); I != E; ++I) {
 667
 668       bool Unknown = false;
 669       switch (I->getTemplateSpecializationKind()) {
 670       case TSK_ImplicitInstantiation: Unknown = false; break;
 671       case TSK_Undeclared: Unknown = true; break;
 672
 673       // These will be covered at their respective sites.
 674       case TSK_ExplicitSpecialization: continue;
 675       case TSK_ExplicitInstantiationDeclaration: continue;
 676       case TSK_ExplicitInstantiationDefinition: continue;
 677       }
 678
 679       TemporaryContainer C(*this,
 680                            Unknown ? "uninstantiated" : "instantiation");
 681       visitTemplateArguments(I->getTemplateArgs());
 682       dispatch(*I);
 683     }
 684   }
 685
 686   // TemplateTypeParmDecl
 687   void visitTemplateTypeParmDeclAttrs(TemplateTypeParmDecl *D) {
 688     setInteger("depth", D->getDepth());
 689     setInteger("index", D->getIndex());
 690   }
 691   void visitTemplateTypeParmDeclChildren(TemplateTypeParmDecl *D) {
 692     if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
 693       dispatch(D->getDefaultArgumentInfo()->getTypeLoc());
 694     // parameter pack?
 695   }
 696
 697   // NonTypeTemplateParmDecl
 698   void visitNonTypeTemplateParmDeclAttrs(NonTypeTemplateParmDecl *D) {
 699     setInteger("depth", D->getDepth());
 700     setInteger("index", D->getIndex());
 701   }
 702   void visitNonTypeTemplateParmDeclChildren(NonTypeTemplateParmDecl *D) {
 703     if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
 704       dispatch(D->getDefaultArgument());
 705     // parameter pack?
 706   }
 707
 708   // TemplateTemplateParmDecl
 709   void visitTemplateTemplateParmDeclAttrs(TemplateTemplateParmDecl *D) {
 710     setInteger("depth", D->getDepth());
 711     setInteger("index", D->getIndex());
 712   }
 713   void visitTemplateTemplateParmDeclChildren(TemplateTemplateParmDecl *D) {
 714     if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
 715       dispatch(D->getDefaultArgument());
 716     // parameter pack?
 717   }
 718
 719   // FriendDecl
 720   void visitFriendDeclChildren(FriendDecl *D) {
 721     if (TypeSourceInfo *T = D->getFriendType())
 722       dispatch(T->getTypeLoc());
 723     else
 724       dispatch(D->getFriendDecl());
 725   }
 726
 727   // UsingDirectiveDecl ?
 728   // UsingDecl ?
 729   // UsingShadowDecl ?
 730   // NamespaceAliasDecl ?
 731   // UnresolvedUsingValueDecl ?
 732   // UnresolvedUsingTypenameDecl ?
 733   // StaticAssertDecl ?
 734
 735   // ObjCImplDecl
 736   void visitObjCImplDeclChildren(ObjCImplDecl *D) {
 737     visitDeclRef(D->getClassInterface());
 738   }
 739   void visitObjCImplDeclAsContext(ObjCImplDecl *D) {
 740     visitDeclContext(D);
 741   }
 742
 743   // ObjCClassDecl
 744   void visitObjCClassDeclChildren(ObjCClassDecl *D) {
 745     visitDeclRef(D->getForwardInterfaceDecl());
 746   }
 747
 748   // ObjCInterfaceDecl
 749   void visitCategoryList(ObjCCategoryDecl *D) {
 750     if (!D) return;
 751
 752     TemporaryContainer C(*this, "categories");
 753     for (; D; D = D->getNextClassCategory())
 754       visitDeclRef(D);
 755   }
 756   void visitObjCInterfaceDeclAttrs(ObjCInterfaceDecl *D) {
 757     setPointer("typeptr", D->getTypeForDecl());
 758     setFlag("forward_decl", D->isForwardDecl());
 759     setFlag("implicit_interface", D->isImplicitInterfaceDecl());
 760   }
 761   void visitObjCInterfaceDeclChildren(ObjCInterfaceDecl *D) {
 762     visitDeclRef("super", D->getSuperClass());
 763     visitDeclRef("implementation", D->getImplementation());
 764     if (D->protocol_begin() != D->protocol_end()) {
 765       TemporaryContainer C(*this, "protocols");
 766       for (ObjCInterfaceDecl::protocol_iterator
 767              I = D->protocol_begin(), E = D->protocol_end(); I != E; ++I)
 768         visitDeclRef(*I);
 769     }
 770     visitCategoryList(D->getCategoryList());
 771   }
 772   void visitObjCInterfaceDeclAsContext(ObjCInterfaceDecl *D) {
 773     visitDeclContext(D);
 774   }
 775
 776   // ObjCCategoryDecl
 777   void visitObjCCategoryDeclAttrs(ObjCCategoryDecl *D) {
 778     setFlag("extension", D->IsClassExtension());
 779     setFlag("synth_bitfield", D->hasSynthBitfield());
 780   }
 781   void visitObjCCategoryDeclChildren(ObjCCategoryDecl *D) {
 782     visitDeclRef("interface", D->getClassInterface());
 783     visitDeclRef("implementation", D->getImplementation());
 784     if (D->protocol_begin() != D->protocol_end()) {
 785       TemporaryContainer C(*this, "protocols");
 786       for (ObjCCategoryDecl::protocol_iterator
 787              I = D->protocol_begin(), E = D->protocol_end(); I != E; ++I)
 788         visitDeclRef(*I);
 789     }
 790   }
 791   void visitObjCCategoryDeclAsContext(ObjCCategoryDecl *D) {
 792     visitDeclContext(D);
 793   }
 794
 795   // ObjCCategoryImplDecl
 796   void visitObjCCategoryImplDeclAttrs(ObjCCategoryImplDecl *D) {
 797     set("identifier", D->getName());
 798   }
 799   void visitObjCCategoryImplDeclChildren(ObjCCategoryImplDecl *D) {
 800     visitDeclRef(D->getCategoryDecl());
 801   }
 802
 803   // ObjCImplementationDecl
 804   void visitObjCImplementationDeclAttrs(ObjCImplementationDecl *D) {
 805     setFlag("synth_bitfield", D->hasSynthBitfield());
 806     set("identifier", D->getName());
 807   }
 808   void visitObjCImplementationDeclChildren(ObjCImplementationDecl *D) {
 809     visitDeclRef("super", D->getSuperClass());
 810     if (D->init_begin() != D->init_end()) {
 811       TemporaryContainer C(*this, "initializers");
 812       for (ObjCImplementationDecl::init_iterator
 813              I = D->init_begin(), E = D->init_end(); I != E; ++I)
 814         dispatch(*I);
 815     }
 816   }
 817
 818   // ObjCForwardProtocolDecl
 819   void visitObjCForwardProtocolDeclChildren(ObjCForwardProtocolDecl *D) {
 820     for (ObjCForwardProtocolDecl::protocol_iterator
 821            I = D->protocol_begin(), E = D->protocol_end(); I != E; ++I)
 822       visitDeclRef(*I);
 823   }
 824
 825   // ObjCProtocolDecl
 826   void visitObjCProtocolDeclAttrs(ObjCProtocolDecl *D) {
 827     setFlag("forward_decl", D->isForwardDecl());
 828   }
 829   void visitObjCProtocolDeclChildren(ObjCProtocolDecl *D) {
 830     if (D->protocol_begin() != D->protocol_end()) {
 831       TemporaryContainer C(*this, "protocols");
 832       for (ObjCInterfaceDecl::protocol_iterator
 833              I = D->protocol_begin(), E = D->protocol_end(); I != E; ++I)
 834         visitDeclRef(*I);
 835     }
 836   }
 837   void visitObjCProtocolDeclAsContext(ObjCProtocolDecl *D) {
 838     visitDeclContext(D);
 839   }
 840
 841   // ObjCMethodDecl
 842   void visitObjCMethodDeclAttrs(ObjCMethodDecl *D) {
 843     // decl qualifier?
 844     // implementation control?
 845
 846     setFlag("instance", D->isInstanceMethod());
 847     setFlag("variadic", D->isVariadic());
 848     setFlag("synthesized", D->isSynthesized());
 849     setFlag("defined", D->isDefined());
 850     setFlag("related_result_type", D->hasRelatedResultType());
 851   }
 852   void visitObjCMethodDeclChildren(ObjCMethodDecl *D) {
 853     dispatch(D->getResultType());
 854     for (ObjCMethodDecl::param_iterator
 855            I = D->param_begin(), E = D->param_end(); I != E; ++I)
 856       dispatch(*I);
 857     if (D->isThisDeclarationADefinition())
 858       dispatch(D->getBody());
 859   }
 860
 861   // ObjCIvarDecl
 862   void setAccessControl(StringRef prop, ObjCIvarDecl::AccessControl AC) {
 863     switch (AC) {
 864     case ObjCIvarDecl::None: return set(prop, "none");
 865     case ObjCIvarDecl::Private: return set(prop, "private");
 866     case ObjCIvarDecl::Protected: return set(prop, "protected");
 867     case ObjCIvarDecl::Public: return set(prop, "public");
 868     case ObjCIvarDecl::Package: return set(prop, "package");
 869     }
 870   }
 871   void visitObjCIvarDeclAttrs(ObjCIvarDecl *D) {
 872     setFlag("synthesize", D->getSynthesize());
 873     setAccessControl("access", D->getAccessControl());
 874   }
 875
 876   // ObjCCompatibleAliasDecl
 877   void visitObjCCompatibleAliasDeclChildren(ObjCCompatibleAliasDecl *D) {
 878     visitDeclRef(D->getClassInterface());
 879   }
 880
 881   // FIXME: ObjCPropertyDecl
 882   // FIXME: ObjCPropertyImplDecl
 883
 884   //---- Types -----------------------------------------------------//
 885   void dispatch(TypeLoc TL) {
 886     dispatch(TL.getType()); // for now
 887   }
 888
 889   void dispatch(QualType T) {
 890     if (T.hasLocalQualifiers()) {
 891       push("QualType");
 892       Qualifiers Qs = T.getLocalQualifiers();
 893       setFlag("const", Qs.hasConst());
 894       setFlag("volatile", Qs.hasVolatile());
 895       setFlag("restrict", Qs.hasRestrict());
 896       if (Qs.hasAddressSpace()) setInteger("addrspace", Qs.getAddressSpace());
 897       if (Qs.hasObjCGCAttr()) {
 898         switch (Qs.getObjCGCAttr()) {
 899         case Qualifiers::Weak: set("gc", "weak"); break;
 900         case Qualifiers::Strong: set("gc", "strong"); break;
 901         case Qualifiers::GCNone: llvm_unreachable("explicit none");
 902         }
 903       }
 904
 905       completeAttrs();
 906       dispatch(QualType(T.getTypePtr(), 0));
 907       pop();
 908       return;
 909     }
 910
 911     Type *Ty = const_cast<Type*>(T.getTypePtr());
 912     push(getTypeKindName(Ty));
 913     XMLTypeVisitor<XMLDumper>::dispatch(const_cast<Type*>(T.getTypePtr()));
 914     pop();
 915   }
 916
 917   void setCallingConv(CallingConv CC) {
 918     switch (CC) {
 919     case CC_Default: return;
 920     case CC_C: return set("cc", "cdecl");
 921     case CC_X86FastCall: return set("cc", "x86_fastcall");
 922     case CC_X86StdCall: return set("cc", "x86_stdcall");
 923     case CC_X86ThisCall: return set("cc", "x86_thiscall");
 924     case CC_X86Pascal: return set("cc", "x86_pascal");
 925     case CC_AAPCS: return set("cc", "aapcs");
 926     case CC_AAPCS_VFP: return set("cc", "aapcs_vfp");
 927     }
 928   }
 929
 930   void visitTypeAttrs(Type *D) {
 931     setPointer(D);
 932     setFlag("dependent", D->isDependentType());
 933     setFlag("variably_modified", D->isVariablyModifiedType());
 934
 935     setPointer("canonical", D->getCanonicalTypeInternal().getAsOpaquePtr());
 936   }
 937
 938   void visitPointerTypeChildren(PointerType *T) {
 939     dispatch(T->getPointeeType());
 940   }
 941   void visitReferenceTypeChildren(ReferenceType *T) {
 942     dispatch(T->getPointeeType());
 943   }
 944   void visitObjCObjectPointerTypeChildren(ObjCObjectPointerType *T) {
 945     dispatch(T->getPointeeType());
 946   }
 947   void visitBlockPointerTypeChildren(BlockPointerType *T) {
 948     dispatch(T->getPointeeType());
 949   }
 950
 951   // Types that just wrap declarations.
 952   void visitTagTypeChildren(TagType *T) {
 953     visitDeclRef(T->getDecl());
 954   }
 955   void visitTypedefTypeChildren(TypedefType *T) {
 956     visitDeclRef(T->getDecl());
 957   }
 958   void visitObjCInterfaceTypeChildren(ObjCInterfaceType *T) {
 959     visitDeclRef(T->getDecl());
 960   }
 961   void visitUnresolvedUsingTypeChildren(UnresolvedUsingType *T) {
 962     visitDeclRef(T->getDecl());
 963   }
 964   void visitInjectedClassNameTypeChildren(InjectedClassNameType *T) {
 965     visitDeclRef(T->getDecl());
 966   }
 967
 968   void visitFunctionTypeAttrs(FunctionType *T) {
 969     setFlag("noreturn", T->getNoReturnAttr());
 970     setCallingConv(T->getCallConv());
 971     if (T->getHasRegParm()) setInteger("regparm", T->getRegParmType());
 972   }
 973   void visitFunctionTypeChildren(FunctionType *T) {
 974     dispatch(T->getResultType());
 975   }
 976
 977   void visitFunctionProtoTypeAttrs(FunctionProtoType *T) {
 978     setFlag("const", T->getTypeQuals() & Qualifiers::Const);
 979     setFlag("volatile", T->getTypeQuals() & Qualifiers::Volatile);
 980     setFlag("restrict", T->getTypeQuals() & Qualifiers::Restrict);
 981   }
 982   void visitFunctionProtoTypeChildren(FunctionProtoType *T) {
 983     push("parameters");
 984     setFlag("variadic", T->isVariadic());
 985     completeAttrs();
 986     for (FunctionProtoType::arg_type_iterator
 987            I = T->arg_type_begin(), E = T->arg_type_end(); I != E; ++I)
 988       dispatch(*I);
 989     pop();
 990
 991     if (T->hasDynamicExceptionSpec()) {
 992       push("exception_specifiers");
 993       setFlag("any", T->getExceptionSpecType() == EST_MSAny);
 994       completeAttrs();
 995       for (FunctionProtoType::exception_iterator
 996              I = T->exception_begin(), E = T->exception_end(); I != E; ++I)
 997         dispatch(*I);
 998       pop();
 999     }
1000     // FIXME: noexcept specifier
1001   }
1002
1003   void visitTemplateSpecializationTypeChildren(TemplateSpecializationType *T) {
1004     if (const RecordType *RT = T->getAs<RecordType>())
1005       visitDeclRef(RT->getDecl());
1006
1007     // TODO: TemplateName
1008
1009     push("template_arguments");
1010     completeAttrs();
1011     for (unsigned I = 0, E = T->getNumArgs(); I != E; ++I)
1012       dispatch(T->getArg(I));
1013     pop();
1014   }
1015
1016   //---- Statements ------------------------------------------------//
1017   void dispatch(Stmt *S) {
1018     // FIXME: this is not really XML at all
1019     push("Stmt");
1020     out << ">\n";
1021     Stack.back().State = NS_Children; // explicitly become non-lazy
1022     S->dump(out, Context.getSourceManager());
1023     out << '\n';
1024     pop();
1025   }
1026 };
1027 }
1028
1029 void Decl::dumpXML() const {
1030   dumpXML(llvm::errs());
1031 }
1032
1033 void Decl::dumpXML(raw_ostream &out) const {
1034   XMLDumper(out, getASTContext()).dispatch(const_cast<Decl*>(this));
1035 }
1036
1037 #else /* ifndef NDEBUG */
1038
1039 void Decl::dumpXML() const {}
1040 void Decl::dumpXML(raw_ostream &out) const {}
1041
1042 #endif