contrib/llvm-project/clang/lib/AST/ASTDumper.cpp

   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
  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)->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
  84 template <typename SpecializationDecl>
  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>
 127 void 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
 137 void 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
 144 void ASTDumper::VisitClassTemplateDecl(const ClassTemplateDecl *D) {
 145   dumpTemplateDecl(D, false);
 146 }
 147
 148 void ASTDumper::VisitVarTemplateDecl(const VarTemplateDecl *D) {
 149   dumpTemplateDecl(D, false);
 150 }
 151
 152 //===----------------------------------------------------------------------===//
 153 // Type method implementations
 154 //===----------------------------------------------------------------------===//
 155
 156 void QualType::dump(const char *msg) const {
 157   if (msg)
 158     llvm::errs() << msg << ": ";
 159   dump();
 160 }
 161
 162 LLVM_DUMP_METHOD void QualType::dump() const { dump(llvm::errs()); }
 163
 164 LLVM_DUMP_METHOD void QualType::dump(llvm::raw_ostream &OS) const {
 165   ASTDumper Dumper(OS, nullptr, nullptr);
 166   Dumper.Visit(*this);
 167 }
 168
 169 LLVM_DUMP_METHOD void Type::dump() const { dump(llvm::errs()); }
 170
 171 LLVM_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
 179 LLVM_DUMP_METHOD void Decl::dump() const { dump(llvm::errs()); }
 180
 181 LLVM_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
 199 LLVM_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
 207 LLVM_DUMP_METHOD void DeclContext::dumpLookups() const {
 208   dumpLookups(llvm::errs());
 209 }
 210
 211 LLVM_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
 229 LLVM_DUMP_METHOD void Stmt::dump(SourceManager &SM) const {
 230   dump(llvm::errs(), SM);
 231 }
 232
 233 LLVM_DUMP_METHOD void Stmt::dump(raw_ostream &OS, SourceManager &SM) const {
 234   ASTDumper P(OS, nullptr, &SM);
 235   P.Visit(this);
 236 }
 237
 238 LLVM_DUMP_METHOD void Stmt::dump(raw_ostream &OS) const {
 239   ASTDumper P(OS, nullptr, nullptr);
 240   P.Visit(this);
 241 }
 242
 243 LLVM_DUMP_METHOD void Stmt::dump() const {
 244   ASTDumper P(llvm::errs(), nullptr, nullptr);
 245   P.Visit(this);
 246 }
 247
 248 LLVM_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
 257 LLVM_DUMP_METHOD void Comment::dump() const {
 258   dump(llvm::errs(), nullptr, nullptr);
 259 }
 260
 261 LLVM_DUMP_METHOD void Comment::dump(const ASTContext &Context) const {
 262   dump(llvm::errs(), &Context.getCommentCommandTraits(),
 263        &Context.getSourceManager());
 264 }
 265
 266 void 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
 275 LLVM_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 }