1 //===--- ASTDumper.cpp - Dumping implementation for ASTs ------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file implements the AST dump methods, which dump out the 11 // AST in a form that exposes type details and other fields. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #include "clang/AST/ASTContext.h" 16 #include "clang/AST/Attr.h" 17 #include "clang/AST/CommentVisitor.h" 18 #include "clang/AST/DeclCXX.h" 19 #include "clang/AST/DeclLookups.h" 20 #include "clang/AST/DeclObjC.h" 21 #include "clang/AST/DeclOpenMP.h" 22 #include "clang/AST/DeclVisitor.h" 23 #include "clang/AST/LocInfoType.h" 24 #include "clang/AST/StmtVisitor.h" 25 #include "clang/AST/TypeVisitor.h" 26 #include "clang/Basic/Builtins.h" 27 #include "clang/Basic/Module.h" 28 #include "clang/Basic/SourceManager.h" 29 #include "llvm/Support/raw_ostream.h" 30 using namespace clang; 31 using namespace clang::comments; 32 33 //===----------------------------------------------------------------------===// 34 // ASTDumper Visitor 35 //===----------------------------------------------------------------------===// 36 37 namespace { 38 // Colors used for various parts of the AST dump 39 // Do not use bold yellow for any text. It is hard to read on white screens. 40 41 struct TerminalColor { 42 raw_ostream::Colors Color; 43 bool Bold; 44 }; 45 46 // Red - CastColor 47 // Green - TypeColor 48 // Bold Green - DeclKindNameColor, UndeserializedColor 49 // Yellow - AddressColor, LocationColor 50 // Blue - CommentColor, NullColor, IndentColor 51 // Bold Blue - AttrColor 52 // Bold Magenta - StmtColor 53 // Cyan - ValueKindColor, ObjectKindColor 54 // Bold Cyan - ValueColor, DeclNameColor 55 56 // Decl kind names (VarDecl, FunctionDecl, etc) 57 static const TerminalColor DeclKindNameColor = { raw_ostream::GREEN, true }; 58 // Attr names (CleanupAttr, GuardedByAttr, etc) 59 static const TerminalColor AttrColor = { raw_ostream::BLUE, true }; 60 // Statement names (DeclStmt, ImplicitCastExpr, etc) 61 static const TerminalColor StmtColor = { raw_ostream::MAGENTA, true }; 62 // Comment names (FullComment, ParagraphComment, TextComment, etc) 63 static const TerminalColor CommentColor = { raw_ostream::BLUE, false }; 64 65 // Type names (int, float, etc, plus user defined types) 66 static const TerminalColor TypeColor = { raw_ostream::GREEN, false }; 67 68 // Pointer address 69 static const TerminalColor AddressColor = { raw_ostream::YELLOW, false }; 70 // Source locations 71 static const TerminalColor LocationColor = { raw_ostream::YELLOW, false }; 72 73 // lvalue/xvalue 74 static const TerminalColor ValueKindColor = { raw_ostream::CYAN, false }; 75 // bitfield/objcproperty/objcsubscript/vectorcomponent 76 static const TerminalColor ObjectKindColor = { raw_ostream::CYAN, false }; 77 78 // Null statements 79 static const TerminalColor NullColor = { raw_ostream::BLUE, false }; 80 81 // Undeserialized entities 82 static const TerminalColor UndeserializedColor = { raw_ostream::GREEN, true }; 83 84 // CastKind from CastExpr's 85 static const TerminalColor CastColor = { raw_ostream::RED, false }; 86 87 // Value of the statement 88 static const TerminalColor ValueColor = { raw_ostream::CYAN, true }; 89 // Decl names 90 static const TerminalColor DeclNameColor = { raw_ostream::CYAN, true }; 91 92 // Indents ( `, -. | ) 93 static const TerminalColor IndentColor = { raw_ostream::BLUE, false }; 94 95 class ASTDumper 96 : public ConstDeclVisitor<ASTDumper>, public ConstStmtVisitor<ASTDumper>, 97 public ConstCommentVisitor<ASTDumper>, public TypeVisitor<ASTDumper> { 98 raw_ostream &OS; 99 const CommandTraits *Traits; 100 const SourceManager *SM; 101 102 /// The policy to use for printing; can be defaulted. 103 PrintingPolicy PrintPolicy; 104 105 /// Pending[i] is an action to dump an entity at level i. 106 llvm::SmallVector<std::function<void(bool isLastChild)>, 32> Pending; 107 108 /// Indicates whether we should trigger deserialization of nodes that had 109 /// not already been loaded. 110 bool Deserialize = false; 111 112 /// Indicates whether we're at the top level. 113 bool TopLevel = true; 114 115 /// Indicates if we're handling the first child after entering a new depth. 116 bool FirstChild = true; 117 118 /// Prefix for currently-being-dumped entity. 119 std::string Prefix; 120 121 /// Keep track of the last location we print out so that we can 122 /// print out deltas from then on out. 123 const char *LastLocFilename = ""; 124 unsigned LastLocLine = ~0U; 125 126 /// The \c FullComment parent of the comment being dumped. 127 const FullComment *FC = nullptr; 128 129 bool ShowColors; 130 131 /// Dump a child of the current node. 132 template<typename Fn> void dumpChild(Fn doDumpChild) { 133 // If we're at the top level, there's nothing interesting to do; just 134 // run the dumper. 135 if (TopLevel) { 136 TopLevel = false; 137 doDumpChild(); 138 while (!Pending.empty()) { 139 Pending.back()(true); 140 Pending.pop_back(); 141 } 142 Prefix.clear(); 143 OS << "\n"; 144 TopLevel = true; 145 return; 146 } 147 148 const FullComment *OrigFC = FC; 149 auto dumpWithIndent = [this, doDumpChild, OrigFC](bool isLastChild) { 150 // Print out the appropriate tree structure and work out the prefix for 151 // children of this node. For instance: 152 // 153 // A Prefix = "" 154 // |-B Prefix = "| " 155 // | `-C Prefix = "| " 156 // `-D Prefix = " " 157 // |-E Prefix = " | " 158 // `-F Prefix = " " 159 // G Prefix = "" 160 // 161 // Note that the first level gets no prefix. 162 { 163 OS << '\n'; 164 ColorScope Color(*this, IndentColor); 165 OS << Prefix << (isLastChild ? '`' : '|') << '-'; 166 this->Prefix.push_back(isLastChild ? ' ' : '|'); 167 this->Prefix.push_back(' '); 168 } 169 170 FirstChild = true; 171 unsigned Depth = Pending.size(); 172 173 FC = OrigFC; 174 doDumpChild(); 175 176 // If any children are left, they're the last at their nesting level. 177 // Dump those ones out now. 178 while (Depth < Pending.size()) { 179 Pending.back()(true); 180 this->Pending.pop_back(); 181 } 182 183 // Restore the old prefix. 184 this->Prefix.resize(Prefix.size() - 2); 185 }; 186 187 if (FirstChild) { 188 Pending.push_back(std::move(dumpWithIndent)); 189 } else { 190 Pending.back()(false); 191 Pending.back() = std::move(dumpWithIndent); 192 } 193 FirstChild = false; 194 } 195 196 class ColorScope { 197 ASTDumper &Dumper; 198 public: 199 ColorScope(ASTDumper &Dumper, TerminalColor Color) 200 : Dumper(Dumper) { 201 if (Dumper.ShowColors) 202 Dumper.OS.changeColor(Color.Color, Color.Bold); 203 } 204 ~ColorScope() { 205 if (Dumper.ShowColors) 206 Dumper.OS.resetColor(); 207 } 208 }; 209 210 public: 211 ASTDumper(raw_ostream &OS, const CommandTraits *Traits, 212 const SourceManager *SM) 213 : ASTDumper(OS, Traits, SM, 214 SM && SM->getDiagnostics().getShowColors()) {} 215 216 ASTDumper(raw_ostream &OS, const CommandTraits *Traits, 217 const SourceManager *SM, bool ShowColors) 218 : ASTDumper(OS, Traits, SM, ShowColors, LangOptions()) {} 219 ASTDumper(raw_ostream &OS, const CommandTraits *Traits, 220 const SourceManager *SM, bool ShowColors, 221 const PrintingPolicy &PrintPolicy) 222 : OS(OS), Traits(Traits), SM(SM), PrintPolicy(PrintPolicy), 223 ShowColors(ShowColors) {} 224 225 void setDeserialize(bool D) { Deserialize = D; } 226 227 void dumpDecl(const Decl *D); 228 void dumpStmt(const Stmt *S); 229 void dumpFullComment(const FullComment *C); 230 231 // Utilities 232 void dumpPointer(const void *Ptr); 233 void dumpSourceRange(SourceRange R); 234 void dumpLocation(SourceLocation Loc); 235 void dumpBareType(QualType T, bool Desugar = true); 236 void dumpType(QualType T); 237 void dumpTypeAsChild(QualType T); 238 void dumpTypeAsChild(const Type *T); 239 void dumpBareDeclRef(const Decl *Node); 240 void dumpDeclRef(const Decl *Node, const char *Label = nullptr); 241 void dumpName(const NamedDecl *D); 242 bool hasNodes(const DeclContext *DC); 243 void dumpDeclContext(const DeclContext *DC); 244 void dumpLookups(const DeclContext *DC, bool DumpDecls); 245 void dumpAttr(const Attr *A); 246 247 // C++ Utilities 248 void dumpAccessSpecifier(AccessSpecifier AS); 249 void dumpCXXCtorInitializer(const CXXCtorInitializer *Init); 250 void dumpTemplateParameters(const TemplateParameterList *TPL); 251 void dumpTemplateArgumentListInfo(const TemplateArgumentListInfo &TALI); 252 void dumpTemplateArgumentLoc(const TemplateArgumentLoc &A); 253 void dumpTemplateArgumentList(const TemplateArgumentList &TAL); 254 void dumpTemplateArgument(const TemplateArgument &A, 255 SourceRange R = SourceRange()); 256 257 // Objective-C utilities. 258 void dumpObjCTypeParamList(const ObjCTypeParamList *typeParams); 259 260 // Types 261 void VisitComplexType(const ComplexType *T) { 262 dumpTypeAsChild(T->getElementType()); 263 } 264 void VisitPointerType(const PointerType *T) { 265 dumpTypeAsChild(T->getPointeeType()); 266 } 267 void VisitBlockPointerType(const BlockPointerType *T) { 268 dumpTypeAsChild(T->getPointeeType()); 269 } 270 void VisitReferenceType(const ReferenceType *T) { 271 dumpTypeAsChild(T->getPointeeType()); 272 } 273 void VisitRValueReferenceType(const ReferenceType *T) { 274 if (T->isSpelledAsLValue()) 275 OS << " written as lvalue reference"; 276 VisitReferenceType(T); 277 } 278 void VisitMemberPointerType(const MemberPointerType *T) { 279 dumpTypeAsChild(T->getClass()); 280 dumpTypeAsChild(T->getPointeeType()); 281 } 282 void VisitArrayType(const ArrayType *T) { 283 switch (T->getSizeModifier()) { 284 case ArrayType::Normal: break; 285 case ArrayType::Static: OS << " static"; break; 286 case ArrayType::Star: OS << " *"; break; 287 } 288 OS << " " << T->getIndexTypeQualifiers().getAsString(); 289 dumpTypeAsChild(T->getElementType()); 290 } 291 void VisitConstantArrayType(const ConstantArrayType *T) { 292 OS << " " << T->getSize(); 293 VisitArrayType(T); 294 } 295 void VisitVariableArrayType(const VariableArrayType *T) { 296 OS << " "; 297 dumpSourceRange(T->getBracketsRange()); 298 VisitArrayType(T); 299 dumpStmt(T->getSizeExpr()); 300 } 301 void VisitDependentSizedArrayType(const DependentSizedArrayType *T) { 302 VisitArrayType(T); 303 OS << " "; 304 dumpSourceRange(T->getBracketsRange()); 305 dumpStmt(T->getSizeExpr()); 306 } 307 void VisitDependentSizedExtVectorType( 308 const DependentSizedExtVectorType *T) { 309 OS << " "; 310 dumpLocation(T->getAttributeLoc()); 311 dumpTypeAsChild(T->getElementType()); 312 dumpStmt(T->getSizeExpr()); 313 } 314 void VisitVectorType(const VectorType *T) { 315 switch (T->getVectorKind()) { 316 case VectorType::GenericVector: break; 317 case VectorType::AltiVecVector: OS << " altivec"; break; 318 case VectorType::AltiVecPixel: OS << " altivec pixel"; break; 319 case VectorType::AltiVecBool: OS << " altivec bool"; break; 320 case VectorType::NeonVector: OS << " neon"; break; 321 case VectorType::NeonPolyVector: OS << " neon poly"; break; 322 } 323 OS << " " << T->getNumElements(); 324 dumpTypeAsChild(T->getElementType()); 325 } 326 void VisitFunctionType(const FunctionType *T) { 327 auto EI = T->getExtInfo(); 328 if (EI.getNoReturn()) OS << " noreturn"; 329 if (EI.getProducesResult()) OS << " produces_result"; 330 if (EI.getHasRegParm()) OS << " regparm " << EI.getRegParm(); 331 OS << " " << FunctionType::getNameForCallConv(EI.getCC()); 332 dumpTypeAsChild(T->getReturnType()); 333 } 334 void VisitFunctionProtoType(const FunctionProtoType *T) { 335 auto EPI = T->getExtProtoInfo(); 336 if (EPI.HasTrailingReturn) OS << " trailing_return"; 337 if (T->isConst()) OS << " const"; 338 if (T->isVolatile()) OS << " volatile"; 339 if (T->isRestrict()) OS << " restrict"; 340 switch (EPI.RefQualifier) { 341 case RQ_None: break; 342 case RQ_LValue: OS << " &"; break; 343 case RQ_RValue: OS << " &&"; break; 344 } 345 // FIXME: Exception specification. 346 // FIXME: Consumed parameters. 347 VisitFunctionType(T); 348 for (QualType PT : T->getParamTypes()) 349 dumpTypeAsChild(PT); 350 if (EPI.Variadic) 351 dumpChild([=] { OS << "..."; }); 352 } 353 void VisitUnresolvedUsingType(const UnresolvedUsingType *T) { 354 dumpDeclRef(T->getDecl()); 355 } 356 void VisitTypedefType(const TypedefType *T) { 357 dumpDeclRef(T->getDecl()); 358 } 359 void VisitTypeOfExprType(const TypeOfExprType *T) { 360 dumpStmt(T->getUnderlyingExpr()); 361 } 362 void VisitDecltypeType(const DecltypeType *T) { 363 dumpStmt(T->getUnderlyingExpr()); 364 } 365 void VisitUnaryTransformType(const UnaryTransformType *T) { 366 switch (T->getUTTKind()) { 367 case UnaryTransformType::EnumUnderlyingType: 368 OS << " underlying_type"; 369 break; 370 } 371 dumpTypeAsChild(T->getBaseType()); 372 } 373 void VisitTagType(const TagType *T) { 374 dumpDeclRef(T->getDecl()); 375 } 376 void VisitAttributedType(const AttributedType *T) { 377 // FIXME: AttrKind 378 dumpTypeAsChild(T->getModifiedType()); 379 } 380 void VisitTemplateTypeParmType(const TemplateTypeParmType *T) { 381 OS << " depth " << T->getDepth() << " index " << T->getIndex(); 382 if (T->isParameterPack()) OS << " pack"; 383 dumpDeclRef(T->getDecl()); 384 } 385 void VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) { 386 dumpTypeAsChild(T->getReplacedParameter()); 387 } 388 void VisitSubstTemplateTypeParmPackType( 389 const SubstTemplateTypeParmPackType *T) { 390 dumpTypeAsChild(T->getReplacedParameter()); 391 dumpTemplateArgument(T->getArgumentPack()); 392 } 393 void VisitAutoType(const AutoType *T) { 394 if (T->isDecltypeAuto()) OS << " decltype(auto)"; 395 if (!T->isDeduced()) 396 OS << " undeduced"; 397 } 398 void VisitTemplateSpecializationType(const TemplateSpecializationType *T) { 399 if (T->isTypeAlias()) OS << " alias"; 400 OS << " "; T->getTemplateName().dump(OS); 401 for (auto &Arg : *T) 402 dumpTemplateArgument(Arg); 403 if (T->isTypeAlias()) 404 dumpTypeAsChild(T->getAliasedType()); 405 } 406 void VisitInjectedClassNameType(const InjectedClassNameType *T) { 407 dumpDeclRef(T->getDecl()); 408 } 409 void VisitObjCInterfaceType(const ObjCInterfaceType *T) { 410 dumpDeclRef(T->getDecl()); 411 } 412 void VisitObjCObjectPointerType(const ObjCObjectPointerType *T) { 413 dumpTypeAsChild(T->getPointeeType()); 414 } 415 void VisitAtomicType(const AtomicType *T) { 416 dumpTypeAsChild(T->getValueType()); 417 } 418 void VisitPipeType(const PipeType *T) { 419 dumpTypeAsChild(T->getElementType()); 420 } 421 void VisitAdjustedType(const AdjustedType *T) { 422 dumpTypeAsChild(T->getOriginalType()); 423 } 424 void VisitPackExpansionType(const PackExpansionType *T) { 425 if (auto N = T->getNumExpansions()) OS << " expansions " << *N; 426 if (!T->isSugared()) 427 dumpTypeAsChild(T->getPattern()); 428 } 429 // FIXME: ElaboratedType, DependentNameType, 430 // DependentTemplateSpecializationType, ObjCObjectType 431 432 // Decls 433 void VisitLabelDecl(const LabelDecl *D); 434 void VisitTypedefDecl(const TypedefDecl *D); 435 void VisitEnumDecl(const EnumDecl *D); 436 void VisitRecordDecl(const RecordDecl *D); 437 void VisitEnumConstantDecl(const EnumConstantDecl *D); 438 void VisitIndirectFieldDecl(const IndirectFieldDecl *D); 439 void VisitFunctionDecl(const FunctionDecl *D); 440 void VisitFieldDecl(const FieldDecl *D); 441 void VisitVarDecl(const VarDecl *D); 442 void VisitDecompositionDecl(const DecompositionDecl *D); 443 void VisitBindingDecl(const BindingDecl *D); 444 void VisitFileScopeAsmDecl(const FileScopeAsmDecl *D); 445 void VisitImportDecl(const ImportDecl *D); 446 void VisitPragmaCommentDecl(const PragmaCommentDecl *D); 447 void VisitPragmaDetectMismatchDecl(const PragmaDetectMismatchDecl *D); 448 void VisitCapturedDecl(const CapturedDecl *D); 449 450 // OpenMP decls 451 void VisitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D); 452 void VisitOMPDeclareReductionDecl(const OMPDeclareReductionDecl *D); 453 void VisitOMPCapturedExprDecl(const OMPCapturedExprDecl *D); 454 455 // C++ Decls 456 void VisitNamespaceDecl(const NamespaceDecl *D); 457 void VisitUsingDirectiveDecl(const UsingDirectiveDecl *D); 458 void VisitNamespaceAliasDecl(const NamespaceAliasDecl *D); 459 void VisitTypeAliasDecl(const TypeAliasDecl *D); 460 void VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D); 461 void VisitCXXRecordDecl(const CXXRecordDecl *D); 462 void VisitStaticAssertDecl(const StaticAssertDecl *D); 463 template<typename SpecializationDecl> 464 void VisitTemplateDeclSpecialization(const SpecializationDecl *D, 465 bool DumpExplicitInst, 466 bool DumpRefOnly); 467 template<typename TemplateDecl> 468 void VisitTemplateDecl(const TemplateDecl *D, bool DumpExplicitInst); 469 void VisitFunctionTemplateDecl(const FunctionTemplateDecl *D); 470 void VisitClassTemplateDecl(const ClassTemplateDecl *D); 471 void VisitClassTemplateSpecializationDecl( 472 const ClassTemplateSpecializationDecl *D); 473 void VisitClassTemplatePartialSpecializationDecl( 474 const ClassTemplatePartialSpecializationDecl *D); 475 void VisitClassScopeFunctionSpecializationDecl( 476 const ClassScopeFunctionSpecializationDecl *D); 477 void VisitBuiltinTemplateDecl(const BuiltinTemplateDecl *D); 478 void VisitVarTemplateDecl(const VarTemplateDecl *D); 479 void VisitVarTemplateSpecializationDecl( 480 const VarTemplateSpecializationDecl *D); 481 void VisitVarTemplatePartialSpecializationDecl( 482 const VarTemplatePartialSpecializationDecl *D); 483 void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D); 484 void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D); 485 void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D); 486 void VisitUsingDecl(const UsingDecl *D); 487 void VisitUnresolvedUsingTypenameDecl(const UnresolvedUsingTypenameDecl *D); 488 void VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl *D); 489 void VisitUsingShadowDecl(const UsingShadowDecl *D); 490 void VisitConstructorUsingShadowDecl(const ConstructorUsingShadowDecl *D); 491 void VisitLinkageSpecDecl(const LinkageSpecDecl *D); 492 void VisitAccessSpecDecl(const AccessSpecDecl *D); 493 void VisitFriendDecl(const FriendDecl *D); 494 495 // ObjC Decls 496 void VisitObjCIvarDecl(const ObjCIvarDecl *D); 497 void VisitObjCMethodDecl(const ObjCMethodDecl *D); 498 void VisitObjCTypeParamDecl(const ObjCTypeParamDecl *D); 499 void VisitObjCCategoryDecl(const ObjCCategoryDecl *D); 500 void VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D); 501 void VisitObjCProtocolDecl(const ObjCProtocolDecl *D); 502 void VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D); 503 void VisitObjCImplementationDecl(const ObjCImplementationDecl *D); 504 void VisitObjCCompatibleAliasDecl(const ObjCCompatibleAliasDecl *D); 505 void VisitObjCPropertyDecl(const ObjCPropertyDecl *D); 506 void VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D); 507 void VisitBlockDecl(const BlockDecl *D); 508 509 // Stmts. 510 void VisitStmt(const Stmt *Node); 511 void VisitDeclStmt(const DeclStmt *Node); 512 void VisitAttributedStmt(const AttributedStmt *Node); 513 void VisitLabelStmt(const LabelStmt *Node); 514 void VisitGotoStmt(const GotoStmt *Node); 515 void VisitCXXCatchStmt(const CXXCatchStmt *Node); 516 void VisitCapturedStmt(const CapturedStmt *Node); 517 518 // OpenMP 519 void VisitOMPExecutableDirective(const OMPExecutableDirective *Node); 520 521 // Exprs 522 void VisitExpr(const Expr *Node); 523 void VisitCastExpr(const CastExpr *Node); 524 void VisitDeclRefExpr(const DeclRefExpr *Node); 525 void VisitPredefinedExpr(const PredefinedExpr *Node); 526 void VisitCharacterLiteral(const CharacterLiteral *Node); 527 void VisitIntegerLiteral(const IntegerLiteral *Node); 528 void VisitFloatingLiteral(const FloatingLiteral *Node); 529 void VisitStringLiteral(const StringLiteral *Str); 530 void VisitInitListExpr(const InitListExpr *ILE); 531 void VisitArrayInitLoopExpr(const ArrayInitLoopExpr *ILE); 532 void VisitArrayInitIndexExpr(const ArrayInitIndexExpr *ILE); 533 void VisitUnaryOperator(const UnaryOperator *Node); 534 void VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *Node); 535 void VisitMemberExpr(const MemberExpr *Node); 536 void VisitExtVectorElementExpr(const ExtVectorElementExpr *Node); 537 void VisitBinaryOperator(const BinaryOperator *Node); 538 void VisitCompoundAssignOperator(const CompoundAssignOperator *Node); 539 void VisitAddrLabelExpr(const AddrLabelExpr *Node); 540 void VisitBlockExpr(const BlockExpr *Node); 541 void VisitOpaqueValueExpr(const OpaqueValueExpr *Node); 542 void VisitGenericSelectionExpr(const GenericSelectionExpr *E); 543 544 // C++ 545 void VisitCXXNamedCastExpr(const CXXNamedCastExpr *Node); 546 void VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *Node); 547 void VisitCXXThisExpr(const CXXThisExpr *Node); 548 void VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *Node); 549 void VisitCXXUnresolvedConstructExpr(const CXXUnresolvedConstructExpr *Node); 550 void VisitCXXConstructExpr(const CXXConstructExpr *Node); 551 void VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *Node); 552 void VisitCXXNewExpr(const CXXNewExpr *Node); 553 void VisitCXXDeleteExpr(const CXXDeleteExpr *Node); 554 void VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *Node); 555 void VisitExprWithCleanups(const ExprWithCleanups *Node); 556 void VisitUnresolvedLookupExpr(const UnresolvedLookupExpr *Node); 557 void dumpCXXTemporary(const CXXTemporary *Temporary); 558 void VisitLambdaExpr(const LambdaExpr *Node) { 559 VisitExpr(Node); 560 dumpDecl(Node->getLambdaClass()); 561 } 562 void VisitSizeOfPackExpr(const SizeOfPackExpr *Node); 563 void 564 VisitCXXDependentScopeMemberExpr(const CXXDependentScopeMemberExpr *Node); 565 566 // ObjC 567 void VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node); 568 void VisitObjCEncodeExpr(const ObjCEncodeExpr *Node); 569 void VisitObjCMessageExpr(const ObjCMessageExpr *Node); 570 void VisitObjCBoxedExpr(const ObjCBoxedExpr *Node); 571 void VisitObjCSelectorExpr(const ObjCSelectorExpr *Node); 572 void VisitObjCProtocolExpr(const ObjCProtocolExpr *Node); 573 void VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *Node); 574 void VisitObjCSubscriptRefExpr(const ObjCSubscriptRefExpr *Node); 575 void VisitObjCIvarRefExpr(const ObjCIvarRefExpr *Node); 576 void VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *Node); 577 578 // Comments. 579 const char *getCommandName(unsigned CommandID); 580 void dumpComment(const Comment *C); 581 582 // Inline comments. 583 void visitTextComment(const TextComment *C); 584 void visitInlineCommandComment(const InlineCommandComment *C); 585 void visitHTMLStartTagComment(const HTMLStartTagComment *C); 586 void visitHTMLEndTagComment(const HTMLEndTagComment *C); 587 588 // Block comments. 589 void visitBlockCommandComment(const BlockCommandComment *C); 590 void visitParamCommandComment(const ParamCommandComment *C); 591 void visitTParamCommandComment(const TParamCommandComment *C); 592 void visitVerbatimBlockComment(const VerbatimBlockComment *C); 593 void visitVerbatimBlockLineComment(const VerbatimBlockLineComment *C); 594 void visitVerbatimLineComment(const VerbatimLineComment *C); 595 }; 596 } 597 598 //===----------------------------------------------------------------------===// 599 // Utilities 600 //===----------------------------------------------------------------------===// 601 602 void ASTDumper::dumpPointer(const void *Ptr) { 603 ColorScope Color(*this, AddressColor); 604 OS << ' ' << Ptr; 605 } 606 607 void ASTDumper::dumpLocation(SourceLocation Loc) { 608 if (!SM) 609 return; 610 611 ColorScope Color(*this, LocationColor); 612 SourceLocation SpellingLoc = SM->getSpellingLoc(Loc); 613 614 // The general format we print out is filename:line:col, but we drop pieces 615 // that haven't changed since the last loc printed. 616 PresumedLoc PLoc = SM->getPresumedLoc(SpellingLoc); 617 618 if (PLoc.isInvalid()) { 619 OS << "<invalid sloc>"; 620 return; 621 } 622 623 if (strcmp(PLoc.getFilename(), LastLocFilename) != 0) { 624 OS << PLoc.getFilename() << ':' << PLoc.getLine() 625 << ':' << PLoc.getColumn(); 626 LastLocFilename = PLoc.getFilename(); 627 LastLocLine = PLoc.getLine(); 628 } else if (PLoc.getLine() != LastLocLine) { 629 OS << "line" << ':' << PLoc.getLine() 630 << ':' << PLoc.getColumn(); 631 LastLocLine = PLoc.getLine(); 632 } else { 633 OS << "col" << ':' << PLoc.getColumn(); 634 } 635 } 636 637 void ASTDumper::dumpSourceRange(SourceRange R) { 638 // Can't translate locations if a SourceManager isn't available. 639 if (!SM) 640 return; 641 642 OS << " <"; 643 dumpLocation(R.getBegin()); 644 if (R.getBegin() != R.getEnd()) { 645 OS << ", "; 646 dumpLocation(R.getEnd()); 647 } 648 OS << ">"; 649 650 // <t2.c:123:421[blah], t2.c:412:321> 651 652 } 653 654 void ASTDumper::dumpBareType(QualType T, bool Desugar) { 655 ColorScope Color(*this, TypeColor); 656 657 SplitQualType T_split = T.split(); 658 OS << "'" << QualType::getAsString(T_split, PrintPolicy) << "'"; 659 660 if (Desugar && !T.isNull()) { 661 // If the type is sugared, also dump a (shallow) desugared type. 662 SplitQualType D_split = T.getSplitDesugaredType(); 663 if (T_split != D_split) 664 OS << ":'" << QualType::getAsString(D_split, PrintPolicy) << "'"; 665 } 666 } 667 668 void ASTDumper::dumpType(QualType T) { 669 OS << ' '; 670 dumpBareType(T); 671 } 672 673 void ASTDumper::dumpTypeAsChild(QualType T) { 674 SplitQualType SQT = T.split(); 675 if (!SQT.Quals.hasQualifiers()) 676 return dumpTypeAsChild(SQT.Ty); 677 678 dumpChild([=] { 679 OS << "QualType"; 680 dumpPointer(T.getAsOpaquePtr()); 681 OS << " "; 682 dumpBareType(T, false); 683 OS << " " << T.split().Quals.getAsString(); 684 dumpTypeAsChild(T.split().Ty); 685 }); 686 } 687 688 void ASTDumper::dumpTypeAsChild(const Type *T) { 689 dumpChild([=] { 690 if (!T) { 691 ColorScope Color(*this, NullColor); 692 OS << "<<<NULL>>>"; 693 return; 694 } 695 if (const LocInfoType *LIT = llvm::dyn_cast<LocInfoType>(T)) { 696 { 697 ColorScope Color(*this, TypeColor); 698 OS << "LocInfo Type"; 699 } 700 dumpPointer(T); 701 dumpTypeAsChild(LIT->getTypeSourceInfo()->getType()); 702 return; 703 } 704 705 { 706 ColorScope Color(*this, TypeColor); 707 OS << T->getTypeClassName() << "Type"; 708 } 709 dumpPointer(T); 710 OS << " "; 711 dumpBareType(QualType(T, 0), false); 712 713 QualType SingleStepDesugar = 714 T->getLocallyUnqualifiedSingleStepDesugaredType(); 715 if (SingleStepDesugar != QualType(T, 0)) 716 OS << " sugar"; 717 if (T->isDependentType()) 718 OS << " dependent"; 719 else if (T->isInstantiationDependentType()) 720 OS << " instantiation_dependent"; 721 if (T->isVariablyModifiedType()) 722 OS << " variably_modified"; 723 if (T->containsUnexpandedParameterPack()) 724 OS << " contains_unexpanded_pack"; 725 if (T->isFromAST()) 726 OS << " imported"; 727 728 TypeVisitor<ASTDumper>::Visit(T); 729 730 if (SingleStepDesugar != QualType(T, 0)) 731 dumpTypeAsChild(SingleStepDesugar); 732 }); 733 } 734 735 void ASTDumper::dumpBareDeclRef(const Decl *D) { 736 if (!D) { 737 ColorScope Color(*this, NullColor); 738 OS << "<<<NULL>>>"; 739 return; 740 } 741 742 { 743 ColorScope Color(*this, DeclKindNameColor); 744 OS << D->getDeclKindName(); 745 } 746 dumpPointer(D); 747 748 if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) { 749 ColorScope Color(*this, DeclNameColor); 750 OS << " '" << ND->getDeclName() << '\''; 751 } 752 753 if (const ValueDecl *VD = dyn_cast<ValueDecl>(D)) 754 dumpType(VD->getType()); 755 } 756 757 void ASTDumper::dumpDeclRef(const Decl *D, const char *Label) { 758 if (!D) 759 return; 760 761 dumpChild([=]{ 762 if (Label) 763 OS << Label << ' '; 764 dumpBareDeclRef(D); 765 }); 766 } 767 768 void ASTDumper::dumpName(const NamedDecl *ND) { 769 if (ND->getDeclName()) { 770 ColorScope Color(*this, DeclNameColor); 771 OS << ' ' << ND->getNameAsString(); 772 } 773 } 774 775 bool ASTDumper::hasNodes(const DeclContext *DC) { 776 if (!DC) 777 return false; 778 779 return DC->hasExternalLexicalStorage() || 780 (Deserialize ? DC->decls_begin() != DC->decls_end() 781 : DC->noload_decls_begin() != DC->noload_decls_end()); 782 } 783 784 void ASTDumper::dumpDeclContext(const DeclContext *DC) { 785 if (!DC) 786 return; 787 788 for (auto *D : (Deserialize ? DC->decls() : DC->noload_decls())) 789 dumpDecl(D); 790 791 if (DC->hasExternalLexicalStorage()) { 792 dumpChild([=]{ 793 ColorScope Color(*this, UndeserializedColor); 794 OS << "<undeserialized declarations>"; 795 }); 796 } 797 } 798 799 void ASTDumper::dumpLookups(const DeclContext *DC, bool DumpDecls) { 800 dumpChild([=] { 801 OS << "StoredDeclsMap "; 802 dumpBareDeclRef(cast<Decl>(DC)); 803 804 const DeclContext *Primary = DC->getPrimaryContext(); 805 if (Primary != DC) { 806 OS << " primary"; 807 dumpPointer(cast<Decl>(Primary)); 808 } 809 810 bool HasUndeserializedLookups = Primary->hasExternalVisibleStorage(); 811 812 auto Range = Deserialize 813 ? Primary->lookups() 814 : Primary->noload_lookups(/*PreserveInternalState=*/true); 815 for (auto I = Range.begin(), E = Range.end(); I != E; ++I) { 816 DeclarationName Name = I.getLookupName(); 817 DeclContextLookupResult R = *I; 818 819 dumpChild([=] { 820 OS << "DeclarationName "; 821 { 822 ColorScope Color(*this, DeclNameColor); 823 OS << '\'' << Name << '\''; 824 } 825 826 for (DeclContextLookupResult::iterator RI = R.begin(), RE = R.end(); 827 RI != RE; ++RI) { 828 dumpChild([=] { 829 dumpBareDeclRef(*RI); 830 831 if ((*RI)->isHidden()) 832 OS << " hidden"; 833 834 // If requested, dump the redecl chain for this lookup. 835 if (DumpDecls) { 836 // Dump earliest decl first. 837 std::function<void(Decl *)> DumpWithPrev = [&](Decl *D) { 838 if (Decl *Prev = D->getPreviousDecl()) 839 DumpWithPrev(Prev); 840 dumpDecl(D); 841 }; 842 DumpWithPrev(*RI); 843 } 844 }); 845 } 846 }); 847 } 848 849 if (HasUndeserializedLookups) { 850 dumpChild([=] { 851 ColorScope Color(*this, UndeserializedColor); 852 OS << "<undeserialized lookups>"; 853 }); 854 } 855 }); 856 } 857 858 void ASTDumper::dumpAttr(const Attr *A) { 859 dumpChild([=] { 860 { 861 ColorScope Color(*this, AttrColor); 862 863 switch (A->getKind()) { 864 #define ATTR(X) case attr::X: OS << #X; break; 865 #include "clang/Basic/AttrList.inc" 866 } 867 OS << "Attr"; 868 } 869 dumpPointer(A); 870 dumpSourceRange(A->getRange()); 871 if (A->isInherited()) 872 OS << " Inherited"; 873 if (A->isImplicit()) 874 OS << " Implicit"; 875 #include "clang/AST/AttrDump.inc" 876 }); 877 } 878 879 static void dumpPreviousDeclImpl(raw_ostream &OS, ...) {} 880 881 template<typename T> 882 static void dumpPreviousDeclImpl(raw_ostream &OS, const Mergeable<T> *D) { 883 const T *First = D->getFirstDecl(); 884 if (First != D) 885 OS << " first " << First; 886 } 887 888 template<typename T> 889 static void dumpPreviousDeclImpl(raw_ostream &OS, const Redeclarable<T> *D) { 890 const T *Prev = D->getPreviousDecl(); 891 if (Prev) 892 OS << " prev " << Prev; 893 } 894 895 /// Dump the previous declaration in the redeclaration chain for a declaration, 896 /// if any. 897 static void dumpPreviousDecl(raw_ostream &OS, const Decl *D) { 898 switch (D->getKind()) { 899 #define DECL(DERIVED, BASE) \ 900 case Decl::DERIVED: \ 901 return dumpPreviousDeclImpl(OS, cast<DERIVED##Decl>(D)); 902 #define ABSTRACT_DECL(DECL) 903 #include "clang/AST/DeclNodes.inc" 904 } 905 llvm_unreachable("Decl that isn't part of DeclNodes.inc!"); 906 } 907 908 //===----------------------------------------------------------------------===// 909 // C++ Utilities 910 //===----------------------------------------------------------------------===// 911 912 void ASTDumper::dumpAccessSpecifier(AccessSpecifier AS) { 913 switch (AS) { 914 case AS_none: 915 break; 916 case AS_public: 917 OS << "public"; 918 break; 919 case AS_protected: 920 OS << "protected"; 921 break; 922 case AS_private: 923 OS << "private"; 924 break; 925 } 926 } 927 928 void ASTDumper::dumpCXXCtorInitializer(const CXXCtorInitializer *Init) { 929 dumpChild([=] { 930 OS << "CXXCtorInitializer"; 931 if (Init->isAnyMemberInitializer()) { 932 OS << ' '; 933 dumpBareDeclRef(Init->getAnyMember()); 934 } else if (Init->isBaseInitializer()) { 935 dumpType(QualType(Init->getBaseClass(), 0)); 936 } else if (Init->isDelegatingInitializer()) { 937 dumpType(Init->getTypeSourceInfo()->getType()); 938 } else { 939 llvm_unreachable("Unknown initializer type"); 940 } 941 dumpStmt(Init->getInit()); 942 }); 943 } 944 945 void ASTDumper::dumpTemplateParameters(const TemplateParameterList *TPL) { 946 if (!TPL) 947 return; 948 949 for (TemplateParameterList::const_iterator I = TPL->begin(), E = TPL->end(); 950 I != E; ++I) 951 dumpDecl(*I); 952 } 953 954 void ASTDumper::dumpTemplateArgumentListInfo( 955 const TemplateArgumentListInfo &TALI) { 956 for (unsigned i = 0, e = TALI.size(); i < e; ++i) 957 dumpTemplateArgumentLoc(TALI[i]); 958 } 959 960 void ASTDumper::dumpTemplateArgumentLoc(const TemplateArgumentLoc &A) { 961 dumpTemplateArgument(A.getArgument(), A.getSourceRange()); 962 } 963 964 void ASTDumper::dumpTemplateArgumentList(const TemplateArgumentList &TAL) { 965 for (unsigned i = 0, e = TAL.size(); i < e; ++i) 966 dumpTemplateArgument(TAL[i]); 967 } 968 969 void ASTDumper::dumpTemplateArgument(const TemplateArgument &A, SourceRange R) { 970 dumpChild([=] { 971 OS << "TemplateArgument"; 972 if (R.isValid()) 973 dumpSourceRange(R); 974 975 switch (A.getKind()) { 976 case TemplateArgument::Null: 977 OS << " null"; 978 break; 979 case TemplateArgument::Type: 980 OS << " type"; 981 dumpType(A.getAsType()); 982 break; 983 case TemplateArgument::Declaration: 984 OS << " decl"; 985 dumpDeclRef(A.getAsDecl()); 986 break; 987 case TemplateArgument::NullPtr: 988 OS << " nullptr"; 989 break; 990 case TemplateArgument::Integral: 991 OS << " integral " << A.getAsIntegral(); 992 break; 993 case TemplateArgument::Template: 994 OS << " template "; 995 A.getAsTemplate().dump(OS); 996 break; 997 case TemplateArgument::TemplateExpansion: 998 OS << " template expansion"; 999 A.getAsTemplateOrTemplatePattern().dump(OS); 1000 break; 1001 case TemplateArgument::Expression: 1002 OS << " expr"; 1003 dumpStmt(A.getAsExpr()); 1004 break; 1005 case TemplateArgument::Pack: 1006 OS << " pack"; 1007 for (TemplateArgument::pack_iterator I = A.pack_begin(), E = A.pack_end(); 1008 I != E; ++I) 1009 dumpTemplateArgument(*I); 1010 break; 1011 } 1012 }); 1013 } 1014 1015 //===----------------------------------------------------------------------===// 1016 // Objective-C Utilities 1017 //===----------------------------------------------------------------------===// 1018 void ASTDumper::dumpObjCTypeParamList(const ObjCTypeParamList *typeParams) { 1019 if (!typeParams) 1020 return; 1021 1022 for (auto typeParam : *typeParams) { 1023 dumpDecl(typeParam); 1024 } 1025 } 1026 1027 //===----------------------------------------------------------------------===// 1028 // Decl dumping methods. 1029 //===----------------------------------------------------------------------===// 1030 1031 void ASTDumper::dumpDecl(const Decl *D) { 1032 dumpChild([=] { 1033 if (!D) { 1034 ColorScope Color(*this, NullColor); 1035 OS << "<<<NULL>>>"; 1036 return; 1037 } 1038 1039 { 1040 ColorScope Color(*this, DeclKindNameColor); 1041 OS << D->getDeclKindName() << "Decl"; 1042 } 1043 dumpPointer(D); 1044 if (D->getLexicalDeclContext() != D->getDeclContext()) 1045 OS << " parent " << cast<Decl>(D->getDeclContext()); 1046 dumpPreviousDecl(OS, D); 1047 dumpSourceRange(D->getSourceRange()); 1048 OS << ' '; 1049 dumpLocation(D->getLocation()); 1050 if (D->isFromASTFile()) 1051 OS << " imported"; 1052 if (Module *M = D->getOwningModule()) 1053 OS << " in " << M->getFullModuleName(); 1054 if (auto *ND = dyn_cast<NamedDecl>(D)) 1055 for (Module *M : D->getASTContext().getModulesWithMergedDefinition( 1056 const_cast<NamedDecl *>(ND))) 1057 dumpChild([=] { OS << "also in " << M->getFullModuleName(); }); 1058 if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) 1059 if (ND->isHidden()) 1060 OS << " hidden"; 1061 if (D->isImplicit()) 1062 OS << " implicit"; 1063 if (D->isUsed()) 1064 OS << " used"; 1065 else if (D->isThisDeclarationReferenced()) 1066 OS << " referenced"; 1067 if (D->isInvalidDecl()) 1068 OS << " invalid"; 1069 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) 1070 if (FD->isConstexpr()) 1071 OS << " constexpr"; 1072 1073 1074 ConstDeclVisitor<ASTDumper>::Visit(D); 1075 1076 for (Decl::attr_iterator I = D->attr_begin(), E = D->attr_end(); I != E; 1077 ++I) 1078 dumpAttr(*I); 1079 1080 if (const FullComment *Comment = 1081 D->getASTContext().getLocalCommentForDeclUncached(D)) 1082 dumpFullComment(Comment); 1083 1084 // Decls within functions are visited by the body. 1085 if (!isa<FunctionDecl>(*D) && !isa<ObjCMethodDecl>(*D) && 1086 hasNodes(dyn_cast<DeclContext>(D))) 1087 dumpDeclContext(cast<DeclContext>(D)); 1088 }); 1089 } 1090 1091 void ASTDumper::VisitLabelDecl(const LabelDecl *D) { 1092 dumpName(D); 1093 } 1094 1095 void ASTDumper::VisitTypedefDecl(const TypedefDecl *D) { 1096 dumpName(D); 1097 dumpType(D->getUnderlyingType()); 1098 if (D->isModulePrivate()) 1099 OS << " __module_private__"; 1100 dumpTypeAsChild(D->getUnderlyingType()); 1101 } 1102 1103 void ASTDumper::VisitEnumDecl(const EnumDecl *D) { 1104 if (D->isScoped()) { 1105 if (D->isScopedUsingClassTag()) 1106 OS << " class"; 1107 else 1108 OS << " struct"; 1109 } 1110 dumpName(D); 1111 if (D->isModulePrivate()) 1112 OS << " __module_private__"; 1113 if (D->isFixed()) 1114 dumpType(D->getIntegerType()); 1115 } 1116 1117 void ASTDumper::VisitRecordDecl(const RecordDecl *D) { 1118 OS << ' ' << D->getKindName(); 1119 dumpName(D); 1120 if (D->isModulePrivate()) 1121 OS << " __module_private__"; 1122 if (D->isCompleteDefinition()) 1123 OS << " definition"; 1124 } 1125 1126 void ASTDumper::VisitEnumConstantDecl(const EnumConstantDecl *D) { 1127 dumpName(D); 1128 dumpType(D->getType()); 1129 if (const Expr *Init = D->getInitExpr()) 1130 dumpStmt(Init); 1131 } 1132 1133 void ASTDumper::VisitIndirectFieldDecl(const IndirectFieldDecl *D) { 1134 dumpName(D); 1135 dumpType(D->getType()); 1136 1137 for (auto *Child : D->chain()) 1138 dumpDeclRef(Child); 1139 } 1140 1141 void ASTDumper::VisitFunctionDecl(const FunctionDecl *D) { 1142 dumpName(D); 1143 dumpType(D->getType()); 1144 1145 StorageClass SC = D->getStorageClass(); 1146 if (SC != SC_None) 1147 OS << ' ' << VarDecl::getStorageClassSpecifierString(SC); 1148 if (D->isInlineSpecified()) 1149 OS << " inline"; 1150 if (D->isVirtualAsWritten()) 1151 OS << " virtual"; 1152 if (D->isModulePrivate()) 1153 OS << " __module_private__"; 1154 1155 if (D->isPure()) 1156 OS << " pure"; 1157 if (D->isDefaulted()) { 1158 OS << " default"; 1159 if (D->isDeleted()) 1160 OS << "_delete"; 1161 } 1162 if (D->isDeletedAsWritten()) 1163 OS << " delete"; 1164 if (D->isTrivial()) 1165 OS << " trivial"; 1166 1167 if (const FunctionProtoType *FPT = D->getType()->getAs<FunctionProtoType>()) { 1168 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 1169 switch (EPI.ExceptionSpec.Type) { 1170 default: break; 1171 case EST_Unevaluated: 1172 OS << " noexcept-unevaluated " << EPI.ExceptionSpec.SourceDecl; 1173 break; 1174 case EST_Uninstantiated: 1175 OS << " noexcept-uninstantiated " << EPI.ExceptionSpec.SourceTemplate; 1176 break; 1177 } 1178 } 1179 1180 if (const FunctionTemplateSpecializationInfo *FTSI = 1181 D->getTemplateSpecializationInfo()) 1182 dumpTemplateArgumentList(*FTSI->TemplateArguments); 1183 1184 if (!D->param_begin() && D->getNumParams()) 1185 dumpChild([=] { OS << "<<NULL params x " << D->getNumParams() << ">>"; }); 1186 else 1187 for (const ParmVarDecl *Parameter : D->parameters()) 1188 dumpDecl(Parameter); 1189 1190 if (const CXXConstructorDecl *C = dyn_cast<CXXConstructorDecl>(D)) 1191 for (CXXConstructorDecl::init_const_iterator I = C->init_begin(), 1192 E = C->init_end(); 1193 I != E; ++I) 1194 dumpCXXCtorInitializer(*I); 1195 1196 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) { 1197 if (MD->size_overridden_methods() != 0) { 1198 auto dumpOverride = [=](const CXXMethodDecl *D) { 1199 SplitQualType T_split = D->getType().split(); 1200 OS << D << " " << D->getParent()->getName() 1201 << "::" << D->getNameAsString() << " '" 1202 << QualType::getAsString(T_split, PrintPolicy) << "'"; 1203 }; 1204 1205 dumpChild([=] { 1206 auto Overrides = MD->overridden_methods(); 1207 OS << "Overrides: [ "; 1208 dumpOverride(*Overrides.begin()); 1209 for (const auto *Override : 1210 llvm::make_range(Overrides.begin() + 1, Overrides.end())) { 1211 OS << ", "; 1212 dumpOverride(Override); 1213 } 1214 OS << " ]"; 1215 }); 1216 } 1217 } 1218 1219 if (D->doesThisDeclarationHaveABody()) 1220 dumpStmt(D->getBody()); 1221 } 1222 1223 void ASTDumper::VisitFieldDecl(const FieldDecl *D) { 1224 dumpName(D); 1225 dumpType(D->getType()); 1226 if (D->isMutable()) 1227 OS << " mutable"; 1228 if (D->isModulePrivate()) 1229 OS << " __module_private__"; 1230 1231 if (D->isBitField()) 1232 dumpStmt(D->getBitWidth()); 1233 if (Expr *Init = D->getInClassInitializer()) 1234 dumpStmt(Init); 1235 } 1236 1237 void ASTDumper::VisitVarDecl(const VarDecl *D) { 1238 dumpName(D); 1239 dumpType(D->getType()); 1240 StorageClass SC = D->getStorageClass(); 1241 if (SC != SC_None) 1242 OS << ' ' << VarDecl::getStorageClassSpecifierString(SC); 1243 switch (D->getTLSKind()) { 1244 case VarDecl::TLS_None: break; 1245 case VarDecl::TLS_Static: OS << " tls"; break; 1246 case VarDecl::TLS_Dynamic: OS << " tls_dynamic"; break; 1247 } 1248 if (D->isModulePrivate()) 1249 OS << " __module_private__"; 1250 if (D->isNRVOVariable()) 1251 OS << " nrvo"; 1252 if (D->isInline()) 1253 OS << " inline"; 1254 if (D->isConstexpr()) 1255 OS << " constexpr"; 1256 if (D->hasInit()) { 1257 switch (D->getInitStyle()) { 1258 case VarDecl::CInit: OS << " cinit"; break; 1259 case VarDecl::CallInit: OS << " callinit"; break; 1260 case VarDecl::ListInit: OS << " listinit"; break; 1261 } 1262 dumpStmt(D->getInit()); 1263 } 1264 } 1265 1266 void ASTDumper::VisitDecompositionDecl(const DecompositionDecl *D) { 1267 VisitVarDecl(D); 1268 for (auto *B : D->bindings()) 1269 dumpDecl(B); 1270 } 1271 1272 void ASTDumper::VisitBindingDecl(const BindingDecl *D) { 1273 dumpName(D); 1274 dumpType(D->getType()); 1275 if (auto *E = D->getBinding()) 1276 dumpStmt(E); 1277 } 1278 1279 void ASTDumper::VisitFileScopeAsmDecl(const FileScopeAsmDecl *D) { 1280 dumpStmt(D->getAsmString()); 1281 } 1282 1283 void ASTDumper::VisitImportDecl(const ImportDecl *D) { 1284 OS << ' ' << D->getImportedModule()->getFullModuleName(); 1285 } 1286 1287 void ASTDumper::VisitPragmaCommentDecl(const PragmaCommentDecl *D) { 1288 OS << ' '; 1289 switch (D->getCommentKind()) { 1290 case PCK_Unknown: llvm_unreachable("unexpected pragma comment kind"); 1291 case PCK_Compiler: OS << "compiler"; break; 1292 case PCK_ExeStr: OS << "exestr"; break; 1293 case PCK_Lib: OS << "lib"; break; 1294 case PCK_Linker: OS << "linker"; break; 1295 case PCK_User: OS << "user"; break; 1296 } 1297 StringRef Arg = D->getArg(); 1298 if (!Arg.empty()) 1299 OS << " \"" << Arg << "\""; 1300 } 1301 1302 void ASTDumper::VisitPragmaDetectMismatchDecl( 1303 const PragmaDetectMismatchDecl *D) { 1304 OS << " \"" << D->getName() << "\" \"" << D->getValue() << "\""; 1305 } 1306 1307 void ASTDumper::VisitCapturedDecl(const CapturedDecl *D) { 1308 dumpStmt(D->getBody()); 1309 } 1310 1311 //===----------------------------------------------------------------------===// 1312 // OpenMP Declarations 1313 //===----------------------------------------------------------------------===// 1314 1315 void ASTDumper::VisitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D) { 1316 for (auto *E : D->varlists()) 1317 dumpStmt(E); 1318 } 1319 1320 void ASTDumper::VisitOMPDeclareReductionDecl(const OMPDeclareReductionDecl *D) { 1321 dumpName(D); 1322 dumpType(D->getType()); 1323 OS << " combiner"; 1324 dumpStmt(D->getCombiner()); 1325 if (auto *Initializer = D->getInitializer()) { 1326 OS << " initializer"; 1327 switch (D->getInitializerKind()) { 1328 case OMPDeclareReductionDecl::DirectInit: 1329 OS << " omp_priv = "; 1330 break; 1331 case OMPDeclareReductionDecl::CopyInit: 1332 OS << " omp_priv ()"; 1333 break; 1334 case OMPDeclareReductionDecl::CallInit: 1335 break; 1336 } 1337 dumpStmt(Initializer); 1338 } 1339 } 1340 1341 void ASTDumper::VisitOMPCapturedExprDecl(const OMPCapturedExprDecl *D) { 1342 dumpName(D); 1343 dumpType(D->getType()); 1344 dumpStmt(D->getInit()); 1345 } 1346 1347 //===----------------------------------------------------------------------===// 1348 // C++ Declarations 1349 //===----------------------------------------------------------------------===// 1350 1351 void ASTDumper::VisitNamespaceDecl(const NamespaceDecl *D) { 1352 dumpName(D); 1353 if (D->isInline()) 1354 OS << " inline"; 1355 if (!D->isOriginalNamespace()) 1356 dumpDeclRef(D->getOriginalNamespace(), "original"); 1357 } 1358 1359 void ASTDumper::VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) { 1360 OS << ' '; 1361 dumpBareDeclRef(D->getNominatedNamespace()); 1362 } 1363 1364 void ASTDumper::VisitNamespaceAliasDecl(const NamespaceAliasDecl *D) { 1365 dumpName(D); 1366 dumpDeclRef(D->getAliasedNamespace()); 1367 } 1368 1369 void ASTDumper::VisitTypeAliasDecl(const TypeAliasDecl *D) { 1370 dumpName(D); 1371 dumpType(D->getUnderlyingType()); 1372 dumpTypeAsChild(D->getUnderlyingType()); 1373 } 1374 1375 void ASTDumper::VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D) { 1376 dumpName(D); 1377 dumpTemplateParameters(D->getTemplateParameters()); 1378 dumpDecl(D->getTemplatedDecl()); 1379 } 1380 1381 void ASTDumper::VisitCXXRecordDecl(const CXXRecordDecl *D) { 1382 VisitRecordDecl(D); 1383 if (!D->isCompleteDefinition()) 1384 return; 1385 1386 dumpChild([=] { 1387 { 1388 ColorScope Color(*this, DeclKindNameColor); 1389 OS << "DefinitionData"; 1390 } 1391 #define FLAG(fn, name) if (D->fn()) OS << " " #name; 1392 FLAG(isParsingBaseSpecifiers, parsing_base_specifiers); 1393 1394 FLAG(isGenericLambda, generic); 1395 FLAG(isLambda, lambda); 1396 1397 FLAG(canPassInRegisters, pass_in_registers); 1398 FLAG(isEmpty, empty); 1399 FLAG(isAggregate, aggregate); 1400 FLAG(isStandardLayout, standard_layout); 1401 FLAG(isTriviallyCopyable, trivially_copyable); 1402 FLAG(isPOD, pod); 1403 FLAG(isTrivial, trivial); 1404 FLAG(isPolymorphic, polymorphic); 1405 FLAG(isAbstract, abstract); 1406 FLAG(isLiteral, literal); 1407 1408 FLAG(hasUserDeclaredConstructor, has_user_declared_ctor); 1409 FLAG(hasConstexprNonCopyMoveConstructor, has_constexpr_non_copy_move_ctor); 1410 FLAG(hasMutableFields, has_mutable_fields); 1411 FLAG(hasVariantMembers, has_variant_members); 1412 FLAG(allowConstDefaultInit, can_const_default_init); 1413 1414 dumpChild([=] { 1415 { 1416 ColorScope Color(*this, DeclKindNameColor); 1417 OS << "DefaultConstructor"; 1418 } 1419 FLAG(hasDefaultConstructor, exists); 1420 FLAG(hasTrivialDefaultConstructor, trivial); 1421 FLAG(hasNonTrivialDefaultConstructor, non_trivial); 1422 FLAG(hasUserProvidedDefaultConstructor, user_provided); 1423 FLAG(hasConstexprDefaultConstructor, constexpr); 1424 FLAG(needsImplicitDefaultConstructor, needs_implicit); 1425 FLAG(defaultedDefaultConstructorIsConstexpr, defaulted_is_constexpr); 1426 }); 1427 1428 dumpChild([=] { 1429 { 1430 ColorScope Color(*this, DeclKindNameColor); 1431 OS << "CopyConstructor"; 1432 } 1433 FLAG(hasSimpleCopyConstructor, simple); 1434 FLAG(hasTrivialCopyConstructor, trivial); 1435 FLAG(hasNonTrivialCopyConstructor, non_trivial); 1436 FLAG(hasUserDeclaredCopyConstructor, user_declared); 1437 FLAG(hasCopyConstructorWithConstParam, has_const_param); 1438 FLAG(needsImplicitCopyConstructor, needs_implicit); 1439 FLAG(needsOverloadResolutionForCopyConstructor, 1440 needs_overload_resolution); 1441 if (!D->needsOverloadResolutionForCopyConstructor()) 1442 FLAG(defaultedCopyConstructorIsDeleted, defaulted_is_deleted); 1443 FLAG(implicitCopyConstructorHasConstParam, implicit_has_const_param); 1444 }); 1445 1446 dumpChild([=] { 1447 { 1448 ColorScope Color(*this, DeclKindNameColor); 1449 OS << "MoveConstructor"; 1450 } 1451 FLAG(hasMoveConstructor, exists); 1452 FLAG(hasSimpleMoveConstructor, simple); 1453 FLAG(hasTrivialMoveConstructor, trivial); 1454 FLAG(hasNonTrivialMoveConstructor, non_trivial); 1455 FLAG(hasUserDeclaredMoveConstructor, user_declared); 1456 FLAG(needsImplicitMoveConstructor, needs_implicit); 1457 FLAG(needsOverloadResolutionForMoveConstructor, 1458 needs_overload_resolution); 1459 if (!D->needsOverloadResolutionForMoveConstructor()) 1460 FLAG(defaultedMoveConstructorIsDeleted, defaulted_is_deleted); 1461 }); 1462 1463 dumpChild([=] { 1464 { 1465 ColorScope Color(*this, DeclKindNameColor); 1466 OS << "CopyAssignment"; 1467 } 1468 FLAG(hasTrivialCopyAssignment, trivial); 1469 FLAG(hasNonTrivialCopyAssignment, non_trivial); 1470 FLAG(hasCopyAssignmentWithConstParam, has_const_param); 1471 FLAG(hasUserDeclaredCopyAssignment, user_declared); 1472 FLAG(needsImplicitCopyAssignment, needs_implicit); 1473 FLAG(needsOverloadResolutionForCopyAssignment, needs_overload_resolution); 1474 FLAG(implicitCopyAssignmentHasConstParam, implicit_has_const_param); 1475 }); 1476 1477 dumpChild([=] { 1478 { 1479 ColorScope Color(*this, DeclKindNameColor); 1480 OS << "MoveAssignment"; 1481 } 1482 FLAG(hasMoveAssignment, exists); 1483 FLAG(hasSimpleMoveAssignment, simple); 1484 FLAG(hasTrivialMoveAssignment, trivial); 1485 FLAG(hasNonTrivialMoveAssignment, non_trivial); 1486 FLAG(hasUserDeclaredMoveAssignment, user_declared); 1487 FLAG(needsImplicitMoveAssignment, needs_implicit); 1488 FLAG(needsOverloadResolutionForMoveAssignment, needs_overload_resolution); 1489 }); 1490 1491 dumpChild([=] { 1492 { 1493 ColorScope Color(*this, DeclKindNameColor); 1494 OS << "Destructor"; 1495 } 1496 FLAG(hasSimpleDestructor, simple); 1497 FLAG(hasIrrelevantDestructor, irrelevant); 1498 FLAG(hasTrivialDestructor, trivial); 1499 FLAG(hasNonTrivialDestructor, non_trivial); 1500 FLAG(hasUserDeclaredDestructor, user_declared); 1501 FLAG(needsImplicitDestructor, needs_implicit); 1502 FLAG(needsOverloadResolutionForDestructor, needs_overload_resolution); 1503 if (!D->needsOverloadResolutionForDestructor()) 1504 FLAG(defaultedDestructorIsDeleted, defaulted_is_deleted); 1505 }); 1506 }); 1507 1508 for (const auto &I : D->bases()) { 1509 dumpChild([=] { 1510 if (I.isVirtual()) 1511 OS << "virtual "; 1512 dumpAccessSpecifier(I.getAccessSpecifier()); 1513 dumpType(I.getType()); 1514 if (I.isPackExpansion()) 1515 OS << "..."; 1516 }); 1517 } 1518 } 1519 1520 void ASTDumper::VisitStaticAssertDecl(const StaticAssertDecl *D) { 1521 dumpStmt(D->getAssertExpr()); 1522 dumpStmt(D->getMessage()); 1523 } 1524 1525 template<typename SpecializationDecl> 1526 void ASTDumper::VisitTemplateDeclSpecialization(const SpecializationDecl *D, 1527 bool DumpExplicitInst, 1528 bool DumpRefOnly) { 1529 bool DumpedAny = false; 1530 for (auto *RedeclWithBadType : D->redecls()) { 1531 // FIXME: The redecls() range sometimes has elements of a less-specific 1532 // type. (In particular, ClassTemplateSpecializationDecl::redecls() gives 1533 // us TagDecls, and should give CXXRecordDecls). 1534 auto *Redecl = dyn_cast<SpecializationDecl>(RedeclWithBadType); 1535 if (!Redecl) { 1536 // Found the injected-class-name for a class template. This will be dumped 1537 // as part of its surrounding class so we don't need to dump it here. 1538 assert(isa<CXXRecordDecl>(RedeclWithBadType) && 1539 "expected an injected-class-name"); 1540 continue; 1541 } 1542 1543 switch (Redecl->getTemplateSpecializationKind()) { 1544 case TSK_ExplicitInstantiationDeclaration: 1545 case TSK_ExplicitInstantiationDefinition: 1546 if (!DumpExplicitInst) 1547 break; 1548 LLVM_FALLTHROUGH; 1549 case TSK_Undeclared: 1550 case TSK_ImplicitInstantiation: 1551 if (DumpRefOnly) 1552 dumpDeclRef(Redecl); 1553 else 1554 dumpDecl(Redecl); 1555 DumpedAny = true; 1556 break; 1557 case TSK_ExplicitSpecialization: 1558 break; 1559 } 1560 } 1561 1562 // Ensure we dump at least one decl for each specialization. 1563 if (!DumpedAny) 1564 dumpDeclRef(D); 1565 } 1566 1567 template<typename TemplateDecl> 1568 void ASTDumper::VisitTemplateDecl(const TemplateDecl *D, 1569 bool DumpExplicitInst) { 1570 dumpName(D); 1571 dumpTemplateParameters(D->getTemplateParameters()); 1572 1573 dumpDecl(D->getTemplatedDecl()); 1574 1575 for (auto *Child : D->specializations()) 1576 VisitTemplateDeclSpecialization(Child, DumpExplicitInst, 1577 !D->isCanonicalDecl()); 1578 } 1579 1580 void ASTDumper::VisitFunctionTemplateDecl(const FunctionTemplateDecl *D) { 1581 // FIXME: We don't add a declaration of a function template specialization 1582 // to its context when it's explicitly instantiated, so dump explicit 1583 // instantiations when we dump the template itself. 1584 VisitTemplateDecl(D, true); 1585 } 1586 1587 void ASTDumper::VisitClassTemplateDecl(const ClassTemplateDecl *D) { 1588 VisitTemplateDecl(D, false); 1589 } 1590 1591 void ASTDumper::VisitClassTemplateSpecializationDecl( 1592 const ClassTemplateSpecializationDecl *D) { 1593 VisitCXXRecordDecl(D); 1594 dumpTemplateArgumentList(D->getTemplateArgs()); 1595 } 1596 1597 void ASTDumper::VisitClassTemplatePartialSpecializationDecl( 1598 const ClassTemplatePartialSpecializationDecl *D) { 1599 VisitClassTemplateSpecializationDecl(D); 1600 dumpTemplateParameters(D->getTemplateParameters()); 1601 } 1602 1603 void ASTDumper::VisitClassScopeFunctionSpecializationDecl( 1604 const ClassScopeFunctionSpecializationDecl *D) { 1605 dumpDeclRef(D->getSpecialization()); 1606 if (D->hasExplicitTemplateArgs()) 1607 dumpTemplateArgumentListInfo(D->templateArgs()); 1608 } 1609 1610 void ASTDumper::VisitVarTemplateDecl(const VarTemplateDecl *D) { 1611 VisitTemplateDecl(D, false); 1612 } 1613 1614 void ASTDumper::VisitBuiltinTemplateDecl(const BuiltinTemplateDecl *D) { 1615 dumpName(D); 1616 dumpTemplateParameters(D->getTemplateParameters()); 1617 } 1618 1619 void ASTDumper::VisitVarTemplateSpecializationDecl( 1620 const VarTemplateSpecializationDecl *D) { 1621 dumpTemplateArgumentList(D->getTemplateArgs()); 1622 VisitVarDecl(D); 1623 } 1624 1625 void ASTDumper::VisitVarTemplatePartialSpecializationDecl( 1626 const VarTemplatePartialSpecializationDecl *D) { 1627 dumpTemplateParameters(D->getTemplateParameters()); 1628 VisitVarTemplateSpecializationDecl(D); 1629 } 1630 1631 void ASTDumper::VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) { 1632 if (D->wasDeclaredWithTypename()) 1633 OS << " typename"; 1634 else 1635 OS << " class"; 1636 OS << " depth " << D->getDepth() << " index " << D->getIndex(); 1637 if (D->isParameterPack()) 1638 OS << " ..."; 1639 dumpName(D); 1640 if (D->hasDefaultArgument()) 1641 dumpTemplateArgument(D->getDefaultArgument()); 1642 } 1643 1644 void ASTDumper::VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) { 1645 dumpType(D->getType()); 1646 OS << " depth " << D->getDepth() << " index " << D->getIndex(); 1647 if (D->isParameterPack()) 1648 OS << " ..."; 1649 dumpName(D); 1650 if (D->hasDefaultArgument()) 1651 dumpTemplateArgument(D->getDefaultArgument()); 1652 } 1653 1654 void ASTDumper::VisitTemplateTemplateParmDecl( 1655 const TemplateTemplateParmDecl *D) { 1656 OS << " depth " << D->getDepth() << " index " << D->getIndex(); 1657 if (D->isParameterPack()) 1658 OS << " ..."; 1659 dumpName(D); 1660 dumpTemplateParameters(D->getTemplateParameters()); 1661 if (D->hasDefaultArgument()) 1662 dumpTemplateArgumentLoc(D->getDefaultArgument()); 1663 } 1664 1665 void ASTDumper::VisitUsingDecl(const UsingDecl *D) { 1666 OS << ' '; 1667 if (D->getQualifier()) 1668 D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy()); 1669 OS << D->getNameAsString(); 1670 } 1671 1672 void ASTDumper::VisitUnresolvedUsingTypenameDecl( 1673 const UnresolvedUsingTypenameDecl *D) { 1674 OS << ' '; 1675 if (D->getQualifier()) 1676 D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy()); 1677 OS << D->getNameAsString(); 1678 } 1679 1680 void ASTDumper::VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl *D) { 1681 OS << ' '; 1682 if (D->getQualifier()) 1683 D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy()); 1684 OS << D->getNameAsString(); 1685 dumpType(D->getType()); 1686 } 1687 1688 void ASTDumper::VisitUsingShadowDecl(const UsingShadowDecl *D) { 1689 OS << ' '; 1690 dumpBareDeclRef(D->getTargetDecl()); 1691 if (auto *TD = dyn_cast<TypeDecl>(D->getUnderlyingDecl())) 1692 dumpTypeAsChild(TD->getTypeForDecl()); 1693 } 1694 1695 void ASTDumper::VisitConstructorUsingShadowDecl( 1696 const ConstructorUsingShadowDecl *D) { 1697 if (D->constructsVirtualBase()) 1698 OS << " virtual"; 1699 1700 dumpChild([=] { 1701 OS << "target "; 1702 dumpBareDeclRef(D->getTargetDecl()); 1703 }); 1704 1705 dumpChild([=] { 1706 OS << "nominated "; 1707 dumpBareDeclRef(D->getNominatedBaseClass()); 1708 OS << ' '; 1709 dumpBareDeclRef(D->getNominatedBaseClassShadowDecl()); 1710 }); 1711 1712 dumpChild([=] { 1713 OS << "constructed "; 1714 dumpBareDeclRef(D->getConstructedBaseClass()); 1715 OS << ' '; 1716 dumpBareDeclRef(D->getConstructedBaseClassShadowDecl()); 1717 }); 1718 } 1719 1720 void ASTDumper::VisitLinkageSpecDecl(const LinkageSpecDecl *D) { 1721 switch (D->getLanguage()) { 1722 case LinkageSpecDecl::lang_c: OS << " C"; break; 1723 case LinkageSpecDecl::lang_cxx: OS << " C++"; break; 1724 } 1725 } 1726 1727 void ASTDumper::VisitAccessSpecDecl(const AccessSpecDecl *D) { 1728 OS << ' '; 1729 dumpAccessSpecifier(D->getAccess()); 1730 } 1731 1732 void ASTDumper::VisitFriendDecl(const FriendDecl *D) { 1733 if (TypeSourceInfo *T = D->getFriendType()) 1734 dumpType(T->getType()); 1735 else 1736 dumpDecl(D->getFriendDecl()); 1737 } 1738 1739 //===----------------------------------------------------------------------===// 1740 // Obj-C Declarations 1741 //===----------------------------------------------------------------------===// 1742 1743 void ASTDumper::VisitObjCIvarDecl(const ObjCIvarDecl *D) { 1744 dumpName(D); 1745 dumpType(D->getType()); 1746 if (D->getSynthesize()) 1747 OS << " synthesize"; 1748 1749 switch (D->getAccessControl()) { 1750 case ObjCIvarDecl::None: 1751 OS << " none"; 1752 break; 1753 case ObjCIvarDecl::Private: 1754 OS << " private"; 1755 break; 1756 case ObjCIvarDecl::Protected: 1757 OS << " protected"; 1758 break; 1759 case ObjCIvarDecl::Public: 1760 OS << " public"; 1761 break; 1762 case ObjCIvarDecl::Package: 1763 OS << " package"; 1764 break; 1765 } 1766 } 1767 1768 void ASTDumper::VisitObjCMethodDecl(const ObjCMethodDecl *D) { 1769 if (D->isInstanceMethod()) 1770 OS << " -"; 1771 else 1772 OS << " +"; 1773 dumpName(D); 1774 dumpType(D->getReturnType()); 1775 1776 if (D->isThisDeclarationADefinition()) { 1777 dumpDeclContext(D); 1778 } else { 1779 for (const ParmVarDecl *Parameter : D->parameters()) 1780 dumpDecl(Parameter); 1781 } 1782 1783 if (D->isVariadic()) 1784 dumpChild([=] { OS << "..."; }); 1785 1786 if (D->hasBody()) 1787 dumpStmt(D->getBody()); 1788 } 1789 1790 void ASTDumper::VisitObjCTypeParamDecl(const ObjCTypeParamDecl *D) { 1791 dumpName(D); 1792 switch (D->getVariance()) { 1793 case ObjCTypeParamVariance::Invariant: 1794 break; 1795 1796 case ObjCTypeParamVariance::Covariant: 1797 OS << " covariant"; 1798 break; 1799 1800 case ObjCTypeParamVariance::Contravariant: 1801 OS << " contravariant"; 1802 break; 1803 } 1804 1805 if (D->hasExplicitBound()) 1806 OS << " bounded"; 1807 dumpType(D->getUnderlyingType()); 1808 } 1809 1810 void ASTDumper::VisitObjCCategoryDecl(const ObjCCategoryDecl *D) { 1811 dumpName(D); 1812 dumpDeclRef(D->getClassInterface()); 1813 dumpObjCTypeParamList(D->getTypeParamList()); 1814 dumpDeclRef(D->getImplementation()); 1815 for (ObjCCategoryDecl::protocol_iterator I = D->protocol_begin(), 1816 E = D->protocol_end(); 1817 I != E; ++I) 1818 dumpDeclRef(*I); 1819 } 1820 1821 void ASTDumper::VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D) { 1822 dumpName(D); 1823 dumpDeclRef(D->getClassInterface()); 1824 dumpDeclRef(D->getCategoryDecl()); 1825 } 1826 1827 void ASTDumper::VisitObjCProtocolDecl(const ObjCProtocolDecl *D) { 1828 dumpName(D); 1829 1830 for (auto *Child : D->protocols()) 1831 dumpDeclRef(Child); 1832 } 1833 1834 void ASTDumper::VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) { 1835 dumpName(D); 1836 dumpObjCTypeParamList(D->getTypeParamListAsWritten()); 1837 dumpDeclRef(D->getSuperClass(), "super"); 1838 1839 dumpDeclRef(D->getImplementation()); 1840 for (auto *Child : D->protocols()) 1841 dumpDeclRef(Child); 1842 } 1843 1844 void ASTDumper::VisitObjCImplementationDecl(const ObjCImplementationDecl *D) { 1845 dumpName(D); 1846 dumpDeclRef(D->getSuperClass(), "super"); 1847 dumpDeclRef(D->getClassInterface()); 1848 for (ObjCImplementationDecl::init_const_iterator I = D->init_begin(), 1849 E = D->init_end(); 1850 I != E; ++I) 1851 dumpCXXCtorInitializer(*I); 1852 } 1853 1854 void ASTDumper::VisitObjCCompatibleAliasDecl(const ObjCCompatibleAliasDecl *D) { 1855 dumpName(D); 1856 dumpDeclRef(D->getClassInterface()); 1857 } 1858 1859 void ASTDumper::VisitObjCPropertyDecl(const ObjCPropertyDecl *D) { 1860 dumpName(D); 1861 dumpType(D->getType()); 1862 1863 if (D->getPropertyImplementation() == ObjCPropertyDecl::Required) 1864 OS << " required"; 1865 else if (D->getPropertyImplementation() == ObjCPropertyDecl::Optional) 1866 OS << " optional"; 1867 1868 ObjCPropertyDecl::PropertyAttributeKind Attrs = D->getPropertyAttributes(); 1869 if (Attrs != ObjCPropertyDecl::OBJC_PR_noattr) { 1870 if (Attrs & ObjCPropertyDecl::OBJC_PR_readonly) 1871 OS << " readonly"; 1872 if (Attrs & ObjCPropertyDecl::OBJC_PR_assign) 1873 OS << " assign"; 1874 if (Attrs & ObjCPropertyDecl::OBJC_PR_readwrite) 1875 OS << " readwrite"; 1876 if (Attrs & ObjCPropertyDecl::OBJC_PR_retain) 1877 OS << " retain"; 1878 if (Attrs & ObjCPropertyDecl::OBJC_PR_copy) 1879 OS << " copy"; 1880 if (Attrs & ObjCPropertyDecl::OBJC_PR_nonatomic) 1881 OS << " nonatomic"; 1882 if (Attrs & ObjCPropertyDecl::OBJC_PR_atomic) 1883 OS << " atomic"; 1884 if (Attrs & ObjCPropertyDecl::OBJC_PR_weak) 1885 OS << " weak"; 1886 if (Attrs & ObjCPropertyDecl::OBJC_PR_strong) 1887 OS << " strong"; 1888 if (Attrs & ObjCPropertyDecl::OBJC_PR_unsafe_unretained) 1889 OS << " unsafe_unretained"; 1890 if (Attrs & ObjCPropertyDecl::OBJC_PR_class) 1891 OS << " class"; 1892 if (Attrs & ObjCPropertyDecl::OBJC_PR_getter) 1893 dumpDeclRef(D->getGetterMethodDecl(), "getter"); 1894 if (Attrs & ObjCPropertyDecl::OBJC_PR_setter) 1895 dumpDeclRef(D->getSetterMethodDecl(), "setter"); 1896 } 1897 } 1898 1899 void ASTDumper::VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D) { 1900 dumpName(D->getPropertyDecl()); 1901 if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) 1902 OS << " synthesize"; 1903 else 1904 OS << " dynamic"; 1905 dumpDeclRef(D->getPropertyDecl()); 1906 dumpDeclRef(D->getPropertyIvarDecl()); 1907 } 1908 1909 void ASTDumper::VisitBlockDecl(const BlockDecl *D) { 1910 for (auto I : D->parameters()) 1911 dumpDecl(I); 1912 1913 if (D->isVariadic()) 1914 dumpChild([=]{ OS << "..."; }); 1915 1916 if (D->capturesCXXThis()) 1917 dumpChild([=]{ OS << "capture this"; }); 1918 1919 for (const auto &I : D->captures()) { 1920 dumpChild([=] { 1921 OS << "capture"; 1922 if (I.isByRef()) 1923 OS << " byref"; 1924 if (I.isNested()) 1925 OS << " nested"; 1926 if (I.getVariable()) { 1927 OS << ' '; 1928 dumpBareDeclRef(I.getVariable()); 1929 } 1930 if (I.hasCopyExpr()) 1931 dumpStmt(I.getCopyExpr()); 1932 }); 1933 } 1934 dumpStmt(D->getBody()); 1935 } 1936 1937 //===----------------------------------------------------------------------===// 1938 // Stmt dumping methods. 1939 //===----------------------------------------------------------------------===// 1940 1941 void ASTDumper::dumpStmt(const Stmt *S) { 1942 dumpChild([=] { 1943 if (!S) { 1944 ColorScope Color(*this, NullColor); 1945 OS << "<<<NULL>>>"; 1946 return; 1947 } 1948 1949 // Some statements have custom mechanisms for dumping their children. 1950 if (const DeclStmt *DS = dyn_cast<DeclStmt>(S)) { 1951 VisitDeclStmt(DS); 1952 return; 1953 } 1954 if (const GenericSelectionExpr *GSE = dyn_cast<GenericSelectionExpr>(S)) { 1955 VisitGenericSelectionExpr(GSE); 1956 return; 1957 } 1958 1959 ConstStmtVisitor<ASTDumper>::Visit(S); 1960 1961 for (const Stmt *SubStmt : S->children()) 1962 dumpStmt(SubStmt); 1963 }); 1964 } 1965 1966 void ASTDumper::VisitStmt(const Stmt *Node) { 1967 { 1968 ColorScope Color(*this, StmtColor); 1969 OS << Node->getStmtClassName(); 1970 } 1971 dumpPointer(Node); 1972 dumpSourceRange(Node->getSourceRange()); 1973 } 1974 1975 void ASTDumper::VisitDeclStmt(const DeclStmt *Node) { 1976 VisitStmt(Node); 1977 for (DeclStmt::const_decl_iterator I = Node->decl_begin(), 1978 E = Node->decl_end(); 1979 I != E; ++I) 1980 dumpDecl(*I); 1981 } 1982 1983 void ASTDumper::VisitAttributedStmt(const AttributedStmt *Node) { 1984 VisitStmt(Node); 1985 for (ArrayRef<const Attr *>::iterator I = Node->getAttrs().begin(), 1986 E = Node->getAttrs().end(); 1987 I != E; ++I) 1988 dumpAttr(*I); 1989 } 1990 1991 void ASTDumper::VisitLabelStmt(const LabelStmt *Node) { 1992 VisitStmt(Node); 1993 OS << " '" << Node->getName() << "'"; 1994 } 1995 1996 void ASTDumper::VisitGotoStmt(const GotoStmt *Node) { 1997 VisitStmt(Node); 1998 OS << " '" << Node->getLabel()->getName() << "'"; 1999 dumpPointer(Node->getLabel()); 2000 } 2001 2002 void ASTDumper::VisitCXXCatchStmt(const CXXCatchStmt *Node) { 2003 VisitStmt(Node); 2004 dumpDecl(Node->getExceptionDecl()); 2005 } 2006 2007 void ASTDumper::VisitCapturedStmt(const CapturedStmt *Node) { 2008 VisitStmt(Node); 2009 dumpDecl(Node->getCapturedDecl()); 2010 } 2011 2012 //===----------------------------------------------------------------------===// 2013 // OpenMP dumping methods. 2014 //===----------------------------------------------------------------------===// 2015 2016 void ASTDumper::VisitOMPExecutableDirective( 2017 const OMPExecutableDirective *Node) { 2018 VisitStmt(Node); 2019 for (auto *C : Node->clauses()) { 2020 dumpChild([=] { 2021 if (!C) { 2022 ColorScope Color(*this, NullColor); 2023 OS << "<<<NULL>>> OMPClause"; 2024 return; 2025 } 2026 { 2027 ColorScope Color(*this, AttrColor); 2028 StringRef ClauseName(getOpenMPClauseName(C->getClauseKind())); 2029 OS << "OMP" << ClauseName.substr(/*Start=*/0, /*N=*/1).upper() 2030 << ClauseName.drop_front() << "Clause"; 2031 } 2032 dumpPointer(C); 2033 dumpSourceRange(SourceRange(C->getLocStart(), C->getLocEnd())); 2034 if (C->isImplicit()) 2035 OS << " <implicit>"; 2036 for (auto *S : C->children()) 2037 dumpStmt(S); 2038 }); 2039 } 2040 } 2041 2042 //===----------------------------------------------------------------------===// 2043 // Expr dumping methods. 2044 //===----------------------------------------------------------------------===// 2045 2046 void ASTDumper::VisitExpr(const Expr *Node) { 2047 VisitStmt(Node); 2048 dumpType(Node->getType()); 2049 2050 { 2051 ColorScope Color(*this, ValueKindColor); 2052 switch (Node->getValueKind()) { 2053 case VK_RValue: 2054 break; 2055 case VK_LValue: 2056 OS << " lvalue"; 2057 break; 2058 case VK_XValue: 2059 OS << " xvalue"; 2060 break; 2061 } 2062 } 2063 2064 { 2065 ColorScope Color(*this, ObjectKindColor); 2066 switch (Node->getObjectKind()) { 2067 case OK_Ordinary: 2068 break; 2069 case OK_BitField: 2070 OS << " bitfield"; 2071 break; 2072 case OK_ObjCProperty: 2073 OS << " objcproperty"; 2074 break; 2075 case OK_ObjCSubscript: 2076 OS << " objcsubscript"; 2077 break; 2078 case OK_VectorComponent: 2079 OS << " vectorcomponent"; 2080 break; 2081 } 2082 } 2083 } 2084 2085 static void dumpBasePath(raw_ostream &OS, const CastExpr *Node) { 2086 if (Node->path_empty()) 2087 return; 2088 2089 OS << " ("; 2090 bool First = true; 2091 for (CastExpr::path_const_iterator I = Node->path_begin(), 2092 E = Node->path_end(); 2093 I != E; ++I) { 2094 const CXXBaseSpecifier *Base = *I; 2095 if (!First) 2096 OS << " -> "; 2097 2098 const CXXRecordDecl *RD = 2099 cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl()); 2100 2101 if (Base->isVirtual()) 2102 OS << "virtual "; 2103 OS << RD->getName(); 2104 First = false; 2105 } 2106 2107 OS << ')'; 2108 } 2109 2110 void ASTDumper::VisitCastExpr(const CastExpr *Node) { 2111 VisitExpr(Node); 2112 OS << " <"; 2113 { 2114 ColorScope Color(*this, CastColor); 2115 OS << Node->getCastKindName(); 2116 } 2117 dumpBasePath(OS, Node); 2118 OS << ">"; 2119 } 2120 2121 void ASTDumper::VisitDeclRefExpr(const DeclRefExpr *Node) { 2122 VisitExpr(Node); 2123 2124 OS << " "; 2125 dumpBareDeclRef(Node->getDecl()); 2126 if (Node->getDecl() != Node->getFoundDecl()) { 2127 OS << " ("; 2128 dumpBareDeclRef(Node->getFoundDecl()); 2129 OS << ")"; 2130 } 2131 } 2132 2133 void ASTDumper::VisitUnresolvedLookupExpr(const UnresolvedLookupExpr *Node) { 2134 VisitExpr(Node); 2135 OS << " ("; 2136 if (!Node->requiresADL()) 2137 OS << "no "; 2138 OS << "ADL) = '" << Node->getName() << '\''; 2139 2140 UnresolvedLookupExpr::decls_iterator 2141 I = Node->decls_begin(), E = Node->decls_end(); 2142 if (I == E) 2143 OS << " empty"; 2144 for (; I != E; ++I) 2145 dumpPointer(*I); 2146 } 2147 2148 void ASTDumper::VisitObjCIvarRefExpr(const ObjCIvarRefExpr *Node) { 2149 VisitExpr(Node); 2150 2151 { 2152 ColorScope Color(*this, DeclKindNameColor); 2153 OS << " " << Node->getDecl()->getDeclKindName() << "Decl"; 2154 } 2155 OS << "='" << *Node->getDecl() << "'"; 2156 dumpPointer(Node->getDecl()); 2157 if (Node->isFreeIvar()) 2158 OS << " isFreeIvar"; 2159 } 2160 2161 void ASTDumper::VisitPredefinedExpr(const PredefinedExpr *Node) { 2162 VisitExpr(Node); 2163 OS << " " << PredefinedExpr::getIdentTypeName(Node->getIdentType()); 2164 } 2165 2166 void ASTDumper::VisitCharacterLiteral(const CharacterLiteral *Node) { 2167 VisitExpr(Node); 2168 ColorScope Color(*this, ValueColor); 2169 OS << " " << Node->getValue(); 2170 } 2171 2172 void ASTDumper::VisitIntegerLiteral(const IntegerLiteral *Node) { 2173 VisitExpr(Node); 2174 2175 bool isSigned = Node->getType()->isSignedIntegerType(); 2176 ColorScope Color(*this, ValueColor); 2177 OS << " " << Node->getValue().toString(10, isSigned); 2178 } 2179 2180 void ASTDumper::VisitFloatingLiteral(const FloatingLiteral *Node) { 2181 VisitExpr(Node); 2182 ColorScope Color(*this, ValueColor); 2183 OS << " " << Node->getValueAsApproximateDouble(); 2184 } 2185 2186 void ASTDumper::VisitStringLiteral(const StringLiteral *Str) { 2187 VisitExpr(Str); 2188 ColorScope Color(*this, ValueColor); 2189 OS << " "; 2190 Str->outputString(OS); 2191 } 2192 2193 void ASTDumper::VisitInitListExpr(const InitListExpr *ILE) { 2194 VisitExpr(ILE); 2195 if (auto *Filler = ILE->getArrayFiller()) { 2196 dumpChild([=] { 2197 OS << "array filler"; 2198 dumpStmt(Filler); 2199 }); 2200 } 2201 if (auto *Field = ILE->getInitializedFieldInUnion()) { 2202 OS << " field "; 2203 dumpBareDeclRef(Field); 2204 } 2205 } 2206 2207 void ASTDumper::VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E) { 2208 VisitExpr(E); 2209 } 2210 2211 void ASTDumper::VisitArrayInitIndexExpr(const ArrayInitIndexExpr *E) { 2212 VisitExpr(E); 2213 } 2214 2215 void ASTDumper::VisitUnaryOperator(const UnaryOperator *Node) { 2216 VisitExpr(Node); 2217 OS << " " << (Node->isPostfix() ? "postfix" : "prefix") 2218 << " '" << UnaryOperator::getOpcodeStr(Node->getOpcode()) << "'"; 2219 if (!Node->canOverflow()) 2220 OS << " cannot overflow"; 2221 } 2222 2223 void ASTDumper::VisitUnaryExprOrTypeTraitExpr( 2224 const UnaryExprOrTypeTraitExpr *Node) { 2225 VisitExpr(Node); 2226 switch(Node->getKind()) { 2227 case UETT_SizeOf: 2228 OS << " sizeof"; 2229 break; 2230 case UETT_AlignOf: 2231 OS << " alignof"; 2232 break; 2233 case UETT_VecStep: 2234 OS << " vec_step"; 2235 break; 2236 case UETT_OpenMPRequiredSimdAlign: 2237 OS << " __builtin_omp_required_simd_align"; 2238 break; 2239 } 2240 if (Node->isArgumentType()) 2241 dumpType(Node->getArgumentType()); 2242 } 2243 2244 void ASTDumper::VisitMemberExpr(const MemberExpr *Node) { 2245 VisitExpr(Node); 2246 OS << " " << (Node->isArrow() ? "->" : ".") << *Node->getMemberDecl(); 2247 dumpPointer(Node->getMemberDecl()); 2248 } 2249 2250 void ASTDumper::VisitExtVectorElementExpr(const ExtVectorElementExpr *Node) { 2251 VisitExpr(Node); 2252 OS << " " << Node->getAccessor().getNameStart(); 2253 } 2254 2255 void ASTDumper::VisitBinaryOperator(const BinaryOperator *Node) { 2256 VisitExpr(Node); 2257 OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode()) << "'"; 2258 } 2259 2260 void ASTDumper::VisitCompoundAssignOperator( 2261 const CompoundAssignOperator *Node) { 2262 VisitExpr(Node); 2263 OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode()) 2264 << "' ComputeLHSTy="; 2265 dumpBareType(Node->getComputationLHSType()); 2266 OS << " ComputeResultTy="; 2267 dumpBareType(Node->getComputationResultType()); 2268 } 2269 2270 void ASTDumper::VisitBlockExpr(const BlockExpr *Node) { 2271 VisitExpr(Node); 2272 dumpDecl(Node->getBlockDecl()); 2273 } 2274 2275 void ASTDumper::VisitOpaqueValueExpr(const OpaqueValueExpr *Node) { 2276 VisitExpr(Node); 2277 2278 if (Expr *Source = Node->getSourceExpr()) 2279 dumpStmt(Source); 2280 } 2281 2282 void ASTDumper::VisitGenericSelectionExpr(const GenericSelectionExpr *E) { 2283 VisitExpr(E); 2284 if (E->isResultDependent()) 2285 OS << " result_dependent"; 2286 dumpStmt(E->getControllingExpr()); 2287 dumpTypeAsChild(E->getControllingExpr()->getType()); // FIXME: remove 2288 2289 for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) { 2290 dumpChild([=] { 2291 if (const TypeSourceInfo *TSI = E->getAssocTypeSourceInfo(I)) { 2292 OS << "case "; 2293 dumpType(TSI->getType()); 2294 } else { 2295 OS << "default"; 2296 } 2297 2298 if (!E->isResultDependent() && E->getResultIndex() == I) 2299 OS << " selected"; 2300 2301 if (const TypeSourceInfo *TSI = E->getAssocTypeSourceInfo(I)) 2302 dumpTypeAsChild(TSI->getType()); 2303 dumpStmt(E->getAssocExpr(I)); 2304 }); 2305 } 2306 } 2307 2308 // GNU extensions. 2309 2310 void ASTDumper::VisitAddrLabelExpr(const AddrLabelExpr *Node) { 2311 VisitExpr(Node); 2312 OS << " " << Node->getLabel()->getName(); 2313 dumpPointer(Node->getLabel()); 2314 } 2315 2316 //===----------------------------------------------------------------------===// 2317 // C++ Expressions 2318 //===----------------------------------------------------------------------===// 2319 2320 void ASTDumper::VisitCXXNamedCastExpr(const CXXNamedCastExpr *Node) { 2321 VisitExpr(Node); 2322 OS << " " << Node->getCastName() 2323 << "<" << Node->getTypeAsWritten().getAsString() << ">" 2324 << " <" << Node->getCastKindName(); 2325 dumpBasePath(OS, Node); 2326 OS << ">"; 2327 } 2328 2329 void ASTDumper::VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *Node) { 2330 VisitExpr(Node); 2331 OS << " " << (Node->getValue() ? "true" : "false"); 2332 } 2333 2334 void ASTDumper::VisitCXXThisExpr(const CXXThisExpr *Node) { 2335 VisitExpr(Node); 2336 OS << " this"; 2337 } 2338 2339 void ASTDumper::VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *Node) { 2340 VisitExpr(Node); 2341 OS << " functional cast to " << Node->getTypeAsWritten().getAsString() 2342 << " <" << Node->getCastKindName() << ">"; 2343 } 2344 2345 void ASTDumper::VisitCXXUnresolvedConstructExpr( 2346 const CXXUnresolvedConstructExpr *Node) { 2347 VisitExpr(Node); 2348 dumpType(Node->getTypeAsWritten()); 2349 if (Node->isListInitialization()) 2350 OS << " list"; 2351 } 2352 2353 void ASTDumper::VisitCXXConstructExpr(const CXXConstructExpr *Node) { 2354 VisitExpr(Node); 2355 CXXConstructorDecl *Ctor = Node->getConstructor(); 2356 dumpType(Ctor->getType()); 2357 if (Node->isElidable()) 2358 OS << " elidable"; 2359 if (Node->isListInitialization()) 2360 OS << " list"; 2361 if (Node->isStdInitListInitialization()) 2362 OS << " std::initializer_list"; 2363 if (Node->requiresZeroInitialization()) 2364 OS << " zeroing"; 2365 } 2366 2367 void ASTDumper::VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *Node) { 2368 VisitExpr(Node); 2369 OS << " "; 2370 dumpCXXTemporary(Node->getTemporary()); 2371 } 2372 2373 void ASTDumper::VisitCXXNewExpr(const CXXNewExpr *Node) { 2374 VisitExpr(Node); 2375 if (Node->isGlobalNew()) 2376 OS << " global"; 2377 if (Node->isArray()) 2378 OS << " array"; 2379 if (Node->getOperatorNew()) { 2380 OS << ' '; 2381 dumpBareDeclRef(Node->getOperatorNew()); 2382 } 2383 // We could dump the deallocation function used in case of error, but it's 2384 // usually not that interesting. 2385 } 2386 2387 void ASTDumper::VisitCXXDeleteExpr(const CXXDeleteExpr *Node) { 2388 VisitExpr(Node); 2389 if (Node->isGlobalDelete()) 2390 OS << " global"; 2391 if (Node->isArrayForm()) 2392 OS << " array"; 2393 if (Node->getOperatorDelete()) { 2394 OS << ' '; 2395 dumpBareDeclRef(Node->getOperatorDelete()); 2396 } 2397 } 2398 2399 void 2400 ASTDumper::VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *Node) { 2401 VisitExpr(Node); 2402 if (const ValueDecl *VD = Node->getExtendingDecl()) { 2403 OS << " extended by "; 2404 dumpBareDeclRef(VD); 2405 } 2406 } 2407 2408 void ASTDumper::VisitExprWithCleanups(const ExprWithCleanups *Node) { 2409 VisitExpr(Node); 2410 for (unsigned i = 0, e = Node->getNumObjects(); i != e; ++i) 2411 dumpDeclRef(Node->getObject(i), "cleanup"); 2412 } 2413 2414 void ASTDumper::dumpCXXTemporary(const CXXTemporary *Temporary) { 2415 OS << "(CXXTemporary"; 2416 dumpPointer(Temporary); 2417 OS << ")"; 2418 } 2419 2420 void ASTDumper::VisitSizeOfPackExpr(const SizeOfPackExpr *Node) { 2421 VisitExpr(Node); 2422 dumpPointer(Node->getPack()); 2423 dumpName(Node->getPack()); 2424 if (Node->isPartiallySubstituted()) 2425 for (const auto &A : Node->getPartialArguments()) 2426 dumpTemplateArgument(A); 2427 } 2428 2429 void ASTDumper::VisitCXXDependentScopeMemberExpr( 2430 const CXXDependentScopeMemberExpr *Node) { 2431 VisitExpr(Node); 2432 OS << " " << (Node->isArrow() ? "->" : ".") << Node->getMember(); 2433 } 2434 2435 //===----------------------------------------------------------------------===// 2436 // Obj-C Expressions 2437 //===----------------------------------------------------------------------===// 2438 2439 void ASTDumper::VisitObjCMessageExpr(const ObjCMessageExpr *Node) { 2440 VisitExpr(Node); 2441 OS << " selector="; 2442 Node->getSelector().print(OS); 2443 switch (Node->getReceiverKind()) { 2444 case ObjCMessageExpr::Instance: 2445 break; 2446 2447 case ObjCMessageExpr::Class: 2448 OS << " class="; 2449 dumpBareType(Node->getClassReceiver()); 2450 break; 2451 2452 case ObjCMessageExpr::SuperInstance: 2453 OS << " super (instance)"; 2454 break; 2455 2456 case ObjCMessageExpr::SuperClass: 2457 OS << " super (class)"; 2458 break; 2459 } 2460 } 2461 2462 void ASTDumper::VisitObjCBoxedExpr(const ObjCBoxedExpr *Node) { 2463 VisitExpr(Node); 2464 if (auto *BoxingMethod = Node->getBoxingMethod()) { 2465 OS << " selector="; 2466 BoxingMethod->getSelector().print(OS); 2467 } 2468 } 2469 2470 void ASTDumper::VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node) { 2471 VisitStmt(Node); 2472 if (const VarDecl *CatchParam = Node->getCatchParamDecl()) 2473 dumpDecl(CatchParam); 2474 else 2475 OS << " catch all"; 2476 } 2477 2478 void ASTDumper::VisitObjCEncodeExpr(const ObjCEncodeExpr *Node) { 2479 VisitExpr(Node); 2480 dumpType(Node->getEncodedType()); 2481 } 2482 2483 void ASTDumper::VisitObjCSelectorExpr(const ObjCSelectorExpr *Node) { 2484 VisitExpr(Node); 2485 2486 OS << " "; 2487 Node->getSelector().print(OS); 2488 } 2489 2490 void ASTDumper::VisitObjCProtocolExpr(const ObjCProtocolExpr *Node) { 2491 VisitExpr(Node); 2492 2493 OS << ' ' << *Node->getProtocol(); 2494 } 2495 2496 void ASTDumper::VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *Node) { 2497 VisitExpr(Node); 2498 if (Node->isImplicitProperty()) { 2499 OS << " Kind=MethodRef Getter=\""; 2500 if (Node->getImplicitPropertyGetter()) 2501 Node->getImplicitPropertyGetter()->getSelector().print(OS); 2502 else 2503 OS << "(null)"; 2504 2505 OS << "\" Setter=\""; 2506 if (ObjCMethodDecl *Setter = Node->getImplicitPropertySetter()) 2507 Setter->getSelector().print(OS); 2508 else 2509 OS << "(null)"; 2510 OS << "\""; 2511 } else { 2512 OS << " Kind=PropertyRef Property=\"" << *Node->getExplicitProperty() <<'"'; 2513 } 2514 2515 if (Node->isSuperReceiver()) 2516 OS << " super"; 2517 2518 OS << " Messaging="; 2519 if (Node->isMessagingGetter() && Node->isMessagingSetter()) 2520 OS << "Getter&Setter"; 2521 else if (Node->isMessagingGetter()) 2522 OS << "Getter"; 2523 else if (Node->isMessagingSetter()) 2524 OS << "Setter"; 2525 } 2526 2527 void ASTDumper::VisitObjCSubscriptRefExpr(const ObjCSubscriptRefExpr *Node) { 2528 VisitExpr(Node); 2529 if (Node->isArraySubscriptRefExpr()) 2530 OS << " Kind=ArraySubscript GetterForArray=\""; 2531 else 2532 OS << " Kind=DictionarySubscript GetterForDictionary=\""; 2533 if (Node->getAtIndexMethodDecl()) 2534 Node->getAtIndexMethodDecl()->getSelector().print(OS); 2535 else 2536 OS << "(null)"; 2537 2538 if (Node->isArraySubscriptRefExpr()) 2539 OS << "\" SetterForArray=\""; 2540 else 2541 OS << "\" SetterForDictionary=\""; 2542 if (Node->setAtIndexMethodDecl()) 2543 Node->setAtIndexMethodDecl()->getSelector().print(OS); 2544 else 2545 OS << "(null)"; 2546 } 2547 2548 void ASTDumper::VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *Node) { 2549 VisitExpr(Node); 2550 OS << " " << (Node->getValue() ? "__objc_yes" : "__objc_no"); 2551 } 2552 2553 //===----------------------------------------------------------------------===// 2554 // Comments 2555 //===----------------------------------------------------------------------===// 2556 2557 const char *ASTDumper::getCommandName(unsigned CommandID) { 2558 if (Traits) 2559 return Traits->getCommandInfo(CommandID)->Name; 2560 const CommandInfo *Info = CommandTraits::getBuiltinCommandInfo(CommandID); 2561 if (Info) 2562 return Info->Name; 2563 return "<not a builtin command>"; 2564 } 2565 2566 void ASTDumper::dumpFullComment(const FullComment *C) { 2567 if (!C) 2568 return; 2569 2570 FC = C; 2571 dumpComment(C); 2572 FC = nullptr; 2573 } 2574 2575 void ASTDumper::dumpComment(const Comment *C) { 2576 dumpChild([=] { 2577 if (!C) { 2578 ColorScope Color(*this, NullColor); 2579 OS << "<<<NULL>>>"; 2580 return; 2581 } 2582 2583 { 2584 ColorScope Color(*this, CommentColor); 2585 OS << C->getCommentKindName(); 2586 } 2587 dumpPointer(C); 2588 dumpSourceRange(C->getSourceRange()); 2589 ConstCommentVisitor<ASTDumper>::visit(C); 2590 for (Comment::child_iterator I = C->child_begin(), E = C->child_end(); 2591 I != E; ++I) 2592 dumpComment(*I); 2593 }); 2594 } 2595 2596 void ASTDumper::visitTextComment(const TextComment *C) { 2597 OS << " Text=\"" << C->getText() << "\""; 2598 } 2599 2600 void ASTDumper::visitInlineCommandComment(const InlineCommandComment *C) { 2601 OS << " Name=\"" << getCommandName(C->getCommandID()) << "\""; 2602 switch (C->getRenderKind()) { 2603 case InlineCommandComment::RenderNormal: 2604 OS << " RenderNormal"; 2605 break; 2606 case InlineCommandComment::RenderBold: 2607 OS << " RenderBold"; 2608 break; 2609 case InlineCommandComment::RenderMonospaced: 2610 OS << " RenderMonospaced"; 2611 break; 2612 case InlineCommandComment::RenderEmphasized: 2613 OS << " RenderEmphasized"; 2614 break; 2615 } 2616 2617 for (unsigned i = 0, e = C->getNumArgs(); i != e; ++i) 2618 OS << " Arg[" << i << "]=\"" << C->getArgText(i) << "\""; 2619 } 2620 2621 void ASTDumper::visitHTMLStartTagComment(const HTMLStartTagComment *C) { 2622 OS << " Name=\"" << C->getTagName() << "\""; 2623 if (C->getNumAttrs() != 0) { 2624 OS << " Attrs: "; 2625 for (unsigned i = 0, e = C->getNumAttrs(); i != e; ++i) { 2626 const HTMLStartTagComment::Attribute &Attr = C->getAttr(i); 2627 OS << " \"" << Attr.Name << "=\"" << Attr.Value << "\""; 2628 } 2629 } 2630 if (C->isSelfClosing()) 2631 OS << " SelfClosing"; 2632 } 2633 2634 void ASTDumper::visitHTMLEndTagComment(const HTMLEndTagComment *C) { 2635 OS << " Name=\"" << C->getTagName() << "\""; 2636 } 2637 2638 void ASTDumper::visitBlockCommandComment(const BlockCommandComment *C) { 2639 OS << " Name=\"" << getCommandName(C->getCommandID()) << "\""; 2640 for (unsigned i = 0, e = C->getNumArgs(); i != e; ++i) 2641 OS << " Arg[" << i << "]=\"" << C->getArgText(i) << "\""; 2642 } 2643 2644 void ASTDumper::visitParamCommandComment(const ParamCommandComment *C) { 2645 OS << " " << ParamCommandComment::getDirectionAsString(C->getDirection()); 2646 2647 if (C->isDirectionExplicit()) 2648 OS << " explicitly"; 2649 else 2650 OS << " implicitly"; 2651 2652 if (C->hasParamName()) { 2653 if (C->isParamIndexValid()) 2654 OS << " Param=\"" << C->getParamName(FC) << "\""; 2655 else 2656 OS << " Param=\"" << C->getParamNameAsWritten() << "\""; 2657 } 2658 2659 if (C->isParamIndexValid() && !C->isVarArgParam()) 2660 OS << " ParamIndex=" << C->getParamIndex(); 2661 } 2662 2663 void ASTDumper::visitTParamCommandComment(const TParamCommandComment *C) { 2664 if (C->hasParamName()) { 2665 if (C->isPositionValid()) 2666 OS << " Param=\"" << C->getParamName(FC) << "\""; 2667 else 2668 OS << " Param=\"" << C->getParamNameAsWritten() << "\""; 2669 } 2670 2671 if (C->isPositionValid()) { 2672 OS << " Position=<"; 2673 for (unsigned i = 0, e = C->getDepth(); i != e; ++i) { 2674 OS << C->getIndex(i); 2675 if (i != e - 1) 2676 OS << ", "; 2677 } 2678 OS << ">"; 2679 } 2680 } 2681 2682 void ASTDumper::visitVerbatimBlockComment(const VerbatimBlockComment *C) { 2683 OS << " Name=\"" << getCommandName(C->getCommandID()) << "\"" 2684 " CloseName=\"" << C->getCloseName() << "\""; 2685 } 2686 2687 void ASTDumper::visitVerbatimBlockLineComment( 2688 const VerbatimBlockLineComment *C) { 2689 OS << " Text=\"" << C->getText() << "\""; 2690 } 2691 2692 void ASTDumper::visitVerbatimLineComment(const VerbatimLineComment *C) { 2693 OS << " Text=\"" << C->getText() << "\""; 2694 } 2695 2696 //===----------------------------------------------------------------------===// 2697 // Type method implementations 2698 //===----------------------------------------------------------------------===// 2699 2700 void QualType::dump(const char *msg) const { 2701 if (msg) 2702 llvm::errs() << msg << ": "; 2703 dump(); 2704 } 2705 2706 LLVM_DUMP_METHOD void QualType::dump() const { dump(llvm::errs()); } 2707 2708 LLVM_DUMP_METHOD void QualType::dump(llvm::raw_ostream &OS) const { 2709 ASTDumper Dumper(OS, nullptr, nullptr); 2710 Dumper.dumpTypeAsChild(*this); 2711 } 2712 2713 LLVM_DUMP_METHOD void Type::dump() const { dump(llvm::errs()); } 2714 2715 LLVM_DUMP_METHOD void Type::dump(llvm::raw_ostream &OS) const { 2716 QualType(this, 0).dump(OS); 2717 } 2718 2719 //===----------------------------------------------------------------------===// 2720 // Decl method implementations 2721 //===----------------------------------------------------------------------===// 2722 2723 LLVM_DUMP_METHOD void Decl::dump() const { dump(llvm::errs()); } 2724 2725 LLVM_DUMP_METHOD void Decl::dump(raw_ostream &OS, bool Deserialize) const { 2726 const ASTContext &Ctx = getASTContext(); 2727 const SourceManager &SM = Ctx.getSourceManager(); 2728 ASTDumper P(OS, &Ctx.getCommentCommandTraits(), &SM, 2729 SM.getDiagnostics().getShowColors(), Ctx.getPrintingPolicy()); 2730 P.setDeserialize(Deserialize); 2731 P.dumpDecl(this); 2732 } 2733 2734 LLVM_DUMP_METHOD void Decl::dumpColor() const { 2735 const ASTContext &Ctx = getASTContext(); 2736 ASTDumper P(llvm::errs(), &Ctx.getCommentCommandTraits(), 2737 &Ctx.getSourceManager(), /*ShowColors*/ true, 2738 Ctx.getPrintingPolicy()); 2739 P.dumpDecl(this); 2740 } 2741 2742 LLVM_DUMP_METHOD void DeclContext::dumpLookups() const { 2743 dumpLookups(llvm::errs()); 2744 } 2745 2746 LLVM_DUMP_METHOD void DeclContext::dumpLookups(raw_ostream &OS, 2747 bool DumpDecls, 2748 bool Deserialize) const { 2749 const DeclContext *DC = this; 2750 while (!DC->isTranslationUnit()) 2751 DC = DC->getParent(); 2752 ASTContext &Ctx = cast<TranslationUnitDecl>(DC)->getASTContext(); 2753 const SourceManager &SM = Ctx.getSourceManager(); 2754 ASTDumper P(OS, &Ctx.getCommentCommandTraits(), &Ctx.getSourceManager(), 2755 SM.getDiagnostics().getShowColors(), Ctx.getPrintingPolicy()); 2756 P.setDeserialize(Deserialize); 2757 P.dumpLookups(this, DumpDecls); 2758 } 2759 2760 //===----------------------------------------------------------------------===// 2761 // Stmt method implementations 2762 //===----------------------------------------------------------------------===// 2763 2764 LLVM_DUMP_METHOD void Stmt::dump(SourceManager &SM) const { 2765 dump(llvm::errs(), SM); 2766 } 2767 2768 LLVM_DUMP_METHOD void Stmt::dump(raw_ostream &OS, SourceManager &SM) const { 2769 ASTDumper P(OS, nullptr, &SM); 2770 P.dumpStmt(this); 2771 } 2772 2773 LLVM_DUMP_METHOD void Stmt::dump(raw_ostream &OS) const { 2774 ASTDumper P(OS, nullptr, nullptr); 2775 P.dumpStmt(this); 2776 } 2777 2778 LLVM_DUMP_METHOD void Stmt::dump() const { 2779 ASTDumper P(llvm::errs(), nullptr, nullptr); 2780 P.dumpStmt(this); 2781 } 2782 2783 LLVM_DUMP_METHOD void Stmt::dumpColor() const { 2784 ASTDumper P(llvm::errs(), nullptr, nullptr, /*ShowColors*/true); 2785 P.dumpStmt(this); 2786 } 2787 2788 //===----------------------------------------------------------------------===// 2789 // Comment method implementations 2790 //===----------------------------------------------------------------------===// 2791 2792 LLVM_DUMP_METHOD void Comment::dump() const { 2793 dump(llvm::errs(), nullptr, nullptr); 2794 } 2795 2796 LLVM_DUMP_METHOD void Comment::dump(const ASTContext &Context) const { 2797 dump(llvm::errs(), &Context.getCommentCommandTraits(), 2798 &Context.getSourceManager()); 2799 } 2800 2801 void Comment::dump(raw_ostream &OS, const CommandTraits *Traits, 2802 const SourceManager *SM) const { 2803 const FullComment *FC = dyn_cast<FullComment>(this); 2804 ASTDumper D(OS, Traits, SM); 2805 D.dumpFullComment(FC); 2806 } 2807 2808 LLVM_DUMP_METHOD void Comment::dumpColor() const { 2809 const FullComment *FC = dyn_cast<FullComment>(this); 2810 ASTDumper D(llvm::errs(), nullptr, nullptr, /*ShowColors*/true); 2811 D.dumpFullComment(FC); 2812 } 2813