1 //===--- TextNodeDumper.cpp - Printing of AST nodes -----------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements AST dumping of components of individual AST nodes.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "clang/AST/TextNodeDumper.h"
14 #include "clang/AST/APValue.h"
15 #include "clang/AST/DeclFriend.h"
16 #include "clang/AST/DeclOpenMP.h"
17 #include "clang/AST/DeclTemplate.h"
18 #include "clang/AST/LocInfoType.h"
19 #include "clang/AST/Type.h"
20 #include "clang/Basic/Module.h"
21 #include "clang/Basic/SourceManager.h"
22 #include "clang/Basic/Specifiers.h"
23 #include "clang/Basic/TypeTraits.h"
24 #include "llvm/ADT/StringExtras.h"
25
26 #include <algorithm>
27 #include <utility>
28
29 using namespace clang;
30
dumpPreviousDeclImpl(raw_ostream & OS,...)31 static void dumpPreviousDeclImpl(raw_ostream &OS, ...) {}
32
33 template <typename T>
dumpPreviousDeclImpl(raw_ostream & OS,const Mergeable<T> * D)34 static void dumpPreviousDeclImpl(raw_ostream &OS, const Mergeable<T> *D) {
35 const T *First = D->getFirstDecl();
36 if (First != D)
37 OS << " first " << First;
38 }
39
40 template <typename T>
dumpPreviousDeclImpl(raw_ostream & OS,const Redeclarable<T> * D)41 static void dumpPreviousDeclImpl(raw_ostream &OS, const Redeclarable<T> *D) {
42 const T *Prev = D->getPreviousDecl();
43 if (Prev)
44 OS << " prev " << Prev;
45 }
46
47 /// Dump the previous declaration in the redeclaration chain for a declaration,
48 /// if any.
dumpPreviousDecl(raw_ostream & OS,const Decl * D)49 static void dumpPreviousDecl(raw_ostream &OS, const Decl *D) {
50 switch (D->getKind()) {
51 #define DECL(DERIVED, BASE) \
52 case Decl::DERIVED: \
53 return dumpPreviousDeclImpl(OS, cast<DERIVED##Decl>(D));
54 #define ABSTRACT_DECL(DECL)
55 #include "clang/AST/DeclNodes.inc"
56 }
57 llvm_unreachable("Decl that isn't part of DeclNodes.inc!");
58 }
59
TextNodeDumper(raw_ostream & OS,const ASTContext & Context,bool ShowColors)60 TextNodeDumper::TextNodeDumper(raw_ostream &OS, const ASTContext &Context,
61 bool ShowColors)
62 : TextTreeStructure(OS, ShowColors), OS(OS), ShowColors(ShowColors),
63 Context(&Context), SM(&Context.getSourceManager()),
64 PrintPolicy(Context.getPrintingPolicy()),
65 Traits(&Context.getCommentCommandTraits()) {}
66
TextNodeDumper(raw_ostream & OS,bool ShowColors)67 TextNodeDumper::TextNodeDumper(raw_ostream &OS, bool ShowColors)
68 : TextTreeStructure(OS, ShowColors), OS(OS), ShowColors(ShowColors) {}
69
Visit(const comments::Comment * C,const comments::FullComment * FC)70 void TextNodeDumper::Visit(const comments::Comment *C,
71 const comments::FullComment *FC) {
72 if (!C) {
73 ColorScope Color(OS, ShowColors, NullColor);
74 OS << "<<<NULL>>>";
75 return;
76 }
77
78 {
79 ColorScope Color(OS, ShowColors, CommentColor);
80 OS << C->getCommentKindName();
81 }
82 dumpPointer(C);
83 dumpSourceRange(C->getSourceRange());
84
85 ConstCommentVisitor<TextNodeDumper, void,
86 const comments::FullComment *>::visit(C, FC);
87 }
88
Visit(const Attr * A)89 void TextNodeDumper::Visit(const Attr *A) {
90 {
91 ColorScope Color(OS, ShowColors, AttrColor);
92
93 switch (A->getKind()) {
94 #define ATTR(X) \
95 case attr::X: \
96 OS << #X; \
97 break;
98 #include "clang/Basic/AttrList.inc"
99 }
100 OS << "Attr";
101 }
102 dumpPointer(A);
103 dumpSourceRange(A->getRange());
104 if (A->isInherited())
105 OS << " Inherited";
106 if (A->isImplicit())
107 OS << " Implicit";
108
109 ConstAttrVisitor<TextNodeDumper>::Visit(A);
110 }
111
Visit(const TemplateArgument & TA,SourceRange R,const Decl * From,StringRef Label)112 void TextNodeDumper::Visit(const TemplateArgument &TA, SourceRange R,
113 const Decl *From, StringRef Label) {
114 OS << "TemplateArgument";
115 if (R.isValid())
116 dumpSourceRange(R);
117
118 if (From)
119 dumpDeclRef(From, Label);
120
121 ConstTemplateArgumentVisitor<TextNodeDumper>::Visit(TA);
122 }
123
Visit(const Stmt * Node)124 void TextNodeDumper::Visit(const Stmt *Node) {
125 if (!Node) {
126 ColorScope Color(OS, ShowColors, NullColor);
127 OS << "<<<NULL>>>";
128 return;
129 }
130 {
131 ColorScope Color(OS, ShowColors, StmtColor);
132 OS << Node->getStmtClassName();
133 }
134 dumpPointer(Node);
135 dumpSourceRange(Node->getSourceRange());
136
137 if (const auto *E = dyn_cast<Expr>(Node)) {
138 dumpType(E->getType());
139
140 if (E->containsErrors()) {
141 ColorScope Color(OS, ShowColors, ErrorsColor);
142 OS << " contains-errors";
143 }
144
145 {
146 ColorScope Color(OS, ShowColors, ValueKindColor);
147 switch (E->getValueKind()) {
148 case VK_PRValue:
149 break;
150 case VK_LValue:
151 OS << " lvalue";
152 break;
153 case VK_XValue:
154 OS << " xvalue";
155 break;
156 }
157 }
158
159 {
160 ColorScope Color(OS, ShowColors, ObjectKindColor);
161 switch (E->getObjectKind()) {
162 case OK_Ordinary:
163 break;
164 case OK_BitField:
165 OS << " bitfield";
166 break;
167 case OK_ObjCProperty:
168 OS << " objcproperty";
169 break;
170 case OK_ObjCSubscript:
171 OS << " objcsubscript";
172 break;
173 case OK_VectorComponent:
174 OS << " vectorcomponent";
175 break;
176 case OK_MatrixComponent:
177 OS << " matrixcomponent";
178 break;
179 }
180 }
181 }
182
183 ConstStmtVisitor<TextNodeDumper>::Visit(Node);
184 }
185
Visit(const Type * T)186 void TextNodeDumper::Visit(const Type *T) {
187 if (!T) {
188 ColorScope Color(OS, ShowColors, NullColor);
189 OS << "<<<NULL>>>";
190 return;
191 }
192 if (isa<LocInfoType>(T)) {
193 {
194 ColorScope Color(OS, ShowColors, TypeColor);
195 OS << "LocInfo Type";
196 }
197 dumpPointer(T);
198 return;
199 }
200
201 {
202 ColorScope Color(OS, ShowColors, TypeColor);
203 OS << T->getTypeClassName() << "Type";
204 }
205 dumpPointer(T);
206 OS << " ";
207 dumpBareType(QualType(T, 0), false);
208
209 QualType SingleStepDesugar =
210 T->getLocallyUnqualifiedSingleStepDesugaredType();
211 if (SingleStepDesugar != QualType(T, 0))
212 OS << " sugar";
213
214 if (T->containsErrors()) {
215 ColorScope Color(OS, ShowColors, ErrorsColor);
216 OS << " contains-errors";
217 }
218
219 if (T->isDependentType())
220 OS << " dependent";
221 else if (T->isInstantiationDependentType())
222 OS << " instantiation_dependent";
223
224 if (T->isVariablyModifiedType())
225 OS << " variably_modified";
226 if (T->containsUnexpandedParameterPack())
227 OS << " contains_unexpanded_pack";
228 if (T->isFromAST())
229 OS << " imported";
230
231 TypeVisitor<TextNodeDumper>::Visit(T);
232 }
233
Visit(QualType T)234 void TextNodeDumper::Visit(QualType T) {
235 OS << "QualType";
236 dumpPointer(T.getAsOpaquePtr());
237 OS << " ";
238 dumpBareType(T, false);
239 OS << " " << T.split().Quals.getAsString();
240 }
241
Visit(const Decl * D)242 void TextNodeDumper::Visit(const Decl *D) {
243 if (!D) {
244 ColorScope Color(OS, ShowColors, NullColor);
245 OS << "<<<NULL>>>";
246 return;
247 }
248
249 {
250 ColorScope Color(OS, ShowColors, DeclKindNameColor);
251 OS << D->getDeclKindName() << "Decl";
252 }
253 dumpPointer(D);
254 if (D->getLexicalDeclContext() != D->getDeclContext())
255 OS << " parent " << cast<Decl>(D->getDeclContext());
256 dumpPreviousDecl(OS, D);
257 dumpSourceRange(D->getSourceRange());
258 OS << ' ';
259 dumpLocation(D->getLocation());
260 if (D->isFromASTFile())
261 OS << " imported";
262 if (Module *M = D->getOwningModule())
263 OS << " in " << M->getFullModuleName();
264 if (auto *ND = dyn_cast<NamedDecl>(D))
265 for (Module *M : D->getASTContext().getModulesWithMergedDefinition(
266 const_cast<NamedDecl *>(ND)))
267 AddChild([=] { OS << "also in " << M->getFullModuleName(); });
268 if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
269 if (!ND->isUnconditionallyVisible())
270 OS << " hidden";
271 if (D->isImplicit())
272 OS << " implicit";
273
274 if (D->isUsed())
275 OS << " used";
276 else if (D->isThisDeclarationReferenced())
277 OS << " referenced";
278
279 if (D->isInvalidDecl())
280 OS << " invalid";
281 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
282 if (FD->isConstexprSpecified())
283 OS << " constexpr";
284 if (FD->isConsteval())
285 OS << " consteval";
286 }
287
288 if (!isa<FunctionDecl>(*D)) {
289 const auto *MD = dyn_cast<ObjCMethodDecl>(D);
290 if (!MD || !MD->isThisDeclarationADefinition()) {
291 const auto *DC = dyn_cast<DeclContext>(D);
292 if (DC && DC->hasExternalLexicalStorage()) {
293 ColorScope Color(OS, ShowColors, UndeserializedColor);
294 OS << " <undeserialized declarations>";
295 }
296 }
297 }
298
299 ConstDeclVisitor<TextNodeDumper>::Visit(D);
300 }
301
Visit(const CXXCtorInitializer * Init)302 void TextNodeDumper::Visit(const CXXCtorInitializer *Init) {
303 OS << "CXXCtorInitializer";
304 if (Init->isAnyMemberInitializer()) {
305 OS << ' ';
306 dumpBareDeclRef(Init->getAnyMember());
307 } else if (Init->isBaseInitializer()) {
308 dumpType(QualType(Init->getBaseClass(), 0));
309 } else if (Init->isDelegatingInitializer()) {
310 dumpType(Init->getTypeSourceInfo()->getType());
311 } else {
312 llvm_unreachable("Unknown initializer type");
313 }
314 }
315
Visit(const BlockDecl::Capture & C)316 void TextNodeDumper::Visit(const BlockDecl::Capture &C) {
317 OS << "capture";
318 if (C.isByRef())
319 OS << " byref";
320 if (C.isNested())
321 OS << " nested";
322 if (C.getVariable()) {
323 OS << ' ';
324 dumpBareDeclRef(C.getVariable());
325 }
326 }
327
Visit(const OMPClause * C)328 void TextNodeDumper::Visit(const OMPClause *C) {
329 if (!C) {
330 ColorScope Color(OS, ShowColors, NullColor);
331 OS << "<<<NULL>>> OMPClause";
332 return;
333 }
334 {
335 ColorScope Color(OS, ShowColors, AttrColor);
336 StringRef ClauseName(llvm::omp::getOpenMPClauseName(C->getClauseKind()));
337 OS << "OMP" << ClauseName.substr(/*Start=*/0, /*N=*/1).upper()
338 << ClauseName.drop_front() << "Clause";
339 }
340 dumpPointer(C);
341 dumpSourceRange(SourceRange(C->getBeginLoc(), C->getEndLoc()));
342 if (C->isImplicit())
343 OS << " <implicit>";
344 }
345
Visit(const GenericSelectionExpr::ConstAssociation & A)346 void TextNodeDumper::Visit(const GenericSelectionExpr::ConstAssociation &A) {
347 const TypeSourceInfo *TSI = A.getTypeSourceInfo();
348 if (TSI) {
349 OS << "case ";
350 dumpType(TSI->getType());
351 } else {
352 OS << "default";
353 }
354
355 if (A.isSelected())
356 OS << " selected";
357 }
358
Visit(const concepts::Requirement * R)359 void TextNodeDumper::Visit(const concepts::Requirement *R) {
360 if (!R) {
361 ColorScope Color(OS, ShowColors, NullColor);
362 OS << "<<<NULL>>> Requirement";
363 return;
364 }
365
366 {
367 ColorScope Color(OS, ShowColors, StmtColor);
368 switch (R->getKind()) {
369 case concepts::Requirement::RK_Type:
370 OS << "TypeRequirement";
371 break;
372 case concepts::Requirement::RK_Simple:
373 OS << "SimpleRequirement";
374 break;
375 case concepts::Requirement::RK_Compound:
376 OS << "CompoundRequirement";
377 break;
378 case concepts::Requirement::RK_Nested:
379 OS << "NestedRequirement";
380 break;
381 }
382 }
383
384 dumpPointer(R);
385
386 if (auto *ER = dyn_cast<concepts::ExprRequirement>(R)) {
387 if (ER->hasNoexceptRequirement())
388 OS << " noexcept";
389 }
390
391 if (R->isDependent())
392 OS << " dependent";
393 else
394 OS << (R->isSatisfied() ? " satisfied" : " unsatisfied");
395 if (R->containsUnexpandedParameterPack())
396 OS << " contains_unexpanded_pack";
397 }
398
GetApproxValue(const llvm::APFloat & F)399 static double GetApproxValue(const llvm::APFloat &F) {
400 llvm::APFloat V = F;
401 bool ignored;
402 V.convert(llvm::APFloat::IEEEdouble(), llvm::APFloat::rmNearestTiesToEven,
403 &ignored);
404 return V.convertToDouble();
405 }
406
407 /// True if the \p APValue \p Value can be folded onto the current line.
isSimpleAPValue(const APValue & Value)408 static bool isSimpleAPValue(const APValue &Value) {
409 switch (Value.getKind()) {
410 case APValue::None:
411 case APValue::Indeterminate:
412 case APValue::Int:
413 case APValue::Float:
414 case APValue::FixedPoint:
415 case APValue::ComplexInt:
416 case APValue::ComplexFloat:
417 case APValue::LValue:
418 case APValue::MemberPointer:
419 case APValue::AddrLabelDiff:
420 return true;
421 case APValue::Vector:
422 case APValue::Array:
423 case APValue::Struct:
424 return false;
425 case APValue::Union:
426 return isSimpleAPValue(Value.getUnionValue());
427 }
428 llvm_unreachable("unexpected APValue kind!");
429 }
430
431 /// Dump the children of the \p APValue \p Value.
432 ///
433 /// \param[in] Value The \p APValue to visit
434 /// \param[in] Ty The \p QualType passed to \p Visit
435 ///
436 /// \param[in] IdxToChildFun A function mapping an \p APValue and an index
437 /// to one of the child of the \p APValue
438 ///
439 /// \param[in] NumChildren \p IdxToChildFun will be called on \p Value with
440 /// the indices in the range \p [0,NumChildren(
441 ///
442 /// \param[in] LabelSingular The label to use on a line with a single child
443 /// \param[in] LabelPlurial The label to use on a line with multiple children
dumpAPValueChildren(const APValue & Value,QualType Ty,const APValue & (* IdxToChildFun)(const APValue &,unsigned),unsigned NumChildren,StringRef LabelSingular,StringRef LabelPlurial)444 void TextNodeDumper::dumpAPValueChildren(
445 const APValue &Value, QualType Ty,
446 const APValue &(*IdxToChildFun)(const APValue &, unsigned),
447 unsigned NumChildren, StringRef LabelSingular, StringRef LabelPlurial) {
448 // To save some vertical space we print up to MaxChildrenPerLine APValues
449 // considered to be simple (by isSimpleAPValue) on a single line.
450 constexpr unsigned MaxChildrenPerLine = 4;
451 unsigned I = 0;
452 while (I < NumChildren) {
453 unsigned J = I;
454 while (J < NumChildren) {
455 if (isSimpleAPValue(IdxToChildFun(Value, J)) &&
456 (J - I < MaxChildrenPerLine)) {
457 ++J;
458 continue;
459 }
460 break;
461 }
462
463 J = std::max(I + 1, J);
464
465 // Print [I,J) on a single line.
466 AddChild(J - I > 1 ? LabelPlurial : LabelSingular, [=]() {
467 for (unsigned X = I; X < J; ++X) {
468 Visit(IdxToChildFun(Value, X), Ty);
469 if (X + 1 != J)
470 OS << ", ";
471 }
472 });
473 I = J;
474 }
475 }
476
Visit(const APValue & Value,QualType Ty)477 void TextNodeDumper::Visit(const APValue &Value, QualType Ty) {
478 ColorScope Color(OS, ShowColors, ValueKindColor);
479 switch (Value.getKind()) {
480 case APValue::None:
481 OS << "None";
482 return;
483 case APValue::Indeterminate:
484 OS << "Indeterminate";
485 return;
486 case APValue::Int:
487 OS << "Int ";
488 {
489 ColorScope Color(OS, ShowColors, ValueColor);
490 OS << Value.getInt();
491 }
492 return;
493 case APValue::Float:
494 OS << "Float ";
495 {
496 ColorScope Color(OS, ShowColors, ValueColor);
497 OS << GetApproxValue(Value.getFloat());
498 }
499 return;
500 case APValue::FixedPoint:
501 OS << "FixedPoint ";
502 {
503 ColorScope Color(OS, ShowColors, ValueColor);
504 OS << Value.getFixedPoint();
505 }
506 return;
507 case APValue::Vector: {
508 unsigned VectorLength = Value.getVectorLength();
509 OS << "Vector length=" << VectorLength;
510
511 dumpAPValueChildren(
512 Value, Ty,
513 [](const APValue &Value, unsigned Index) -> const APValue & {
514 return Value.getVectorElt(Index);
515 },
516 VectorLength, "element", "elements");
517 return;
518 }
519 case APValue::ComplexInt:
520 OS << "ComplexInt ";
521 {
522 ColorScope Color(OS, ShowColors, ValueColor);
523 OS << Value.getComplexIntReal() << " + " << Value.getComplexIntImag()
524 << 'i';
525 }
526 return;
527 case APValue::ComplexFloat:
528 OS << "ComplexFloat ";
529 {
530 ColorScope Color(OS, ShowColors, ValueColor);
531 OS << GetApproxValue(Value.getComplexFloatReal()) << " + "
532 << GetApproxValue(Value.getComplexFloatImag()) << 'i';
533 }
534 return;
535 case APValue::LValue:
536 (void)Context;
537 OS << "LValue <todo>";
538 return;
539 case APValue::Array: {
540 unsigned ArraySize = Value.getArraySize();
541 unsigned NumInitializedElements = Value.getArrayInitializedElts();
542 OS << "Array size=" << ArraySize;
543
544 dumpAPValueChildren(
545 Value, Ty,
546 [](const APValue &Value, unsigned Index) -> const APValue & {
547 return Value.getArrayInitializedElt(Index);
548 },
549 NumInitializedElements, "element", "elements");
550
551 if (Value.hasArrayFiller()) {
552 AddChild("filler", [=] {
553 {
554 ColorScope Color(OS, ShowColors, ValueColor);
555 OS << ArraySize - NumInitializedElements << " x ";
556 }
557 Visit(Value.getArrayFiller(), Ty);
558 });
559 }
560
561 return;
562 }
563 case APValue::Struct: {
564 OS << "Struct";
565
566 dumpAPValueChildren(
567 Value, Ty,
568 [](const APValue &Value, unsigned Index) -> const APValue & {
569 return Value.getStructBase(Index);
570 },
571 Value.getStructNumBases(), "base", "bases");
572
573 dumpAPValueChildren(
574 Value, Ty,
575 [](const APValue &Value, unsigned Index) -> const APValue & {
576 return Value.getStructField(Index);
577 },
578 Value.getStructNumFields(), "field", "fields");
579
580 return;
581 }
582 case APValue::Union: {
583 OS << "Union";
584 {
585 ColorScope Color(OS, ShowColors, ValueColor);
586 if (const FieldDecl *FD = Value.getUnionField())
587 OS << " ." << *cast<NamedDecl>(FD);
588 }
589 // If the union value is considered to be simple, fold it into the
590 // current line to save some vertical space.
591 const APValue &UnionValue = Value.getUnionValue();
592 if (isSimpleAPValue(UnionValue)) {
593 OS << ' ';
594 Visit(UnionValue, Ty);
595 } else {
596 AddChild([=] { Visit(UnionValue, Ty); });
597 }
598
599 return;
600 }
601 case APValue::MemberPointer:
602 OS << "MemberPointer <todo>";
603 return;
604 case APValue::AddrLabelDiff:
605 OS << "AddrLabelDiff <todo>";
606 return;
607 }
608 llvm_unreachable("Unknown APValue kind!");
609 }
610
dumpPointer(const void * Ptr)611 void TextNodeDumper::dumpPointer(const void *Ptr) {
612 ColorScope Color(OS, ShowColors, AddressColor);
613 OS << ' ' << Ptr;
614 }
615
dumpLocation(SourceLocation Loc)616 void TextNodeDumper::dumpLocation(SourceLocation Loc) {
617 if (!SM)
618 return;
619
620 ColorScope Color(OS, ShowColors, LocationColor);
621 SourceLocation SpellingLoc = SM->getSpellingLoc(Loc);
622
623 // The general format we print out is filename:line:col, but we drop pieces
624 // that haven't changed since the last loc printed.
625 PresumedLoc PLoc = SM->getPresumedLoc(SpellingLoc);
626
627 if (PLoc.isInvalid()) {
628 OS << "<invalid sloc>";
629 return;
630 }
631
632 if (strcmp(PLoc.getFilename(), LastLocFilename) != 0) {
633 OS << PLoc.getFilename() << ':' << PLoc.getLine() << ':'
634 << PLoc.getColumn();
635 LastLocFilename = PLoc.getFilename();
636 LastLocLine = PLoc.getLine();
637 } else if (PLoc.getLine() != LastLocLine) {
638 OS << "line" << ':' << PLoc.getLine() << ':' << PLoc.getColumn();
639 LastLocLine = PLoc.getLine();
640 } else {
641 OS << "col" << ':' << PLoc.getColumn();
642 }
643 }
644
dumpSourceRange(SourceRange R)645 void TextNodeDumper::dumpSourceRange(SourceRange R) {
646 // Can't translate locations if a SourceManager isn't available.
647 if (!SM)
648 return;
649
650 OS << " <";
651 dumpLocation(R.getBegin());
652 if (R.getBegin() != R.getEnd()) {
653 OS << ", ";
654 dumpLocation(R.getEnd());
655 }
656 OS << ">";
657
658 // <t2.c:123:421[blah], t2.c:412:321>
659 }
660
dumpBareType(QualType T,bool Desugar)661 void TextNodeDumper::dumpBareType(QualType T, bool Desugar) {
662 ColorScope Color(OS, ShowColors, TypeColor);
663
664 SplitQualType T_split = T.split();
665 OS << "'" << QualType::getAsString(T_split, PrintPolicy) << "'";
666
667 if (Desugar && !T.isNull()) {
668 // If the type is sugared, also dump a (shallow) desugared type.
669 SplitQualType D_split = T.getSplitDesugaredType();
670 if (T_split != D_split)
671 OS << ":'" << QualType::getAsString(D_split, PrintPolicy) << "'";
672 }
673 }
674
dumpType(QualType T)675 void TextNodeDumper::dumpType(QualType T) {
676 OS << ' ';
677 dumpBareType(T);
678 }
679
dumpBareDeclRef(const Decl * D)680 void TextNodeDumper::dumpBareDeclRef(const Decl *D) {
681 if (!D) {
682 ColorScope Color(OS, ShowColors, NullColor);
683 OS << "<<<NULL>>>";
684 return;
685 }
686
687 {
688 ColorScope Color(OS, ShowColors, DeclKindNameColor);
689 OS << D->getDeclKindName();
690 }
691 dumpPointer(D);
692
693 if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
694 ColorScope Color(OS, ShowColors, DeclNameColor);
695 OS << " '" << ND->getDeclName() << '\'';
696 }
697
698 if (const ValueDecl *VD = dyn_cast<ValueDecl>(D))
699 dumpType(VD->getType());
700 }
701
dumpName(const NamedDecl * ND)702 void TextNodeDumper::dumpName(const NamedDecl *ND) {
703 if (ND->getDeclName()) {
704 ColorScope Color(OS, ShowColors, DeclNameColor);
705 OS << ' ' << ND->getDeclName();
706 }
707 }
708
dumpAccessSpecifier(AccessSpecifier AS)709 void TextNodeDumper::dumpAccessSpecifier(AccessSpecifier AS) {
710 const auto AccessSpelling = getAccessSpelling(AS);
711 if (AccessSpelling.empty())
712 return;
713 OS << AccessSpelling;
714 }
715
dumpCleanupObject(const ExprWithCleanups::CleanupObject & C)716 void TextNodeDumper::dumpCleanupObject(
717 const ExprWithCleanups::CleanupObject &C) {
718 if (auto *BD = C.dyn_cast<BlockDecl *>())
719 dumpDeclRef(BD, "cleanup");
720 else if (auto *CLE = C.dyn_cast<CompoundLiteralExpr *>())
721 AddChild([=] {
722 OS << "cleanup ";
723 {
724 ColorScope Color(OS, ShowColors, StmtColor);
725 OS << CLE->getStmtClassName();
726 }
727 dumpPointer(CLE);
728 });
729 else
730 llvm_unreachable("unexpected cleanup type");
731 }
732
dumpDeclRef(const Decl * D,StringRef Label)733 void TextNodeDumper::dumpDeclRef(const Decl *D, StringRef Label) {
734 if (!D)
735 return;
736
737 AddChild([=] {
738 if (!Label.empty())
739 OS << Label << ' ';
740 dumpBareDeclRef(D);
741 });
742 }
743
getCommandName(unsigned CommandID)744 const char *TextNodeDumper::getCommandName(unsigned CommandID) {
745 if (Traits)
746 return Traits->getCommandInfo(CommandID)->Name;
747 const comments::CommandInfo *Info =
748 comments::CommandTraits::getBuiltinCommandInfo(CommandID);
749 if (Info)
750 return Info->Name;
751 return "<not a builtin command>";
752 }
753
printFPOptions(FPOptionsOverride FPO)754 void TextNodeDumper::printFPOptions(FPOptionsOverride FPO) {
755 #define OPTION(NAME, TYPE, WIDTH, PREVIOUS) \
756 if (FPO.has##NAME##Override()) \
757 OS << " " #NAME "=" << FPO.get##NAME##Override();
758 #include "clang/Basic/FPOptions.def"
759 }
760
visitTextComment(const comments::TextComment * C,const comments::FullComment *)761 void TextNodeDumper::visitTextComment(const comments::TextComment *C,
762 const comments::FullComment *) {
763 OS << " Text=\"" << C->getText() << "\"";
764 }
765
visitInlineCommandComment(const comments::InlineCommandComment * C,const comments::FullComment *)766 void TextNodeDumper::visitInlineCommandComment(
767 const comments::InlineCommandComment *C, const comments::FullComment *) {
768 OS << " Name=\"" << getCommandName(C->getCommandID()) << "\"";
769 switch (C->getRenderKind()) {
770 case comments::InlineCommandComment::RenderNormal:
771 OS << " RenderNormal";
772 break;
773 case comments::InlineCommandComment::RenderBold:
774 OS << " RenderBold";
775 break;
776 case comments::InlineCommandComment::RenderMonospaced:
777 OS << " RenderMonospaced";
778 break;
779 case comments::InlineCommandComment::RenderEmphasized:
780 OS << " RenderEmphasized";
781 break;
782 case comments::InlineCommandComment::RenderAnchor:
783 OS << " RenderAnchor";
784 break;
785 }
786
787 for (unsigned i = 0, e = C->getNumArgs(); i != e; ++i)
788 OS << " Arg[" << i << "]=\"" << C->getArgText(i) << "\"";
789 }
790
visitHTMLStartTagComment(const comments::HTMLStartTagComment * C,const comments::FullComment *)791 void TextNodeDumper::visitHTMLStartTagComment(
792 const comments::HTMLStartTagComment *C, const comments::FullComment *) {
793 OS << " Name=\"" << C->getTagName() << "\"";
794 if (C->getNumAttrs() != 0) {
795 OS << " Attrs: ";
796 for (unsigned i = 0, e = C->getNumAttrs(); i != e; ++i) {
797 const comments::HTMLStartTagComment::Attribute &Attr = C->getAttr(i);
798 OS << " \"" << Attr.Name << "=\"" << Attr.Value << "\"";
799 }
800 }
801 if (C->isSelfClosing())
802 OS << " SelfClosing";
803 }
804
visitHTMLEndTagComment(const comments::HTMLEndTagComment * C,const comments::FullComment *)805 void TextNodeDumper::visitHTMLEndTagComment(
806 const comments::HTMLEndTagComment *C, const comments::FullComment *) {
807 OS << " Name=\"" << C->getTagName() << "\"";
808 }
809
visitBlockCommandComment(const comments::BlockCommandComment * C,const comments::FullComment *)810 void TextNodeDumper::visitBlockCommandComment(
811 const comments::BlockCommandComment *C, const comments::FullComment *) {
812 OS << " Name=\"" << getCommandName(C->getCommandID()) << "\"";
813 for (unsigned i = 0, e = C->getNumArgs(); i != e; ++i)
814 OS << " Arg[" << i << "]=\"" << C->getArgText(i) << "\"";
815 }
816
visitParamCommandComment(const comments::ParamCommandComment * C,const comments::FullComment * FC)817 void TextNodeDumper::visitParamCommandComment(
818 const comments::ParamCommandComment *C, const comments::FullComment *FC) {
819 OS << " "
820 << comments::ParamCommandComment::getDirectionAsString(C->getDirection());
821
822 if (C->isDirectionExplicit())
823 OS << " explicitly";
824 else
825 OS << " implicitly";
826
827 if (C->hasParamName()) {
828 if (C->isParamIndexValid())
829 OS << " Param=\"" << C->getParamName(FC) << "\"";
830 else
831 OS << " Param=\"" << C->getParamNameAsWritten() << "\"";
832 }
833
834 if (C->isParamIndexValid() && !C->isVarArgParam())
835 OS << " ParamIndex=" << C->getParamIndex();
836 }
837
visitTParamCommandComment(const comments::TParamCommandComment * C,const comments::FullComment * FC)838 void TextNodeDumper::visitTParamCommandComment(
839 const comments::TParamCommandComment *C, const comments::FullComment *FC) {
840 if (C->hasParamName()) {
841 if (C->isPositionValid())
842 OS << " Param=\"" << C->getParamName(FC) << "\"";
843 else
844 OS << " Param=\"" << C->getParamNameAsWritten() << "\"";
845 }
846
847 if (C->isPositionValid()) {
848 OS << " Position=<";
849 for (unsigned i = 0, e = C->getDepth(); i != e; ++i) {
850 OS << C->getIndex(i);
851 if (i != e - 1)
852 OS << ", ";
853 }
854 OS << ">";
855 }
856 }
857
visitVerbatimBlockComment(const comments::VerbatimBlockComment * C,const comments::FullComment *)858 void TextNodeDumper::visitVerbatimBlockComment(
859 const comments::VerbatimBlockComment *C, const comments::FullComment *) {
860 OS << " Name=\"" << getCommandName(C->getCommandID())
861 << "\""
862 " CloseName=\""
863 << C->getCloseName() << "\"";
864 }
865
visitVerbatimBlockLineComment(const comments::VerbatimBlockLineComment * C,const comments::FullComment *)866 void TextNodeDumper::visitVerbatimBlockLineComment(
867 const comments::VerbatimBlockLineComment *C,
868 const comments::FullComment *) {
869 OS << " Text=\"" << C->getText() << "\"";
870 }
871
visitVerbatimLineComment(const comments::VerbatimLineComment * C,const comments::FullComment *)872 void TextNodeDumper::visitVerbatimLineComment(
873 const comments::VerbatimLineComment *C, const comments::FullComment *) {
874 OS << " Text=\"" << C->getText() << "\"";
875 }
876
VisitNullTemplateArgument(const TemplateArgument &)877 void TextNodeDumper::VisitNullTemplateArgument(const TemplateArgument &) {
878 OS << " null";
879 }
880
VisitTypeTemplateArgument(const TemplateArgument & TA)881 void TextNodeDumper::VisitTypeTemplateArgument(const TemplateArgument &TA) {
882 OS << " type";
883 dumpType(TA.getAsType());
884 }
885
VisitDeclarationTemplateArgument(const TemplateArgument & TA)886 void TextNodeDumper::VisitDeclarationTemplateArgument(
887 const TemplateArgument &TA) {
888 OS << " decl";
889 dumpDeclRef(TA.getAsDecl());
890 }
891
VisitNullPtrTemplateArgument(const TemplateArgument &)892 void TextNodeDumper::VisitNullPtrTemplateArgument(const TemplateArgument &) {
893 OS << " nullptr";
894 }
895
VisitIntegralTemplateArgument(const TemplateArgument & TA)896 void TextNodeDumper::VisitIntegralTemplateArgument(const TemplateArgument &TA) {
897 OS << " integral " << TA.getAsIntegral();
898 }
899
VisitTemplateTemplateArgument(const TemplateArgument & TA)900 void TextNodeDumper::VisitTemplateTemplateArgument(const TemplateArgument &TA) {
901 OS << " template ";
902 TA.getAsTemplate().dump(OS);
903 }
904
VisitTemplateExpansionTemplateArgument(const TemplateArgument & TA)905 void TextNodeDumper::VisitTemplateExpansionTemplateArgument(
906 const TemplateArgument &TA) {
907 OS << " template expansion ";
908 TA.getAsTemplateOrTemplatePattern().dump(OS);
909 }
910
VisitExpressionTemplateArgument(const TemplateArgument &)911 void TextNodeDumper::VisitExpressionTemplateArgument(const TemplateArgument &) {
912 OS << " expr";
913 }
914
VisitPackTemplateArgument(const TemplateArgument &)915 void TextNodeDumper::VisitPackTemplateArgument(const TemplateArgument &) {
916 OS << " pack";
917 }
918
dumpBasePath(raw_ostream & OS,const CastExpr * Node)919 static void dumpBasePath(raw_ostream &OS, const CastExpr *Node) {
920 if (Node->path_empty())
921 return;
922
923 OS << " (";
924 bool First = true;
925 for (CastExpr::path_const_iterator I = Node->path_begin(),
926 E = Node->path_end();
927 I != E; ++I) {
928 const CXXBaseSpecifier *Base = *I;
929 if (!First)
930 OS << " -> ";
931
932 const auto *RD =
933 cast<CXXRecordDecl>(Base->getType()->castAs<RecordType>()->getDecl());
934
935 if (Base->isVirtual())
936 OS << "virtual ";
937 OS << RD->getName();
938 First = false;
939 }
940
941 OS << ')';
942 }
943
VisitIfStmt(const IfStmt * Node)944 void TextNodeDumper::VisitIfStmt(const IfStmt *Node) {
945 if (Node->hasInitStorage())
946 OS << " has_init";
947 if (Node->hasVarStorage())
948 OS << " has_var";
949 if (Node->hasElseStorage())
950 OS << " has_else";
951 if (Node->isConstexpr())
952 OS << " constexpr";
953 if (Node->isConsteval()) {
954 OS << " ";
955 if (Node->isNegatedConsteval())
956 OS << "!";
957 OS << "consteval";
958 }
959 }
960
VisitSwitchStmt(const SwitchStmt * Node)961 void TextNodeDumper::VisitSwitchStmt(const SwitchStmt *Node) {
962 if (Node->hasInitStorage())
963 OS << " has_init";
964 if (Node->hasVarStorage())
965 OS << " has_var";
966 }
967
VisitWhileStmt(const WhileStmt * Node)968 void TextNodeDumper::VisitWhileStmt(const WhileStmt *Node) {
969 if (Node->hasVarStorage())
970 OS << " has_var";
971 }
972
VisitLabelStmt(const LabelStmt * Node)973 void TextNodeDumper::VisitLabelStmt(const LabelStmt *Node) {
974 OS << " '" << Node->getName() << "'";
975 if (Node->isSideEntry())
976 OS << " side_entry";
977 }
978
VisitGotoStmt(const GotoStmt * Node)979 void TextNodeDumper::VisitGotoStmt(const GotoStmt *Node) {
980 OS << " '" << Node->getLabel()->getName() << "'";
981 dumpPointer(Node->getLabel());
982 }
983
VisitCaseStmt(const CaseStmt * Node)984 void TextNodeDumper::VisitCaseStmt(const CaseStmt *Node) {
985 if (Node->caseStmtIsGNURange())
986 OS << " gnu_range";
987 }
988
VisitConstantExpr(const ConstantExpr * Node)989 void TextNodeDumper::VisitConstantExpr(const ConstantExpr *Node) {
990 if (Node->hasAPValueResult())
991 AddChild("value",
992 [=] { Visit(Node->getAPValueResult(), Node->getType()); });
993 }
994
VisitCallExpr(const CallExpr * Node)995 void TextNodeDumper::VisitCallExpr(const CallExpr *Node) {
996 if (Node->usesADL())
997 OS << " adl";
998 if (Node->hasStoredFPFeatures())
999 printFPOptions(Node->getFPFeatures());
1000 }
1001
VisitCXXOperatorCallExpr(const CXXOperatorCallExpr * Node)1002 void TextNodeDumper::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *Node) {
1003 const char *OperatorSpelling = clang::getOperatorSpelling(Node->getOperator());
1004 if (OperatorSpelling)
1005 OS << " '" << OperatorSpelling << "'";
1006
1007 VisitCallExpr(Node);
1008 }
1009
VisitCastExpr(const CastExpr * Node)1010 void TextNodeDumper::VisitCastExpr(const CastExpr *Node) {
1011 OS << " <";
1012 {
1013 ColorScope Color(OS, ShowColors, CastColor);
1014 OS << Node->getCastKindName();
1015 }
1016 dumpBasePath(OS, Node);
1017 OS << ">";
1018 if (Node->hasStoredFPFeatures())
1019 printFPOptions(Node->getFPFeatures());
1020 }
1021
VisitImplicitCastExpr(const ImplicitCastExpr * Node)1022 void TextNodeDumper::VisitImplicitCastExpr(const ImplicitCastExpr *Node) {
1023 VisitCastExpr(Node);
1024 if (Node->isPartOfExplicitCast())
1025 OS << " part_of_explicit_cast";
1026 }
1027
VisitDeclRefExpr(const DeclRefExpr * Node)1028 void TextNodeDumper::VisitDeclRefExpr(const DeclRefExpr *Node) {
1029 OS << " ";
1030 dumpBareDeclRef(Node->getDecl());
1031 if (Node->getDecl() != Node->getFoundDecl()) {
1032 OS << " (";
1033 dumpBareDeclRef(Node->getFoundDecl());
1034 OS << ")";
1035 }
1036 switch (Node->isNonOdrUse()) {
1037 case NOUR_None: break;
1038 case NOUR_Unevaluated: OS << " non_odr_use_unevaluated"; break;
1039 case NOUR_Constant: OS << " non_odr_use_constant"; break;
1040 case NOUR_Discarded: OS << " non_odr_use_discarded"; break;
1041 }
1042 }
1043
VisitUnresolvedLookupExpr(const UnresolvedLookupExpr * Node)1044 void TextNodeDumper::VisitUnresolvedLookupExpr(
1045 const UnresolvedLookupExpr *Node) {
1046 OS << " (";
1047 if (!Node->requiresADL())
1048 OS << "no ";
1049 OS << "ADL) = '" << Node->getName() << '\'';
1050
1051 UnresolvedLookupExpr::decls_iterator I = Node->decls_begin(),
1052 E = Node->decls_end();
1053 if (I == E)
1054 OS << " empty";
1055 for (; I != E; ++I)
1056 dumpPointer(*I);
1057 }
1058
VisitObjCIvarRefExpr(const ObjCIvarRefExpr * Node)1059 void TextNodeDumper::VisitObjCIvarRefExpr(const ObjCIvarRefExpr *Node) {
1060 {
1061 ColorScope Color(OS, ShowColors, DeclKindNameColor);
1062 OS << " " << Node->getDecl()->getDeclKindName() << "Decl";
1063 }
1064 OS << "='" << *Node->getDecl() << "'";
1065 dumpPointer(Node->getDecl());
1066 if (Node->isFreeIvar())
1067 OS << " isFreeIvar";
1068 }
1069
VisitSYCLUniqueStableNameExpr(const SYCLUniqueStableNameExpr * Node)1070 void TextNodeDumper::VisitSYCLUniqueStableNameExpr(
1071 const SYCLUniqueStableNameExpr *Node) {
1072 dumpType(Node->getTypeSourceInfo()->getType());
1073 }
1074
VisitPredefinedExpr(const PredefinedExpr * Node)1075 void TextNodeDumper::VisitPredefinedExpr(const PredefinedExpr *Node) {
1076 OS << " " << PredefinedExpr::getIdentKindName(Node->getIdentKind());
1077 }
1078
VisitCharacterLiteral(const CharacterLiteral * Node)1079 void TextNodeDumper::VisitCharacterLiteral(const CharacterLiteral *Node) {
1080 ColorScope Color(OS, ShowColors, ValueColor);
1081 OS << " " << Node->getValue();
1082 }
1083
VisitIntegerLiteral(const IntegerLiteral * Node)1084 void TextNodeDumper::VisitIntegerLiteral(const IntegerLiteral *Node) {
1085 bool isSigned = Node->getType()->isSignedIntegerType();
1086 ColorScope Color(OS, ShowColors, ValueColor);
1087 OS << " " << toString(Node->getValue(), 10, isSigned);
1088 }
1089
VisitFixedPointLiteral(const FixedPointLiteral * Node)1090 void TextNodeDumper::VisitFixedPointLiteral(const FixedPointLiteral *Node) {
1091 ColorScope Color(OS, ShowColors, ValueColor);
1092 OS << " " << Node->getValueAsString(/*Radix=*/10);
1093 }
1094
VisitFloatingLiteral(const FloatingLiteral * Node)1095 void TextNodeDumper::VisitFloatingLiteral(const FloatingLiteral *Node) {
1096 ColorScope Color(OS, ShowColors, ValueColor);
1097 OS << " " << Node->getValueAsApproximateDouble();
1098 }
1099
VisitStringLiteral(const StringLiteral * Str)1100 void TextNodeDumper::VisitStringLiteral(const StringLiteral *Str) {
1101 ColorScope Color(OS, ShowColors, ValueColor);
1102 OS << " ";
1103 Str->outputString(OS);
1104 }
1105
VisitInitListExpr(const InitListExpr * ILE)1106 void TextNodeDumper::VisitInitListExpr(const InitListExpr *ILE) {
1107 if (auto *Field = ILE->getInitializedFieldInUnion()) {
1108 OS << " field ";
1109 dumpBareDeclRef(Field);
1110 }
1111 }
1112
VisitGenericSelectionExpr(const GenericSelectionExpr * E)1113 void TextNodeDumper::VisitGenericSelectionExpr(const GenericSelectionExpr *E) {
1114 if (E->isResultDependent())
1115 OS << " result_dependent";
1116 }
1117
VisitUnaryOperator(const UnaryOperator * Node)1118 void TextNodeDumper::VisitUnaryOperator(const UnaryOperator *Node) {
1119 OS << " " << (Node->isPostfix() ? "postfix" : "prefix") << " '"
1120 << UnaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
1121 if (!Node->canOverflow())
1122 OS << " cannot overflow";
1123 if (Node->hasStoredFPFeatures())
1124 printFPOptions(Node->getStoredFPFeatures());
1125 }
1126
VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr * Node)1127 void TextNodeDumper::VisitUnaryExprOrTypeTraitExpr(
1128 const UnaryExprOrTypeTraitExpr *Node) {
1129 OS << " " << getTraitSpelling(Node->getKind());
1130
1131 if (Node->isArgumentType())
1132 dumpType(Node->getArgumentType());
1133 }
1134
VisitMemberExpr(const MemberExpr * Node)1135 void TextNodeDumper::VisitMemberExpr(const MemberExpr *Node) {
1136 OS << " " << (Node->isArrow() ? "->" : ".") << *Node->getMemberDecl();
1137 dumpPointer(Node->getMemberDecl());
1138 switch (Node->isNonOdrUse()) {
1139 case NOUR_None: break;
1140 case NOUR_Unevaluated: OS << " non_odr_use_unevaluated"; break;
1141 case NOUR_Constant: OS << " non_odr_use_constant"; break;
1142 case NOUR_Discarded: OS << " non_odr_use_discarded"; break;
1143 }
1144 }
1145
VisitExtVectorElementExpr(const ExtVectorElementExpr * Node)1146 void TextNodeDumper::VisitExtVectorElementExpr(
1147 const ExtVectorElementExpr *Node) {
1148 OS << " " << Node->getAccessor().getNameStart();
1149 }
1150
VisitBinaryOperator(const BinaryOperator * Node)1151 void TextNodeDumper::VisitBinaryOperator(const BinaryOperator *Node) {
1152 OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
1153 if (Node->hasStoredFPFeatures())
1154 printFPOptions(Node->getStoredFPFeatures());
1155 }
1156
VisitCompoundAssignOperator(const CompoundAssignOperator * Node)1157 void TextNodeDumper::VisitCompoundAssignOperator(
1158 const CompoundAssignOperator *Node) {
1159 OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode())
1160 << "' ComputeLHSTy=";
1161 dumpBareType(Node->getComputationLHSType());
1162 OS << " ComputeResultTy=";
1163 dumpBareType(Node->getComputationResultType());
1164 if (Node->hasStoredFPFeatures())
1165 printFPOptions(Node->getStoredFPFeatures());
1166 }
1167
VisitAddrLabelExpr(const AddrLabelExpr * Node)1168 void TextNodeDumper::VisitAddrLabelExpr(const AddrLabelExpr *Node) {
1169 OS << " " << Node->getLabel()->getName();
1170 dumpPointer(Node->getLabel());
1171 }
1172
VisitCXXNamedCastExpr(const CXXNamedCastExpr * Node)1173 void TextNodeDumper::VisitCXXNamedCastExpr(const CXXNamedCastExpr *Node) {
1174 OS << " " << Node->getCastName() << "<"
1175 << Node->getTypeAsWritten().getAsString() << ">"
1176 << " <" << Node->getCastKindName();
1177 dumpBasePath(OS, Node);
1178 OS << ">";
1179 }
1180
VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr * Node)1181 void TextNodeDumper::VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *Node) {
1182 OS << " " << (Node->getValue() ? "true" : "false");
1183 }
1184
VisitCXXThisExpr(const CXXThisExpr * Node)1185 void TextNodeDumper::VisitCXXThisExpr(const CXXThisExpr *Node) {
1186 if (Node->isImplicit())
1187 OS << " implicit";
1188 OS << " this";
1189 }
1190
VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr * Node)1191 void TextNodeDumper::VisitCXXFunctionalCastExpr(
1192 const CXXFunctionalCastExpr *Node) {
1193 OS << " functional cast to " << Node->getTypeAsWritten().getAsString() << " <"
1194 << Node->getCastKindName() << ">";
1195 if (Node->hasStoredFPFeatures())
1196 printFPOptions(Node->getFPFeatures());
1197 }
1198
VisitCXXStaticCastExpr(const CXXStaticCastExpr * Node)1199 void TextNodeDumper::VisitCXXStaticCastExpr(const CXXStaticCastExpr *Node) {
1200 VisitCXXNamedCastExpr(Node);
1201 if (Node->hasStoredFPFeatures())
1202 printFPOptions(Node->getFPFeatures());
1203 }
1204
VisitCXXUnresolvedConstructExpr(const CXXUnresolvedConstructExpr * Node)1205 void TextNodeDumper::VisitCXXUnresolvedConstructExpr(
1206 const CXXUnresolvedConstructExpr *Node) {
1207 dumpType(Node->getTypeAsWritten());
1208 if (Node->isListInitialization())
1209 OS << " list";
1210 }
1211
VisitCXXConstructExpr(const CXXConstructExpr * Node)1212 void TextNodeDumper::VisitCXXConstructExpr(const CXXConstructExpr *Node) {
1213 CXXConstructorDecl *Ctor = Node->getConstructor();
1214 dumpType(Ctor->getType());
1215 if (Node->isElidable())
1216 OS << " elidable";
1217 if (Node->isListInitialization())
1218 OS << " list";
1219 if (Node->isStdInitListInitialization())
1220 OS << " std::initializer_list";
1221 if (Node->requiresZeroInitialization())
1222 OS << " zeroing";
1223 }
1224
VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr * Node)1225 void TextNodeDumper::VisitCXXBindTemporaryExpr(
1226 const CXXBindTemporaryExpr *Node) {
1227 OS << " (CXXTemporary";
1228 dumpPointer(Node);
1229 OS << ")";
1230 }
1231
VisitCXXNewExpr(const CXXNewExpr * Node)1232 void TextNodeDumper::VisitCXXNewExpr(const CXXNewExpr *Node) {
1233 if (Node->isGlobalNew())
1234 OS << " global";
1235 if (Node->isArray())
1236 OS << " array";
1237 if (Node->getOperatorNew()) {
1238 OS << ' ';
1239 dumpBareDeclRef(Node->getOperatorNew());
1240 }
1241 // We could dump the deallocation function used in case of error, but it's
1242 // usually not that interesting.
1243 }
1244
VisitCXXDeleteExpr(const CXXDeleteExpr * Node)1245 void TextNodeDumper::VisitCXXDeleteExpr(const CXXDeleteExpr *Node) {
1246 if (Node->isGlobalDelete())
1247 OS << " global";
1248 if (Node->isArrayForm())
1249 OS << " array";
1250 if (Node->getOperatorDelete()) {
1251 OS << ' ';
1252 dumpBareDeclRef(Node->getOperatorDelete());
1253 }
1254 }
1255
VisitTypeTraitExpr(const TypeTraitExpr * Node)1256 void TextNodeDumper::VisitTypeTraitExpr(const TypeTraitExpr *Node) {
1257 OS << " " << getTraitSpelling(Node->getTrait());
1258 }
1259
VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr * Node)1260 void TextNodeDumper::VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *Node) {
1261 OS << " " << getTraitSpelling(Node->getTrait());
1262 }
1263
VisitExpressionTraitExpr(const ExpressionTraitExpr * Node)1264 void TextNodeDumper::VisitExpressionTraitExpr(const ExpressionTraitExpr *Node) {
1265 OS << " " << getTraitSpelling(Node->getTrait());
1266 }
1267
VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr * Node)1268 void TextNodeDumper::VisitMaterializeTemporaryExpr(
1269 const MaterializeTemporaryExpr *Node) {
1270 if (const ValueDecl *VD = Node->getExtendingDecl()) {
1271 OS << " extended by ";
1272 dumpBareDeclRef(VD);
1273 }
1274 }
1275
VisitExprWithCleanups(const ExprWithCleanups * Node)1276 void TextNodeDumper::VisitExprWithCleanups(const ExprWithCleanups *Node) {
1277 for (unsigned i = 0, e = Node->getNumObjects(); i != e; ++i)
1278 dumpCleanupObject(Node->getObject(i));
1279 }
1280
VisitSizeOfPackExpr(const SizeOfPackExpr * Node)1281 void TextNodeDumper::VisitSizeOfPackExpr(const SizeOfPackExpr *Node) {
1282 dumpPointer(Node->getPack());
1283 dumpName(Node->getPack());
1284 }
1285
VisitCXXDependentScopeMemberExpr(const CXXDependentScopeMemberExpr * Node)1286 void TextNodeDumper::VisitCXXDependentScopeMemberExpr(
1287 const CXXDependentScopeMemberExpr *Node) {
1288 OS << " " << (Node->isArrow() ? "->" : ".") << Node->getMember();
1289 }
1290
VisitObjCMessageExpr(const ObjCMessageExpr * Node)1291 void TextNodeDumper::VisitObjCMessageExpr(const ObjCMessageExpr *Node) {
1292 OS << " selector=";
1293 Node->getSelector().print(OS);
1294 switch (Node->getReceiverKind()) {
1295 case ObjCMessageExpr::Instance:
1296 break;
1297
1298 case ObjCMessageExpr::Class:
1299 OS << " class=";
1300 dumpBareType(Node->getClassReceiver());
1301 break;
1302
1303 case ObjCMessageExpr::SuperInstance:
1304 OS << " super (instance)";
1305 break;
1306
1307 case ObjCMessageExpr::SuperClass:
1308 OS << " super (class)";
1309 break;
1310 }
1311 }
1312
VisitObjCBoxedExpr(const ObjCBoxedExpr * Node)1313 void TextNodeDumper::VisitObjCBoxedExpr(const ObjCBoxedExpr *Node) {
1314 if (auto *BoxingMethod = Node->getBoxingMethod()) {
1315 OS << " selector=";
1316 BoxingMethod->getSelector().print(OS);
1317 }
1318 }
1319
VisitObjCAtCatchStmt(const ObjCAtCatchStmt * Node)1320 void TextNodeDumper::VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node) {
1321 if (!Node->getCatchParamDecl())
1322 OS << " catch all";
1323 }
1324
VisitObjCEncodeExpr(const ObjCEncodeExpr * Node)1325 void TextNodeDumper::VisitObjCEncodeExpr(const ObjCEncodeExpr *Node) {
1326 dumpType(Node->getEncodedType());
1327 }
1328
VisitObjCSelectorExpr(const ObjCSelectorExpr * Node)1329 void TextNodeDumper::VisitObjCSelectorExpr(const ObjCSelectorExpr *Node) {
1330 OS << " ";
1331 Node->getSelector().print(OS);
1332 }
1333
VisitObjCProtocolExpr(const ObjCProtocolExpr * Node)1334 void TextNodeDumper::VisitObjCProtocolExpr(const ObjCProtocolExpr *Node) {
1335 OS << ' ' << *Node->getProtocol();
1336 }
1337
VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr * Node)1338 void TextNodeDumper::VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *Node) {
1339 if (Node->isImplicitProperty()) {
1340 OS << " Kind=MethodRef Getter=\"";
1341 if (Node->getImplicitPropertyGetter())
1342 Node->getImplicitPropertyGetter()->getSelector().print(OS);
1343 else
1344 OS << "(null)";
1345
1346 OS << "\" Setter=\"";
1347 if (ObjCMethodDecl *Setter = Node->getImplicitPropertySetter())
1348 Setter->getSelector().print(OS);
1349 else
1350 OS << "(null)";
1351 OS << "\"";
1352 } else {
1353 OS << " Kind=PropertyRef Property=\"" << *Node->getExplicitProperty()
1354 << '"';
1355 }
1356
1357 if (Node->isSuperReceiver())
1358 OS << " super";
1359
1360 OS << " Messaging=";
1361 if (Node->isMessagingGetter() && Node->isMessagingSetter())
1362 OS << "Getter&Setter";
1363 else if (Node->isMessagingGetter())
1364 OS << "Getter";
1365 else if (Node->isMessagingSetter())
1366 OS << "Setter";
1367 }
1368
VisitObjCSubscriptRefExpr(const ObjCSubscriptRefExpr * Node)1369 void TextNodeDumper::VisitObjCSubscriptRefExpr(
1370 const ObjCSubscriptRefExpr *Node) {
1371 if (Node->isArraySubscriptRefExpr())
1372 OS << " Kind=ArraySubscript GetterForArray=\"";
1373 else
1374 OS << " Kind=DictionarySubscript GetterForDictionary=\"";
1375 if (Node->getAtIndexMethodDecl())
1376 Node->getAtIndexMethodDecl()->getSelector().print(OS);
1377 else
1378 OS << "(null)";
1379
1380 if (Node->isArraySubscriptRefExpr())
1381 OS << "\" SetterForArray=\"";
1382 else
1383 OS << "\" SetterForDictionary=\"";
1384 if (Node->setAtIndexMethodDecl())
1385 Node->setAtIndexMethodDecl()->getSelector().print(OS);
1386 else
1387 OS << "(null)";
1388 }
1389
VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr * Node)1390 void TextNodeDumper::VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *Node) {
1391 OS << " " << (Node->getValue() ? "__objc_yes" : "__objc_no");
1392 }
1393
VisitOMPIteratorExpr(const OMPIteratorExpr * Node)1394 void TextNodeDumper::VisitOMPIteratorExpr(const OMPIteratorExpr *Node) {
1395 OS << " ";
1396 for (unsigned I = 0, E = Node->numOfIterators(); I < E; ++I) {
1397 Visit(Node->getIteratorDecl(I));
1398 OS << " = ";
1399 const OMPIteratorExpr::IteratorRange Range = Node->getIteratorRange(I);
1400 OS << " begin ";
1401 Visit(Range.Begin);
1402 OS << " end ";
1403 Visit(Range.End);
1404 if (Range.Step) {
1405 OS << " step ";
1406 Visit(Range.Step);
1407 }
1408 }
1409 }
1410
VisitConceptSpecializationExpr(const ConceptSpecializationExpr * Node)1411 void TextNodeDumper::VisitConceptSpecializationExpr(
1412 const ConceptSpecializationExpr *Node) {
1413 OS << " ";
1414 dumpBareDeclRef(Node->getFoundDecl());
1415 }
1416
VisitRequiresExpr(const RequiresExpr * Node)1417 void TextNodeDumper::VisitRequiresExpr(
1418 const RequiresExpr *Node) {
1419 if (!Node->isValueDependent())
1420 OS << (Node->isSatisfied() ? " satisfied" : " unsatisfied");
1421 }
1422
VisitRValueReferenceType(const ReferenceType * T)1423 void TextNodeDumper::VisitRValueReferenceType(const ReferenceType *T) {
1424 if (T->isSpelledAsLValue())
1425 OS << " written as lvalue reference";
1426 }
1427
VisitArrayType(const ArrayType * T)1428 void TextNodeDumper::VisitArrayType(const ArrayType *T) {
1429 switch (T->getSizeModifier()) {
1430 case ArrayType::Normal:
1431 break;
1432 case ArrayType::Static:
1433 OS << " static";
1434 break;
1435 case ArrayType::Star:
1436 OS << " *";
1437 break;
1438 }
1439 OS << " " << T->getIndexTypeQualifiers().getAsString();
1440 }
1441
VisitConstantArrayType(const ConstantArrayType * T)1442 void TextNodeDumper::VisitConstantArrayType(const ConstantArrayType *T) {
1443 OS << " " << T->getSize();
1444 VisitArrayType(T);
1445 }
1446
VisitVariableArrayType(const VariableArrayType * T)1447 void TextNodeDumper::VisitVariableArrayType(const VariableArrayType *T) {
1448 OS << " ";
1449 dumpSourceRange(T->getBracketsRange());
1450 VisitArrayType(T);
1451 }
1452
VisitDependentSizedArrayType(const DependentSizedArrayType * T)1453 void TextNodeDumper::VisitDependentSizedArrayType(
1454 const DependentSizedArrayType *T) {
1455 VisitArrayType(T);
1456 OS << " ";
1457 dumpSourceRange(T->getBracketsRange());
1458 }
1459
VisitDependentSizedExtVectorType(const DependentSizedExtVectorType * T)1460 void TextNodeDumper::VisitDependentSizedExtVectorType(
1461 const DependentSizedExtVectorType *T) {
1462 OS << " ";
1463 dumpLocation(T->getAttributeLoc());
1464 }
1465
VisitVectorType(const VectorType * T)1466 void TextNodeDumper::VisitVectorType(const VectorType *T) {
1467 switch (T->getVectorKind()) {
1468 case VectorType::GenericVector:
1469 break;
1470 case VectorType::AltiVecVector:
1471 OS << " altivec";
1472 break;
1473 case VectorType::AltiVecPixel:
1474 OS << " altivec pixel";
1475 break;
1476 case VectorType::AltiVecBool:
1477 OS << " altivec bool";
1478 break;
1479 case VectorType::NeonVector:
1480 OS << " neon";
1481 break;
1482 case VectorType::NeonPolyVector:
1483 OS << " neon poly";
1484 break;
1485 case VectorType::SveFixedLengthDataVector:
1486 OS << " fixed-length sve data vector";
1487 break;
1488 case VectorType::SveFixedLengthPredicateVector:
1489 OS << " fixed-length sve predicate vector";
1490 break;
1491 }
1492 OS << " " << T->getNumElements();
1493 }
1494
VisitFunctionType(const FunctionType * T)1495 void TextNodeDumper::VisitFunctionType(const FunctionType *T) {
1496 auto EI = T->getExtInfo();
1497 if (EI.getNoReturn())
1498 OS << " noreturn";
1499 if (EI.getProducesResult())
1500 OS << " produces_result";
1501 if (EI.getHasRegParm())
1502 OS << " regparm " << EI.getRegParm();
1503 OS << " " << FunctionType::getNameForCallConv(EI.getCC());
1504 }
1505
VisitFunctionProtoType(const FunctionProtoType * T)1506 void TextNodeDumper::VisitFunctionProtoType(const FunctionProtoType *T) {
1507 auto EPI = T->getExtProtoInfo();
1508 if (EPI.HasTrailingReturn)
1509 OS << " trailing_return";
1510 if (T->isConst())
1511 OS << " const";
1512 if (T->isVolatile())
1513 OS << " volatile";
1514 if (T->isRestrict())
1515 OS << " restrict";
1516 if (T->getExtProtoInfo().Variadic)
1517 OS << " variadic";
1518 switch (EPI.RefQualifier) {
1519 case RQ_None:
1520 break;
1521 case RQ_LValue:
1522 OS << " &";
1523 break;
1524 case RQ_RValue:
1525 OS << " &&";
1526 break;
1527 }
1528 // FIXME: Exception specification.
1529 // FIXME: Consumed parameters.
1530 VisitFunctionType(T);
1531 }
1532
VisitUnresolvedUsingType(const UnresolvedUsingType * T)1533 void TextNodeDumper::VisitUnresolvedUsingType(const UnresolvedUsingType *T) {
1534 dumpDeclRef(T->getDecl());
1535 }
1536
VisitTypedefType(const TypedefType * T)1537 void TextNodeDumper::VisitTypedefType(const TypedefType *T) {
1538 dumpDeclRef(T->getDecl());
1539 }
1540
VisitUnaryTransformType(const UnaryTransformType * T)1541 void TextNodeDumper::VisitUnaryTransformType(const UnaryTransformType *T) {
1542 switch (T->getUTTKind()) {
1543 case UnaryTransformType::EnumUnderlyingType:
1544 OS << " underlying_type";
1545 break;
1546 }
1547 }
1548
VisitTagType(const TagType * T)1549 void TextNodeDumper::VisitTagType(const TagType *T) {
1550 dumpDeclRef(T->getDecl());
1551 }
1552
VisitTemplateTypeParmType(const TemplateTypeParmType * T)1553 void TextNodeDumper::VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
1554 OS << " depth " << T->getDepth() << " index " << T->getIndex();
1555 if (T->isParameterPack())
1556 OS << " pack";
1557 dumpDeclRef(T->getDecl());
1558 }
1559
VisitAutoType(const AutoType * T)1560 void TextNodeDumper::VisitAutoType(const AutoType *T) {
1561 if (T->isDecltypeAuto())
1562 OS << " decltype(auto)";
1563 if (!T->isDeduced())
1564 OS << " undeduced";
1565 if (T->isConstrained()) {
1566 dumpDeclRef(T->getTypeConstraintConcept());
1567 for (const auto &Arg : T->getTypeConstraintArguments())
1568 VisitTemplateArgument(Arg);
1569 }
1570 }
1571
VisitTemplateSpecializationType(const TemplateSpecializationType * T)1572 void TextNodeDumper::VisitTemplateSpecializationType(
1573 const TemplateSpecializationType *T) {
1574 if (T->isTypeAlias())
1575 OS << " alias";
1576 OS << " ";
1577 T->getTemplateName().dump(OS);
1578 }
1579
VisitInjectedClassNameType(const InjectedClassNameType * T)1580 void TextNodeDumper::VisitInjectedClassNameType(
1581 const InjectedClassNameType *T) {
1582 dumpDeclRef(T->getDecl());
1583 }
1584
VisitObjCInterfaceType(const ObjCInterfaceType * T)1585 void TextNodeDumper::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
1586 dumpDeclRef(T->getDecl());
1587 }
1588
VisitPackExpansionType(const PackExpansionType * T)1589 void TextNodeDumper::VisitPackExpansionType(const PackExpansionType *T) {
1590 if (auto N = T->getNumExpansions())
1591 OS << " expansions " << *N;
1592 }
1593
VisitLabelDecl(const LabelDecl * D)1594 void TextNodeDumper::VisitLabelDecl(const LabelDecl *D) { dumpName(D); }
1595
VisitTypedefDecl(const TypedefDecl * D)1596 void TextNodeDumper::VisitTypedefDecl(const TypedefDecl *D) {
1597 dumpName(D);
1598 dumpType(D->getUnderlyingType());
1599 if (D->isModulePrivate())
1600 OS << " __module_private__";
1601 }
1602
VisitEnumDecl(const EnumDecl * D)1603 void TextNodeDumper::VisitEnumDecl(const EnumDecl *D) {
1604 if (D->isScoped()) {
1605 if (D->isScopedUsingClassTag())
1606 OS << " class";
1607 else
1608 OS << " struct";
1609 }
1610 dumpName(D);
1611 if (D->isModulePrivate())
1612 OS << " __module_private__";
1613 if (D->isFixed())
1614 dumpType(D->getIntegerType());
1615 }
1616
VisitRecordDecl(const RecordDecl * D)1617 void TextNodeDumper::VisitRecordDecl(const RecordDecl *D) {
1618 OS << ' ' << D->getKindName();
1619 dumpName(D);
1620 if (D->isModulePrivate())
1621 OS << " __module_private__";
1622 if (D->isCompleteDefinition())
1623 OS << " definition";
1624 }
1625
VisitEnumConstantDecl(const EnumConstantDecl * D)1626 void TextNodeDumper::VisitEnumConstantDecl(const EnumConstantDecl *D) {
1627 dumpName(D);
1628 dumpType(D->getType());
1629 }
1630
VisitIndirectFieldDecl(const IndirectFieldDecl * D)1631 void TextNodeDumper::VisitIndirectFieldDecl(const IndirectFieldDecl *D) {
1632 dumpName(D);
1633 dumpType(D->getType());
1634
1635 for (const auto *Child : D->chain())
1636 dumpDeclRef(Child);
1637 }
1638
VisitFunctionDecl(const FunctionDecl * D)1639 void TextNodeDumper::VisitFunctionDecl(const FunctionDecl *D) {
1640 dumpName(D);
1641 dumpType(D->getType());
1642
1643 StorageClass SC = D->getStorageClass();
1644 if (SC != SC_None)
1645 OS << ' ' << VarDecl::getStorageClassSpecifierString(SC);
1646 if (D->isInlineSpecified())
1647 OS << " inline";
1648 if (D->isVirtualAsWritten())
1649 OS << " virtual";
1650 if (D->isModulePrivate())
1651 OS << " __module_private__";
1652
1653 if (D->isPure())
1654 OS << " pure";
1655 if (D->isDefaulted()) {
1656 OS << " default";
1657 if (D->isDeleted())
1658 OS << "_delete";
1659 }
1660 if (D->isDeletedAsWritten())
1661 OS << " delete";
1662 if (D->isTrivial())
1663 OS << " trivial";
1664
1665 if (const auto *FPT = D->getType()->getAs<FunctionProtoType>()) {
1666 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
1667 switch (EPI.ExceptionSpec.Type) {
1668 default:
1669 break;
1670 case EST_Unevaluated:
1671 OS << " noexcept-unevaluated " << EPI.ExceptionSpec.SourceDecl;
1672 break;
1673 case EST_Uninstantiated:
1674 OS << " noexcept-uninstantiated " << EPI.ExceptionSpec.SourceTemplate;
1675 break;
1676 }
1677 }
1678
1679 if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
1680 if (MD->size_overridden_methods() != 0) {
1681 auto dumpOverride = [=](const CXXMethodDecl *D) {
1682 SplitQualType T_split = D->getType().split();
1683 OS << D << " " << D->getParent()->getName() << "::" << D->getDeclName()
1684 << " '" << QualType::getAsString(T_split, PrintPolicy) << "'";
1685 };
1686
1687 AddChild([=] {
1688 auto Overrides = MD->overridden_methods();
1689 OS << "Overrides: [ ";
1690 dumpOverride(*Overrides.begin());
1691 for (const auto *Override :
1692 llvm::make_range(Overrides.begin() + 1, Overrides.end())) {
1693 OS << ", ";
1694 dumpOverride(Override);
1695 }
1696 OS << " ]";
1697 });
1698 }
1699 }
1700
1701 // Since NumParams comes from the FunctionProtoType of the FunctionDecl and
1702 // the Params are set later, it is possible for a dump during debugging to
1703 // encounter a FunctionDecl that has been created but hasn't been assigned
1704 // ParmVarDecls yet.
1705 if (!D->param_empty() && !D->param_begin())
1706 OS << " <<<NULL params x " << D->getNumParams() << ">>>";
1707 }
1708
VisitLifetimeExtendedTemporaryDecl(const LifetimeExtendedTemporaryDecl * D)1709 void TextNodeDumper::VisitLifetimeExtendedTemporaryDecl(
1710 const LifetimeExtendedTemporaryDecl *D) {
1711 OS << " extended by ";
1712 dumpBareDeclRef(D->getExtendingDecl());
1713 OS << " mangling ";
1714 {
1715 ColorScope Color(OS, ShowColors, ValueColor);
1716 OS << D->getManglingNumber();
1717 }
1718 }
1719
VisitFieldDecl(const FieldDecl * D)1720 void TextNodeDumper::VisitFieldDecl(const FieldDecl *D) {
1721 dumpName(D);
1722 dumpType(D->getType());
1723 if (D->isMutable())
1724 OS << " mutable";
1725 if (D->isModulePrivate())
1726 OS << " __module_private__";
1727 }
1728
VisitVarDecl(const VarDecl * D)1729 void TextNodeDumper::VisitVarDecl(const VarDecl *D) {
1730 dumpName(D);
1731 dumpType(D->getType());
1732 StorageClass SC = D->getStorageClass();
1733 if (SC != SC_None)
1734 OS << ' ' << VarDecl::getStorageClassSpecifierString(SC);
1735 switch (D->getTLSKind()) {
1736 case VarDecl::TLS_None:
1737 break;
1738 case VarDecl::TLS_Static:
1739 OS << " tls";
1740 break;
1741 case VarDecl::TLS_Dynamic:
1742 OS << " tls_dynamic";
1743 break;
1744 }
1745 if (D->isModulePrivate())
1746 OS << " __module_private__";
1747 if (D->isNRVOVariable())
1748 OS << " nrvo";
1749 if (D->isInline())
1750 OS << " inline";
1751 if (D->isConstexpr())
1752 OS << " constexpr";
1753 if (D->hasInit()) {
1754 switch (D->getInitStyle()) {
1755 case VarDecl::CInit:
1756 OS << " cinit";
1757 break;
1758 case VarDecl::CallInit:
1759 OS << " callinit";
1760 break;
1761 case VarDecl::ListInit:
1762 OS << " listinit";
1763 break;
1764 }
1765 }
1766 if (D->needsDestruction(D->getASTContext()))
1767 OS << " destroyed";
1768 if (D->isParameterPack())
1769 OS << " pack";
1770
1771 if (D->hasInit()) {
1772 const Expr *E = D->getInit();
1773 // Only dump the value of constexpr VarDecls for now.
1774 if (E && !E->isValueDependent() && D->isConstexpr()) {
1775 const APValue *Value = D->evaluateValue();
1776 if (Value)
1777 AddChild("value", [=] { Visit(*Value, E->getType()); });
1778 }
1779 }
1780 }
1781
VisitBindingDecl(const BindingDecl * D)1782 void TextNodeDumper::VisitBindingDecl(const BindingDecl *D) {
1783 dumpName(D);
1784 dumpType(D->getType());
1785 }
1786
VisitCapturedDecl(const CapturedDecl * D)1787 void TextNodeDumper::VisitCapturedDecl(const CapturedDecl *D) {
1788 if (D->isNothrow())
1789 OS << " nothrow";
1790 }
1791
VisitImportDecl(const ImportDecl * D)1792 void TextNodeDumper::VisitImportDecl(const ImportDecl *D) {
1793 OS << ' ' << D->getImportedModule()->getFullModuleName();
1794
1795 for (Decl *InitD :
1796 D->getASTContext().getModuleInitializers(D->getImportedModule()))
1797 dumpDeclRef(InitD, "initializer");
1798 }
1799
VisitPragmaCommentDecl(const PragmaCommentDecl * D)1800 void TextNodeDumper::VisitPragmaCommentDecl(const PragmaCommentDecl *D) {
1801 OS << ' ';
1802 switch (D->getCommentKind()) {
1803 case PCK_Unknown:
1804 llvm_unreachable("unexpected pragma comment kind");
1805 case PCK_Compiler:
1806 OS << "compiler";
1807 break;
1808 case PCK_ExeStr:
1809 OS << "exestr";
1810 break;
1811 case PCK_Lib:
1812 OS << "lib";
1813 break;
1814 case PCK_Linker:
1815 OS << "linker";
1816 break;
1817 case PCK_User:
1818 OS << "user";
1819 break;
1820 }
1821 StringRef Arg = D->getArg();
1822 if (!Arg.empty())
1823 OS << " \"" << Arg << "\"";
1824 }
1825
VisitPragmaDetectMismatchDecl(const PragmaDetectMismatchDecl * D)1826 void TextNodeDumper::VisitPragmaDetectMismatchDecl(
1827 const PragmaDetectMismatchDecl *D) {
1828 OS << " \"" << D->getName() << "\" \"" << D->getValue() << "\"";
1829 }
1830
VisitOMPExecutableDirective(const OMPExecutableDirective * D)1831 void TextNodeDumper::VisitOMPExecutableDirective(
1832 const OMPExecutableDirective *D) {
1833 if (D->isStandaloneDirective())
1834 OS << " openmp_standalone_directive";
1835 }
1836
VisitOMPDeclareReductionDecl(const OMPDeclareReductionDecl * D)1837 void TextNodeDumper::VisitOMPDeclareReductionDecl(
1838 const OMPDeclareReductionDecl *D) {
1839 dumpName(D);
1840 dumpType(D->getType());
1841 OS << " combiner";
1842 dumpPointer(D->getCombiner());
1843 if (const auto *Initializer = D->getInitializer()) {
1844 OS << " initializer";
1845 dumpPointer(Initializer);
1846 switch (D->getInitializerKind()) {
1847 case OMPDeclareReductionDecl::DirectInit:
1848 OS << " omp_priv = ";
1849 break;
1850 case OMPDeclareReductionDecl::CopyInit:
1851 OS << " omp_priv ()";
1852 break;
1853 case OMPDeclareReductionDecl::CallInit:
1854 break;
1855 }
1856 }
1857 }
1858
VisitOMPRequiresDecl(const OMPRequiresDecl * D)1859 void TextNodeDumper::VisitOMPRequiresDecl(const OMPRequiresDecl *D) {
1860 for (const auto *C : D->clauselists()) {
1861 AddChild([=] {
1862 if (!C) {
1863 ColorScope Color(OS, ShowColors, NullColor);
1864 OS << "<<<NULL>>> OMPClause";
1865 return;
1866 }
1867 {
1868 ColorScope Color(OS, ShowColors, AttrColor);
1869 StringRef ClauseName(
1870 llvm::omp::getOpenMPClauseName(C->getClauseKind()));
1871 OS << "OMP" << ClauseName.substr(/*Start=*/0, /*N=*/1).upper()
1872 << ClauseName.drop_front() << "Clause";
1873 }
1874 dumpPointer(C);
1875 dumpSourceRange(SourceRange(C->getBeginLoc(), C->getEndLoc()));
1876 });
1877 }
1878 }
1879
VisitOMPCapturedExprDecl(const OMPCapturedExprDecl * D)1880 void TextNodeDumper::VisitOMPCapturedExprDecl(const OMPCapturedExprDecl *D) {
1881 dumpName(D);
1882 dumpType(D->getType());
1883 }
1884
VisitNamespaceDecl(const NamespaceDecl * D)1885 void TextNodeDumper::VisitNamespaceDecl(const NamespaceDecl *D) {
1886 dumpName(D);
1887 if (D->isInline())
1888 OS << " inline";
1889 if (!D->isOriginalNamespace())
1890 dumpDeclRef(D->getOriginalNamespace(), "original");
1891 }
1892
VisitUsingDirectiveDecl(const UsingDirectiveDecl * D)1893 void TextNodeDumper::VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
1894 OS << ' ';
1895 dumpBareDeclRef(D->getNominatedNamespace());
1896 }
1897
VisitNamespaceAliasDecl(const NamespaceAliasDecl * D)1898 void TextNodeDumper::VisitNamespaceAliasDecl(const NamespaceAliasDecl *D) {
1899 dumpName(D);
1900 dumpDeclRef(D->getAliasedNamespace());
1901 }
1902
VisitTypeAliasDecl(const TypeAliasDecl * D)1903 void TextNodeDumper::VisitTypeAliasDecl(const TypeAliasDecl *D) {
1904 dumpName(D);
1905 dumpType(D->getUnderlyingType());
1906 }
1907
VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl * D)1908 void TextNodeDumper::VisitTypeAliasTemplateDecl(
1909 const TypeAliasTemplateDecl *D) {
1910 dumpName(D);
1911 }
1912
VisitCXXRecordDecl(const CXXRecordDecl * D)1913 void TextNodeDumper::VisitCXXRecordDecl(const CXXRecordDecl *D) {
1914 VisitRecordDecl(D);
1915 if (!D->isCompleteDefinition())
1916 return;
1917
1918 AddChild([=] {
1919 {
1920 ColorScope Color(OS, ShowColors, DeclKindNameColor);
1921 OS << "DefinitionData";
1922 }
1923 #define FLAG(fn, name) \
1924 if (D->fn()) \
1925 OS << " " #name;
1926 FLAG(isParsingBaseSpecifiers, parsing_base_specifiers);
1927
1928 FLAG(isGenericLambda, generic);
1929 FLAG(isLambda, lambda);
1930
1931 FLAG(isAnonymousStructOrUnion, is_anonymous);
1932 FLAG(canPassInRegisters, pass_in_registers);
1933 FLAG(isEmpty, empty);
1934 FLAG(isAggregate, aggregate);
1935 FLAG(isStandardLayout, standard_layout);
1936 FLAG(isTriviallyCopyable, trivially_copyable);
1937 FLAG(isPOD, pod);
1938 FLAG(isTrivial, trivial);
1939 FLAG(isPolymorphic, polymorphic);
1940 FLAG(isAbstract, abstract);
1941 FLAG(isLiteral, literal);
1942
1943 FLAG(hasUserDeclaredConstructor, has_user_declared_ctor);
1944 FLAG(hasConstexprNonCopyMoveConstructor, has_constexpr_non_copy_move_ctor);
1945 FLAG(hasMutableFields, has_mutable_fields);
1946 FLAG(hasVariantMembers, has_variant_members);
1947 FLAG(allowConstDefaultInit, can_const_default_init);
1948
1949 AddChild([=] {
1950 {
1951 ColorScope Color(OS, ShowColors, DeclKindNameColor);
1952 OS << "DefaultConstructor";
1953 }
1954 FLAG(hasDefaultConstructor, exists);
1955 FLAG(hasTrivialDefaultConstructor, trivial);
1956 FLAG(hasNonTrivialDefaultConstructor, non_trivial);
1957 FLAG(hasUserProvidedDefaultConstructor, user_provided);
1958 FLAG(hasConstexprDefaultConstructor, constexpr);
1959 FLAG(needsImplicitDefaultConstructor, needs_implicit);
1960 FLAG(defaultedDefaultConstructorIsConstexpr, defaulted_is_constexpr);
1961 });
1962
1963 AddChild([=] {
1964 {
1965 ColorScope Color(OS, ShowColors, DeclKindNameColor);
1966 OS << "CopyConstructor";
1967 }
1968 FLAG(hasSimpleCopyConstructor, simple);
1969 FLAG(hasTrivialCopyConstructor, trivial);
1970 FLAG(hasNonTrivialCopyConstructor, non_trivial);
1971 FLAG(hasUserDeclaredCopyConstructor, user_declared);
1972 FLAG(hasCopyConstructorWithConstParam, has_const_param);
1973 FLAG(needsImplicitCopyConstructor, needs_implicit);
1974 FLAG(needsOverloadResolutionForCopyConstructor,
1975 needs_overload_resolution);
1976 if (!D->needsOverloadResolutionForCopyConstructor())
1977 FLAG(defaultedCopyConstructorIsDeleted, defaulted_is_deleted);
1978 FLAG(implicitCopyConstructorHasConstParam, implicit_has_const_param);
1979 });
1980
1981 AddChild([=] {
1982 {
1983 ColorScope Color(OS, ShowColors, DeclKindNameColor);
1984 OS << "MoveConstructor";
1985 }
1986 FLAG(hasMoveConstructor, exists);
1987 FLAG(hasSimpleMoveConstructor, simple);
1988 FLAG(hasTrivialMoveConstructor, trivial);
1989 FLAG(hasNonTrivialMoveConstructor, non_trivial);
1990 FLAG(hasUserDeclaredMoveConstructor, user_declared);
1991 FLAG(needsImplicitMoveConstructor, needs_implicit);
1992 FLAG(needsOverloadResolutionForMoveConstructor,
1993 needs_overload_resolution);
1994 if (!D->needsOverloadResolutionForMoveConstructor())
1995 FLAG(defaultedMoveConstructorIsDeleted, defaulted_is_deleted);
1996 });
1997
1998 AddChild([=] {
1999 {
2000 ColorScope Color(OS, ShowColors, DeclKindNameColor);
2001 OS << "CopyAssignment";
2002 }
2003 FLAG(hasSimpleCopyAssignment, simple);
2004 FLAG(hasTrivialCopyAssignment, trivial);
2005 FLAG(hasNonTrivialCopyAssignment, non_trivial);
2006 FLAG(hasCopyAssignmentWithConstParam, has_const_param);
2007 FLAG(hasUserDeclaredCopyAssignment, user_declared);
2008 FLAG(needsImplicitCopyAssignment, needs_implicit);
2009 FLAG(needsOverloadResolutionForCopyAssignment, needs_overload_resolution);
2010 FLAG(implicitCopyAssignmentHasConstParam, implicit_has_const_param);
2011 });
2012
2013 AddChild([=] {
2014 {
2015 ColorScope Color(OS, ShowColors, DeclKindNameColor);
2016 OS << "MoveAssignment";
2017 }
2018 FLAG(hasMoveAssignment, exists);
2019 FLAG(hasSimpleMoveAssignment, simple);
2020 FLAG(hasTrivialMoveAssignment, trivial);
2021 FLAG(hasNonTrivialMoveAssignment, non_trivial);
2022 FLAG(hasUserDeclaredMoveAssignment, user_declared);
2023 FLAG(needsImplicitMoveAssignment, needs_implicit);
2024 FLAG(needsOverloadResolutionForMoveAssignment, needs_overload_resolution);
2025 });
2026
2027 AddChild([=] {
2028 {
2029 ColorScope Color(OS, ShowColors, DeclKindNameColor);
2030 OS << "Destructor";
2031 }
2032 FLAG(hasSimpleDestructor, simple);
2033 FLAG(hasIrrelevantDestructor, irrelevant);
2034 FLAG(hasTrivialDestructor, trivial);
2035 FLAG(hasNonTrivialDestructor, non_trivial);
2036 FLAG(hasUserDeclaredDestructor, user_declared);
2037 FLAG(hasConstexprDestructor, constexpr);
2038 FLAG(needsImplicitDestructor, needs_implicit);
2039 FLAG(needsOverloadResolutionForDestructor, needs_overload_resolution);
2040 if (!D->needsOverloadResolutionForDestructor())
2041 FLAG(defaultedDestructorIsDeleted, defaulted_is_deleted);
2042 });
2043 });
2044
2045 for (const auto &I : D->bases()) {
2046 AddChild([=] {
2047 if (I.isVirtual())
2048 OS << "virtual ";
2049 dumpAccessSpecifier(I.getAccessSpecifier());
2050 dumpType(I.getType());
2051 if (I.isPackExpansion())
2052 OS << "...";
2053 });
2054 }
2055 }
2056
VisitFunctionTemplateDecl(const FunctionTemplateDecl * D)2057 void TextNodeDumper::VisitFunctionTemplateDecl(const FunctionTemplateDecl *D) {
2058 dumpName(D);
2059 }
2060
VisitClassTemplateDecl(const ClassTemplateDecl * D)2061 void TextNodeDumper::VisitClassTemplateDecl(const ClassTemplateDecl *D) {
2062 dumpName(D);
2063 }
2064
VisitVarTemplateDecl(const VarTemplateDecl * D)2065 void TextNodeDumper::VisitVarTemplateDecl(const VarTemplateDecl *D) {
2066 dumpName(D);
2067 }
2068
VisitBuiltinTemplateDecl(const BuiltinTemplateDecl * D)2069 void TextNodeDumper::VisitBuiltinTemplateDecl(const BuiltinTemplateDecl *D) {
2070 dumpName(D);
2071 }
2072
VisitTemplateTypeParmDecl(const TemplateTypeParmDecl * D)2073 void TextNodeDumper::VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) {
2074 if (const auto *TC = D->getTypeConstraint()) {
2075 OS << " ";
2076 dumpBareDeclRef(TC->getNamedConcept());
2077 if (TC->getNamedConcept() != TC->getFoundDecl()) {
2078 OS << " (";
2079 dumpBareDeclRef(TC->getFoundDecl());
2080 OS << ")";
2081 }
2082 } else if (D->wasDeclaredWithTypename())
2083 OS << " typename";
2084 else
2085 OS << " class";
2086 OS << " depth " << D->getDepth() << " index " << D->getIndex();
2087 if (D->isParameterPack())
2088 OS << " ...";
2089 dumpName(D);
2090 }
2091
VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl * D)2092 void TextNodeDumper::VisitNonTypeTemplateParmDecl(
2093 const NonTypeTemplateParmDecl *D) {
2094 dumpType(D->getType());
2095 OS << " depth " << D->getDepth() << " index " << D->getIndex();
2096 if (D->isParameterPack())
2097 OS << " ...";
2098 dumpName(D);
2099 }
2100
VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl * D)2101 void TextNodeDumper::VisitTemplateTemplateParmDecl(
2102 const TemplateTemplateParmDecl *D) {
2103 OS << " depth " << D->getDepth() << " index " << D->getIndex();
2104 if (D->isParameterPack())
2105 OS << " ...";
2106 dumpName(D);
2107 }
2108
VisitUsingDecl(const UsingDecl * D)2109 void TextNodeDumper::VisitUsingDecl(const UsingDecl *D) {
2110 OS << ' ';
2111 if (D->getQualifier())
2112 D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
2113 OS << D->getDeclName();
2114 }
2115
VisitUsingEnumDecl(const UsingEnumDecl * D)2116 void TextNodeDumper::VisitUsingEnumDecl(const UsingEnumDecl *D) {
2117 OS << ' ';
2118 dumpBareDeclRef(D->getEnumDecl());
2119 }
2120
VisitUnresolvedUsingTypenameDecl(const UnresolvedUsingTypenameDecl * D)2121 void TextNodeDumper::VisitUnresolvedUsingTypenameDecl(
2122 const UnresolvedUsingTypenameDecl *D) {
2123 OS << ' ';
2124 if (D->getQualifier())
2125 D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
2126 OS << D->getDeclName();
2127 }
2128
VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl * D)2129 void TextNodeDumper::VisitUnresolvedUsingValueDecl(
2130 const UnresolvedUsingValueDecl *D) {
2131 OS << ' ';
2132 if (D->getQualifier())
2133 D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
2134 OS << D->getDeclName();
2135 dumpType(D->getType());
2136 }
2137
VisitUsingShadowDecl(const UsingShadowDecl * D)2138 void TextNodeDumper::VisitUsingShadowDecl(const UsingShadowDecl *D) {
2139 OS << ' ';
2140 dumpBareDeclRef(D->getTargetDecl());
2141 }
2142
VisitConstructorUsingShadowDecl(const ConstructorUsingShadowDecl * D)2143 void TextNodeDumper::VisitConstructorUsingShadowDecl(
2144 const ConstructorUsingShadowDecl *D) {
2145 if (D->constructsVirtualBase())
2146 OS << " virtual";
2147
2148 AddChild([=] {
2149 OS << "target ";
2150 dumpBareDeclRef(D->getTargetDecl());
2151 });
2152
2153 AddChild([=] {
2154 OS << "nominated ";
2155 dumpBareDeclRef(D->getNominatedBaseClass());
2156 OS << ' ';
2157 dumpBareDeclRef(D->getNominatedBaseClassShadowDecl());
2158 });
2159
2160 AddChild([=] {
2161 OS << "constructed ";
2162 dumpBareDeclRef(D->getConstructedBaseClass());
2163 OS << ' ';
2164 dumpBareDeclRef(D->getConstructedBaseClassShadowDecl());
2165 });
2166 }
2167
VisitLinkageSpecDecl(const LinkageSpecDecl * D)2168 void TextNodeDumper::VisitLinkageSpecDecl(const LinkageSpecDecl *D) {
2169 switch (D->getLanguage()) {
2170 case LinkageSpecDecl::lang_c:
2171 OS << " C";
2172 break;
2173 case LinkageSpecDecl::lang_cxx:
2174 OS << " C++";
2175 break;
2176 }
2177 }
2178
VisitAccessSpecDecl(const AccessSpecDecl * D)2179 void TextNodeDumper::VisitAccessSpecDecl(const AccessSpecDecl *D) {
2180 OS << ' ';
2181 dumpAccessSpecifier(D->getAccess());
2182 }
2183
VisitFriendDecl(const FriendDecl * D)2184 void TextNodeDumper::VisitFriendDecl(const FriendDecl *D) {
2185 if (TypeSourceInfo *T = D->getFriendType())
2186 dumpType(T->getType());
2187 }
2188
VisitObjCIvarDecl(const ObjCIvarDecl * D)2189 void TextNodeDumper::VisitObjCIvarDecl(const ObjCIvarDecl *D) {
2190 dumpName(D);
2191 dumpType(D->getType());
2192 if (D->getSynthesize())
2193 OS << " synthesize";
2194
2195 switch (D->getAccessControl()) {
2196 case ObjCIvarDecl::None:
2197 OS << " none";
2198 break;
2199 case ObjCIvarDecl::Private:
2200 OS << " private";
2201 break;
2202 case ObjCIvarDecl::Protected:
2203 OS << " protected";
2204 break;
2205 case ObjCIvarDecl::Public:
2206 OS << " public";
2207 break;
2208 case ObjCIvarDecl::Package:
2209 OS << " package";
2210 break;
2211 }
2212 }
2213
VisitObjCMethodDecl(const ObjCMethodDecl * D)2214 void TextNodeDumper::VisitObjCMethodDecl(const ObjCMethodDecl *D) {
2215 if (D->isInstanceMethod())
2216 OS << " -";
2217 else
2218 OS << " +";
2219 dumpName(D);
2220 dumpType(D->getReturnType());
2221
2222 if (D->isVariadic())
2223 OS << " variadic";
2224 }
2225
VisitObjCTypeParamDecl(const ObjCTypeParamDecl * D)2226 void TextNodeDumper::VisitObjCTypeParamDecl(const ObjCTypeParamDecl *D) {
2227 dumpName(D);
2228 switch (D->getVariance()) {
2229 case ObjCTypeParamVariance::Invariant:
2230 break;
2231
2232 case ObjCTypeParamVariance::Covariant:
2233 OS << " covariant";
2234 break;
2235
2236 case ObjCTypeParamVariance::Contravariant:
2237 OS << " contravariant";
2238 break;
2239 }
2240
2241 if (D->hasExplicitBound())
2242 OS << " bounded";
2243 dumpType(D->getUnderlyingType());
2244 }
2245
VisitObjCCategoryDecl(const ObjCCategoryDecl * D)2246 void TextNodeDumper::VisitObjCCategoryDecl(const ObjCCategoryDecl *D) {
2247 dumpName(D);
2248 dumpDeclRef(D->getClassInterface());
2249 dumpDeclRef(D->getImplementation());
2250 for (const auto *P : D->protocols())
2251 dumpDeclRef(P);
2252 }
2253
VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl * D)2254 void TextNodeDumper::VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D) {
2255 dumpName(D);
2256 dumpDeclRef(D->getClassInterface());
2257 dumpDeclRef(D->getCategoryDecl());
2258 }
2259
VisitObjCProtocolDecl(const ObjCProtocolDecl * D)2260 void TextNodeDumper::VisitObjCProtocolDecl(const ObjCProtocolDecl *D) {
2261 dumpName(D);
2262
2263 for (const auto *Child : D->protocols())
2264 dumpDeclRef(Child);
2265 }
2266
VisitObjCInterfaceDecl(const ObjCInterfaceDecl * D)2267 void TextNodeDumper::VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) {
2268 dumpName(D);
2269 dumpDeclRef(D->getSuperClass(), "super");
2270
2271 dumpDeclRef(D->getImplementation());
2272 for (const auto *Child : D->protocols())
2273 dumpDeclRef(Child);
2274 }
2275
VisitObjCImplementationDecl(const ObjCImplementationDecl * D)2276 void TextNodeDumper::VisitObjCImplementationDecl(
2277 const ObjCImplementationDecl *D) {
2278 dumpName(D);
2279 dumpDeclRef(D->getSuperClass(), "super");
2280 dumpDeclRef(D->getClassInterface());
2281 }
2282
VisitObjCCompatibleAliasDecl(const ObjCCompatibleAliasDecl * D)2283 void TextNodeDumper::VisitObjCCompatibleAliasDecl(
2284 const ObjCCompatibleAliasDecl *D) {
2285 dumpName(D);
2286 dumpDeclRef(D->getClassInterface());
2287 }
2288
VisitObjCPropertyDecl(const ObjCPropertyDecl * D)2289 void TextNodeDumper::VisitObjCPropertyDecl(const ObjCPropertyDecl *D) {
2290 dumpName(D);
2291 dumpType(D->getType());
2292
2293 if (D->getPropertyImplementation() == ObjCPropertyDecl::Required)
2294 OS << " required";
2295 else if (D->getPropertyImplementation() == ObjCPropertyDecl::Optional)
2296 OS << " optional";
2297
2298 ObjCPropertyAttribute::Kind Attrs = D->getPropertyAttributes();
2299 if (Attrs != ObjCPropertyAttribute::kind_noattr) {
2300 if (Attrs & ObjCPropertyAttribute::kind_readonly)
2301 OS << " readonly";
2302 if (Attrs & ObjCPropertyAttribute::kind_assign)
2303 OS << " assign";
2304 if (Attrs & ObjCPropertyAttribute::kind_readwrite)
2305 OS << " readwrite";
2306 if (Attrs & ObjCPropertyAttribute::kind_retain)
2307 OS << " retain";
2308 if (Attrs & ObjCPropertyAttribute::kind_copy)
2309 OS << " copy";
2310 if (Attrs & ObjCPropertyAttribute::kind_nonatomic)
2311 OS << " nonatomic";
2312 if (Attrs & ObjCPropertyAttribute::kind_atomic)
2313 OS << " atomic";
2314 if (Attrs & ObjCPropertyAttribute::kind_weak)
2315 OS << " weak";
2316 if (Attrs & ObjCPropertyAttribute::kind_strong)
2317 OS << " strong";
2318 if (Attrs & ObjCPropertyAttribute::kind_unsafe_unretained)
2319 OS << " unsafe_unretained";
2320 if (Attrs & ObjCPropertyAttribute::kind_class)
2321 OS << " class";
2322 if (Attrs & ObjCPropertyAttribute::kind_direct)
2323 OS << " direct";
2324 if (Attrs & ObjCPropertyAttribute::kind_getter)
2325 dumpDeclRef(D->getGetterMethodDecl(), "getter");
2326 if (Attrs & ObjCPropertyAttribute::kind_setter)
2327 dumpDeclRef(D->getSetterMethodDecl(), "setter");
2328 }
2329 }
2330
VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl * D)2331 void TextNodeDumper::VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D) {
2332 dumpName(D->getPropertyDecl());
2333 if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize)
2334 OS << " synthesize";
2335 else
2336 OS << " dynamic";
2337 dumpDeclRef(D->getPropertyDecl());
2338 dumpDeclRef(D->getPropertyIvarDecl());
2339 }
2340
VisitBlockDecl(const BlockDecl * D)2341 void TextNodeDumper::VisitBlockDecl(const BlockDecl *D) {
2342 if (D->isVariadic())
2343 OS << " variadic";
2344
2345 if (D->capturesCXXThis())
2346 OS << " captures_this";
2347 }
2348
VisitConceptDecl(const ConceptDecl * D)2349 void TextNodeDumper::VisitConceptDecl(const ConceptDecl *D) {
2350 dumpName(D);
2351 }
2352