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)->isHidden()) 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 for (const auto *Child : D->specializations()) 133 dumpTemplateDeclSpecialization(Child, DumpExplicitInst, 134 !D->isCanonicalDecl()); 135} 136 137void ASTDumper::VisitFunctionTemplateDecl(const FunctionTemplateDecl *D) { 138 // FIXME: We don't add a declaration of a function template specialization 139 // to its context when it's explicitly instantiated, so dump explicit 140 // instantiations when we dump the template itself. 141 dumpTemplateDecl(D, true); 142} 143 144void ASTDumper::VisitClassTemplateDecl(const ClassTemplateDecl *D) { 145 dumpTemplateDecl(D, false); 146} 147 148void ASTDumper::VisitVarTemplateDecl(const VarTemplateDecl *D) { 149 dumpTemplateDecl(D, false); 150} 151 152//===----------------------------------------------------------------------===// 153// Type method implementations 154//===----------------------------------------------------------------------===// 155 156void QualType::dump(const char *msg) const { 157 if (msg) 158 llvm::errs() << msg << ": "; 159 dump(); 160} 161 162LLVM_DUMP_METHOD void QualType::dump() const { dump(llvm::errs()); } 163 164LLVM_DUMP_METHOD void QualType::dump(llvm::raw_ostream &OS) const { 165 ASTDumper Dumper(OS, nullptr, nullptr); 166 Dumper.Visit(*this); 167} 168 169LLVM_DUMP_METHOD void Type::dump() const { dump(llvm::errs()); } 170 171LLVM_DUMP_METHOD void Type::dump(llvm::raw_ostream &OS) const { 172 QualType(this, 0).dump(OS); 173} 174 175//===----------------------------------------------------------------------===// 176// Decl method implementations 177//===----------------------------------------------------------------------===// 178 179LLVM_DUMP_METHOD void Decl::dump() const { dump(llvm::errs()); } 180 181LLVM_DUMP_METHOD void Decl::dump(raw_ostream &OS, bool Deserialize, 182 ASTDumpOutputFormat Format) const { 183 ASTContext &Ctx = getASTContext(); 184 const SourceManager &SM = Ctx.getSourceManager(); 185 186 if (ADOF_JSON == Format) { 187 JSONDumper P(OS, SM, Ctx, Ctx.getPrintingPolicy(), 188 &Ctx.getCommentCommandTraits()); 189 (void)Deserialize; // FIXME? 190 P.Visit(this); 191 } else { 192 ASTDumper P(OS, &Ctx.getCommentCommandTraits(), &SM, 193 SM.getDiagnostics().getShowColors(), Ctx.getPrintingPolicy()); 194 P.setDeserialize(Deserialize); 195 P.Visit(this); 196 } 197} 198 199LLVM_DUMP_METHOD void Decl::dumpColor() const { 200 const ASTContext &Ctx = getASTContext(); 201 ASTDumper P(llvm::errs(), &Ctx.getCommentCommandTraits(), 202 &Ctx.getSourceManager(), /*ShowColors*/ true, 203 Ctx.getPrintingPolicy()); 204 P.Visit(this); 205} 206 207LLVM_DUMP_METHOD void DeclContext::dumpLookups() const { 208 dumpLookups(llvm::errs()); 209} 210 211LLVM_DUMP_METHOD void DeclContext::dumpLookups(raw_ostream &OS, 212 bool DumpDecls, 213 bool Deserialize) const { 214 const DeclContext *DC = this; 215 while (!DC->isTranslationUnit()) 216 DC = DC->getParent(); 217 ASTContext &Ctx = cast<TranslationUnitDecl>(DC)->getASTContext(); 218 const SourceManager &SM = Ctx.getSourceManager(); 219 ASTDumper P(OS, &Ctx.getCommentCommandTraits(), &Ctx.getSourceManager(), 220 SM.getDiagnostics().getShowColors(), Ctx.getPrintingPolicy()); 221 P.setDeserialize(Deserialize); 222 P.dumpLookups(this, DumpDecls); 223} 224 225//===----------------------------------------------------------------------===// 226// Stmt method implementations 227//===----------------------------------------------------------------------===// 228 229LLVM_DUMP_METHOD void Stmt::dump(SourceManager &SM) const { 230 dump(llvm::errs(), SM); 231} 232 233LLVM_DUMP_METHOD void Stmt::dump(raw_ostream &OS, SourceManager &SM) const { 234 ASTDumper P(OS, nullptr, &SM); 235 P.Visit(this); 236} 237 238LLVM_DUMP_METHOD void Stmt::dump(raw_ostream &OS) const { 239 ASTDumper P(OS, nullptr, nullptr); 240 P.Visit(this); 241} 242 243LLVM_DUMP_METHOD void Stmt::dump() const { 244 ASTDumper P(llvm::errs(), nullptr, nullptr); 245 P.Visit(this); 246} 247 248LLVM_DUMP_METHOD void Stmt::dumpColor() const { 249 ASTDumper P(llvm::errs(), nullptr, nullptr, /*ShowColors*/true); 250 P.Visit(this); 251} 252 253//===----------------------------------------------------------------------===// 254// Comment method implementations 255//===----------------------------------------------------------------------===// 256 257LLVM_DUMP_METHOD void Comment::dump() const { 258 dump(llvm::errs(), nullptr, nullptr); 259} 260 261LLVM_DUMP_METHOD void Comment::dump(const ASTContext &Context) const { 262 dump(llvm::errs(), &Context.getCommentCommandTraits(), 263 &Context.getSourceManager()); 264} 265 266void Comment::dump(raw_ostream &OS, const CommandTraits *Traits, 267 const SourceManager *SM) const { 268 const FullComment *FC = dyn_cast<FullComment>(this); 269 if (!FC) 270 return; 271 ASTDumper D(OS, Traits, SM); 272 D.Visit(FC, FC); 273} 274 275LLVM_DUMP_METHOD void Comment::dumpColor() const { 276 const FullComment *FC = dyn_cast<FullComment>(this); 277 if (!FC) 278 return; 279 ASTDumper D(llvm::errs(), nullptr, nullptr, /*ShowColors*/true); 280 D.Visit(FC, FC); 281} 282