ASTConsumers.cpp revision 288943 
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"
27using namespace clang;
28
29//===----------------------------------------------------------------------===//
30/// ASTPrinter - Pretty-printer and dumper of ASTs
31
32namespace {
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
125std::unique_ptr<ASTConsumer> clang::CreateASTPrinter(raw_ostream *Out,
126                                                     StringRef FilterString) {
127  return llvm::make_unique<ASTPrinter>(Out, /*Dump=*/false, FilterString);
128}
129
130std::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
138std::unique_ptr<ASTConsumer> clang::CreateASTDeclNodeLister() {
139  return llvm::make_unique<ASTDeclNodeLister>(nullptr);
140}
141
142//===----------------------------------------------------------------------===//
143/// ASTViewer - AST Visualization
144
145namespace {
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
163void 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
175std::unique_ptr<ASTConsumer> clang::CreateASTViewer() {
176  return llvm::make_unique<ASTViewer>();
177}
178
179//===----------------------------------------------------------------------===//
180/// DeclContextPrinter - Decl and DeclContext Visualization
181
182namespace {
183
184class DeclContextPrinter : public ASTConsumer {
185  raw_ostream& Out;
186public:
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
197void 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}
487std::unique_ptr<ASTConsumer> clang::CreateDeclContextPrinter() {
488  return llvm::make_unique<DeclContextPrinter>();
489}
490