| //===--- ASTDumper.cpp - Dumping implementation for ASTs ------------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file implements the AST dump methods, which dump out the |
| // AST in a form that exposes type details and other fields. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "clang/AST/ASTDumper.h" |
| #include "clang/AST/ASTContext.h" |
| #include "clang/AST/DeclLookups.h" |
| #include "clang/AST/JSONNodeDumper.h" |
| #include "clang/Basic/Builtins.h" |
| #include "clang/Basic/Module.h" |
| #include "clang/Basic/SourceManager.h" |
| #include "llvm/Support/raw_ostream.h" |
| using namespace clang; |
| using namespace clang::comments; |
| |
| void ASTDumper::dumpLookups(const DeclContext *DC, bool DumpDecls) { |
| NodeDumper.AddChild([=] { |
| OS << "StoredDeclsMap "; |
| NodeDumper.dumpBareDeclRef(cast<Decl>(DC)); |
| |
| const DeclContext *Primary = DC->getPrimaryContext(); |
| if (Primary != DC) { |
| OS << " primary"; |
| NodeDumper.dumpPointer(cast<Decl>(Primary)); |
| } |
| |
| bool HasUndeserializedLookups = Primary->hasExternalVisibleStorage(); |
| |
| auto Range = getDeserialize() |
| ? Primary->lookups() |
| : Primary->noload_lookups(/*PreserveInternalState=*/true); |
| for (auto I = Range.begin(), E = Range.end(); I != E; ++I) { |
| DeclarationName Name = I.getLookupName(); |
| DeclContextLookupResult R = *I; |
| |
| NodeDumper.AddChild([=] { |
| OS << "DeclarationName "; |
| { |
| ColorScope Color(OS, ShowColors, DeclNameColor); |
| OS << '\'' << Name << '\''; |
| } |
| |
| for (DeclContextLookupResult::iterator RI = R.begin(), RE = R.end(); |
| RI != RE; ++RI) { |
| NodeDumper.AddChild([=] { |
| NodeDumper.dumpBareDeclRef(*RI); |
| |
| if ((*RI)->isHidden()) |
| OS << " hidden"; |
| |
| // If requested, dump the redecl chain for this lookup. |
| if (DumpDecls) { |
| // Dump earliest decl first. |
| std::function<void(Decl *)> DumpWithPrev = [&](Decl *D) { |
| if (Decl *Prev = D->getPreviousDecl()) |
| DumpWithPrev(Prev); |
| Visit(D); |
| }; |
| DumpWithPrev(*RI); |
| } |
| }); |
| } |
| }); |
| } |
| |
| if (HasUndeserializedLookups) { |
| NodeDumper.AddChild([=] { |
| ColorScope Color(OS, ShowColors, UndeserializedColor); |
| OS << "<undeserialized lookups>"; |
| }); |
| } |
| }); |
| } |
| |
| template <typename SpecializationDecl> |
| void ASTDumper::dumpTemplateDeclSpecialization(const SpecializationDecl *D, |
| bool DumpExplicitInst, |
| bool DumpRefOnly) { |
| bool DumpedAny = false; |
| for (const auto *RedeclWithBadType : D->redecls()) { |
| // FIXME: The redecls() range sometimes has elements of a less-specific |
| // type. (In particular, ClassTemplateSpecializationDecl::redecls() gives |
| // us TagDecls, and should give CXXRecordDecls). |
| auto *Redecl = dyn_cast<SpecializationDecl>(RedeclWithBadType); |
| if (!Redecl) { |
| // Found the injected-class-name for a class template. This will be dumped |
| // as part of its surrounding class so we don't need to dump it here. |
| assert(isa<CXXRecordDecl>(RedeclWithBadType) && |
| "expected an injected-class-name"); |
| continue; |
| } |
| |
| switch (Redecl->getTemplateSpecializationKind()) { |
| case TSK_ExplicitInstantiationDeclaration: |
| case TSK_ExplicitInstantiationDefinition: |
| if (!DumpExplicitInst) |
| break; |
| LLVM_FALLTHROUGH; |
| case TSK_Undeclared: |
| case TSK_ImplicitInstantiation: |
| if (DumpRefOnly) |
| NodeDumper.dumpDeclRef(Redecl); |
| else |
| Visit(Redecl); |
| DumpedAny = true; |
| break; |
| case TSK_ExplicitSpecialization: |
| break; |
| } |
| } |
| |
| // Ensure we dump at least one decl for each specialization. |
| if (!DumpedAny) |
| NodeDumper.dumpDeclRef(D); |
| } |
| |
| template <typename TemplateDecl> |
| void ASTDumper::dumpTemplateDecl(const TemplateDecl *D, bool DumpExplicitInst) { |
| dumpTemplateParameters(D->getTemplateParameters()); |
| |
| Visit(D->getTemplatedDecl()); |
| |
| for (const auto *Child : D->specializations()) |
| dumpTemplateDeclSpecialization(Child, DumpExplicitInst, |
| !D->isCanonicalDecl()); |
| } |
| |
| void ASTDumper::VisitFunctionTemplateDecl(const FunctionTemplateDecl *D) { |
| // FIXME: We don't add a declaration of a function template specialization |
| // to its context when it's explicitly instantiated, so dump explicit |
| // instantiations when we dump the template itself. |
| dumpTemplateDecl(D, true); |
| } |
| |
| void ASTDumper::VisitClassTemplateDecl(const ClassTemplateDecl *D) { |
| dumpTemplateDecl(D, false); |
| } |
| |
| void ASTDumper::VisitVarTemplateDecl(const VarTemplateDecl *D) { |
| dumpTemplateDecl(D, false); |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // Type method implementations |
| //===----------------------------------------------------------------------===// |
| |
| void QualType::dump(const char *msg) const { |
| if (msg) |
| llvm::errs() << msg << ": "; |
| dump(); |
| } |
| |
| LLVM_DUMP_METHOD void QualType::dump() const { dump(llvm::errs()); } |
| |
| LLVM_DUMP_METHOD void QualType::dump(llvm::raw_ostream &OS) const { |
| ASTDumper Dumper(OS, nullptr, nullptr); |
| Dumper.Visit(*this); |
| } |
| |
| LLVM_DUMP_METHOD void Type::dump() const { dump(llvm::errs()); } |
| |
| LLVM_DUMP_METHOD void Type::dump(llvm::raw_ostream &OS) const { |
| QualType(this, 0).dump(OS); |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // Decl method implementations |
| //===----------------------------------------------------------------------===// |
| |
| LLVM_DUMP_METHOD void Decl::dump() const { dump(llvm::errs()); } |
| |
| LLVM_DUMP_METHOD void Decl::dump(raw_ostream &OS, bool Deserialize, |
| ASTDumpOutputFormat Format) const { |
| ASTContext &Ctx = getASTContext(); |
| const SourceManager &SM = Ctx.getSourceManager(); |
| |
| if (ADOF_JSON == Format) { |
| JSONDumper P(OS, SM, Ctx, Ctx.getPrintingPolicy(), |
| &Ctx.getCommentCommandTraits()); |
| (void)Deserialize; // FIXME? |
| P.Visit(this); |
| } else { |
| ASTDumper P(OS, &Ctx.getCommentCommandTraits(), &SM, |
| SM.getDiagnostics().getShowColors(), Ctx.getPrintingPolicy()); |
| P.setDeserialize(Deserialize); |
| P.Visit(this); |
| } |
| } |
| |
| LLVM_DUMP_METHOD void Decl::dumpColor() const { |
| const ASTContext &Ctx = getASTContext(); |
| ASTDumper P(llvm::errs(), &Ctx.getCommentCommandTraits(), |
| &Ctx.getSourceManager(), /*ShowColors*/ true, |
| Ctx.getPrintingPolicy()); |
| P.Visit(this); |
| } |
| |
| LLVM_DUMP_METHOD void DeclContext::dumpLookups() const { |
| dumpLookups(llvm::errs()); |
| } |
| |
| LLVM_DUMP_METHOD void DeclContext::dumpLookups(raw_ostream &OS, |
| bool DumpDecls, |
| bool Deserialize) const { |
| const DeclContext *DC = this; |
| while (!DC->isTranslationUnit()) |
| DC = DC->getParent(); |
| ASTContext &Ctx = cast<TranslationUnitDecl>(DC)->getASTContext(); |
| const SourceManager &SM = Ctx.getSourceManager(); |
| ASTDumper P(OS, &Ctx.getCommentCommandTraits(), &Ctx.getSourceManager(), |
| SM.getDiagnostics().getShowColors(), Ctx.getPrintingPolicy()); |
| P.setDeserialize(Deserialize); |
| P.dumpLookups(this, DumpDecls); |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // Stmt method implementations |
| //===----------------------------------------------------------------------===// |
| |
| LLVM_DUMP_METHOD void Stmt::dump(SourceManager &SM) const { |
| dump(llvm::errs(), SM); |
| } |
| |
| LLVM_DUMP_METHOD void Stmt::dump(raw_ostream &OS, SourceManager &SM) const { |
| ASTDumper P(OS, nullptr, &SM); |
| P.Visit(this); |
| } |
| |
| LLVM_DUMP_METHOD void Stmt::dump(raw_ostream &OS) const { |
| ASTDumper P(OS, nullptr, nullptr); |
| P.Visit(this); |
| } |
| |
| LLVM_DUMP_METHOD void Stmt::dump() const { |
| ASTDumper P(llvm::errs(), nullptr, nullptr); |
| P.Visit(this); |
| } |
| |
| LLVM_DUMP_METHOD void Stmt::dumpColor() const { |
| ASTDumper P(llvm::errs(), nullptr, nullptr, /*ShowColors*/true); |
| P.Visit(this); |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // Comment method implementations |
| //===----------------------------------------------------------------------===// |
| |
| LLVM_DUMP_METHOD void Comment::dump() const { |
| dump(llvm::errs(), nullptr, nullptr); |
| } |
| |
| LLVM_DUMP_METHOD void Comment::dump(const ASTContext &Context) const { |
| dump(llvm::errs(), &Context.getCommentCommandTraits(), |
| &Context.getSourceManager()); |
| } |
| |
| void Comment::dump(raw_ostream &OS, const CommandTraits *Traits, |
| const SourceManager *SM) const { |
| const FullComment *FC = dyn_cast<FullComment>(this); |
| if (!FC) |
| return; |
| ASTDumper D(OS, Traits, SM); |
| D.Visit(FC, FC); |
| } |
| |
| LLVM_DUMP_METHOD void Comment::dumpColor() const { |
| const FullComment *FC = dyn_cast<FullComment>(this); |
| if (!FC) |
| return; |
| ASTDumper D(llvm::errs(), nullptr, nullptr, /*ShowColors*/true); |
| D.Visit(FC, FC); |
| } |