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

   1 //===--- StmtDumper.cpp - Dumping implementation for Stmt ASTs ------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the Stmt::dump/Stmt::print methods, which dump out the
  11 // AST in a form that exposes type details and other fields.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "clang/AST/StmtVisitor.h"
  16 #include "clang/AST/DeclObjC.h"
  17 #include "clang/AST/DeclCXX.h"
  18 #include "clang/AST/PrettyPrinter.h"
  19 #include "clang/Basic/SourceManager.h"
  20 #include "llvm/Support/raw_ostream.h"
  21 using namespace clang;
  22
  23 //===----------------------------------------------------------------------===//
  24 // StmtDumper Visitor
  25 //===----------------------------------------------------------------------===//
  26
  27 namespace  {
  28   class StmtDumper : public StmtVisitor<StmtDumper> {
  29     SourceManager *SM;
  30     llvm::raw_ostream &OS;
  31     unsigned IndentLevel;
  32
  33     /// MaxDepth - When doing a normal dump (not dumpAll) we only want to dump
  34     /// the first few levels of an AST.  This keeps track of how many ast levels
  35     /// are left.
  36     unsigned MaxDepth;
  37
  38     /// LastLocFilename/LastLocLine - Keep track of the last location we print
  39     /// out so that we can print out deltas from then on out.
  40     const char *LastLocFilename;
  41     unsigned LastLocLine;
  42
  43   public:
  44     StmtDumper(SourceManager *sm, llvm::raw_ostream &os, unsigned maxDepth)
  45       : SM(sm), OS(os), IndentLevel(0-1), MaxDepth(maxDepth) {
  46       LastLocFilename = "";
  47       LastLocLine = ~0U;
  48     }
  49
  50     void DumpSubTree(Stmt *S) {
  51       // Prune the recursion if not using dump all.
  52       if (MaxDepth == 0) return;
  53
  54       ++IndentLevel;
  55       if (S) {
  56         if (DeclStmt* DS = dyn_cast<DeclStmt>(S))
  57           VisitDeclStmt(DS);
  58         else {
  59           Visit(S);
  60
  61           // Print out children.
  62           Stmt::child_range CI = S->children();
  63           if (CI) {
  64             while (CI) {
  65               OS << '\n';
  66               DumpSubTree(*CI++);
  67             }
  68           }
  69         }
  70         OS << ')';
  71       } else {
  72         Indent();
  73         OS << "<<<NULL>>>";
  74       }
  75       --IndentLevel;
  76     }
  77
  78     void DumpDeclarator(Decl *D);
  79
  80     void Indent() const {
  81       for (int i = 0, e = IndentLevel; i < e; ++i)
  82         OS << "  ";
  83     }
  84
  85     void DumpType(QualType T) {
  86       SplitQualType T_split = T.split();
  87       OS << "'" << QualType::getAsString(T_split) << "'";
  88
  89       if (!T.isNull()) {
  90         // If the type is sugared, also dump a (shallow) desugared type.
  91         SplitQualType D_split = T.getSplitDesugaredType();
  92         if (T_split != D_split)
  93           OS << ":'" << QualType::getAsString(D_split) << "'";
  94       }
  95     }
  96     void DumpDeclRef(Decl *node);
  97     void DumpStmt(const Stmt *Node) {
  98       Indent();
  99       OS << "(" << Node->getStmtClassName()
 100          << " " << (void*)Node;
 101       DumpSourceRange(Node);
 102     }
 103     void DumpValueKind(ExprValueKind K) {
 104       switch (K) {
 105       case VK_RValue: break;
 106       case VK_LValue: OS << " lvalue"; break;
 107       case VK_XValue: OS << " xvalue"; break;
 108       }
 109     }
 110     void DumpObjectKind(ExprObjectKind K) {
 111       switch (K) {
 112       case OK_Ordinary: break;
 113       case OK_BitField: OS << " bitfield"; break;
 114       case OK_ObjCProperty: OS << " objcproperty"; break;
 115       case OK_VectorComponent: OS << " vectorcomponent"; break;
 116       }
 117     }
 118     void DumpExpr(const Expr *Node) {
 119       DumpStmt(Node);
 120       OS << ' ';
 121       DumpType(Node->getType());
 122       DumpValueKind(Node->getValueKind());
 123       DumpObjectKind(Node->getObjectKind());
 124     }
 125     void DumpSourceRange(const Stmt *Node);
 126     void DumpLocation(SourceLocation Loc);
 127
 128     // Stmts.
 129     void VisitStmt(Stmt *Node);
 130     void VisitDeclStmt(DeclStmt *Node);
 131     void VisitLabelStmt(LabelStmt *Node);
 132     void VisitGotoStmt(GotoStmt *Node);
 133
 134     // Exprs
 135     void VisitExpr(Expr *Node);
 136     void VisitCastExpr(CastExpr *Node);
 137     void VisitDeclRefExpr(DeclRefExpr *Node);
 138     void VisitPredefinedExpr(PredefinedExpr *Node);
 139     void VisitCharacterLiteral(CharacterLiteral *Node);
 140     void VisitIntegerLiteral(IntegerLiteral *Node);
 141     void VisitFloatingLiteral(FloatingLiteral *Node);
 142     void VisitStringLiteral(StringLiteral *Str);
 143     void VisitUnaryOperator(UnaryOperator *Node);
 144     void VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *Node);
 145     void VisitMemberExpr(MemberExpr *Node);
 146     void VisitExtVectorElementExpr(ExtVectorElementExpr *Node);
 147     void VisitBinaryOperator(BinaryOperator *Node);
 148     void VisitCompoundAssignOperator(CompoundAssignOperator *Node);
 149     void VisitAddrLabelExpr(AddrLabelExpr *Node);
 150     void VisitBlockExpr(BlockExpr *Node);
 151
 152     // C++
 153     void VisitCXXNamedCastExpr(CXXNamedCastExpr *Node);
 154     void VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node);
 155     void VisitCXXThisExpr(CXXThisExpr *Node);
 156     void VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node);
 157     void VisitCXXConstructExpr(CXXConstructExpr *Node);
 158     void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *Node);
 159     void VisitExprWithCleanups(ExprWithCleanups *Node);
 160     void VisitUnresolvedLookupExpr(UnresolvedLookupExpr *Node);
 161     void DumpCXXTemporary(CXXTemporary *Temporary);
 162
 163     // ObjC
 164     void VisitObjCAtCatchStmt(ObjCAtCatchStmt *Node);
 165     void VisitObjCEncodeExpr(ObjCEncodeExpr *Node);
 166     void VisitObjCMessageExpr(ObjCMessageExpr* Node);
 167     void VisitObjCSelectorExpr(ObjCSelectorExpr *Node);
 168     void VisitObjCProtocolExpr(ObjCProtocolExpr *Node);
 169     void VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *Node);
 170     void VisitObjCIvarRefExpr(ObjCIvarRefExpr *Node);
 171   };
 172 }
 173
 174 //===----------------------------------------------------------------------===//
 175 //  Utilities
 176 //===----------------------------------------------------------------------===//
 177
 178 void StmtDumper::DumpLocation(SourceLocation Loc) {
 179   SourceLocation SpellingLoc = SM->getSpellingLoc(Loc);
 180
 181   // The general format we print out is filename:line:col, but we drop pieces
 182   // that haven't changed since the last loc printed.
 183   PresumedLoc PLoc = SM->getPresumedLoc(SpellingLoc);
 184
 185   if (PLoc.isInvalid()) {
 186     OS << "<invalid sloc>";
 187     return;
 188   }
 189
 190   if (strcmp(PLoc.getFilename(), LastLocFilename) != 0) {
 191     OS << PLoc.getFilename() << ':' << PLoc.getLine()
 192        << ':' << PLoc.getColumn();
 193     LastLocFilename = PLoc.getFilename();
 194     LastLocLine = PLoc.getLine();
 195   } else if (PLoc.getLine() != LastLocLine) {
 196     OS << "line" << ':' << PLoc.getLine()
 197        << ':' << PLoc.getColumn();
 198     LastLocLine = PLoc.getLine();
 199   } else {
 200     OS << "col" << ':' << PLoc.getColumn();
 201   }
 202 }
 203
 204 void StmtDumper::DumpSourceRange(const Stmt *Node) {
 205   // Can't translate locations if a SourceManager isn't available.
 206   if (SM == 0) return;
 207
 208   // TODO: If the parent expression is available, we can print a delta vs its
 209   // location.
 210   SourceRange R = Node->getSourceRange();
 211
 212   OS << " <";
 213   DumpLocation(R.getBegin());
 214   if (R.getBegin() != R.getEnd()) {
 215     OS << ", ";
 216     DumpLocation(R.getEnd());
 217   }
 218   OS << ">";
 219
 220   // <t2.c:123:421[blah], t2.c:412:321>
 221
 222 }
 223
 224
 225 //===----------------------------------------------------------------------===//
 226 //  Stmt printing methods.
 227 //===----------------------------------------------------------------------===//
 228
 229 void StmtDumper::VisitStmt(Stmt *Node) {
 230   DumpStmt(Node);
 231 }
 232
 233 void StmtDumper::DumpDeclarator(Decl *D) {
 234   // FIXME: Need to complete/beautify this... this code simply shows the
 235   // nodes are where they need to be.
 236   if (TypedefDecl *localType = dyn_cast<TypedefDecl>(D)) {
 237     OS << "\"typedef " << localType->getUnderlyingType().getAsString()
 238        << ' ' << localType << '"';
 239   } else if (TypeAliasDecl *localType = dyn_cast<TypeAliasDecl>(D)) {
 240     OS << "\"using " << localType << " = "
 241        << localType->getUnderlyingType().getAsString() << '"';
 242   } else if (ValueDecl *VD = dyn_cast<ValueDecl>(D)) {
 243     OS << "\"";
 244     // Emit storage class for vardecls.
 245     if (VarDecl *V = dyn_cast<VarDecl>(VD)) {
 246       if (V->getStorageClass() != SC_None)
 247         OS << VarDecl::getStorageClassSpecifierString(V->getStorageClass())
 248            << " ";
 249     }
 250
 251     std::string Name = VD->getNameAsString();
 252     VD->getType().getAsStringInternal(Name,
 253                           PrintingPolicy(VD->getASTContext().getLangOptions()));
 254     OS << Name;
 255
 256     // If this is a vardecl with an initializer, emit it.
 257     if (VarDecl *V = dyn_cast<VarDecl>(VD)) {
 258       if (V->getInit()) {
 259         OS << " =\n";
 260         DumpSubTree(V->getInit());
 261       }
 262     }
 263     OS << '"';
 264   } else if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
 265     // print a free standing tag decl (e.g. "struct x;").
 266     const char *tagname;
 267     if (const IdentifierInfo *II = TD->getIdentifier())
 268       tagname = II->getNameStart();
 269     else
 270       tagname = "<anonymous>";
 271     OS << '"' << TD->getKindName() << ' ' << tagname << ";\"";
 272     // FIXME: print tag bodies.
 273   } else if (UsingDirectiveDecl *UD = dyn_cast<UsingDirectiveDecl>(D)) {
 274     // print using-directive decl (e.g. "using namespace x;")
 275     const char *ns;
 276     if (const IdentifierInfo *II = UD->getNominatedNamespace()->getIdentifier())
 277       ns = II->getNameStart();
 278     else
 279       ns = "<anonymous>";
 280     OS << '"' << UD->getDeclKindName() << ns << ";\"";
 281   } else if (UsingDecl *UD = dyn_cast<UsingDecl>(D)) {
 282     // print using decl (e.g. "using std::string;")
 283     const char *tn = UD->isTypeName() ? "typename " : "";
 284     OS << '"' << UD->getDeclKindName() << tn;
 285     UD->getQualifier()->print(OS,
 286                         PrintingPolicy(UD->getASTContext().getLangOptions()));
 287     OS << ";\"";
 288   } else if (LabelDecl *LD = dyn_cast<LabelDecl>(D)) {
 289     OS << "label " << LD->getNameAsString();
 290   } else if (StaticAssertDecl *SAD = dyn_cast<StaticAssertDecl>(D)) {
 291     OS << "\"static_assert(\n";
 292     DumpSubTree(SAD->getAssertExpr());
 293     OS << ",\n";
 294     DumpSubTree(SAD->getMessage());
 295     OS << ");\"";
 296   } else {
 297     assert(0 && "Unexpected decl");
 298   }
 299 }
 300
 301 void StmtDumper::VisitDeclStmt(DeclStmt *Node) {
 302   DumpStmt(Node);
 303   OS << "\n";
 304   for (DeclStmt::decl_iterator DI = Node->decl_begin(), DE = Node->decl_end();
 305        DI != DE; ++DI) {
 306     Decl* D = *DI;
 307     ++IndentLevel;
 308     Indent();
 309     OS << (void*) D << " ";
 310     DumpDeclarator(D);
 311     if (DI+1 != DE)
 312       OS << "\n";
 313     --IndentLevel;
 314   }
 315 }
 316
 317 void StmtDumper::VisitLabelStmt(LabelStmt *Node) {
 318   DumpStmt(Node);
 319   OS << " '" << Node->getName() << "'";
 320 }
 321
 322 void StmtDumper::VisitGotoStmt(GotoStmt *Node) {
 323   DumpStmt(Node);
 324   OS << " '" << Node->getLabel()->getName()
 325      << "':" << (void*)Node->getLabel();
 326 }
 327
 328 //===----------------------------------------------------------------------===//
 329 //  Expr printing methods.
 330 //===----------------------------------------------------------------------===//
 331
 332 void StmtDumper::VisitExpr(Expr *Node) {
 333   DumpExpr(Node);
 334 }
 335
 336 static void DumpBasePath(llvm::raw_ostream &OS, CastExpr *Node) {
 337   if (Node->path_empty())
 338     return;
 339
 340   OS << " (";
 341   bool First = true;
 342   for (CastExpr::path_iterator
 343          I = Node->path_begin(), E = Node->path_end(); I != E; ++I) {
 344     const CXXBaseSpecifier *Base = *I;
 345     if (!First)
 346       OS << " -> ";
 347
 348     const CXXRecordDecl *RD =
 349     cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
 350
 351     if (Base->isVirtual())
 352       OS << "virtual ";
 353     OS << RD->getName();
 354     First = false;
 355   }
 356
 357   OS << ')';
 358 }
 359
 360 void StmtDumper::VisitCastExpr(CastExpr *Node) {
 361   DumpExpr(Node);
 362   OS << " <" << Node->getCastKindName();
 363   DumpBasePath(OS, Node);
 364   OS << ">";
 365 }
 366
 367 void StmtDumper::VisitDeclRefExpr(DeclRefExpr *Node) {
 368   DumpExpr(Node);
 369
 370   OS << " ";
 371   DumpDeclRef(Node->getDecl());
 372   if (Node->getDecl() != Node->getFoundDecl()) {
 373     OS << " (";
 374     DumpDeclRef(Node->getFoundDecl());
 375     OS << ")";
 376   }
 377 }
 378
 379 void StmtDumper::DumpDeclRef(Decl *d) {
 380   OS << d->getDeclKindName() << ' ' << (void*) d;
 381
 382   if (NamedDecl *nd = dyn_cast<NamedDecl>(d)) {
 383     OS << " '";
 384     nd->getDeclName().printName(OS);
 385     OS << "'";
 386   }
 387
 388   if (ValueDecl *vd = dyn_cast<ValueDecl>(d)) {
 389     OS << ' '; DumpType(vd->getType());
 390   }
 391 }
 392
 393 void StmtDumper::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *Node) {
 394   DumpExpr(Node);
 395   OS << " (";
 396   if (!Node->requiresADL()) OS << "no ";
 397   OS << "ADL) = '" << Node->getName() << '\'';
 398
 399   UnresolvedLookupExpr::decls_iterator
 400     I = Node->decls_begin(), E = Node->decls_end();
 401   if (I == E) OS << " empty";
 402   for (; I != E; ++I)
 403     OS << " " << (void*) *I;
 404 }
 405
 406 void StmtDumper::VisitObjCIvarRefExpr(ObjCIvarRefExpr *Node) {
 407   DumpExpr(Node);
 408
 409   OS << " " << Node->getDecl()->getDeclKindName()
 410      << "Decl='" << Node->getDecl()
 411      << "' " << (void*)Node->getDecl();
 412   if (Node->isFreeIvar())
 413     OS << " isFreeIvar";
 414 }
 415
 416 void StmtDumper::VisitPredefinedExpr(PredefinedExpr *Node) {
 417   DumpExpr(Node);
 418   switch (Node->getIdentType()) {
 419   default: assert(0 && "unknown case");
 420   case PredefinedExpr::Func:           OS <<  " __func__"; break;
 421   case PredefinedExpr::Function:       OS <<  " __FUNCTION__"; break;
 422   case PredefinedExpr::PrettyFunction: OS <<  " __PRETTY_FUNCTION__";break;
 423   }
 424 }
 425
 426 void StmtDumper::VisitCharacterLiteral(CharacterLiteral *Node) {
 427   DumpExpr(Node);
 428   OS << Node->getValue();
 429 }
 430
 431 void StmtDumper::VisitIntegerLiteral(IntegerLiteral *Node) {
 432   DumpExpr(Node);
 433
 434   bool isSigned = Node->getType()->isSignedIntegerType();
 435   OS << " " << Node->getValue().toString(10, isSigned);
 436 }
 437 void StmtDumper::VisitFloatingLiteral(FloatingLiteral *Node) {
 438   DumpExpr(Node);
 439   OS << " " << Node->getValueAsApproximateDouble();
 440 }
 441
 442 void StmtDumper::VisitStringLiteral(StringLiteral *Str) {
 443   DumpExpr(Str);
 444   // FIXME: this doesn't print wstrings right.
 445   OS << " ";
 446   if (Str->isWide())
 447     OS << "L";
 448   OS << '"';
 449   OS.write_escaped(Str->getString());
 450   OS << '"';
 451 }
 452
 453 void StmtDumper::VisitUnaryOperator(UnaryOperator *Node) {
 454   DumpExpr(Node);
 455   OS << " " << (Node->isPostfix() ? "postfix" : "prefix")
 456      << " '" << UnaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
 457 }
 458 void StmtDumper::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *Node) {
 459   DumpExpr(Node);
 460   switch(Node->getKind()) {
 461   case UETT_SizeOf:
 462     OS << " sizeof ";
 463     break;
 464   case UETT_AlignOf:
 465     OS << " __alignof ";
 466     break;
 467   case UETT_VecStep:
 468     OS << " vec_step ";
 469     break;
 470   }
 471   if (Node->isArgumentType())
 472     DumpType(Node->getArgumentType());
 473 }
 474
 475 void StmtDumper::VisitMemberExpr(MemberExpr *Node) {
 476   DumpExpr(Node);
 477   OS << " " << (Node->isArrow() ? "->" : ".")
 478      << Node->getMemberDecl() << ' '
 479      << (void*)Node->getMemberDecl();
 480 }
 481 void StmtDumper::VisitExtVectorElementExpr(ExtVectorElementExpr *Node) {
 482   DumpExpr(Node);
 483   OS << " " << Node->getAccessor().getNameStart();
 484 }
 485 void StmtDumper::VisitBinaryOperator(BinaryOperator *Node) {
 486   DumpExpr(Node);
 487   OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
 488 }
 489 void StmtDumper::VisitCompoundAssignOperator(CompoundAssignOperator *Node) {
 490   DumpExpr(Node);
 491   OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode())
 492      << "' ComputeLHSTy=";
 493   DumpType(Node->getComputationLHSType());
 494   OS << " ComputeResultTy=";
 495   DumpType(Node->getComputationResultType());
 496 }
 497
 498 void StmtDumper::VisitBlockExpr(BlockExpr *Node) {
 499   DumpExpr(Node);
 500
 501   IndentLevel++;
 502   BlockDecl *block = Node->getBlockDecl();
 503   if (block->capturesCXXThis()) {
 504     OS << '\n'; Indent(); OS << "(capture this)";
 505   }
 506   for (BlockDecl::capture_iterator
 507          i = block->capture_begin(), e = block->capture_end(); i != e; ++i) {
 508     OS << '\n';
 509     Indent();
 510     OS << "(capture ";
 511     if (i->isByRef()) OS << "byref ";
 512     if (i->isNested()) OS << "nested ";
 513     DumpDeclRef(i->getVariable());
 514     if (i->hasCopyExpr()) DumpSubTree(i->getCopyExpr());
 515     OS << ")";
 516   }
 517   IndentLevel--;
 518
 519   DumpSubTree(block->getBody());
 520 }
 521
 522 // GNU extensions.
 523
 524 void StmtDumper::VisitAddrLabelExpr(AddrLabelExpr *Node) {
 525   DumpExpr(Node);
 526   OS << " " << Node->getLabel()->getName()
 527      << " " << (void*)Node->getLabel();
 528 }
 529
 530 //===----------------------------------------------------------------------===//
 531 // C++ Expressions
 532 //===----------------------------------------------------------------------===//
 533
 534 void StmtDumper::VisitCXXNamedCastExpr(CXXNamedCastExpr *Node) {
 535   DumpExpr(Node);
 536   OS << " " << Node->getCastName()
 537      << "<" << Node->getTypeAsWritten().getAsString() << ">"
 538      << " <" << Node->getCastKindName();
 539   DumpBasePath(OS, Node);
 540   OS << ">";
 541 }
 542
 543 void StmtDumper::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node) {
 544   DumpExpr(Node);
 545   OS << " " << (Node->getValue() ? "true" : "false");
 546 }
 547
 548 void StmtDumper::VisitCXXThisExpr(CXXThisExpr *Node) {
 549   DumpExpr(Node);
 550   OS << " this";
 551 }
 552
 553 void StmtDumper::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node) {
 554   DumpExpr(Node);
 555   OS << " functional cast to " << Node->getTypeAsWritten().getAsString();
 556 }
 557
 558 void StmtDumper::VisitCXXConstructExpr(CXXConstructExpr *Node) {
 559   DumpExpr(Node);
 560   CXXConstructorDecl *Ctor = Node->getConstructor();
 561   DumpType(Ctor->getType());
 562   if (Node->isElidable())
 563     OS << " elidable";
 564   if (Node->requiresZeroInitialization())
 565     OS << " zeroing";
 566 }
 567
 568 void StmtDumper::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *Node) {
 569   DumpExpr(Node);
 570   OS << " ";
 571   DumpCXXTemporary(Node->getTemporary());
 572 }
 573
 574 void StmtDumper::VisitExprWithCleanups(ExprWithCleanups *Node) {
 575   DumpExpr(Node);
 576   ++IndentLevel;
 577   for (unsigned i = 0, e = Node->getNumTemporaries(); i != e; ++i) {
 578     OS << "\n";
 579     Indent();
 580     DumpCXXTemporary(Node->getTemporary(i));
 581   }
 582   --IndentLevel;
 583 }
 584
 585 void StmtDumper::DumpCXXTemporary(CXXTemporary *Temporary) {
 586   OS << "(CXXTemporary " << (void *)Temporary << ")";
 587 }
 588
 589 //===----------------------------------------------------------------------===//
 590 // Obj-C Expressions
 591 //===----------------------------------------------------------------------===//
 592
 593 void StmtDumper::VisitObjCMessageExpr(ObjCMessageExpr* Node) {
 594   DumpExpr(Node);
 595   OS << " selector=" << Node->getSelector().getAsString();
 596   switch (Node->getReceiverKind()) {
 597   case ObjCMessageExpr::Instance:
 598     break;
 599
 600   case ObjCMessageExpr::Class:
 601     OS << " class=";
 602     DumpType(Node->getClassReceiver());
 603     break;
 604
 605   case ObjCMessageExpr::SuperInstance:
 606     OS << " super (instance)";
 607     break;
 608
 609   case ObjCMessageExpr::SuperClass:
 610     OS << " super (class)";
 611     break;
 612   }
 613 }
 614
 615 void StmtDumper::VisitObjCAtCatchStmt(ObjCAtCatchStmt *Node) {
 616   DumpStmt(Node);
 617   if (VarDecl *CatchParam = Node->getCatchParamDecl()) {
 618     OS << " catch parm = ";
 619     DumpDeclarator(CatchParam);
 620   } else {
 621     OS << " catch all";
 622   }
 623 }
 624
 625 void StmtDumper::VisitObjCEncodeExpr(ObjCEncodeExpr *Node) {
 626   DumpExpr(Node);
 627   OS << " ";
 628   DumpType(Node->getEncodedType());
 629 }
 630
 631 void StmtDumper::VisitObjCSelectorExpr(ObjCSelectorExpr *Node) {
 632   DumpExpr(Node);
 633
 634   OS << " " << Node->getSelector().getAsString();
 635 }
 636
 637 void StmtDumper::VisitObjCProtocolExpr(ObjCProtocolExpr *Node) {
 638   DumpExpr(Node);
 639
 640   OS << ' ' << Node->getProtocol();
 641 }
 642
 643 void StmtDumper::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *Node) {
 644   DumpExpr(Node);
 645   if (Node->isImplicitProperty()) {
 646     OS << " Kind=MethodRef Getter=\"";
 647     if (Node->getImplicitPropertyGetter())
 648       OS << Node->getImplicitPropertyGetter()->getSelector().getAsString();
 649     else
 650       OS << "(null)";
 651
 652     OS << "\" Setter=\"";
 653     if (ObjCMethodDecl *Setter = Node->getImplicitPropertySetter())
 654       OS << Setter->getSelector().getAsString();
 655     else
 656       OS << "(null)";
 657     OS << "\"";
 658   } else {
 659     OS << " Kind=PropertyRef Property=\"" << Node->getExplicitProperty() << '"';
 660   }
 661
 662   if (Node->isSuperReceiver())
 663     OS << " super";
 664 }
 665
 666 //===----------------------------------------------------------------------===//
 667 // Stmt method implementations
 668 //===----------------------------------------------------------------------===//
 669
 670 /// dump - This does a local dump of the specified AST fragment.  It dumps the
 671 /// specified node and a few nodes underneath it, but not the whole subtree.
 672 /// This is useful in a debugger.
 673 void Stmt::dump(SourceManager &SM) const {
 674   dump(llvm::errs(), SM);
 675 }
 676
 677 void Stmt::dump(llvm::raw_ostream &OS, SourceManager &SM) const {
 678   StmtDumper P(&SM, OS, 4);
 679   P.DumpSubTree(const_cast<Stmt*>(this));
 680   OS << "\n";
 681 }
 682
 683 /// dump - This does a local dump of the specified AST fragment.  It dumps the
 684 /// specified node and a few nodes underneath it, but not the whole subtree.
 685 /// This is useful in a debugger.
 686 void Stmt::dump() const {
 687   StmtDumper P(0, llvm::errs(), 4);
 688   P.DumpSubTree(const_cast<Stmt*>(this));
 689   llvm::errs() << "\n";
 690 }
 691
 692 /// dumpAll - This does a dump of the specified AST fragment and all subtrees.
 693 void Stmt::dumpAll(SourceManager &SM) const {
 694   StmtDumper P(&SM, llvm::errs(), ~0U);
 695   P.DumpSubTree(const_cast<Stmt*>(this));
 696   llvm::errs() << "\n";
 697 }
 698
 699 /// dumpAll - This does a dump of the specified AST fragment and all subtrees.
 700 void Stmt::dumpAll() const {
 701   StmtDumper P(0, llvm::errs(), ~0U);
 702   P.DumpSubTree(const_cast<Stmt*>(this));
 703   llvm::errs() << "\n";
 704 }