1 //===--- ASTDumper.cpp - Dumping implementation for ASTs ------------------===//
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 // This file implements the AST dump methods, which dump out the
10 // AST in a form that exposes type details and other fields.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "clang/AST/ASTDumper.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/DeclLookups.h"
17 #include "clang/AST/JSONNodeDumper.h"
18 #include "clang/Basic/Builtins.h"
19 #include "clang/Basic/Module.h"
20 #include "clang/Basic/SourceManager.h"
21 #include "llvm/Support/raw_ostream.h"
22 using namespace clang;
23 using namespace clang::comments;
24
dumpLookups(const DeclContext * DC,bool DumpDecls)25 void ASTDumper::dumpLookups(const DeclContext *DC, bool DumpDecls) {
26 NodeDumper.AddChild([=] {
27 OS << "StoredDeclsMap ";
28 NodeDumper.dumpBareDeclRef(cast<Decl>(DC));
29
30 const DeclContext *Primary = DC->getPrimaryContext();
31 if (Primary != DC) {
32 OS << " primary";
33 NodeDumper.dumpPointer(cast<Decl>(Primary));
34 }
35
36 bool HasUndeserializedLookups = Primary->hasExternalVisibleStorage();
37
38 auto Range = getDeserialize()
39 ? Primary->lookups()
40 : Primary->noload_lookups(/*PreserveInternalState=*/true);
41 for (auto I = Range.begin(), E = Range.end(); I != E; ++I) {
42 DeclarationName Name = I.getLookupName();
43 DeclContextLookupResult R = *I;
44
45 NodeDumper.AddChild([=] {
46 OS << "DeclarationName ";
47 {
48 ColorScope Color(OS, ShowColors, DeclNameColor);
49 OS << '\'' << Name << '\'';
50 }
51
52 for (DeclContextLookupResult::iterator RI = R.begin(), RE = R.end();
53 RI != RE; ++RI) {
54 NodeDumper.AddChild([=] {
55 NodeDumper.dumpBareDeclRef(*RI);
56
57 if (!(*RI)->isUnconditionallyVisible())
58 OS << " hidden";
59
60 // If requested, dump the redecl chain for this lookup.
61 if (DumpDecls) {
62 // Dump earliest decl first.
63 std::function<void(Decl *)> DumpWithPrev = [&](Decl *D) {
64 if (Decl *Prev = D->getPreviousDecl())
65 DumpWithPrev(Prev);
66 Visit(D);
67 };
68 DumpWithPrev(*RI);
69 }
70 });
71 }
72 });
73 }
74
75 if (HasUndeserializedLookups) {
76 NodeDumper.AddChild([=] {
77 ColorScope Color(OS, ShowColors, UndeserializedColor);
78 OS << "<undeserialized lookups>";
79 });
80 }
81 });
82 }
83
84 template <typename SpecializationDecl>
dumpTemplateDeclSpecialization(const SpecializationDecl * D,bool DumpExplicitInst,bool DumpRefOnly)85 void ASTDumper::dumpTemplateDeclSpecialization(const SpecializationDecl *D,
86 bool DumpExplicitInst,
87 bool DumpRefOnly) {
88 bool DumpedAny = false;
89 for (const auto *RedeclWithBadType : D->redecls()) {
90 // FIXME: The redecls() range sometimes has elements of a less-specific
91 // type. (In particular, ClassTemplateSpecializationDecl::redecls() gives
92 // us TagDecls, and should give CXXRecordDecls).
93 auto *Redecl = dyn_cast<SpecializationDecl>(RedeclWithBadType);
94 if (!Redecl) {
95 // Found the injected-class-name for a class template. This will be dumped
96 // as part of its surrounding class so we don't need to dump it here.
97 assert(isa<CXXRecordDecl>(RedeclWithBadType) &&
98 "expected an injected-class-name");
99 continue;
100 }
101
102 switch (Redecl->getTemplateSpecializationKind()) {
103 case TSK_ExplicitInstantiationDeclaration:
104 case TSK_ExplicitInstantiationDefinition:
105 if (!DumpExplicitInst)
106 break;
107 LLVM_FALLTHROUGH;
108 case TSK_Undeclared:
109 case TSK_ImplicitInstantiation:
110 if (DumpRefOnly)
111 NodeDumper.dumpDeclRef(Redecl);
112 else
113 Visit(Redecl);
114 DumpedAny = true;
115 break;
116 case TSK_ExplicitSpecialization:
117 break;
118 }
119 }
120
121 // Ensure we dump at least one decl for each specialization.
122 if (!DumpedAny)
123 NodeDumper.dumpDeclRef(D);
124 }
125
126 template <typename TemplateDecl>
dumpTemplateDecl(const TemplateDecl * D,bool DumpExplicitInst)127 void ASTDumper::dumpTemplateDecl(const TemplateDecl *D, bool DumpExplicitInst) {
128 dumpTemplateParameters(D->getTemplateParameters());
129
130 Visit(D->getTemplatedDecl());
131
132 if (GetTraversalKind() == TK_AsIs) {
133 for (const auto *Child : D->specializations())
134 dumpTemplateDeclSpecialization(Child, DumpExplicitInst,
135 !D->isCanonicalDecl());
136 }
137 }
138
VisitFunctionTemplateDecl(const FunctionTemplateDecl * D)139 void ASTDumper::VisitFunctionTemplateDecl(const FunctionTemplateDecl *D) {
140 // FIXME: We don't add a declaration of a function template specialization
141 // to its context when it's explicitly instantiated, so dump explicit
142 // instantiations when we dump the template itself.
143 dumpTemplateDecl(D, true);
144 }
145
VisitClassTemplateDecl(const ClassTemplateDecl * D)146 void ASTDumper::VisitClassTemplateDecl(const ClassTemplateDecl *D) {
147 dumpTemplateDecl(D, false);
148 }
149
VisitVarTemplateDecl(const VarTemplateDecl * D)150 void ASTDumper::VisitVarTemplateDecl(const VarTemplateDecl *D) {
151 dumpTemplateDecl(D, false);
152 }
153
154 //===----------------------------------------------------------------------===//
155 // Type method implementations
156 //===----------------------------------------------------------------------===//
157
dump(const char * msg) const158 void QualType::dump(const char *msg) const {
159 if (msg)
160 llvm::errs() << msg << ": ";
161 dump();
162 }
163
dump() const164 LLVM_DUMP_METHOD void QualType::dump() const {
165 ASTDumper Dumper(llvm::errs(), /*ShowColors=*/false);
166 Dumper.Visit(*this);
167 }
168
dump(llvm::raw_ostream & OS,const ASTContext & Context) const169 LLVM_DUMP_METHOD void QualType::dump(llvm::raw_ostream &OS,
170 const ASTContext &Context) const {
171 ASTDumper Dumper(OS, Context, Context.getDiagnostics().getShowColors());
172 Dumper.Visit(*this);
173 }
174
dump() const175 LLVM_DUMP_METHOD void Type::dump() const { QualType(this, 0).dump(); }
176
dump(llvm::raw_ostream & OS,const ASTContext & Context) const177 LLVM_DUMP_METHOD void Type::dump(llvm::raw_ostream &OS,
178 const ASTContext &Context) const {
179 QualType(this, 0).dump(OS, Context);
180 }
181
182 //===----------------------------------------------------------------------===//
183 // Decl method implementations
184 //===----------------------------------------------------------------------===//
185
dump() const186 LLVM_DUMP_METHOD void Decl::dump() const { dump(llvm::errs()); }
187
dump(raw_ostream & OS,bool Deserialize,ASTDumpOutputFormat Format) const188 LLVM_DUMP_METHOD void Decl::dump(raw_ostream &OS, bool Deserialize,
189 ASTDumpOutputFormat Format) const {
190 ASTContext &Ctx = getASTContext();
191 const SourceManager &SM = Ctx.getSourceManager();
192
193 if (ADOF_JSON == Format) {
194 JSONDumper P(OS, SM, Ctx, Ctx.getPrintingPolicy(),
195 &Ctx.getCommentCommandTraits());
196 (void)Deserialize; // FIXME?
197 P.Visit(this);
198 } else {
199 ASTDumper P(OS, Ctx, Ctx.getDiagnostics().getShowColors());
200 P.setDeserialize(Deserialize);
201 P.Visit(this);
202 }
203 }
204
dumpColor() const205 LLVM_DUMP_METHOD void Decl::dumpColor() const {
206 const ASTContext &Ctx = getASTContext();
207 ASTDumper P(llvm::errs(), Ctx, /*ShowColors=*/true);
208 P.Visit(this);
209 }
210
dumpLookups() const211 LLVM_DUMP_METHOD void DeclContext::dumpLookups() const {
212 dumpLookups(llvm::errs());
213 }
214
dumpLookups(raw_ostream & OS,bool DumpDecls,bool Deserialize) const215 LLVM_DUMP_METHOD void DeclContext::dumpLookups(raw_ostream &OS,
216 bool DumpDecls,
217 bool Deserialize) const {
218 const DeclContext *DC = this;
219 while (!DC->isTranslationUnit())
220 DC = DC->getParent();
221 const ASTContext &Ctx = cast<TranslationUnitDecl>(DC)->getASTContext();
222 ASTDumper P(OS, Ctx, Ctx.getDiagnostics().getShowColors());
223 P.setDeserialize(Deserialize);
224 P.dumpLookups(this, DumpDecls);
225 }
226
227 //===----------------------------------------------------------------------===//
228 // Stmt method implementations
229 //===----------------------------------------------------------------------===//
230
dump() const231 LLVM_DUMP_METHOD void Stmt::dump() const {
232 ASTDumper P(llvm::errs(), /*ShowColors=*/false);
233 P.Visit(this);
234 }
235
dump(raw_ostream & OS,const ASTContext & Context) const236 LLVM_DUMP_METHOD void Stmt::dump(raw_ostream &OS,
237 const ASTContext &Context) const {
238 ASTDumper P(OS, Context, Context.getDiagnostics().getShowColors());
239 P.Visit(this);
240 }
241
dumpColor() const242 LLVM_DUMP_METHOD void Stmt::dumpColor() const {
243 ASTDumper P(llvm::errs(), /*ShowColors=*/true);
244 P.Visit(this);
245 }
246
247 //===----------------------------------------------------------------------===//
248 // Comment method implementations
249 //===----------------------------------------------------------------------===//
250
dump() const251 LLVM_DUMP_METHOD void Comment::dump() const {
252 const auto *FC = dyn_cast<FullComment>(this);
253 if (!FC)
254 return;
255 ASTDumper Dumper(llvm::errs(), /*ShowColors=*/false);
256 Dumper.Visit(FC, FC);
257 }
258
dump(raw_ostream & OS,const ASTContext & Context) const259 LLVM_DUMP_METHOD void Comment::dump(raw_ostream &OS,
260 const ASTContext &Context) const {
261 const auto *FC = dyn_cast<FullComment>(this);
262 if (!FC)
263 return;
264 ASTDumper Dumper(OS, Context, Context.getDiagnostics().getShowColors());
265 Dumper.Visit(FC, FC);
266 }
267
dumpColor() const268 LLVM_DUMP_METHOD void Comment::dumpColor() const {
269 const auto *FC = dyn_cast<FullComment>(this);
270 if (!FC)
271 return;
272 ASTDumper Dumper(llvm::errs(), /*ShowColors=*/true);
273 Dumper.Visit(FC, FC);
274 }
275
276 //===----------------------------------------------------------------------===//
277 // APValue method implementations
278 //===----------------------------------------------------------------------===//
279
dump() const280 LLVM_DUMP_METHOD void APValue::dump() const {
281 ASTDumper Dumper(llvm::errs(), /*ShowColors=*/false);
282 Dumper.Visit(*this, /*Ty=*/QualType());
283 }
284
dump(raw_ostream & OS,const ASTContext & Context) const285 LLVM_DUMP_METHOD void APValue::dump(raw_ostream &OS,
286 const ASTContext &Context) const {
287 ASTDumper Dumper(llvm::errs(), Context,
288 Context.getDiagnostics().getShowColors());
289 Dumper.Visit(*this, /*Ty=*/Context.getPointerType(Context.CharTy));
290 }
291