You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
291 lines
9.6 KiB
291 lines
9.6 KiB
//===--- 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)->isUnconditionallyVisible())
|
|
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());
|
|
|
|
if (GetTraversalKind() == TK_AsIs) {
|
|
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 {
|
|
ASTDumper Dumper(llvm::errs(), /*ShowColors=*/false);
|
|
Dumper.Visit(*this);
|
|
}
|
|
|
|
LLVM_DUMP_METHOD void QualType::dump(llvm::raw_ostream &OS,
|
|
const ASTContext &Context) const {
|
|
ASTDumper Dumper(OS, Context, Context.getDiagnostics().getShowColors());
|
|
Dumper.Visit(*this);
|
|
}
|
|
|
|
LLVM_DUMP_METHOD void Type::dump() const { QualType(this, 0).dump(); }
|
|
|
|
LLVM_DUMP_METHOD void Type::dump(llvm::raw_ostream &OS,
|
|
const ASTContext &Context) const {
|
|
QualType(this, 0).dump(OS, Context);
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// 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, Ctx.getDiagnostics().getShowColors());
|
|
P.setDeserialize(Deserialize);
|
|
P.Visit(this);
|
|
}
|
|
}
|
|
|
|
LLVM_DUMP_METHOD void Decl::dumpColor() const {
|
|
const ASTContext &Ctx = getASTContext();
|
|
ASTDumper P(llvm::errs(), Ctx, /*ShowColors=*/true);
|
|
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();
|
|
const ASTContext &Ctx = cast<TranslationUnitDecl>(DC)->getASTContext();
|
|
ASTDumper P(OS, Ctx, Ctx.getDiagnostics().getShowColors());
|
|
P.setDeserialize(Deserialize);
|
|
P.dumpLookups(this, DumpDecls);
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Stmt method implementations
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
LLVM_DUMP_METHOD void Stmt::dump() const {
|
|
ASTDumper P(llvm::errs(), /*ShowColors=*/false);
|
|
P.Visit(this);
|
|
}
|
|
|
|
LLVM_DUMP_METHOD void Stmt::dump(raw_ostream &OS,
|
|
const ASTContext &Context) const {
|
|
ASTDumper P(OS, Context, Context.getDiagnostics().getShowColors());
|
|
P.Visit(this);
|
|
}
|
|
|
|
LLVM_DUMP_METHOD void Stmt::dumpColor() const {
|
|
ASTDumper P(llvm::errs(), /*ShowColors=*/true);
|
|
P.Visit(this);
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Comment method implementations
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
LLVM_DUMP_METHOD void Comment::dump() const {
|
|
const auto *FC = dyn_cast<FullComment>(this);
|
|
if (!FC)
|
|
return;
|
|
ASTDumper Dumper(llvm::errs(), /*ShowColors=*/false);
|
|
Dumper.Visit(FC, FC);
|
|
}
|
|
|
|
LLVM_DUMP_METHOD void Comment::dump(raw_ostream &OS,
|
|
const ASTContext &Context) const {
|
|
const auto *FC = dyn_cast<FullComment>(this);
|
|
if (!FC)
|
|
return;
|
|
ASTDumper Dumper(OS, Context, Context.getDiagnostics().getShowColors());
|
|
Dumper.Visit(FC, FC);
|
|
}
|
|
|
|
LLVM_DUMP_METHOD void Comment::dumpColor() const {
|
|
const auto *FC = dyn_cast<FullComment>(this);
|
|
if (!FC)
|
|
return;
|
|
ASTDumper Dumper(llvm::errs(), /*ShowColors=*/true);
|
|
Dumper.Visit(FC, FC);
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// APValue method implementations
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
LLVM_DUMP_METHOD void APValue::dump() const {
|
|
ASTDumper Dumper(llvm::errs(), /*ShowColors=*/false);
|
|
Dumper.Visit(*this, /*Ty=*/QualType());
|
|
}
|
|
|
|
LLVM_DUMP_METHOD void APValue::dump(raw_ostream &OS,
|
|
const ASTContext &Context) const {
|
|
ASTDumper Dumper(llvm::errs(), Context,
|
|
Context.getDiagnostics().getShowColors());
|
|
Dumper.Visit(*this, /*Ty=*/Context.getPointerType(Context.CharTy));
|
|
}
|