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