/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/Frontend/ASTConsumers.cpp
Line | Count | Source (jump to first uncovered line) |
1 | | //===--- ASTConsumers.cpp - ASTConsumer implementations -------------------===// |
2 | | // |
3 | | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | | // See https://llvm.org/LICENSE.txt for license information. |
5 | | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | | // |
7 | | //===----------------------------------------------------------------------===// |
8 | | // |
9 | | // AST Consumer Implementations. |
10 | | // |
11 | | //===----------------------------------------------------------------------===// |
12 | | |
13 | | #include "clang/Frontend/ASTConsumers.h" |
14 | | #include "clang/AST/AST.h" |
15 | | #include "clang/AST/ASTConsumer.h" |
16 | | #include "clang/AST/ASTContext.h" |
17 | | #include "clang/AST/PrettyPrinter.h" |
18 | | #include "clang/AST/RecordLayout.h" |
19 | | #include "clang/AST/RecursiveASTVisitor.h" |
20 | | #include "clang/Basic/Diagnostic.h" |
21 | | #include "clang/Basic/SourceManager.h" |
22 | | #include "llvm/Support/Path.h" |
23 | | #include "llvm/Support/Timer.h" |
24 | | #include "llvm/Support/raw_ostream.h" |
25 | | using namespace clang; |
26 | | |
27 | | //===----------------------------------------------------------------------===// |
28 | | /// ASTPrinter - Pretty-printer and dumper of ASTs |
29 | | |
30 | | namespace { |
31 | | class ASTPrinter : public ASTConsumer, |
32 | | public RecursiveASTVisitor<ASTPrinter> { |
33 | | typedef RecursiveASTVisitor<ASTPrinter> base; |
34 | | |
35 | | public: |
36 | | enum Kind { DumpFull, Dump, Print, None }; |
37 | | ASTPrinter(std::unique_ptr<raw_ostream> Out, Kind K, |
38 | | ASTDumpOutputFormat Format, StringRef FilterString, |
39 | | bool DumpLookups = false, bool DumpDeclTypes = false) |
40 | 1.40k | : Out(Out ? *Out769 : llvm::outs()640 ), OwnedOut(std::move(Out)), |
41 | 1.40k | OutputKind(K), OutputFormat(Format), FilterString(FilterString), |
42 | 1.40k | DumpLookups(DumpLookups), DumpDeclTypes(DumpDeclTypes) {} |
43 | | |
44 | 1.42k | void HandleTranslationUnit(ASTContext &Context) override { |
45 | 1.42k | TranslationUnitDecl *D = Context.getTranslationUnitDecl(); |
46 | | |
47 | 1.42k | if (FilterString.empty()) |
48 | 1.29k | return print(D); |
49 | | |
50 | 129 | TraverseDecl(D); |
51 | 129 | } |
52 | | |
53 | 2.76k | bool shouldWalkTypesOfTypeLocs() const { return false; } |
54 | | |
55 | 4.46k | bool TraverseDecl(Decl *D) { |
56 | 4.46k | if (D && filterMatches(D)4.45k ) { |
57 | 792 | bool ShowColors = Out.has_colors(); |
58 | 792 | if (ShowColors) |
59 | 0 | Out.changeColor(raw_ostream::BLUE); |
60 | | |
61 | 792 | if (OutputFormat == ADOF_Default) |
62 | 689 | Out << (OutputKind != Print ? "Dumping " : "Printing "0 ) << getName(D) |
63 | 689 | << ":\n"; |
64 | | |
65 | 792 | if (ShowColors) |
66 | 0 | Out.resetColor(); |
67 | 792 | print(D); |
68 | 792 | Out << "\n"; |
69 | | // Don't traverse child nodes to avoid output duplication. |
70 | 792 | return true; |
71 | 792 | } |
72 | 3.67k | return base::TraverseDecl(D); |
73 | 4.46k | } |
74 | | |
75 | | private: |
76 | 5.13k | std::string getName(Decl *D) { |
77 | 5.13k | if (isa<NamedDecl>(D)) |
78 | 4.91k | return cast<NamedDecl>(D)->getQualifiedNameAsString(); |
79 | 229 | return ""; |
80 | 5.13k | } |
81 | 4.45k | bool filterMatches(Decl *D) { |
82 | 4.45k | return getName(D).find(FilterString) != std::string::npos; |
83 | 4.45k | } |
84 | 2.08k | void print(Decl *D) { |
85 | 2.08k | if (DumpLookups) { |
86 | 17 | if (DeclContext *DC = dyn_cast<DeclContext>(D)) { |
87 | 13 | if (DC == DC->getPrimaryContext()) |
88 | 7 | DC->dumpLookups(Out, OutputKind != None, OutputKind == DumpFull); |
89 | 6 | else |
90 | 6 | Out << "Lookup map is in primary DeclContext " |
91 | 6 | << DC->getPrimaryContext() << "\n"; |
92 | 13 | } else |
93 | 4 | Out << "Not a DeclContext\n"; |
94 | 2.07k | } else if (OutputKind == Print) { |
95 | 770 | PrintingPolicy Policy(D->getASTContext().getLangOpts()); |
96 | 770 | D->print(Out, Policy, /*Indentation=*/0, /*PrintInstantiation=*/true); |
97 | 1.30k | } else if (OutputKind != None) { |
98 | 1.30k | D->dump(Out, OutputKind == DumpFull, OutputFormat); |
99 | 1.30k | } |
100 | | |
101 | 2.08k | if (DumpDeclTypes) { |
102 | 44 | Decl *InnerD = D; |
103 | 44 | if (auto *TD = dyn_cast<TemplateDecl>(D)) |
104 | 44 | InnerD = TD->getTemplatedDecl(); |
105 | | |
106 | | // FIXME: Support OutputFormat in type dumping. |
107 | | // FIXME: Support combining -ast-dump-decl-types with -ast-dump-lookups. |
108 | 44 | if (auto *VD = dyn_cast<ValueDecl>(InnerD)) |
109 | 44 | VD->getType().dump(Out, VD->getASTContext()); |
110 | 44 | if (auto *TD = dyn_cast<TypeDecl>(InnerD)) |
111 | 0 | TD->getTypeForDecl()->dump(Out, TD->getASTContext()); |
112 | 44 | } |
113 | 2.08k | } |
114 | | |
115 | | raw_ostream &Out; |
116 | | std::unique_ptr<raw_ostream> OwnedOut; |
117 | | |
118 | | /// How to output individual declarations. |
119 | | Kind OutputKind; |
120 | | |
121 | | /// What format should the output take? |
122 | | ASTDumpOutputFormat OutputFormat; |
123 | | |
124 | | /// Which declarations or DeclContexts to display. |
125 | | std::string FilterString; |
126 | | |
127 | | /// Whether the primary output is lookup results or declarations. Individual |
128 | | /// results will be output with a format determined by OutputKind. This is |
129 | | /// incompatible with OutputKind == Print. |
130 | | bool DumpLookups; |
131 | | |
132 | | /// Whether to dump the type for each declaration dumped. |
133 | | bool DumpDeclTypes; |
134 | | }; |
135 | | |
136 | | class ASTDeclNodeLister : public ASTConsumer, |
137 | | public RecursiveASTVisitor<ASTDeclNodeLister> { |
138 | | public: |
139 | | ASTDeclNodeLister(raw_ostream *Out = nullptr) |
140 | 1 | : Out(Out ? *Out0 : llvm::outs()) {} |
141 | | |
142 | 1 | void HandleTranslationUnit(ASTContext &Context) override { |
143 | 1 | TraverseDecl(Context.getTranslationUnitDecl()); |
144 | 1 | } |
145 | | |
146 | 4 | bool shouldWalkTypesOfTypeLocs() const { return false; } |
147 | | |
148 | 10 | bool VisitNamedDecl(NamedDecl *D) { |
149 | 10 | D->printQualifiedName(Out); |
150 | 10 | Out << '\n'; |
151 | 10 | return true; |
152 | 10 | } |
153 | | |
154 | | private: |
155 | | raw_ostream &Out; |
156 | | }; |
157 | | } // end anonymous namespace |
158 | | |
159 | | std::unique_ptr<ASTConsumer> |
160 | | clang::CreateASTPrinter(std::unique_ptr<raw_ostream> Out, |
161 | 770 | StringRef FilterString) { |
162 | 770 | return std::make_unique<ASTPrinter>(std::move(Out), ASTPrinter::Print, |
163 | 770 | ADOF_Default, FilterString); |
164 | 770 | } |
165 | | |
166 | | std::unique_ptr<ASTConsumer> |
167 | | clang::CreateASTDumper(std::unique_ptr<raw_ostream> Out, StringRef FilterString, |
168 | | bool DumpDecls, bool Deserialize, bool DumpLookups, |
169 | 639 | bool DumpDeclTypes, ASTDumpOutputFormat Format) { |
170 | 639 | assert((DumpDecls || Deserialize || DumpLookups) && "nothing to dump"); |
171 | 639 | return std::make_unique<ASTPrinter>( |
172 | 639 | std::move(Out), |
173 | 639 | Deserialize ? ASTPrinter::DumpFull92 |
174 | 639 | : DumpDecls547 ? ASTPrinter::Dump542 : ASTPrinter::None5 , |
175 | 639 | Format, FilterString, DumpLookups, DumpDeclTypes); |
176 | 639 | } |
177 | | |
178 | 1 | std::unique_ptr<ASTConsumer> clang::CreateASTDeclNodeLister() { |
179 | 1 | return std::make_unique<ASTDeclNodeLister>(nullptr); |
180 | 1 | } |
181 | | |
182 | | //===----------------------------------------------------------------------===// |
183 | | /// ASTViewer - AST Visualization |
184 | | |
185 | | namespace { |
186 | | class ASTViewer : public ASTConsumer { |
187 | | ASTContext *Context = nullptr; |
188 | | |
189 | | public: |
190 | 0 | void Initialize(ASTContext &Context) override { this->Context = &Context; } |
191 | | |
192 | 0 | bool HandleTopLevelDecl(DeclGroupRef D) override { |
193 | 0 | for (DeclGroupRef::iterator I = D.begin(), E = D.end(); I != E; ++I) |
194 | 0 | HandleTopLevelSingleDecl(*I); |
195 | 0 | return true; |
196 | 0 | } |
197 | | |
198 | | void HandleTopLevelSingleDecl(Decl *D); |
199 | | }; |
200 | | } |
201 | | |
202 | 0 | void ASTViewer::HandleTopLevelSingleDecl(Decl *D) { |
203 | 0 | if (isa<FunctionDecl>(D) || isa<ObjCMethodDecl>(D)) { |
204 | 0 | D->print(llvm::errs()); |
205 | |
|
206 | 0 | if (Stmt *Body = D->getBody()) { |
207 | 0 | llvm::errs() << '\n'; |
208 | 0 | Body->viewAST(); |
209 | 0 | llvm::errs() << '\n'; |
210 | 0 | } |
211 | 0 | } |
212 | 0 | } |
213 | | |
214 | 0 | std::unique_ptr<ASTConsumer> clang::CreateASTViewer() { |
215 | 0 | return std::make_unique<ASTViewer>(); |
216 | 0 | } |