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