contrib/llvm/tools/clang/lib/Frontend/ASTConsumers.cpp

   1 //===--- ASTConsumers.cpp - ASTConsumer implementations -------------------===//
   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 // AST Consumer Implementations.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/Frontend/ASTConsumers.h"
  15 #include "clang/AST/AST.h"
  16 #include "clang/AST/ASTConsumer.h"
  17 #include "clang/AST/ASTContext.h"
  18 #include "clang/AST/PrettyPrinter.h"
  19 #include "clang/AST/RecordLayout.h"
  20 #include "clang/AST/RecursiveASTVisitor.h"
  21 #include "clang/Basic/Diagnostic.h"
  22 #include "clang/Basic/FileManager.h"
  23 #include "clang/Basic/SourceManager.h"
  24 #include "llvm/IR/Module.h"
  25 #include "llvm/Support/Path.h"
  26 #include "llvm/Support/Timer.h"
  27 #include "llvm/Support/raw_ostream.h"
  28 using namespace clang;
  29
  30 //===----------------------------------------------------------------------===//
  31 /// ASTPrinter - Pretty-printer and dumper of ASTs
  32
  33 namespace {
  34   class ASTPrinter : public ASTConsumer,
  35                      public RecursiveASTVisitor<ASTPrinter> {
  36     typedef RecursiveASTVisitor<ASTPrinter> base;
  37
  38   public:
  39     ASTPrinter(raw_ostream *Out = NULL, bool Dump = false,
  40                StringRef FilterString = "", bool DumpLookups = false)
  41         : Out(Out ? *Out : llvm::outs()), Dump(Dump),
  42           FilterString(FilterString), DumpLookups(DumpLookups) {}
  43
  44     virtual void HandleTranslationUnit(ASTContext &Context) {
  45       TranslationUnitDecl *D = Context.getTranslationUnitDecl();
  46
  47       if (FilterString.empty())
  48         return print(D);
  49
  50       TraverseDecl(D);
  51     }
  52
  53     bool shouldWalkTypesOfTypeLocs() const { return false; }
  54
  55     bool TraverseDecl(Decl *D) {
  56       if (D != NULL && filterMatches(D)) {
  57         bool ShowColors = Out.has_colors();
  58         if (ShowColors)
  59           Out.changeColor(raw_ostream::BLUE);
  60         Out << (Dump ? "Dumping " : "Printing ") << getName(D) << ":\n";
  61         if (ShowColors)
  62           Out.resetColor();
  63         print(D);
  64         Out << "\n";
  65         // Don't traverse child nodes to avoid output duplication.
  66         return true;
  67       }
  68       return base::TraverseDecl(D);
  69     }
  70
  71   private:
  72     std::string getName(Decl *D) {
  73       if (isa<NamedDecl>(D))
  74         return cast<NamedDecl>(D)->getQualifiedNameAsString();
  75       return "";
  76     }
  77     bool filterMatches(Decl *D) {
  78       return getName(D).find(FilterString) != std::string::npos;
  79     }
  80     void print(Decl *D) {
  81       if (DumpLookups) {
  82         if (DeclContext *DC = dyn_cast<DeclContext>(D))
  83           DC->dumpLookups(Out);
  84         else
  85           Out << "Not a DeclContext\n";
  86       } else if (Dump)
  87         D->dump(Out);
  88       else
  89         D->print(Out, /*Indentation=*/0, /*PrintInstantiation=*/true);
  90     }
  91
  92     raw_ostream &Out;
  93     bool Dump;
  94     std::string FilterString;
  95     bool DumpLookups;
  96   };
  97
  98   class ASTDeclNodeLister : public ASTConsumer,
  99                      public RecursiveASTVisitor<ASTDeclNodeLister> {
 100   public:
 101     ASTDeclNodeLister(raw_ostream *Out = NULL)
 102         : Out(Out ? *Out : llvm::outs()) {}
 103
 104     virtual void HandleTranslationUnit(ASTContext &Context) {
 105       TraverseDecl(Context.getTranslationUnitDecl());
 106     }
 107
 108     bool shouldWalkTypesOfTypeLocs() const { return false; }
 109
 110     virtual bool VisitNamedDecl(NamedDecl *D) {
 111       D->printQualifiedName(Out);
 112       Out << '\n';
 113       return true;
 114     }
 115
 116   private:
 117     raw_ostream &Out;
 118   };
 119 } // end anonymous namespace
 120
 121 ASTConsumer *clang::CreateASTPrinter(raw_ostream *Out,
 122                                      StringRef FilterString) {
 123   return new ASTPrinter(Out, /*Dump=*/ false, FilterString);
 124 }
 125
 126 ASTConsumer *clang::CreateASTDumper(StringRef FilterString, bool DumpLookups) {
 127   return new ASTPrinter(0, /*Dump=*/ true, FilterString, DumpLookups);
 128 }
 129
 130 ASTConsumer *clang::CreateASTDeclNodeLister() {
 131   return new ASTDeclNodeLister(0);
 132 }
 133
 134 //===----------------------------------------------------------------------===//
 135 /// ASTViewer - AST Visualization
 136
 137 namespace {
 138   class ASTViewer : public ASTConsumer {
 139     ASTContext *Context;
 140   public:
 141     void Initialize(ASTContext &Context) {
 142       this->Context = &Context;
 143     }
 144
 145     virtual bool HandleTopLevelDecl(DeclGroupRef D) {
 146       for (DeclGroupRef::iterator I = D.begin(), E = D.end(); I != E; ++I)
 147         HandleTopLevelSingleDecl(*I);
 148       return true;
 149     }
 150
 151     void HandleTopLevelSingleDecl(Decl *D);
 152   };
 153 }
 154
 155 void ASTViewer::HandleTopLevelSingleDecl(Decl *D) {
 156   if (isa<FunctionDecl>(D) || isa<ObjCMethodDecl>(D)) {
 157     D->print(llvm::errs());
 158
 159     if (Stmt *Body = D->getBody()) {
 160       llvm::errs() << '\n';
 161       Body->viewAST();
 162       llvm::errs() << '\n';
 163     }
 164   }
 165 }
 166
 167
 168 ASTConsumer *clang::CreateASTViewer() { return new ASTViewer(); }
 169
 170 //===----------------------------------------------------------------------===//
 171 /// DeclContextPrinter - Decl and DeclContext Visualization
 172
 173 namespace {
 174
 175 class DeclContextPrinter : public ASTConsumer {
 176   raw_ostream& Out;
 177 public:
 178   DeclContextPrinter() : Out(llvm::errs()) {}
 179
 180   void HandleTranslationUnit(ASTContext &C) {
 181     PrintDeclContext(C.getTranslationUnitDecl(), 4);
 182   }
 183
 184   void PrintDeclContext(const DeclContext* DC, unsigned Indentation);
 185 };
 186 }  // end anonymous namespace
 187
 188 void DeclContextPrinter::PrintDeclContext(const DeclContext* DC,
 189                                           unsigned Indentation) {
 190   // Print DeclContext name.
 191   switch (DC->getDeclKind()) {
 192   case Decl::TranslationUnit:
 193     Out << "[translation unit] " << DC;
 194     break;
 195   case Decl::Namespace: {
 196     Out << "[namespace] ";
 197     const NamespaceDecl* ND = cast<NamespaceDecl>(DC);
 198     Out << *ND;
 199     break;
 200   }
 201   case Decl::Enum: {
 202     const EnumDecl* ED = cast<EnumDecl>(DC);
 203     if (ED->isCompleteDefinition())
 204       Out << "[enum] ";
 205     else
 206       Out << "<enum> ";
 207     Out << *ED;
 208     break;
 209   }
 210   case Decl::Record: {
 211     const RecordDecl* RD = cast<RecordDecl>(DC);
 212     if (RD->isCompleteDefinition())
 213       Out << "[struct] ";
 214     else
 215       Out << "<struct> ";
 216     Out << *RD;
 217     break;
 218   }
 219   case Decl::CXXRecord: {
 220     const CXXRecordDecl* RD = cast<CXXRecordDecl>(DC);
 221     if (RD->isCompleteDefinition())
 222       Out << "[class] ";
 223     else
 224       Out << "<class> ";
 225     Out << *RD << ' ' << DC;
 226     break;
 227   }
 228   case Decl::ObjCMethod:
 229     Out << "[objc method]";
 230     break;
 231   case Decl::ObjCInterface:
 232     Out << "[objc interface]";
 233     break;
 234   case Decl::ObjCCategory:
 235     Out << "[objc category]";
 236     break;
 237   case Decl::ObjCProtocol:
 238     Out << "[objc protocol]";
 239     break;
 240   case Decl::ObjCImplementation:
 241     Out << "[objc implementation]";
 242     break;
 243   case Decl::ObjCCategoryImpl:
 244     Out << "[objc categoryimpl]";
 245     break;
 246   case Decl::LinkageSpec:
 247     Out << "[linkage spec]";
 248     break;
 249   case Decl::Block:
 250     Out << "[block]";
 251     break;
 252   case Decl::Function: {
 253     const FunctionDecl* FD = cast<FunctionDecl>(DC);
 254     if (FD->doesThisDeclarationHaveABody())
 255       Out << "[function] ";
 256     else
 257       Out << "<function> ";
 258     Out << *FD;
 259     // Print the parameters.
 260     Out << "(";
 261     bool PrintComma = false;
 262     for (FunctionDecl::param_const_iterator I = FD->param_begin(),
 263            E = FD->param_end(); I != E; ++I) {
 264       if (PrintComma)
 265         Out << ", ";
 266       else
 267         PrintComma = true;
 268       Out << **I;
 269     }
 270     Out << ")";
 271     break;
 272   }
 273   case Decl::CXXMethod: {
 274     const CXXMethodDecl* D = cast<CXXMethodDecl>(DC);
 275     if (D->isOutOfLine())
 276       Out << "[c++ method] ";
 277     else if (D->isImplicit())
 278       Out << "(c++ method) ";
 279     else
 280       Out << "<c++ method> ";
 281     Out << *D;
 282     // Print the parameters.
 283     Out << "(";
 284     bool PrintComma = false;
 285     for (FunctionDecl::param_const_iterator I = D->param_begin(),
 286            E = D->param_end(); I != E; ++I) {
 287       if (PrintComma)
 288         Out << ", ";
 289       else
 290         PrintComma = true;
 291       Out << **I;
 292     }
 293     Out << ")";
 294
 295     // Check the semantic DeclContext.
 296     const DeclContext* SemaDC = D->getDeclContext();
 297     const DeclContext* LexicalDC = D->getLexicalDeclContext();
 298     if (SemaDC != LexicalDC)
 299       Out << " [[" << SemaDC << "]]";
 300
 301     break;
 302   }
 303   case Decl::CXXConstructor: {
 304     const CXXConstructorDecl* D = cast<CXXConstructorDecl>(DC);
 305     if (D->isOutOfLine())
 306       Out << "[c++ ctor] ";
 307     else if (D->isImplicit())
 308       Out << "(c++ ctor) ";
 309     else
 310       Out << "<c++ ctor> ";
 311     Out << *D;
 312     // Print the parameters.
 313     Out << "(";
 314     bool PrintComma = false;
 315     for (FunctionDecl::param_const_iterator I = D->param_begin(),
 316            E = D->param_end(); I != E; ++I) {
 317       if (PrintComma)
 318         Out << ", ";
 319       else
 320         PrintComma = true;
 321       Out << **I;
 322     }
 323     Out << ")";
 324
 325     // Check the semantic DC.
 326     const DeclContext* SemaDC = D->getDeclContext();
 327     const DeclContext* LexicalDC = D->getLexicalDeclContext();
 328     if (SemaDC != LexicalDC)
 329       Out << " [[" << SemaDC << "]]";
 330     break;
 331   }
 332   case Decl::CXXDestructor: {
 333     const CXXDestructorDecl* D = cast<CXXDestructorDecl>(DC);
 334     if (D->isOutOfLine())
 335       Out << "[c++ dtor] ";
 336     else if (D->isImplicit())
 337       Out << "(c++ dtor) ";
 338     else
 339       Out << "<c++ dtor> ";
 340     Out << *D;
 341     // Check the semantic DC.
 342     const DeclContext* SemaDC = D->getDeclContext();
 343     const DeclContext* LexicalDC = D->getLexicalDeclContext();
 344     if (SemaDC != LexicalDC)
 345       Out << " [[" << SemaDC << "]]";
 346     break;
 347   }
 348   case Decl::CXXConversion: {
 349     const CXXConversionDecl* D = cast<CXXConversionDecl>(DC);
 350     if (D->isOutOfLine())
 351       Out << "[c++ conversion] ";
 352     else if (D->isImplicit())
 353       Out << "(c++ conversion) ";
 354     else
 355       Out << "<c++ conversion> ";
 356     Out << *D;
 357     // Check the semantic DC.
 358     const DeclContext* SemaDC = D->getDeclContext();
 359     const DeclContext* LexicalDC = D->getLexicalDeclContext();
 360     if (SemaDC != LexicalDC)
 361       Out << " [[" << SemaDC << "]]";
 362     break;
 363   }
 364
 365   default:
 366     llvm_unreachable("a decl that inherits DeclContext isn't handled");
 367   }
 368
 369   Out << "\n";
 370
 371   // Print decls in the DeclContext.
 372   for (DeclContext::decl_iterator I = DC->decls_begin(), E = DC->decls_end();
 373        I != E; ++I) {
 374     for (unsigned i = 0; i < Indentation; ++i)
 375       Out << "  ";
 376
 377     Decl::Kind DK = I->getKind();
 378     switch (DK) {
 379     case Decl::Namespace:
 380     case Decl::Enum:
 381     case Decl::Record:
 382     case Decl::CXXRecord:
 383     case Decl::ObjCMethod:
 384     case Decl::ObjCInterface:
 385     case Decl::ObjCCategory:
 386     case Decl::ObjCProtocol:
 387     case Decl::ObjCImplementation:
 388     case Decl::ObjCCategoryImpl:
 389     case Decl::LinkageSpec:
 390     case Decl::Block:
 391     case Decl::Function:
 392     case Decl::CXXMethod:
 393     case Decl::CXXConstructor:
 394     case Decl::CXXDestructor:
 395     case Decl::CXXConversion:
 396     {
 397       DeclContext* DC = cast<DeclContext>(*I);
 398       PrintDeclContext(DC, Indentation+2);
 399       break;
 400     }
 401     case Decl::IndirectField: {
 402       IndirectFieldDecl* IFD = cast<IndirectFieldDecl>(*I);
 403       Out << "<IndirectField> " << *IFD << '\n';
 404       break;
 405     }
 406     case Decl::Label: {
 407       LabelDecl *LD = cast<LabelDecl>(*I);
 408       Out << "<Label> " << *LD << '\n';
 409       break;
 410     }
 411     case Decl::Field: {
 412       FieldDecl *FD = cast<FieldDecl>(*I);
 413       Out << "<field> " << *FD << '\n';
 414       break;
 415     }
 416     case Decl::Typedef:
 417     case Decl::TypeAlias: {
 418       TypedefNameDecl* TD = cast<TypedefNameDecl>(*I);
 419       Out << "<typedef> " << *TD << '\n';
 420       break;
 421     }
 422     case Decl::EnumConstant: {
 423       EnumConstantDecl* ECD = cast<EnumConstantDecl>(*I);
 424       Out << "<enum constant> " << *ECD << '\n';
 425       break;
 426     }
 427     case Decl::Var: {
 428       VarDecl* VD = cast<VarDecl>(*I);
 429       Out << "<var> " << *VD << '\n';
 430       break;
 431     }
 432     case Decl::ImplicitParam: {
 433       ImplicitParamDecl* IPD = cast<ImplicitParamDecl>(*I);
 434       Out << "<implicit parameter> " << *IPD << '\n';
 435       break;
 436     }
 437     case Decl::ParmVar: {
 438       ParmVarDecl* PVD = cast<ParmVarDecl>(*I);
 439       Out << "<parameter> " << *PVD << '\n';
 440       break;
 441     }
 442     case Decl::ObjCProperty: {
 443       ObjCPropertyDecl* OPD = cast<ObjCPropertyDecl>(*I);
 444       Out << "<objc property> " << *OPD << '\n';
 445       break;
 446     }
 447     case Decl::FunctionTemplate: {
 448       FunctionTemplateDecl* FTD = cast<FunctionTemplateDecl>(*I);
 449       Out << "<function template> " << *FTD << '\n';
 450       break;
 451     }
 452     case Decl::FileScopeAsm: {
 453       Out << "<file-scope asm>\n";
 454       break;
 455     }
 456     case Decl::UsingDirective: {
 457       Out << "<using directive>\n";
 458       break;
 459     }
 460     case Decl::NamespaceAlias: {
 461       NamespaceAliasDecl* NAD = cast<NamespaceAliasDecl>(*I);
 462       Out << "<namespace alias> " << *NAD << '\n';
 463       break;
 464     }
 465     case Decl::ClassTemplate: {
 466       ClassTemplateDecl *CTD = cast<ClassTemplateDecl>(*I);
 467       Out << "<class template> " << *CTD << '\n';
 468       break;
 469     }
 470     case Decl::OMPThreadPrivate: {
 471       Out << "<omp threadprivate> " << '"' << *I << "\"\n";
 472       break;
 473     }
 474     default:
 475       Out << "DeclKind: " << DK << '"' << *I << "\"\n";
 476       llvm_unreachable("decl unhandled");
 477     }
 478   }
 479 }
 480 ASTConsumer *clang::CreateDeclContextPrinter() {
 481   return new DeclContextPrinter();
 482 }