1 //===--- ASTDumper.cpp - Dumping implementation for ASTs ------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the AST dump methods, which dump out the
11 // AST in a form that exposes type details and other fields.
13 //===----------------------------------------------------------------------===//
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;
33 //===----------------------------------------------------------------------===//
35 //===----------------------------------------------------------------------===//
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.
41 struct TerminalColor {
42 raw_ostream::Colors Color;
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
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 };
65 // Type names (int, float, etc, plus user defined types)
66 static const TerminalColor TypeColor = { raw_ostream::GREEN, false };
69 static const TerminalColor AddressColor = { raw_ostream::YELLOW, false };
71 static const TerminalColor LocationColor = { raw_ostream::YELLOW, false };
74 static const TerminalColor ValueKindColor = { raw_ostream::CYAN, false };
75 // bitfield/objcproperty/objcsubscript/vectorcomponent
76 static const TerminalColor ObjectKindColor = { raw_ostream::CYAN, false };
79 static const TerminalColor NullColor = { raw_ostream::BLUE, false };
81 // Undeserialized entities
82 static const TerminalColor UndeserializedColor = { raw_ostream::GREEN, true };
84 // CastKind from CastExpr's
85 static const TerminalColor CastColor = { raw_ostream::RED, false };
87 // Value of the statement
88 static const TerminalColor ValueColor = { raw_ostream::CYAN, true };
90 static const TerminalColor DeclNameColor = { raw_ostream::CYAN, true };
92 // Indents ( `, -. | )
93 static const TerminalColor IndentColor = { raw_ostream::BLUE, false };
96 : public ConstDeclVisitor<ASTDumper>, public ConstStmtVisitor<ASTDumper>,
97 public ConstCommentVisitor<ASTDumper>, public TypeVisitor<ASTDumper> {
99 const CommandTraits *Traits;
100 const SourceManager *SM;
102 /// The policy to use for printing; can be defaulted.
103 PrintingPolicy PrintPolicy;
105 /// Pending[i] is an action to dump an entity at level i.
106 llvm::SmallVector<std::function<void(bool isLastChild)>, 32> Pending;
108 /// Indicates whether we should trigger deserialization of nodes that had
109 /// not already been loaded.
110 bool Deserialize = false;
112 /// Indicates whether we're at the top level.
113 bool TopLevel = true;
115 /// Indicates if we're handling the first child after entering a new depth.
116 bool FirstChild = true;
118 /// Prefix for currently-being-dumped entity.
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;
126 /// The \c FullComment parent of the comment being dumped.
127 const FullComment *FC = nullptr;
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
138 while (!Pending.empty()) {
139 Pending.back()(true);
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:
155 // | `-C Prefix = "| "
157 // |-E Prefix = " | "
161 // Note that the first level gets no prefix.
164 ColorScope Color(*this, IndentColor);
165 OS << Prefix << (isLastChild ? '`' : '|') << '-';
166 this->Prefix.push_back(isLastChild ? ' ' : '|');
167 this->Prefix.push_back(' ');
171 unsigned Depth = Pending.size();
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();
183 // Restore the old prefix.
184 this->Prefix.resize(Prefix.size() - 2);
188 Pending.push_back(std::move(dumpWithIndent));
190 Pending.back()(false);
191 Pending.back() = std::move(dumpWithIndent);
199 ColorScope(ASTDumper &Dumper, TerminalColor Color)
201 if (Dumper.ShowColors)
202 Dumper.OS.changeColor(Color.Color, Color.Bold);
205 if (Dumper.ShowColors)
206 Dumper.OS.resetColor();
211 ASTDumper(raw_ostream &OS, const CommandTraits *Traits,
212 const SourceManager *SM)
213 : ASTDumper(OS, Traits, SM,
214 SM && SM->getDiagnostics().getShowColors()) {}
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) {}
225 void setDeserialize(bool D) { Deserialize = D; }
227 void dumpDecl(const Decl *D);
228 void dumpStmt(const Stmt *S);
229 void dumpFullComment(const FullComment *C);
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);
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());
257 // Objective-C utilities.
258 void dumpObjCTypeParamList(const ObjCTypeParamList *typeParams);
261 void VisitComplexType(const ComplexType *T) {
262 dumpTypeAsChild(T->getElementType());
264 void VisitPointerType(const PointerType *T) {
265 dumpTypeAsChild(T->getPointeeType());
267 void VisitBlockPointerType(const BlockPointerType *T) {
268 dumpTypeAsChild(T->getPointeeType());
270 void VisitReferenceType(const ReferenceType *T) {
271 dumpTypeAsChild(T->getPointeeType());
273 void VisitRValueReferenceType(const ReferenceType *T) {
274 if (T->isSpelledAsLValue())
275 OS << " written as lvalue reference";
276 VisitReferenceType(T);
278 void VisitMemberPointerType(const MemberPointerType *T) {
279 dumpTypeAsChild(T->getClass());
280 dumpTypeAsChild(T->getPointeeType());
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;
288 OS << " " << T->getIndexTypeQualifiers().getAsString();
289 dumpTypeAsChild(T->getElementType());
291 void VisitConstantArrayType(const ConstantArrayType *T) {
292 OS << " " << T->getSize();
295 void VisitVariableArrayType(const VariableArrayType *T) {
297 dumpSourceRange(T->getBracketsRange());
299 dumpStmt(T->getSizeExpr());
301 void VisitDependentSizedArrayType(const DependentSizedArrayType *T) {
304 dumpSourceRange(T->getBracketsRange());
305 dumpStmt(T->getSizeExpr());
307 void VisitDependentSizedExtVectorType(
308 const DependentSizedExtVectorType *T) {
310 dumpLocation(T->getAttributeLoc());
311 dumpTypeAsChild(T->getElementType());
312 dumpStmt(T->getSizeExpr());
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;
323 OS << " " << T->getNumElements();
324 dumpTypeAsChild(T->getElementType());
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());
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) {
342 case RQ_LValue: OS << " &"; break;
343 case RQ_RValue: OS << " &&"; break;
345 // FIXME: Exception specification.
346 // FIXME: Consumed parameters.
347 VisitFunctionType(T);
348 for (QualType PT : T->getParamTypes())
351 dumpChild([=] { OS << "..."; });
353 void VisitUnresolvedUsingType(const UnresolvedUsingType *T) {
354 dumpDeclRef(T->getDecl());
356 void VisitTypedefType(const TypedefType *T) {
357 dumpDeclRef(T->getDecl());
359 void VisitTypeOfExprType(const TypeOfExprType *T) {
360 dumpStmt(T->getUnderlyingExpr());
362 void VisitDecltypeType(const DecltypeType *T) {
363 dumpStmt(T->getUnderlyingExpr());
365 void VisitUnaryTransformType(const UnaryTransformType *T) {
366 switch (T->getUTTKind()) {
367 case UnaryTransformType::EnumUnderlyingType:
368 OS << " underlying_type";
371 dumpTypeAsChild(T->getBaseType());
373 void VisitTagType(const TagType *T) {
374 dumpDeclRef(T->getDecl());
376 void VisitAttributedType(const AttributedType *T) {
378 dumpTypeAsChild(T->getModifiedType());
380 void VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
381 OS << " depth " << T->getDepth() << " index " << T->getIndex();
382 if (T->isParameterPack()) OS << " pack";
383 dumpDeclRef(T->getDecl());
385 void VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) {
386 dumpTypeAsChild(T->getReplacedParameter());
388 void VisitSubstTemplateTypeParmPackType(
389 const SubstTemplateTypeParmPackType *T) {
390 dumpTypeAsChild(T->getReplacedParameter());
391 dumpTemplateArgument(T->getArgumentPack());
393 void VisitAutoType(const AutoType *T) {
394 if (T->isDecltypeAuto()) OS << " decltype(auto)";
398 void VisitTemplateSpecializationType(const TemplateSpecializationType *T) {
399 if (T->isTypeAlias()) OS << " alias";
400 OS << " "; T->getTemplateName().dump(OS);
402 dumpTemplateArgument(Arg);
403 if (T->isTypeAlias())
404 dumpTypeAsChild(T->getAliasedType());
406 void VisitInjectedClassNameType(const InjectedClassNameType *T) {
407 dumpDeclRef(T->getDecl());
409 void VisitObjCInterfaceType(const ObjCInterfaceType *T) {
410 dumpDeclRef(T->getDecl());
412 void VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
413 dumpTypeAsChild(T->getPointeeType());
415 void VisitAtomicType(const AtomicType *T) {
416 dumpTypeAsChild(T->getValueType());
418 void VisitPipeType(const PipeType *T) {
419 dumpTypeAsChild(T->getElementType());
421 void VisitAdjustedType(const AdjustedType *T) {
422 dumpTypeAsChild(T->getOriginalType());
424 void VisitPackExpansionType(const PackExpansionType *T) {
425 if (auto N = T->getNumExpansions()) OS << " expansions " << *N;
427 dumpTypeAsChild(T->getPattern());
429 // FIXME: ElaboratedType, DependentNameType,
430 // DependentTemplateSpecializationType, ObjCObjectType
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);
451 void VisitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D);
452 void VisitOMPDeclareReductionDecl(const OMPDeclareReductionDecl *D);
453 void VisitOMPCapturedExprDecl(const OMPCapturedExprDecl *D);
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,
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);
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);
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);
519 void VisitOMPExecutableDirective(const OMPExecutableDirective *Node);
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);
544 void VisitCXXNamedCastExpr(const CXXNamedCastExpr *Node);
545 void VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *Node);
546 void VisitCXXThisExpr(const CXXThisExpr *Node);
547 void VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *Node);
548 void VisitCXXUnresolvedConstructExpr(const CXXUnresolvedConstructExpr *Node);
549 void VisitCXXConstructExpr(const CXXConstructExpr *Node);
550 void VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *Node);
551 void VisitCXXNewExpr(const CXXNewExpr *Node);
552 void VisitCXXDeleteExpr(const CXXDeleteExpr *Node);
553 void VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *Node);
554 void VisitExprWithCleanups(const ExprWithCleanups *Node);
555 void VisitUnresolvedLookupExpr(const UnresolvedLookupExpr *Node);
556 void dumpCXXTemporary(const CXXTemporary *Temporary);
557 void VisitLambdaExpr(const LambdaExpr *Node) {
559 dumpDecl(Node->getLambdaClass());
561 void VisitSizeOfPackExpr(const SizeOfPackExpr *Node);
563 VisitCXXDependentScopeMemberExpr(const CXXDependentScopeMemberExpr *Node);
566 void VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node);
567 void VisitObjCEncodeExpr(const ObjCEncodeExpr *Node);
568 void VisitObjCMessageExpr(const ObjCMessageExpr *Node);
569 void VisitObjCBoxedExpr(const ObjCBoxedExpr *Node);
570 void VisitObjCSelectorExpr(const ObjCSelectorExpr *Node);
571 void VisitObjCProtocolExpr(const ObjCProtocolExpr *Node);
572 void VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *Node);
573 void VisitObjCSubscriptRefExpr(const ObjCSubscriptRefExpr *Node);
574 void VisitObjCIvarRefExpr(const ObjCIvarRefExpr *Node);
575 void VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *Node);
578 const char *getCommandName(unsigned CommandID);
579 void dumpComment(const Comment *C);
582 void visitTextComment(const TextComment *C);
583 void visitInlineCommandComment(const InlineCommandComment *C);
584 void visitHTMLStartTagComment(const HTMLStartTagComment *C);
585 void visitHTMLEndTagComment(const HTMLEndTagComment *C);
588 void visitBlockCommandComment(const BlockCommandComment *C);
589 void visitParamCommandComment(const ParamCommandComment *C);
590 void visitTParamCommandComment(const TParamCommandComment *C);
591 void visitVerbatimBlockComment(const VerbatimBlockComment *C);
592 void visitVerbatimBlockLineComment(const VerbatimBlockLineComment *C);
593 void visitVerbatimLineComment(const VerbatimLineComment *C);
597 //===----------------------------------------------------------------------===//
599 //===----------------------------------------------------------------------===//
601 void ASTDumper::dumpPointer(const void *Ptr) {
602 ColorScope Color(*this, AddressColor);
606 void ASTDumper::dumpLocation(SourceLocation Loc) {
610 ColorScope Color(*this, LocationColor);
611 SourceLocation SpellingLoc = SM->getSpellingLoc(Loc);
613 // The general format we print out is filename:line:col, but we drop pieces
614 // that haven't changed since the last loc printed.
615 PresumedLoc PLoc = SM->getPresumedLoc(SpellingLoc);
617 if (PLoc.isInvalid()) {
618 OS << "<invalid sloc>";
622 if (strcmp(PLoc.getFilename(), LastLocFilename) != 0) {
623 OS << PLoc.getFilename() << ':' << PLoc.getLine()
624 << ':' << PLoc.getColumn();
625 LastLocFilename = PLoc.getFilename();
626 LastLocLine = PLoc.getLine();
627 } else if (PLoc.getLine() != LastLocLine) {
628 OS << "line" << ':' << PLoc.getLine()
629 << ':' << PLoc.getColumn();
630 LastLocLine = PLoc.getLine();
632 OS << "col" << ':' << PLoc.getColumn();
636 void ASTDumper::dumpSourceRange(SourceRange R) {
637 // Can't translate locations if a SourceManager isn't available.
642 dumpLocation(R.getBegin());
643 if (R.getBegin() != R.getEnd()) {
645 dumpLocation(R.getEnd());
649 // <t2.c:123:421[blah], t2.c:412:321>
653 void ASTDumper::dumpBareType(QualType T, bool Desugar) {
654 ColorScope Color(*this, TypeColor);
656 SplitQualType T_split = T.split();
657 OS << "'" << QualType::getAsString(T_split, PrintPolicy) << "'";
659 if (Desugar && !T.isNull()) {
660 // If the type is sugared, also dump a (shallow) desugared type.
661 SplitQualType D_split = T.getSplitDesugaredType();
662 if (T_split != D_split)
663 OS << ":'" << QualType::getAsString(D_split, PrintPolicy) << "'";
667 void ASTDumper::dumpType(QualType T) {
672 void ASTDumper::dumpTypeAsChild(QualType T) {
673 SplitQualType SQT = T.split();
674 if (!SQT.Quals.hasQualifiers())
675 return dumpTypeAsChild(SQT.Ty);
679 dumpPointer(T.getAsOpaquePtr());
681 dumpBareType(T, false);
682 OS << " " << T.split().Quals.getAsString();
683 dumpTypeAsChild(T.split().Ty);
687 void ASTDumper::dumpTypeAsChild(const Type *T) {
690 ColorScope Color(*this, NullColor);
694 if (const LocInfoType *LIT = llvm::dyn_cast<LocInfoType>(T)) {
696 ColorScope Color(*this, TypeColor);
697 OS << "LocInfo Type";
700 dumpTypeAsChild(LIT->getTypeSourceInfo()->getType());
705 ColorScope Color(*this, TypeColor);
706 OS << T->getTypeClassName() << "Type";
710 dumpBareType(QualType(T, 0), false);
712 QualType SingleStepDesugar =
713 T->getLocallyUnqualifiedSingleStepDesugaredType();
714 if (SingleStepDesugar != QualType(T, 0))
716 if (T->isDependentType())
718 else if (T->isInstantiationDependentType())
719 OS << " instantiation_dependent";
720 if (T->isVariablyModifiedType())
721 OS << " variably_modified";
722 if (T->containsUnexpandedParameterPack())
723 OS << " contains_unexpanded_pack";
727 TypeVisitor<ASTDumper>::Visit(T);
729 if (SingleStepDesugar != QualType(T, 0))
730 dumpTypeAsChild(SingleStepDesugar);
734 void ASTDumper::dumpBareDeclRef(const Decl *D) {
736 ColorScope Color(*this, NullColor);
742 ColorScope Color(*this, DeclKindNameColor);
743 OS << D->getDeclKindName();
747 if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
748 ColorScope Color(*this, DeclNameColor);
749 OS << " '" << ND->getDeclName() << '\'';
752 if (const ValueDecl *VD = dyn_cast<ValueDecl>(D))
753 dumpType(VD->getType());
756 void ASTDumper::dumpDeclRef(const Decl *D, const char *Label) {
767 void ASTDumper::dumpName(const NamedDecl *ND) {
768 if (ND->getDeclName()) {
769 ColorScope Color(*this, DeclNameColor);
770 OS << ' ' << ND->getNameAsString();
774 bool ASTDumper::hasNodes(const DeclContext *DC) {
778 return DC->hasExternalLexicalStorage() ||
779 (Deserialize ? DC->decls_begin() != DC->decls_end()
780 : DC->noload_decls_begin() != DC->noload_decls_end());
783 void ASTDumper::dumpDeclContext(const DeclContext *DC) {
787 for (auto *D : (Deserialize ? DC->decls() : DC->noload_decls()))
790 if (DC->hasExternalLexicalStorage()) {
792 ColorScope Color(*this, UndeserializedColor);
793 OS << "<undeserialized declarations>";
798 void ASTDumper::dumpLookups(const DeclContext *DC, bool DumpDecls) {
800 OS << "StoredDeclsMap ";
801 dumpBareDeclRef(cast<Decl>(DC));
803 const DeclContext *Primary = DC->getPrimaryContext();
806 dumpPointer(cast<Decl>(Primary));
809 bool HasUndeserializedLookups = Primary->hasExternalVisibleStorage();
811 for (auto I = Deserialize ? Primary->lookups_begin()
812 : Primary->noload_lookups_begin(),
813 E = Deserialize ? Primary->lookups_end()
814 : Primary->noload_lookups_end();
816 DeclarationName Name = I.getLookupName();
817 DeclContextLookupResult R = *I;
820 OS << "DeclarationName ";
822 ColorScope Color(*this, DeclNameColor);
823 OS << '\'' << Name << '\'';
826 for (DeclContextLookupResult::iterator RI = R.begin(), RE = R.end();
829 dumpBareDeclRef(*RI);
831 if ((*RI)->isHidden())
834 // If requested, dump the redecl chain for this lookup.
836 // Dump earliest decl first.
837 std::function<void(Decl *)> DumpWithPrev = [&](Decl *D) {
838 if (Decl *Prev = D->getPreviousDecl())
849 if (HasUndeserializedLookups) {
851 ColorScope Color(*this, UndeserializedColor);
852 OS << "<undeserialized lookups>";
858 void ASTDumper::dumpAttr(const Attr *A) {
861 ColorScope Color(*this, AttrColor);
863 switch (A->getKind()) {
864 #define ATTR(X) case attr::X: OS << #X; break;
865 #include "clang/Basic/AttrList.inc"
870 dumpSourceRange(A->getRange());
871 if (A->isInherited())
875 #include "clang/AST/AttrDump.inc"
879 static void dumpPreviousDeclImpl(raw_ostream &OS, ...) {}
882 static void dumpPreviousDeclImpl(raw_ostream &OS, const Mergeable<T> *D) {
883 const T *First = D->getFirstDecl();
885 OS << " first " << First;
889 static void dumpPreviousDeclImpl(raw_ostream &OS, const Redeclarable<T> *D) {
890 const T *Prev = D->getPreviousDecl();
892 OS << " prev " << Prev;
895 /// Dump the previous declaration in the redeclaration chain for a declaration,
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"
905 llvm_unreachable("Decl that isn't part of DeclNodes.inc!");
908 //===----------------------------------------------------------------------===//
910 //===----------------------------------------------------------------------===//
912 void ASTDumper::dumpAccessSpecifier(AccessSpecifier AS) {
928 void ASTDumper::dumpCXXCtorInitializer(const CXXCtorInitializer *Init) {
930 OS << "CXXCtorInitializer";
931 if (Init->isAnyMemberInitializer()) {
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());
939 llvm_unreachable("Unknown initializer type");
941 dumpStmt(Init->getInit());
945 void ASTDumper::dumpTemplateParameters(const TemplateParameterList *TPL) {
949 for (TemplateParameterList::const_iterator I = TPL->begin(), E = TPL->end();
954 void ASTDumper::dumpTemplateArgumentListInfo(
955 const TemplateArgumentListInfo &TALI) {
956 for (unsigned i = 0, e = TALI.size(); i < e; ++i)
957 dumpTemplateArgumentLoc(TALI[i]);
960 void ASTDumper::dumpTemplateArgumentLoc(const TemplateArgumentLoc &A) {
961 dumpTemplateArgument(A.getArgument(), A.getSourceRange());
964 void ASTDumper::dumpTemplateArgumentList(const TemplateArgumentList &TAL) {
965 for (unsigned i = 0, e = TAL.size(); i < e; ++i)
966 dumpTemplateArgument(TAL[i]);
969 void ASTDumper::dumpTemplateArgument(const TemplateArgument &A, SourceRange R) {
971 OS << "TemplateArgument";
975 switch (A.getKind()) {
976 case TemplateArgument::Null:
979 case TemplateArgument::Type:
981 dumpType(A.getAsType());
983 case TemplateArgument::Declaration:
985 dumpDeclRef(A.getAsDecl());
987 case TemplateArgument::NullPtr:
990 case TemplateArgument::Integral:
991 OS << " integral " << A.getAsIntegral();
993 case TemplateArgument::Template:
995 A.getAsTemplate().dump(OS);
997 case TemplateArgument::TemplateExpansion:
998 OS << " template expansion";
999 A.getAsTemplateOrTemplatePattern().dump(OS);
1001 case TemplateArgument::Expression:
1003 dumpStmt(A.getAsExpr());
1005 case TemplateArgument::Pack:
1007 for (TemplateArgument::pack_iterator I = A.pack_begin(), E = A.pack_end();
1009 dumpTemplateArgument(*I);
1015 //===----------------------------------------------------------------------===//
1016 // Objective-C Utilities
1017 //===----------------------------------------------------------------------===//
1018 void ASTDumper::dumpObjCTypeParamList(const ObjCTypeParamList *typeParams) {
1022 for (auto typeParam : *typeParams) {
1023 dumpDecl(typeParam);
1027 //===----------------------------------------------------------------------===//
1028 // Decl dumping methods.
1029 //===----------------------------------------------------------------------===//
1031 void ASTDumper::dumpDecl(const Decl *D) {
1034 ColorScope Color(*this, NullColor);
1040 ColorScope Color(*this, DeclKindNameColor);
1041 OS << D->getDeclKindName() << "Decl";
1044 if (D->getLexicalDeclContext() != D->getDeclContext())
1045 OS << " parent " << cast<Decl>(D->getDeclContext());
1046 dumpPreviousDecl(OS, D);
1047 dumpSourceRange(D->getSourceRange());
1049 dumpLocation(D->getLocation());
1050 if (D->isFromASTFile())
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))
1061 if (D->isImplicit())
1065 else if (D->isThisDeclarationReferenced())
1066 OS << " referenced";
1067 if (D->isInvalidDecl())
1069 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
1070 if (FD->isConstexpr())
1074 ConstDeclVisitor<ASTDumper>::Visit(D);
1076 for (Decl::attr_iterator I = D->attr_begin(), E = D->attr_end(); I != E;
1080 if (const FullComment *Comment =
1081 D->getASTContext().getLocalCommentForDeclUncached(D))
1082 dumpFullComment(Comment);
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));
1091 void ASTDumper::VisitLabelDecl(const LabelDecl *D) {
1095 void ASTDumper::VisitTypedefDecl(const TypedefDecl *D) {
1097 dumpType(D->getUnderlyingType());
1098 if (D->isModulePrivate())
1099 OS << " __module_private__";
1100 dumpTypeAsChild(D->getUnderlyingType());
1103 void ASTDumper::VisitEnumDecl(const EnumDecl *D) {
1104 if (D->isScoped()) {
1105 if (D->isScopedUsingClassTag())
1111 if (D->isModulePrivate())
1112 OS << " __module_private__";
1114 dumpType(D->getIntegerType());
1117 void ASTDumper::VisitRecordDecl(const RecordDecl *D) {
1118 OS << ' ' << D->getKindName();
1120 if (D->isModulePrivate())
1121 OS << " __module_private__";
1122 if (D->isCompleteDefinition())
1123 OS << " definition";
1126 void ASTDumper::VisitEnumConstantDecl(const EnumConstantDecl *D) {
1128 dumpType(D->getType());
1129 if (const Expr *Init = D->getInitExpr())
1133 void ASTDumper::VisitIndirectFieldDecl(const IndirectFieldDecl *D) {
1135 dumpType(D->getType());
1137 for (auto *Child : D->chain())
1141 void ASTDumper::VisitFunctionDecl(const FunctionDecl *D) {
1143 dumpType(D->getType());
1145 StorageClass SC = D->getStorageClass();
1147 OS << ' ' << VarDecl::getStorageClassSpecifierString(SC);
1148 if (D->isInlineSpecified())
1150 if (D->isVirtualAsWritten())
1152 if (D->isModulePrivate())
1153 OS << " __module_private__";
1157 if (D->isDefaulted()) {
1162 if (D->isDeletedAsWritten())
1167 if (const FunctionProtoType *FPT = D->getType()->getAs<FunctionProtoType>()) {
1168 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
1169 switch (EPI.ExceptionSpec.Type) {
1171 case EST_Unevaluated:
1172 OS << " noexcept-unevaluated " << EPI.ExceptionSpec.SourceDecl;
1174 case EST_Uninstantiated:
1175 OS << " noexcept-uninstantiated " << EPI.ExceptionSpec.SourceTemplate;
1180 if (const FunctionTemplateSpecializationInfo *FTSI =
1181 D->getTemplateSpecializationInfo())
1182 dumpTemplateArgumentList(*FTSI->TemplateArguments);
1184 if (!D->param_begin() && D->getNumParams())
1185 dumpChild([=] { OS << "<<NULL params x " << D->getNumParams() << ">>"; });
1187 for (const ParmVarDecl *Parameter : D->parameters())
1188 dumpDecl(Parameter);
1190 if (const CXXConstructorDecl *C = dyn_cast<CXXConstructorDecl>(D))
1191 for (CXXConstructorDecl::init_const_iterator I = C->init_begin(),
1194 dumpCXXCtorInitializer(*I);
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) << "'";
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())) {
1212 dumpOverride(Override);
1219 if (D->doesThisDeclarationHaveABody())
1220 dumpStmt(D->getBody());
1223 void ASTDumper::VisitFieldDecl(const FieldDecl *D) {
1225 dumpType(D->getType());
1228 if (D->isModulePrivate())
1229 OS << " __module_private__";
1231 if (D->isBitField())
1232 dumpStmt(D->getBitWidth());
1233 if (Expr *Init = D->getInClassInitializer())
1237 void ASTDumper::VisitVarDecl(const VarDecl *D) {
1239 dumpType(D->getType());
1240 StorageClass SC = D->getStorageClass();
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;
1248 if (D->isModulePrivate())
1249 OS << " __module_private__";
1250 if (D->isNRVOVariable())
1254 if (D->isConstexpr())
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;
1262 dumpStmt(D->getInit());
1266 void ASTDumper::VisitDecompositionDecl(const DecompositionDecl *D) {
1268 for (auto *B : D->bindings())
1272 void ASTDumper::VisitBindingDecl(const BindingDecl *D) {
1274 dumpType(D->getType());
1275 if (auto *E = D->getBinding())
1279 void ASTDumper::VisitFileScopeAsmDecl(const FileScopeAsmDecl *D) {
1280 dumpStmt(D->getAsmString());
1283 void ASTDumper::VisitImportDecl(const ImportDecl *D) {
1284 OS << ' ' << D->getImportedModule()->getFullModuleName();
1287 void ASTDumper::VisitPragmaCommentDecl(const PragmaCommentDecl *D) {
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;
1297 StringRef Arg = D->getArg();
1299 OS << " \"" << Arg << "\"";
1302 void ASTDumper::VisitPragmaDetectMismatchDecl(
1303 const PragmaDetectMismatchDecl *D) {
1304 OS << " \"" << D->getName() << "\" \"" << D->getValue() << "\"";
1307 void ASTDumper::VisitCapturedDecl(const CapturedDecl *D) {
1308 dumpStmt(D->getBody());
1311 //===----------------------------------------------------------------------===//
1312 // OpenMP Declarations
1313 //===----------------------------------------------------------------------===//
1315 void ASTDumper::VisitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D) {
1316 for (auto *E : D->varlists())
1320 void ASTDumper::VisitOMPDeclareReductionDecl(const OMPDeclareReductionDecl *D) {
1322 dumpType(D->getType());
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 = ";
1331 case OMPDeclareReductionDecl::CopyInit:
1332 OS << " omp_priv ()";
1334 case OMPDeclareReductionDecl::CallInit:
1337 dumpStmt(Initializer);
1341 void ASTDumper::VisitOMPCapturedExprDecl(const OMPCapturedExprDecl *D) {
1343 dumpType(D->getType());
1344 dumpStmt(D->getInit());
1347 //===----------------------------------------------------------------------===//
1349 //===----------------------------------------------------------------------===//
1351 void ASTDumper::VisitNamespaceDecl(const NamespaceDecl *D) {
1355 if (!D->isOriginalNamespace())
1356 dumpDeclRef(D->getOriginalNamespace(), "original");
1359 void ASTDumper::VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
1361 dumpBareDeclRef(D->getNominatedNamespace());
1364 void ASTDumper::VisitNamespaceAliasDecl(const NamespaceAliasDecl *D) {
1366 dumpDeclRef(D->getAliasedNamespace());
1369 void ASTDumper::VisitTypeAliasDecl(const TypeAliasDecl *D) {
1371 dumpType(D->getUnderlyingType());
1372 dumpTypeAsChild(D->getUnderlyingType());
1375 void ASTDumper::VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D) {
1377 dumpTemplateParameters(D->getTemplateParameters());
1378 dumpDecl(D->getTemplatedDecl());
1381 void ASTDumper::VisitCXXRecordDecl(const CXXRecordDecl *D) {
1383 if (!D->isCompleteDefinition())
1388 ColorScope Color(*this, DeclKindNameColor);
1389 OS << "DefinitionData";
1391 #define FLAG(fn, name) if (D->fn()) OS << " " #name;
1392 FLAG(isParsingBaseSpecifiers, parsing_base_specifiers);
1394 FLAG(isGenericLambda, generic);
1395 FLAG(isLambda, lambda);
1397 FLAG(canPassInRegisters, pass_in_registers);
1398 FLAG(isEmpty, empty);
1399 FLAG(isAggregate, aggregate);
1400 FLAG(isStandardLayout, standard_layout);
1401 FLAG(isTriviallyCopyable, trivially_copyable);
1403 FLAG(isTrivial, trivial);
1404 FLAG(isPolymorphic, polymorphic);
1405 FLAG(isAbstract, abstract);
1406 FLAG(isLiteral, literal);
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);
1416 ColorScope Color(*this, DeclKindNameColor);
1417 OS << "DefaultConstructor";
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);
1430 ColorScope Color(*this, DeclKindNameColor);
1431 OS << "CopyConstructor";
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);
1448 ColorScope Color(*this, DeclKindNameColor);
1449 OS << "MoveConstructor";
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);
1465 ColorScope Color(*this, DeclKindNameColor);
1466 OS << "CopyAssignment";
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);
1479 ColorScope Color(*this, DeclKindNameColor);
1480 OS << "MoveAssignment";
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);
1493 ColorScope Color(*this, DeclKindNameColor);
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);
1508 for (const auto &I : D->bases()) {
1512 dumpAccessSpecifier(I.getAccessSpecifier());
1513 dumpType(I.getType());
1514 if (I.isPackExpansion())
1520 void ASTDumper::VisitStaticAssertDecl(const StaticAssertDecl *D) {
1521 dumpStmt(D->getAssertExpr());
1522 dumpStmt(D->getMessage());
1525 template<typename SpecializationDecl>
1526 void ASTDumper::VisitTemplateDeclSpecialization(const SpecializationDecl *D,
1527 bool DumpExplicitInst,
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);
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");
1543 switch (Redecl->getTemplateSpecializationKind()) {
1544 case TSK_ExplicitInstantiationDeclaration:
1545 case TSK_ExplicitInstantiationDefinition:
1546 if (!DumpExplicitInst)
1549 case TSK_Undeclared:
1550 case TSK_ImplicitInstantiation:
1552 dumpDeclRef(Redecl);
1557 case TSK_ExplicitSpecialization:
1562 // Ensure we dump at least one decl for each specialization.
1567 template<typename TemplateDecl>
1568 void ASTDumper::VisitTemplateDecl(const TemplateDecl *D,
1569 bool DumpExplicitInst) {
1571 dumpTemplateParameters(D->getTemplateParameters());
1573 dumpDecl(D->getTemplatedDecl());
1575 for (auto *Child : D->specializations())
1576 VisitTemplateDeclSpecialization(Child, DumpExplicitInst,
1577 !D->isCanonicalDecl());
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);
1587 void ASTDumper::VisitClassTemplateDecl(const ClassTemplateDecl *D) {
1588 VisitTemplateDecl(D, false);
1591 void ASTDumper::VisitClassTemplateSpecializationDecl(
1592 const ClassTemplateSpecializationDecl *D) {
1593 VisitCXXRecordDecl(D);
1594 dumpTemplateArgumentList(D->getTemplateArgs());
1597 void ASTDumper::VisitClassTemplatePartialSpecializationDecl(
1598 const ClassTemplatePartialSpecializationDecl *D) {
1599 VisitClassTemplateSpecializationDecl(D);
1600 dumpTemplateParameters(D->getTemplateParameters());
1603 void ASTDumper::VisitClassScopeFunctionSpecializationDecl(
1604 const ClassScopeFunctionSpecializationDecl *D) {
1605 dumpDeclRef(D->getSpecialization());
1606 if (D->hasExplicitTemplateArgs())
1607 dumpTemplateArgumentListInfo(D->templateArgs());
1610 void ASTDumper::VisitVarTemplateDecl(const VarTemplateDecl *D) {
1611 VisitTemplateDecl(D, false);
1614 void ASTDumper::VisitBuiltinTemplateDecl(const BuiltinTemplateDecl *D) {
1616 dumpTemplateParameters(D->getTemplateParameters());
1619 void ASTDumper::VisitVarTemplateSpecializationDecl(
1620 const VarTemplateSpecializationDecl *D) {
1621 dumpTemplateArgumentList(D->getTemplateArgs());
1625 void ASTDumper::VisitVarTemplatePartialSpecializationDecl(
1626 const VarTemplatePartialSpecializationDecl *D) {
1627 dumpTemplateParameters(D->getTemplateParameters());
1628 VisitVarTemplateSpecializationDecl(D);
1631 void ASTDumper::VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) {
1632 if (D->wasDeclaredWithTypename())
1636 OS << " depth " << D->getDepth() << " index " << D->getIndex();
1637 if (D->isParameterPack())
1640 if (D->hasDefaultArgument())
1641 dumpTemplateArgument(D->getDefaultArgument());
1644 void ASTDumper::VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) {
1645 dumpType(D->getType());
1646 OS << " depth " << D->getDepth() << " index " << D->getIndex();
1647 if (D->isParameterPack())
1650 if (D->hasDefaultArgument())
1651 dumpTemplateArgument(D->getDefaultArgument());
1654 void ASTDumper::VisitTemplateTemplateParmDecl(
1655 const TemplateTemplateParmDecl *D) {
1656 OS << " depth " << D->getDepth() << " index " << D->getIndex();
1657 if (D->isParameterPack())
1660 dumpTemplateParameters(D->getTemplateParameters());
1661 if (D->hasDefaultArgument())
1662 dumpTemplateArgumentLoc(D->getDefaultArgument());
1665 void ASTDumper::VisitUsingDecl(const UsingDecl *D) {
1667 if (D->getQualifier())
1668 D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
1669 OS << D->getNameAsString();
1672 void ASTDumper::VisitUnresolvedUsingTypenameDecl(
1673 const UnresolvedUsingTypenameDecl *D) {
1675 if (D->getQualifier())
1676 D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
1677 OS << D->getNameAsString();
1680 void ASTDumper::VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl *D) {
1682 if (D->getQualifier())
1683 D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
1684 OS << D->getNameAsString();
1685 dumpType(D->getType());
1688 void ASTDumper::VisitUsingShadowDecl(const UsingShadowDecl *D) {
1690 dumpBareDeclRef(D->getTargetDecl());
1691 if (auto *TD = dyn_cast<TypeDecl>(D->getUnderlyingDecl()))
1692 dumpTypeAsChild(TD->getTypeForDecl());
1695 void ASTDumper::VisitConstructorUsingShadowDecl(
1696 const ConstructorUsingShadowDecl *D) {
1697 if (D->constructsVirtualBase())
1702 dumpBareDeclRef(D->getTargetDecl());
1707 dumpBareDeclRef(D->getNominatedBaseClass());
1709 dumpBareDeclRef(D->getNominatedBaseClassShadowDecl());
1713 OS << "constructed ";
1714 dumpBareDeclRef(D->getConstructedBaseClass());
1716 dumpBareDeclRef(D->getConstructedBaseClassShadowDecl());
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;
1727 void ASTDumper::VisitAccessSpecDecl(const AccessSpecDecl *D) {
1729 dumpAccessSpecifier(D->getAccess());
1732 void ASTDumper::VisitFriendDecl(const FriendDecl *D) {
1733 if (TypeSourceInfo *T = D->getFriendType())
1734 dumpType(T->getType());
1736 dumpDecl(D->getFriendDecl());
1739 //===----------------------------------------------------------------------===//
1740 // Obj-C Declarations
1741 //===----------------------------------------------------------------------===//
1743 void ASTDumper::VisitObjCIvarDecl(const ObjCIvarDecl *D) {
1745 dumpType(D->getType());
1746 if (D->getSynthesize())
1747 OS << " synthesize";
1749 switch (D->getAccessControl()) {
1750 case ObjCIvarDecl::None:
1753 case ObjCIvarDecl::Private:
1756 case ObjCIvarDecl::Protected:
1759 case ObjCIvarDecl::Public:
1762 case ObjCIvarDecl::Package:
1768 void ASTDumper::VisitObjCMethodDecl(const ObjCMethodDecl *D) {
1769 if (D->isInstanceMethod())
1774 dumpType(D->getReturnType());
1776 if (D->isThisDeclarationADefinition()) {
1779 for (const ParmVarDecl *Parameter : D->parameters())
1780 dumpDecl(Parameter);
1783 if (D->isVariadic())
1784 dumpChild([=] { OS << "..."; });
1787 dumpStmt(D->getBody());
1790 void ASTDumper::VisitObjCTypeParamDecl(const ObjCTypeParamDecl *D) {
1792 switch (D->getVariance()) {
1793 case ObjCTypeParamVariance::Invariant:
1796 case ObjCTypeParamVariance::Covariant:
1800 case ObjCTypeParamVariance::Contravariant:
1801 OS << " contravariant";
1805 if (D->hasExplicitBound())
1807 dumpType(D->getUnderlyingType());
1810 void ASTDumper::VisitObjCCategoryDecl(const ObjCCategoryDecl *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();
1821 void ASTDumper::VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D) {
1823 dumpDeclRef(D->getClassInterface());
1824 dumpDeclRef(D->getCategoryDecl());
1827 void ASTDumper::VisitObjCProtocolDecl(const ObjCProtocolDecl *D) {
1830 for (auto *Child : D->protocols())
1834 void ASTDumper::VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) {
1836 dumpObjCTypeParamList(D->getTypeParamListAsWritten());
1837 dumpDeclRef(D->getSuperClass(), "super");
1839 dumpDeclRef(D->getImplementation());
1840 for (auto *Child : D->protocols())
1844 void ASTDumper::VisitObjCImplementationDecl(const ObjCImplementationDecl *D) {
1846 dumpDeclRef(D->getSuperClass(), "super");
1847 dumpDeclRef(D->getClassInterface());
1848 for (ObjCImplementationDecl::init_const_iterator I = D->init_begin(),
1851 dumpCXXCtorInitializer(*I);
1854 void ASTDumper::VisitObjCCompatibleAliasDecl(const ObjCCompatibleAliasDecl *D) {
1856 dumpDeclRef(D->getClassInterface());
1859 void ASTDumper::VisitObjCPropertyDecl(const ObjCPropertyDecl *D) {
1861 dumpType(D->getType());
1863 if (D->getPropertyImplementation() == ObjCPropertyDecl::Required)
1865 else if (D->getPropertyImplementation() == ObjCPropertyDecl::Optional)
1868 ObjCPropertyDecl::PropertyAttributeKind Attrs = D->getPropertyAttributes();
1869 if (Attrs != ObjCPropertyDecl::OBJC_PR_noattr) {
1870 if (Attrs & ObjCPropertyDecl::OBJC_PR_readonly)
1872 if (Attrs & ObjCPropertyDecl::OBJC_PR_assign)
1874 if (Attrs & ObjCPropertyDecl::OBJC_PR_readwrite)
1876 if (Attrs & ObjCPropertyDecl::OBJC_PR_retain)
1878 if (Attrs & ObjCPropertyDecl::OBJC_PR_copy)
1880 if (Attrs & ObjCPropertyDecl::OBJC_PR_nonatomic)
1882 if (Attrs & ObjCPropertyDecl::OBJC_PR_atomic)
1884 if (Attrs & ObjCPropertyDecl::OBJC_PR_weak)
1886 if (Attrs & ObjCPropertyDecl::OBJC_PR_strong)
1888 if (Attrs & ObjCPropertyDecl::OBJC_PR_unsafe_unretained)
1889 OS << " unsafe_unretained";
1890 if (Attrs & ObjCPropertyDecl::OBJC_PR_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");
1899 void ASTDumper::VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D) {
1900 dumpName(D->getPropertyDecl());
1901 if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize)
1902 OS << " synthesize";
1905 dumpDeclRef(D->getPropertyDecl());
1906 dumpDeclRef(D->getPropertyIvarDecl());
1909 void ASTDumper::VisitBlockDecl(const BlockDecl *D) {
1910 for (auto I : D->parameters())
1913 if (D->isVariadic())
1914 dumpChild([=]{ OS << "..."; });
1916 if (D->capturesCXXThis())
1917 dumpChild([=]{ OS << "capture this"; });
1919 for (const auto &I : D->captures()) {
1926 if (I.getVariable()) {
1928 dumpBareDeclRef(I.getVariable());
1930 if (I.hasCopyExpr())
1931 dumpStmt(I.getCopyExpr());
1934 dumpStmt(D->getBody());
1937 //===----------------------------------------------------------------------===//
1938 // Stmt dumping methods.
1939 //===----------------------------------------------------------------------===//
1941 void ASTDumper::dumpStmt(const Stmt *S) {
1944 ColorScope Color(*this, NullColor);
1949 if (const DeclStmt *DS = dyn_cast<DeclStmt>(S)) {
1954 ConstStmtVisitor<ASTDumper>::Visit(S);
1956 for (const Stmt *SubStmt : S->children())
1961 void ASTDumper::VisitStmt(const Stmt *Node) {
1963 ColorScope Color(*this, StmtColor);
1964 OS << Node->getStmtClassName();
1967 dumpSourceRange(Node->getSourceRange());
1970 void ASTDumper::VisitDeclStmt(const DeclStmt *Node) {
1972 for (DeclStmt::const_decl_iterator I = Node->decl_begin(),
1973 E = Node->decl_end();
1978 void ASTDumper::VisitAttributedStmt(const AttributedStmt *Node) {
1980 for (ArrayRef<const Attr *>::iterator I = Node->getAttrs().begin(),
1981 E = Node->getAttrs().end();
1986 void ASTDumper::VisitLabelStmt(const LabelStmt *Node) {
1988 OS << " '" << Node->getName() << "'";
1991 void ASTDumper::VisitGotoStmt(const GotoStmt *Node) {
1993 OS << " '" << Node->getLabel()->getName() << "'";
1994 dumpPointer(Node->getLabel());
1997 void ASTDumper::VisitCXXCatchStmt(const CXXCatchStmt *Node) {
1999 dumpDecl(Node->getExceptionDecl());
2002 void ASTDumper::VisitCapturedStmt(const CapturedStmt *Node) {
2004 dumpDecl(Node->getCapturedDecl());
2007 //===----------------------------------------------------------------------===//
2008 // OpenMP dumping methods.
2009 //===----------------------------------------------------------------------===//
2011 void ASTDumper::VisitOMPExecutableDirective(
2012 const OMPExecutableDirective *Node) {
2014 for (auto *C : Node->clauses()) {
2017 ColorScope Color(*this, NullColor);
2018 OS << "<<<NULL>>> OMPClause";
2022 ColorScope Color(*this, AttrColor);
2023 StringRef ClauseName(getOpenMPClauseName(C->getClauseKind()));
2024 OS << "OMP" << ClauseName.substr(/*Start=*/0, /*N=*/1).upper()
2025 << ClauseName.drop_front() << "Clause";
2028 dumpSourceRange(SourceRange(C->getLocStart(), C->getLocEnd()));
2029 if (C->isImplicit())
2030 OS << " <implicit>";
2031 for (auto *S : C->children())
2037 //===----------------------------------------------------------------------===//
2038 // Expr dumping methods.
2039 //===----------------------------------------------------------------------===//
2041 void ASTDumper::VisitExpr(const Expr *Node) {
2043 dumpType(Node->getType());
2046 ColorScope Color(*this, ValueKindColor);
2047 switch (Node->getValueKind()) {
2060 ColorScope Color(*this, ObjectKindColor);
2061 switch (Node->getObjectKind()) {
2067 case OK_ObjCProperty:
2068 OS << " objcproperty";
2070 case OK_ObjCSubscript:
2071 OS << " objcsubscript";
2073 case OK_VectorComponent:
2074 OS << " vectorcomponent";
2080 static void dumpBasePath(raw_ostream &OS, const CastExpr *Node) {
2081 if (Node->path_empty())
2086 for (CastExpr::path_const_iterator I = Node->path_begin(),
2087 E = Node->path_end();
2089 const CXXBaseSpecifier *Base = *I;
2093 const CXXRecordDecl *RD =
2094 cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
2096 if (Base->isVirtual())
2098 OS << RD->getName();
2105 void ASTDumper::VisitCastExpr(const CastExpr *Node) {
2109 ColorScope Color(*this, CastColor);
2110 OS << Node->getCastKindName();
2112 dumpBasePath(OS, Node);
2116 void ASTDumper::VisitDeclRefExpr(const DeclRefExpr *Node) {
2120 dumpBareDeclRef(Node->getDecl());
2121 if (Node->getDecl() != Node->getFoundDecl()) {
2123 dumpBareDeclRef(Node->getFoundDecl());
2128 void ASTDumper::VisitUnresolvedLookupExpr(const UnresolvedLookupExpr *Node) {
2131 if (!Node->requiresADL())
2133 OS << "ADL) = '" << Node->getName() << '\'';
2135 UnresolvedLookupExpr::decls_iterator
2136 I = Node->decls_begin(), E = Node->decls_end();
2143 void ASTDumper::VisitObjCIvarRefExpr(const ObjCIvarRefExpr *Node) {
2147 ColorScope Color(*this, DeclKindNameColor);
2148 OS << " " << Node->getDecl()->getDeclKindName() << "Decl";
2150 OS << "='" << *Node->getDecl() << "'";
2151 dumpPointer(Node->getDecl());
2152 if (Node->isFreeIvar())
2153 OS << " isFreeIvar";
2156 void ASTDumper::VisitPredefinedExpr(const PredefinedExpr *Node) {
2158 OS << " " << PredefinedExpr::getIdentTypeName(Node->getIdentType());
2161 void ASTDumper::VisitCharacterLiteral(const CharacterLiteral *Node) {
2163 ColorScope Color(*this, ValueColor);
2164 OS << " " << Node->getValue();
2167 void ASTDumper::VisitIntegerLiteral(const IntegerLiteral *Node) {
2170 bool isSigned = Node->getType()->isSignedIntegerType();
2171 ColorScope Color(*this, ValueColor);
2172 OS << " " << Node->getValue().toString(10, isSigned);
2175 void ASTDumper::VisitFloatingLiteral(const FloatingLiteral *Node) {
2177 ColorScope Color(*this, ValueColor);
2178 OS << " " << Node->getValueAsApproximateDouble();
2181 void ASTDumper::VisitStringLiteral(const StringLiteral *Str) {
2183 ColorScope Color(*this, ValueColor);
2185 Str->outputString(OS);
2188 void ASTDumper::VisitInitListExpr(const InitListExpr *ILE) {
2190 if (auto *Filler = ILE->getArrayFiller()) {
2192 OS << "array filler";
2196 if (auto *Field = ILE->getInitializedFieldInUnion()) {
2198 dumpBareDeclRef(Field);
2202 void ASTDumper::VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E) {
2206 void ASTDumper::VisitArrayInitIndexExpr(const ArrayInitIndexExpr *E) {
2210 void ASTDumper::VisitUnaryOperator(const UnaryOperator *Node) {
2212 OS << " " << (Node->isPostfix() ? "postfix" : "prefix")
2213 << " '" << UnaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
2216 void ASTDumper::VisitUnaryExprOrTypeTraitExpr(
2217 const UnaryExprOrTypeTraitExpr *Node) {
2219 switch(Node->getKind()) {
2229 case UETT_OpenMPRequiredSimdAlign:
2230 OS << " __builtin_omp_required_simd_align";
2233 if (Node->isArgumentType())
2234 dumpType(Node->getArgumentType());
2237 void ASTDumper::VisitMemberExpr(const MemberExpr *Node) {
2239 OS << " " << (Node->isArrow() ? "->" : ".") << *Node->getMemberDecl();
2240 dumpPointer(Node->getMemberDecl());
2243 void ASTDumper::VisitExtVectorElementExpr(const ExtVectorElementExpr *Node) {
2245 OS << " " << Node->getAccessor().getNameStart();
2248 void ASTDumper::VisitBinaryOperator(const BinaryOperator *Node) {
2250 OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
2253 void ASTDumper::VisitCompoundAssignOperator(
2254 const CompoundAssignOperator *Node) {
2256 OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode())
2257 << "' ComputeLHSTy=";
2258 dumpBareType(Node->getComputationLHSType());
2259 OS << " ComputeResultTy=";
2260 dumpBareType(Node->getComputationResultType());
2263 void ASTDumper::VisitBlockExpr(const BlockExpr *Node) {
2265 dumpDecl(Node->getBlockDecl());
2268 void ASTDumper::VisitOpaqueValueExpr(const OpaqueValueExpr *Node) {
2271 if (Expr *Source = Node->getSourceExpr())
2277 void ASTDumper::VisitAddrLabelExpr(const AddrLabelExpr *Node) {
2279 OS << " " << Node->getLabel()->getName();
2280 dumpPointer(Node->getLabel());
2283 //===----------------------------------------------------------------------===//
2285 //===----------------------------------------------------------------------===//
2287 void ASTDumper::VisitCXXNamedCastExpr(const CXXNamedCastExpr *Node) {
2289 OS << " " << Node->getCastName()
2290 << "<" << Node->getTypeAsWritten().getAsString() << ">"
2291 << " <" << Node->getCastKindName();
2292 dumpBasePath(OS, Node);
2296 void ASTDumper::VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *Node) {
2298 OS << " " << (Node->getValue() ? "true" : "false");
2301 void ASTDumper::VisitCXXThisExpr(const CXXThisExpr *Node) {
2306 void ASTDumper::VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *Node) {
2308 OS << " functional cast to " << Node->getTypeAsWritten().getAsString()
2309 << " <" << Node->getCastKindName() << ">";
2312 void ASTDumper::VisitCXXUnresolvedConstructExpr(
2313 const CXXUnresolvedConstructExpr *Node) {
2315 dumpType(Node->getTypeAsWritten());
2316 if (Node->isListInitialization())
2320 void ASTDumper::VisitCXXConstructExpr(const CXXConstructExpr *Node) {
2322 CXXConstructorDecl *Ctor = Node->getConstructor();
2323 dumpType(Ctor->getType());
2324 if (Node->isElidable())
2326 if (Node->isListInitialization())
2328 if (Node->isStdInitListInitialization())
2329 OS << " std::initializer_list";
2330 if (Node->requiresZeroInitialization())
2334 void ASTDumper::VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *Node) {
2337 dumpCXXTemporary(Node->getTemporary());
2340 void ASTDumper::VisitCXXNewExpr(const CXXNewExpr *Node) {
2342 if (Node->isGlobalNew())
2344 if (Node->isArray())
2346 if (Node->getOperatorNew()) {
2348 dumpBareDeclRef(Node->getOperatorNew());
2350 // We could dump the deallocation function used in case of error, but it's
2351 // usually not that interesting.
2354 void ASTDumper::VisitCXXDeleteExpr(const CXXDeleteExpr *Node) {
2356 if (Node->isGlobalDelete())
2358 if (Node->isArrayForm())
2360 if (Node->getOperatorDelete()) {
2362 dumpBareDeclRef(Node->getOperatorDelete());
2367 ASTDumper::VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *Node) {
2369 if (const ValueDecl *VD = Node->getExtendingDecl()) {
2370 OS << " extended by ";
2371 dumpBareDeclRef(VD);
2375 void ASTDumper::VisitExprWithCleanups(const ExprWithCleanups *Node) {
2377 for (unsigned i = 0, e = Node->getNumObjects(); i != e; ++i)
2378 dumpDeclRef(Node->getObject(i), "cleanup");
2381 void ASTDumper::dumpCXXTemporary(const CXXTemporary *Temporary) {
2382 OS << "(CXXTemporary";
2383 dumpPointer(Temporary);
2387 void ASTDumper::VisitSizeOfPackExpr(const SizeOfPackExpr *Node) {
2389 dumpPointer(Node->getPack());
2390 dumpName(Node->getPack());
2391 if (Node->isPartiallySubstituted())
2392 for (const auto &A : Node->getPartialArguments())
2393 dumpTemplateArgument(A);
2396 void ASTDumper::VisitCXXDependentScopeMemberExpr(
2397 const CXXDependentScopeMemberExpr *Node) {
2399 OS << " " << (Node->isArrow() ? "->" : ".") << Node->getMember();
2402 //===----------------------------------------------------------------------===//
2403 // Obj-C Expressions
2404 //===----------------------------------------------------------------------===//
2406 void ASTDumper::VisitObjCMessageExpr(const ObjCMessageExpr *Node) {
2409 Node->getSelector().print(OS);
2410 switch (Node->getReceiverKind()) {
2411 case ObjCMessageExpr::Instance:
2414 case ObjCMessageExpr::Class:
2416 dumpBareType(Node->getClassReceiver());
2419 case ObjCMessageExpr::SuperInstance:
2420 OS << " super (instance)";
2423 case ObjCMessageExpr::SuperClass:
2424 OS << " super (class)";
2429 void ASTDumper::VisitObjCBoxedExpr(const ObjCBoxedExpr *Node) {
2431 if (auto *BoxingMethod = Node->getBoxingMethod()) {
2433 BoxingMethod->getSelector().print(OS);
2437 void ASTDumper::VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node) {
2439 if (const VarDecl *CatchParam = Node->getCatchParamDecl())
2440 dumpDecl(CatchParam);
2445 void ASTDumper::VisitObjCEncodeExpr(const ObjCEncodeExpr *Node) {
2447 dumpType(Node->getEncodedType());
2450 void ASTDumper::VisitObjCSelectorExpr(const ObjCSelectorExpr *Node) {
2454 Node->getSelector().print(OS);
2457 void ASTDumper::VisitObjCProtocolExpr(const ObjCProtocolExpr *Node) {
2460 OS << ' ' << *Node->getProtocol();
2463 void ASTDumper::VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *Node) {
2465 if (Node->isImplicitProperty()) {
2466 OS << " Kind=MethodRef Getter=\"";
2467 if (Node->getImplicitPropertyGetter())
2468 Node->getImplicitPropertyGetter()->getSelector().print(OS);
2472 OS << "\" Setter=\"";
2473 if (ObjCMethodDecl *Setter = Node->getImplicitPropertySetter())
2474 Setter->getSelector().print(OS);
2479 OS << " Kind=PropertyRef Property=\"" << *Node->getExplicitProperty() <<'"';
2482 if (Node->isSuperReceiver())
2485 OS << " Messaging=";
2486 if (Node->isMessagingGetter() && Node->isMessagingSetter())
2487 OS << "Getter&Setter";
2488 else if (Node->isMessagingGetter())
2490 else if (Node->isMessagingSetter())
2494 void ASTDumper::VisitObjCSubscriptRefExpr(const ObjCSubscriptRefExpr *Node) {
2496 if (Node->isArraySubscriptRefExpr())
2497 OS << " Kind=ArraySubscript GetterForArray=\"";
2499 OS << " Kind=DictionarySubscript GetterForDictionary=\"";
2500 if (Node->getAtIndexMethodDecl())
2501 Node->getAtIndexMethodDecl()->getSelector().print(OS);
2505 if (Node->isArraySubscriptRefExpr())
2506 OS << "\" SetterForArray=\"";
2508 OS << "\" SetterForDictionary=\"";
2509 if (Node->setAtIndexMethodDecl())
2510 Node->setAtIndexMethodDecl()->getSelector().print(OS);
2515 void ASTDumper::VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *Node) {
2517 OS << " " << (Node->getValue() ? "__objc_yes" : "__objc_no");
2520 //===----------------------------------------------------------------------===//
2522 //===----------------------------------------------------------------------===//
2524 const char *ASTDumper::getCommandName(unsigned CommandID) {
2526 return Traits->getCommandInfo(CommandID)->Name;
2527 const CommandInfo *Info = CommandTraits::getBuiltinCommandInfo(CommandID);
2530 return "<not a builtin command>";
2533 void ASTDumper::dumpFullComment(const FullComment *C) {
2542 void ASTDumper::dumpComment(const Comment *C) {
2545 ColorScope Color(*this, NullColor);
2551 ColorScope Color(*this, CommentColor);
2552 OS << C->getCommentKindName();
2555 dumpSourceRange(C->getSourceRange());
2556 ConstCommentVisitor<ASTDumper>::visit(C);
2557 for (Comment::child_iterator I = C->child_begin(), E = C->child_end();
2563 void ASTDumper::visitTextComment(const TextComment *C) {
2564 OS << " Text=\"" << C->getText() << "\"";
2567 void ASTDumper::visitInlineCommandComment(const InlineCommandComment *C) {
2568 OS << " Name=\"" << getCommandName(C->getCommandID()) << "\"";
2569 switch (C->getRenderKind()) {
2570 case InlineCommandComment::RenderNormal:
2571 OS << " RenderNormal";
2573 case InlineCommandComment::RenderBold:
2574 OS << " RenderBold";
2576 case InlineCommandComment::RenderMonospaced:
2577 OS << " RenderMonospaced";
2579 case InlineCommandComment::RenderEmphasized:
2580 OS << " RenderEmphasized";
2584 for (unsigned i = 0, e = C->getNumArgs(); i != e; ++i)
2585 OS << " Arg[" << i << "]=\"" << C->getArgText(i) << "\"";
2588 void ASTDumper::visitHTMLStartTagComment(const HTMLStartTagComment *C) {
2589 OS << " Name=\"" << C->getTagName() << "\"";
2590 if (C->getNumAttrs() != 0) {
2592 for (unsigned i = 0, e = C->getNumAttrs(); i != e; ++i) {
2593 const HTMLStartTagComment::Attribute &Attr = C->getAttr(i);
2594 OS << " \"" << Attr.Name << "=\"" << Attr.Value << "\"";
2597 if (C->isSelfClosing())
2598 OS << " SelfClosing";
2601 void ASTDumper::visitHTMLEndTagComment(const HTMLEndTagComment *C) {
2602 OS << " Name=\"" << C->getTagName() << "\"";
2605 void ASTDumper::visitBlockCommandComment(const BlockCommandComment *C) {
2606 OS << " Name=\"" << getCommandName(C->getCommandID()) << "\"";
2607 for (unsigned i = 0, e = C->getNumArgs(); i != e; ++i)
2608 OS << " Arg[" << i << "]=\"" << C->getArgText(i) << "\"";
2611 void ASTDumper::visitParamCommandComment(const ParamCommandComment *C) {
2612 OS << " " << ParamCommandComment::getDirectionAsString(C->getDirection());
2614 if (C->isDirectionExplicit())
2615 OS << " explicitly";
2617 OS << " implicitly";
2619 if (C->hasParamName()) {
2620 if (C->isParamIndexValid())
2621 OS << " Param=\"" << C->getParamName(FC) << "\"";
2623 OS << " Param=\"" << C->getParamNameAsWritten() << "\"";
2626 if (C->isParamIndexValid() && !C->isVarArgParam())
2627 OS << " ParamIndex=" << C->getParamIndex();
2630 void ASTDumper::visitTParamCommandComment(const TParamCommandComment *C) {
2631 if (C->hasParamName()) {
2632 if (C->isPositionValid())
2633 OS << " Param=\"" << C->getParamName(FC) << "\"";
2635 OS << " Param=\"" << C->getParamNameAsWritten() << "\"";
2638 if (C->isPositionValid()) {
2639 OS << " Position=<";
2640 for (unsigned i = 0, e = C->getDepth(); i != e; ++i) {
2641 OS << C->getIndex(i);
2649 void ASTDumper::visitVerbatimBlockComment(const VerbatimBlockComment *C) {
2650 OS << " Name=\"" << getCommandName(C->getCommandID()) << "\""
2651 " CloseName=\"" << C->getCloseName() << "\"";
2654 void ASTDumper::visitVerbatimBlockLineComment(
2655 const VerbatimBlockLineComment *C) {
2656 OS << " Text=\"" << C->getText() << "\"";
2659 void ASTDumper::visitVerbatimLineComment(const VerbatimLineComment *C) {
2660 OS << " Text=\"" << C->getText() << "\"";
2663 //===----------------------------------------------------------------------===//
2664 // Type method implementations
2665 //===----------------------------------------------------------------------===//
2667 void QualType::dump(const char *msg) const {
2669 llvm::errs() << msg << ": ";
2673 LLVM_DUMP_METHOD void QualType::dump() const { dump(llvm::errs()); }
2675 LLVM_DUMP_METHOD void QualType::dump(llvm::raw_ostream &OS) const {
2676 ASTDumper Dumper(OS, nullptr, nullptr);
2677 Dumper.dumpTypeAsChild(*this);
2680 LLVM_DUMP_METHOD void Type::dump() const { dump(llvm::errs()); }
2682 LLVM_DUMP_METHOD void Type::dump(llvm::raw_ostream &OS) const {
2683 QualType(this, 0).dump(OS);
2686 //===----------------------------------------------------------------------===//
2687 // Decl method implementations
2688 //===----------------------------------------------------------------------===//
2690 LLVM_DUMP_METHOD void Decl::dump() const { dump(llvm::errs()); }
2692 LLVM_DUMP_METHOD void Decl::dump(raw_ostream &OS, bool Deserialize) const {
2693 const ASTContext &Ctx = getASTContext();
2694 const SourceManager &SM = Ctx.getSourceManager();
2695 ASTDumper P(OS, &Ctx.getCommentCommandTraits(), &SM,
2696 SM.getDiagnostics().getShowColors(), Ctx.getPrintingPolicy());
2697 P.setDeserialize(Deserialize);
2701 LLVM_DUMP_METHOD void Decl::dumpColor() const {
2702 const ASTContext &Ctx = getASTContext();
2703 ASTDumper P(llvm::errs(), &Ctx.getCommentCommandTraits(),
2704 &Ctx.getSourceManager(), /*ShowColors*/ true,
2705 Ctx.getPrintingPolicy());
2709 LLVM_DUMP_METHOD void DeclContext::dumpLookups() const {
2710 dumpLookups(llvm::errs());
2713 LLVM_DUMP_METHOD void DeclContext::dumpLookups(raw_ostream &OS,
2715 bool Deserialize) const {
2716 const DeclContext *DC = this;
2717 while (!DC->isTranslationUnit())
2718 DC = DC->getParent();
2719 ASTContext &Ctx = cast<TranslationUnitDecl>(DC)->getASTContext();
2720 const SourceManager &SM = Ctx.getSourceManager();
2721 ASTDumper P(OS, &Ctx.getCommentCommandTraits(), &Ctx.getSourceManager(),
2722 SM.getDiagnostics().getShowColors(), Ctx.getPrintingPolicy());
2723 P.setDeserialize(Deserialize);
2724 P.dumpLookups(this, DumpDecls);
2727 //===----------------------------------------------------------------------===//
2728 // Stmt method implementations
2729 //===----------------------------------------------------------------------===//
2731 LLVM_DUMP_METHOD void Stmt::dump(SourceManager &SM) const {
2732 dump(llvm::errs(), SM);
2735 LLVM_DUMP_METHOD void Stmt::dump(raw_ostream &OS, SourceManager &SM) const {
2736 ASTDumper P(OS, nullptr, &SM);
2740 LLVM_DUMP_METHOD void Stmt::dump(raw_ostream &OS) const {
2741 ASTDumper P(OS, nullptr, nullptr);
2745 LLVM_DUMP_METHOD void Stmt::dump() const {
2746 ASTDumper P(llvm::errs(), nullptr, nullptr);
2750 LLVM_DUMP_METHOD void Stmt::dumpColor() const {
2751 ASTDumper P(llvm::errs(), nullptr, nullptr, /*ShowColors*/true);
2755 //===----------------------------------------------------------------------===//
2756 // Comment method implementations
2757 //===----------------------------------------------------------------------===//
2759 LLVM_DUMP_METHOD void Comment::dump() const {
2760 dump(llvm::errs(), nullptr, nullptr);
2763 LLVM_DUMP_METHOD void Comment::dump(const ASTContext &Context) const {
2764 dump(llvm::errs(), &Context.getCommentCommandTraits(),
2765 &Context.getSourceManager());
2768 void Comment::dump(raw_ostream &OS, const CommandTraits *Traits,
2769 const SourceManager *SM) const {
2770 const FullComment *FC = dyn_cast<FullComment>(this);
2771 ASTDumper D(OS, Traits, SM);
2772 D.dumpFullComment(FC);
2775 LLVM_DUMP_METHOD void Comment::dumpColor() const {
2776 const FullComment *FC = dyn_cast<FullComment>(this);
2777 ASTDumper D(llvm::errs(), nullptr, nullptr, /*ShowColors*/true);
2778 D.dumpFullComment(FC);