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" 22using namespace clang; 23using namespace clang::comments; 24 25void 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 84template <typename SpecializationDecl> 85void 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 126template <typename TemplateDecl> 127void 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 139void 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 146void ASTDumper::VisitClassTemplateDecl(const ClassTemplateDecl *D) { 147 dumpTemplateDecl(D, false); 148} 149 150void ASTDumper::VisitVarTemplateDecl(const VarTemplateDecl *D) { 151 dumpTemplateDecl(D, false); 152} 153 154//===----------------------------------------------------------------------===// 155// Type method implementations 156//===----------------------------------------------------------------------===// 157 158void QualType::dump(const char *msg) const { 159 if (msg) 160 llvm::errs() << msg << ": "; 161 dump(); 162} 163 164LLVM_DUMP_METHOD void QualType::dump() const { 165 ASTDumper Dumper(llvm::errs(), /*ShowColors=*/false); 166 Dumper.Visit(*this); 167} 168 169LLVM_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 175LLVM_DUMP_METHOD void Type::dump() const { QualType(this, 0).dump(); } 176 177LLVM_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 186LLVM_DUMP_METHOD void Decl::dump() const { dump(llvm::errs()); } 187 188LLVM_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 205LLVM_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 211LLVM_DUMP_METHOD void DeclContext::dumpLookups() const { 212 dumpLookups(llvm::errs()); 213} 214 215LLVM_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 231LLVM_DUMP_METHOD void Stmt::dump() const { 232 ASTDumper P(llvm::errs(), /*ShowColors=*/false); 233 P.Visit(this); 234} 235 236LLVM_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 242LLVM_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 251LLVM_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 259LLVM_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 268LLVM_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 280LLVM_DUMP_METHOD void APValue::dump() const { 281 ASTDumper Dumper(llvm::errs(), /*ShowColors=*/false); 282 Dumper.Visit(*this, /*Ty=*/QualType()); 283} 284 285LLVM_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