clang 10.0.0git

TextNodeDumper.cpp
Go to the documentation of this file.
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/DeclFriend.h"
15 #include "clang/AST/DeclOpenMP.h"
16 #include "clang/AST/DeclTemplate.h"
17 #include "clang/AST/LocInfoType.h"
18
19 using namespace clang;
20
21 static void dumpPreviousDeclImpl(raw_ostream &OS, ...) {}
22
23 template <typename T>
24 static void dumpPreviousDeclImpl(raw_ostream &OS, const Mergeable<T> *D) {
25 const T *First = D->getFirstDecl();
26 if (First != D)
27 OS << " first " << First;
28 }
29
30 template <typename T>
31 static void dumpPreviousDeclImpl(raw_ostream &OS, const Redeclarable<T> *D) {
32 const T *Prev = D->getPreviousDecl();
33 if (Prev)
34 OS << " prev " << Prev;
35 }
36
37 /// Dump the previous declaration in the redeclaration chain for a declaration,
38 /// if any.
39 static void dumpPreviousDecl(raw_ostream &OS, const Decl *D) {
40 switch (D->getKind()) {
41 #define DECL(DERIVED, BASE) \
42 case Decl::DERIVED: \
43 return dumpPreviousDeclImpl(OS, cast<DERIVED##Decl>(D));
44 #define ABSTRACT_DECL(DECL)
45 #include "clang/AST/DeclNodes.inc"
46 }
47 llvm_unreachable("Decl that isn't part of DeclNodes.inc!");
48 }
49
50 TextNodeDumper::TextNodeDumper(raw_ostream &OS, bool ShowColors,
51 const SourceManager *SM,
52 const PrintingPolicy &PrintPolicy,
53 const comments::CommandTraits *Traits)
54 : TextTreeStructure(OS, ShowColors), OS(OS), ShowColors(ShowColors), SM(SM),
55 PrintPolicy(PrintPolicy), Traits(Traits) {}
56
57 void TextNodeDumper::Visit(const comments::Comment *C,
58 const comments::FullComment *FC) {
59 if (!C) {
60 ColorScope Color(OS, ShowColors, NullColor);
61 OS << "<<<NULL>>>";
62 return;
63 }
64
65 {
66 ColorScope Color(OS, ShowColors, CommentColor);
67 OS << C->getCommentKindName();
68 }
69 dumpPointer(C);
70 dumpSourceRange(C->getSourceRange());
71
72 ConstCommentVisitor<TextNodeDumper, void,
73 const comments::FullComment *>::visit(C, FC);
74 }
75
76 void TextNodeDumper::Visit(const Attr *A) {
77 {
78 ColorScope Color(OS, ShowColors, AttrColor);
79
80 switch (A->getKind()) {
81 #define ATTR(X) \
82 case attr::X: \
83 OS << #X; \
84 break;
85 #include "clang/Basic/AttrList.inc"
86 }
87 OS << "Attr";
88 }
89 dumpPointer(A);
90 dumpSourceRange(A->getRange());
91 if (A->isInherited())
92 OS << " Inherited";
93 if (A->isImplicit())
94 OS << " Implicit";
95
96 ConstAttrVisitor<TextNodeDumper>::Visit(A);
97 }
98
99 void TextNodeDumper::Visit(const TemplateArgument &TA, SourceRange R,
100 const Decl *From, StringRef Label) {
101 OS << "TemplateArgument";
102 if (R.isValid())
103 dumpSourceRange(R);
104
105 if (From)
106 dumpDeclRef(From, Label);
107
108 ConstTemplateArgumentVisitor<TextNodeDumper>::Visit(TA);
109 }
110
111 void TextNodeDumper::Visit(const Stmt *Node) {
112 if (!Node) {
113 ColorScope Color(OS, ShowColors, NullColor);
114 OS << "<<<NULL>>>";
115 return;
116 }
117 {
118 ColorScope Color(OS, ShowColors, StmtColor);
119 OS << Node->getStmtClassName();
120 }
121 dumpPointer(Node);
122 dumpSourceRange(Node->getSourceRange());
123
124 if (Node->isOMPStructuredBlock())
125 OS << " openmp_structured_block";
126
127 if (const auto *E = dyn_cast<Expr>(Node)) {
128 dumpType(E->getType());
129
130 {
131 ColorScope Color(OS, ShowColors, ValueKindColor);
132 switch (E->getValueKind()) {
133 case VK_RValue:
134 break;
135 case VK_LValue:
136 OS << " lvalue";
137 break;
138 case VK_XValue:
139 OS << " xvalue";
140 break;
141 }
142 }
143
144 {
145 ColorScope Color(OS, ShowColors, ObjectKindColor);
146 switch (E->getObjectKind()) {
147 case OK_Ordinary:
148 break;
149 case OK_BitField:
150 OS << " bitfield";
151 break;
152 case OK_ObjCProperty:
153 OS << " objcproperty";
154 break;
155 case OK_ObjCSubscript:
156 OS << " objcsubscript";
157 break;
158 case OK_VectorComponent:
159 OS << " vectorcomponent";
160 break;
161 }
162 }
163 }
164
165 ConstStmtVisitor<TextNodeDumper>::Visit(Node);
166 }
167
168 void TextNodeDumper::Visit(const Type *T) {
169 if (!T) {
170 ColorScope Color(OS, ShowColors, NullColor);
171 OS << "<<<NULL>>>";
172 return;
173 }
174 if (isa<LocInfoType>(T)) {
175 {
176 ColorScope Color(OS, ShowColors, TypeColor);
177 OS << "LocInfo Type";
178 }
179 dumpPointer(T);
180 return;
181 }
182
183 {
184 ColorScope Color(OS, ShowColors, TypeColor);
185 OS << T->getTypeClassName() << "Type";
186 }
187 dumpPointer(T);
188 OS << " ";
189 dumpBareType(QualType(T, 0), false);
190
191 QualType SingleStepDesugar =
192 T->getLocallyUnqualifiedSingleStepDesugaredType();
193 if (SingleStepDesugar != QualType(T, 0))
194 OS << " sugar";
195
196 if (T->isDependentType())
197 OS << " dependent";
198 else if (T->isInstantiationDependentType())
199 OS << " instantiation_dependent";
200
201 if (T->isVariablyModifiedType())
202 OS << " variably_modified";
203 if (T->containsUnexpandedParameterPack())
204 OS << " contains_unexpanded_pack";
205 if (T->isFromAST())
206 OS << " imported";
207
208 TypeVisitor<TextNodeDumper>::Visit(T);
209 }
210
211 void TextNodeDumper::Visit(QualType T) {
212 OS << "QualType";
213 dumpPointer(T.getAsOpaquePtr());
214 OS << " ";
215 dumpBareType(T, false);
216 OS << " " << T.split().Quals.getAsString();
217 }
218
219 void TextNodeDumper::Visit(const Decl *D) {
220 if (!D) {
221 ColorScope Color(OS, ShowColors, NullColor);
222 OS << "<<<NULL>>>";
223 return;
224 }
225
226 {
227 ColorScope Color(OS, ShowColors, DeclKindNameColor);
228 OS << D->getDeclKindName() << "Decl";
229 }
230 dumpPointer(D);
231 if (D->getLexicalDeclContext() != D->getDeclContext())
232 OS << " parent " << cast<Decl>(D->getDeclContext());
233 dumpPreviousDecl(OS, D);
234 dumpSourceRange(D->getSourceRange());
235 OS << ' ';
236 dumpLocation(D->getLocation());
237 if (D->isFromASTFile())
238 OS << " imported";
239 if (Module *M = D->getOwningModule())
240 OS << " in " << M->getFullModuleName();
241 if (auto *ND = dyn_cast<NamedDecl>(D))
242 for (Module *M : D->getASTContext().getModulesWithMergedDefinition(
243 const_cast<NamedDecl *>(ND)))
244 AddChild([=] { OS << "also in " << M->getFullModuleName(); });
245 if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
246 if (ND->isHidden())
247 OS << " hidden";
248 if (D->isImplicit())
249 OS << " implicit";
250
251 if (D->isUsed())
252 OS << " used";
253 else if (D->isThisDeclarationReferenced())
254 OS << " referenced";
255
256 if (D->isInvalidDecl())
257 OS << " invalid";
258 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
259 if (FD->isConstexprSpecified())
260 OS << " constexpr";
261 if (FD->isConsteval())
262 OS << " consteval";
263 }
264
265 if (!isa<FunctionDecl>(*D)) {
266 const auto *MD = dyn_cast<ObjCMethodDecl>(D);
267 if (!MD || !MD->isThisDeclarationADefinition()) {
268 const auto *DC = dyn_cast<DeclContext>(D);
269 if (DC && DC->hasExternalLexicalStorage()) {
270 ColorScope Color(OS, ShowColors, UndeserializedColor);
271 OS << " <undeserialized declarations>";
272 }
273 }
274 }
275
276 ConstDeclVisitor<TextNodeDumper>::Visit(D);
277 }
278
279 void TextNodeDumper::Visit(const CXXCtorInitializer *Init) {
280 OS << "CXXCtorInitializer";
281 if (Init->isAnyMemberInitializer()) {
282 OS << ' ';
283 dumpBareDeclRef(Init->getAnyMember());
284 } else if (Init->isBaseInitializer()) {
285 dumpType(QualType(Init->getBaseClass(), 0));
286 } else if (Init->isDelegatingInitializer()) {
287 dumpType(Init->getTypeSourceInfo()->getType());
288 } else {
289 llvm_unreachable("Unknown initializer type");
290 }
291 }
292
293 void TextNodeDumper::Visit(const BlockDecl::Capture &C) {
294 OS << "capture";
295 if (C.isByRef())
296 OS << " byref";
297 if (C.isNested())
298 OS << " nested";
299 if (C.getVariable()) {
300 OS << ' ';
301 dumpBareDeclRef(C.getVariable());
302 }
303 }
304
305 void TextNodeDumper::Visit(const OMPClause *C) {
306 if (!C) {
307 ColorScope Color(OS, ShowColors, NullColor);
308 OS << "<<<NULL>>> OMPClause";
309 return;
310 }
311 {
312 ColorScope Color(OS, ShowColors, AttrColor);
313 StringRef ClauseName(getOpenMPClauseName(C->getClauseKind()));
314 OS << "OMP" << ClauseName.substr(/*Start=*/0, /*N=*/1).upper()
315 << ClauseName.drop_front() << "Clause";
316 }
317 dumpPointer(C);
318 dumpSourceRange(SourceRange(C->getBeginLoc(), C->getEndLoc()));
319 if (C->isImplicit())
320 OS << " <implicit>";
321 }
322
323 void TextNodeDumper::Visit(const GenericSelectionExpr::ConstAssociation &A) {
324 const TypeSourceInfo *TSI = A.getTypeSourceInfo();
325 if (TSI) {
326 OS << "case ";
327 dumpType(TSI->getType());
328 } else {
329 OS << "default";
330 }
331
332 if (A.isSelected())
333 OS << " selected";
334 }
335
336 void TextNodeDumper::dumpPointer(const void *Ptr) {
337 ColorScope Color(OS, ShowColors, AddressColor);
338 OS << ' ' << Ptr;
339 }
340
341 void TextNodeDumper::dumpLocation(SourceLocation Loc) {
342 if (!SM)
343 return;
344
345 ColorScope Color(OS, ShowColors, LocationColor);
346 SourceLocation SpellingLoc = SM->getSpellingLoc(Loc);
347
348 // The general format we print out is filename:line:col, but we drop pieces
349 // that haven't changed since the last loc printed.
350 PresumedLoc PLoc = SM->getPresumedLoc(SpellingLoc);
351
352 if (PLoc.isInvalid()) {
353 OS << "<invalid sloc>";
354 return;
355 }
356
357 if (strcmp(PLoc.getFilename(), LastLocFilename) != 0) {
358 OS << PLoc.getFilename() << ':' << PLoc.getLine() << ':'
359 << PLoc.getColumn();
360 LastLocFilename = PLoc.getFilename();
361 LastLocLine = PLoc.getLine();
362 } else if (PLoc.getLine() != LastLocLine) {
363 OS << "line" << ':' << PLoc.getLine() << ':' << PLoc.getColumn();
364 LastLocLine = PLoc.getLine();
365 } else {
366 OS << "col" << ':' << PLoc.getColumn();
367 }
368 }
369
370 void TextNodeDumper::dumpSourceRange(SourceRange R) {
371 // Can't translate locations if a SourceManager isn't available.
372 if (!SM)
373 return;
374
375 OS << " <";
376 dumpLocation(R.getBegin());
377 if (R.getBegin() != R.getEnd()) {
378 OS << ", ";
379 dumpLocation(R.getEnd());
380 }
381 OS << ">";
382
383 // <t2.c:123:421[blah], t2.c:412:321>
384 }
385
386 void TextNodeDumper::dumpBareType(QualType T, bool Desugar) {
387 ColorScope Color(OS, ShowColors, TypeColor);
388
389 SplitQualType T_split = T.split();
390 OS << "'" << QualType::getAsString(T_split, PrintPolicy) << "'";
391
392 if (Desugar && !T.isNull()) {
393 // If the type is sugared, also dump a (shallow) desugared type.
394 SplitQualType D_split = T.getSplitDesugaredType();
395 if (T_split != D_split)
396 OS << ":'" << QualType::getAsString(D_split, PrintPolicy) << "'";
397 }
398 }
399
400 void TextNodeDumper::dumpType(QualType T) {
401 OS << ' ';
402 dumpBareType(T);
403 }
404
405 void TextNodeDumper::dumpBareDeclRef(const Decl *D) {
406 if (!D) {
407 ColorScope Color(OS, ShowColors, NullColor);
408 OS << "<<<NULL>>>";
409 return;
410 }
411
412 {
413 ColorScope Color(OS, ShowColors, DeclKindNameColor);
414 OS << D->getDeclKindName();
415 }
416 dumpPointer(D);
417
418 if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
419 ColorScope Color(OS, ShowColors, DeclNameColor);
420 OS << " '" << ND->getDeclName() << '\'';
421 }
422
423 if (const ValueDecl *VD = dyn_cast<ValueDecl>(D))
424 dumpType(VD->getType());
425 }
426
427 void TextNodeDumper::dumpName(const NamedDecl *ND) {
428 if (ND->getDeclName()) {
429 ColorScope Color(OS, ShowColors, DeclNameColor);
430 OS << ' ' << ND->getNameAsString();
431 }
432 }
433
434 void TextNodeDumper::dumpAccessSpecifier(AccessSpecifier AS) {
435 switch (AS) {
436 case AS_none:
437 break;
438 case AS_public:
439 OS << "public";
440 break;
441 case AS_protected:
442 OS << "protected";
443 break;
444 case AS_private:
445 OS << "private";
446 break;
447 }
448 }
449
450 void TextNodeDumper::dumpDeclRef(const Decl *D, StringRef Label) {
451 if (!D)
452 return;
453
454 AddChild([=] {
455 if (!Label.empty())
456 OS << Label << ' ';
457 dumpBareDeclRef(D);
458 });
459 }
460
461 const char *TextNodeDumper::getCommandName(unsigned CommandID) {
462 if (Traits)
463 return Traits->getCommandInfo(CommandID)->Name;
464 const comments::CommandInfo *Info =
465 comments::CommandTraits::getBuiltinCommandInfo(CommandID);
466 if (Info)
467 return Info->Name;
468 return "<not a builtin command>";
469 }
470
471 void TextNodeDumper::visitTextComment(const comments::TextComment *C,
472 const comments::FullComment *) {
473 OS << " Text=\"" << C->getText() << "\"";
474 }
475
476 void TextNodeDumper::visitInlineCommandComment(
477 const comments::InlineCommandComment *C, const comments::FullComment *) {
478 OS << " Name=\"" << getCommandName(C->getCommandID()) << "\"";
479 switch (C->getRenderKind()) {
480 case comments::InlineCommandComment::RenderNormal:
481 OS << " RenderNormal";
482 break;
483 case comments::InlineCommandComment::RenderBold:
484 OS << " RenderBold";
485 break;
486 case comments::InlineCommandComment::RenderMonospaced:
487 OS << " RenderMonospaced";
488 break;
489 case comments::InlineCommandComment::RenderEmphasized:
490 OS << " RenderEmphasized";
491 break;
492 case comments::InlineCommandComment::RenderAnchor:
493 OS << " RenderAnchor";
494 break;
495 }
496
497 for (unsigned i = 0, e = C->getNumArgs(); i != e; ++i)
498 OS << " Arg[" << i << "]=\"" << C->getArgText(i) << "\"";
499 }
500
501 void TextNodeDumper::visitHTMLStartTagComment(
502 const comments::HTMLStartTagComment *C, const comments::FullComment *) {
503 OS << " Name=\"" << C->getTagName() << "\"";
504 if (C->getNumAttrs() != 0) {
505 OS << " Attrs: ";
506 for (unsigned i = 0, e = C->getNumAttrs(); i != e; ++i) {
507 const comments::HTMLStartTagComment::Attribute &Attr = C->getAttr(i);
508 OS << " \"" << Attr.Name << "=\"" << Attr.Value << "\"";
509 }
510 }
511 if (C->isSelfClosing())
512 OS << " SelfClosing";
513 }
514
515 void TextNodeDumper::visitHTMLEndTagComment(
516 const comments::HTMLEndTagComment *C, const comments::FullComment *) {
517 OS << " Name=\"" << C->getTagName() << "\"";
518 }
519
520 void TextNodeDumper::visitBlockCommandComment(
521 const comments::BlockCommandComment *C, const comments::FullComment *) {
522 OS << " Name=\"" << getCommandName(C->getCommandID()) << "\"";
523 for (unsigned i = 0, e = C->getNumArgs(); i != e; ++i)
524 OS << " Arg[" << i << "]=\"" << C->getArgText(i) << "\"";
525 }
526
527 void TextNodeDumper::visitParamCommandComment(
528 const comments::ParamCommandComment *C, const comments::FullComment *FC) {
529 OS << " "
530 << comments::ParamCommandComment::getDirectionAsString(C->getDirection());
531
532 if (C->isDirectionExplicit())
533 OS << " explicitly";
534 else
535 OS << " implicitly";
536
537 if (C->hasParamName()) {
538 if (C->isParamIndexValid())
539 OS << " Param=\"" << C->getParamName(FC) << "\"";
540 else
541 OS << " Param=\"" << C->getParamNameAsWritten() << "\"";
542 }
543
544 if (C->isParamIndexValid() && !C->isVarArgParam())
545 OS << " ParamIndex=" << C->getParamIndex();
546 }
547
548 void TextNodeDumper::visitTParamCommandComment(
549 const comments::TParamCommandComment *C, const comments::FullComment *FC) {
550 if (C->hasParamName()) {
551 if (C->isPositionValid())
552 OS << " Param=\"" << C->getParamName(FC) << "\"";
553 else
554 OS << " Param=\"" << C->getParamNameAsWritten() << "\"";
555 }
556
557 if (C->isPositionValid()) {
558 OS << " Position=<";
559 for (unsigned i = 0, e = C->getDepth(); i != e; ++i) {
560 OS << C->getIndex(i);
561 if (i != e - 1)
562 OS << ", ";
563 }
564 OS << ">";
565 }
566 }
567
568 void TextNodeDumper::visitVerbatimBlockComment(
569 const comments::VerbatimBlockComment *C, const comments::FullComment *) {
570 OS << " Name=\"" << getCommandName(C->getCommandID())
571 << "\""
572 " CloseName=\""
573 << C->getCloseName() << "\"";
574 }
575
576 void TextNodeDumper::visitVerbatimBlockLineComment(
577 const comments::VerbatimBlockLineComment *C,
578 const comments::FullComment *) {
579 OS << " Text=\"" << C->getText() << "\"";
580 }
581
582 void TextNodeDumper::visitVerbatimLineComment(
583 const comments::VerbatimLineComment *C, const comments::FullComment *) {
584 OS << " Text=\"" << C->getText() << "\"";
585 }
586
587 void TextNodeDumper::VisitNullTemplateArgument(const TemplateArgument &) {
588 OS << " null";
589 }
590
591 void TextNodeDumper::VisitTypeTemplateArgument(const TemplateArgument &TA) {
592 OS << " type";
593 dumpType(TA.getAsType());
594 }
595
596 void TextNodeDumper::VisitDeclarationTemplateArgument(
597 const TemplateArgument &TA) {
598 OS << " decl";
599 dumpDeclRef(TA.getAsDecl());
600 }
601
602 void TextNodeDumper::VisitNullPtrTemplateArgument(const TemplateArgument &) {
603 OS << " nullptr";
604 }
605
606 void TextNodeDumper::VisitIntegralTemplateArgument(const TemplateArgument &TA) {
607 OS << " integral " << TA.getAsIntegral();
608 }
609
610 void TextNodeDumper::VisitTemplateTemplateArgument(const TemplateArgument &TA) {
611 OS << " template ";
612 TA.getAsTemplate().dump(OS);
613 }
614
615 void TextNodeDumper::VisitTemplateExpansionTemplateArgument(
616 const TemplateArgument &TA) {
617 OS << " template expansion ";
618 TA.getAsTemplateOrTemplatePattern().dump(OS);
619 }
620
621 void TextNodeDumper::VisitExpressionTemplateArgument(const TemplateArgument &) {
622 OS << " expr";
623 }
624
625 void TextNodeDumper::VisitPackTemplateArgument(const TemplateArgument &) {
626 OS << " pack";
627 }
628
629 static void dumpBasePath(raw_ostream &OS, const CastExpr *Node) {
630 if (Node->path_empty())
631 return;
632
633 OS << " (";
634 bool First = true;
635 for (CastExpr::path_const_iterator I = Node->path_begin(),
636 E = Node->path_end();
637 I != E; ++I) {
638 const CXXBaseSpecifier *Base = *I;
639 if (!First)
640 OS << " -> ";
641
642 const auto *RD =
643 cast<CXXRecordDecl>(Base->getType()->castAs<RecordType>()->getDecl());
644
645 if (Base->isVirtual())
646 OS << "virtual ";
647 OS << RD->getName();
648 First = false;
649 }
650
651 OS << ')';
652 }
653
654 void TextNodeDumper::VisitIfStmt(const IfStmt *Node) {
655 if (Node->hasInitStorage())
656 OS << " has_init";
657 if (Node->hasVarStorage())
658 OS << " has_var";
659 if (Node->hasElseStorage())
660 OS << " has_else";
661 }
662
663 void TextNodeDumper::VisitSwitchStmt(const SwitchStmt *Node) {
664 if (Node->hasInitStorage())
665 OS << " has_init";
666 if (Node->hasVarStorage())
667 OS << " has_var";
668 }
669
670 void TextNodeDumper::VisitWhileStmt(const WhileStmt *Node) {
671 if (Node->hasVarStorage())
672 OS << " has_var";
673 }
674
675 void TextNodeDumper::VisitLabelStmt(const LabelStmt *Node) {
676 OS << " '" << Node->getName() << "'";
677 }
678
679 void TextNodeDumper::VisitGotoStmt(const GotoStmt *Node) {
680 OS << " '" << Node->getLabel()->getName() << "'";
681 dumpPointer(Node->getLabel());
682 }
683
684 void TextNodeDumper::VisitCaseStmt(const CaseStmt *Node) {
685 if (Node->caseStmtIsGNURange())
686 OS << " gnu_range";
687 }
688
689 void TextNodeDumper::VisitConstantExpr(const ConstantExpr *Node) {
690 if (Node->getResultAPValueKind() != APValue::None) {
691 ColorScope Color(OS, ShowColors, ValueColor);
692 OS << " ";
693 Node->getAPValueResult().dump(OS);
694 }
695 }
696
697 void TextNodeDumper::VisitCallExpr(const CallExpr *Node) {
698 if (Node->usesADL())
699 OS << " adl";
700 }
701
702 void TextNodeDumper::VisitCastExpr(const CastExpr *Node) {
703 OS << " <";
704 {
705 ColorScope Color(OS, ShowColors, CastColor);
706 OS << Node->getCastKindName();
707 }
708 dumpBasePath(OS, Node);
709 OS << ">";
710 }
711
712 void TextNodeDumper::VisitImplicitCastExpr(const ImplicitCastExpr *Node) {
713 VisitCastExpr(Node);
714 if (Node->isPartOfExplicitCast())
715 OS << " part_of_explicit_cast";
716 }
717
718 void TextNodeDumper::VisitDeclRefExpr(const DeclRefExpr *Node) {
719 OS << " ";
720 dumpBareDeclRef(Node->getDecl());
721 if (Node->getDecl() != Node->getFoundDecl()) {
722 OS << " (";
723 dumpBareDeclRef(Node->getFoundDecl());
724 OS << ")";
725 }
726 switch (Node->isNonOdrUse()) {
727 case NOUR_None: break;
728 case NOUR_Unevaluated: OS << " non_odr_use_unevaluated"; break;
729 case NOUR_Constant: OS << " non_odr_use_constant"; break;
730 case NOUR_Discarded: OS << " non_odr_use_discarded"; break;
731 }
732 }
733
734 void TextNodeDumper::VisitUnresolvedLookupExpr(
735 const UnresolvedLookupExpr *Node) {
736 OS << " (";
737 if (!Node->requiresADL())
738 OS << "no ";
739 OS << "ADL) = '" << Node->getName() << '\'';
740
741 UnresolvedLookupExpr::decls_iterator I = Node->decls_begin(),
742 E = Node->decls_end();
743 if (I == E)
744 OS << " empty";
745 for (; I != E; ++I)
746 dumpPointer(*I);
747 }
748
749 void TextNodeDumper::VisitObjCIvarRefExpr(const ObjCIvarRefExpr *Node) {
750 {
751 ColorScope Color(OS, ShowColors, DeclKindNameColor);
752 OS << " " << Node->getDecl()->getDeclKindName() << "Decl";
753 }
754 OS << "='" << *Node->getDecl() << "'";
755 dumpPointer(Node->getDecl());
756 if (Node->isFreeIvar())
757 OS << " isFreeIvar";
758 }
759
760 void TextNodeDumper::VisitPredefinedExpr(const PredefinedExpr *Node) {
761 OS << " " << PredefinedExpr::getIdentKindName(Node->getIdentKind());
762 }
763
764 void TextNodeDumper::VisitCharacterLiteral(const CharacterLiteral *Node) {
765 ColorScope Color(OS, ShowColors, ValueColor);
766 OS << " " << Node->getValue();
767 }
768
769 void TextNodeDumper::VisitIntegerLiteral(const IntegerLiteral *Node) {
770 bool isSigned = Node->getType()->isSignedIntegerType();
771 ColorScope Color(OS, ShowColors, ValueColor);
772 OS << " " << Node->getValue().toString(10, isSigned);
773 }
774
775 void TextNodeDumper::VisitFixedPointLiteral(const FixedPointLiteral *Node) {
776 ColorScope Color(OS, ShowColors, ValueColor);
777 OS << " " << Node->getValueAsString(/*Radix=*/10);
778 }
779
780 void TextNodeDumper::VisitFloatingLiteral(const FloatingLiteral *Node) {
781 ColorScope Color(OS, ShowColors, ValueColor);
782 OS << " " << Node->getValueAsApproximateDouble();
783 }
784
785 void TextNodeDumper::VisitStringLiteral(const StringLiteral *Str) {
786 ColorScope Color(OS, ShowColors, ValueColor);
787 OS << " ";
788 Str->outputString(OS);
789 }
790
791 void TextNodeDumper::VisitInitListExpr(const InitListExpr *ILE) {
792 if (auto *Field = ILE->getInitializedFieldInUnion()) {
793 OS << " field ";
794 dumpBareDeclRef(Field);
795 }
796 }
797
798 void TextNodeDumper::VisitGenericSelectionExpr(const GenericSelectionExpr *E) {
799 if (E->isResultDependent())
800 OS << " result_dependent";
801 }
802
803 void TextNodeDumper::VisitUnaryOperator(const UnaryOperator *Node) {
804 OS << " " << (Node->isPostfix() ? "postfix" : "prefix") << " '"
805 << UnaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
806 if (!Node->canOverflow())
807 OS << " cannot overflow";
808 }
809
810 void TextNodeDumper::VisitUnaryExprOrTypeTraitExpr(
811 const UnaryExprOrTypeTraitExpr *Node) {
812 switch (Node->getKind()) {
813 case UETT_SizeOf:
814 OS << " sizeof";
815 break;
816 case UETT_AlignOf:
817 OS << " alignof";
818 break;
819 case UETT_VecStep:
820 OS << " vec_step";
821 break;
822 case UETT_OpenMPRequiredSimdAlign:
823 OS << " __builtin_omp_required_simd_align";
824 break;
825 case UETT_PreferredAlignOf:
826 OS << " __alignof";
827 break;
828 }
829 if (Node->isArgumentType())
830 dumpType(Node->getArgumentType());
831 }
832
833 void TextNodeDumper::VisitMemberExpr(const MemberExpr *Node) {
834 OS << " " << (Node->isArrow() ? "->" : ".") << *Node->getMemberDecl();
835 dumpPointer(Node->getMemberDecl());
836 switch (Node->isNonOdrUse()) {
837 case NOUR_None: break;
838 case NOUR_Unevaluated: OS << " non_odr_use_unevaluated"; break;
839 case NOUR_Constant: OS << " non_odr_use_constant"; break;
840 case NOUR_Discarded: OS << " non_odr_use_discarded"; break;
841 }
842 }
843
844 void TextNodeDumper::VisitExtVectorElementExpr(
845 const ExtVectorElementExpr *Node) {
846 OS << " " << Node->getAccessor().getNameStart();
847 }
848
849 void TextNodeDumper::VisitBinaryOperator(const BinaryOperator *Node) {
850 OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
851 }
852
853 void TextNodeDumper::VisitCompoundAssignOperator(
854 const CompoundAssignOperator *Node) {
855 OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode())
856 << "' ComputeLHSTy=";
857 dumpBareType(Node->getComputationLHSType());
858 OS << " ComputeResultTy=";
859 dumpBareType(Node->getComputationResultType());
860 }
861
862 void TextNodeDumper::VisitAddrLabelExpr(const AddrLabelExpr *Node) {
863 OS << " " << Node->getLabel()->getName();
864 dumpPointer(Node->getLabel());
865 }
866
867 void TextNodeDumper::VisitCXXNamedCastExpr(const CXXNamedCastExpr *Node) {
868 OS << " " << Node->getCastName() << "<"
869 << Node->getTypeAsWritten().getAsString() << ">"
870 << " <" << Node->getCastKindName();
871 dumpBasePath(OS, Node);
872 OS << ">";
873 }
874
875 void TextNodeDumper::VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *Node) {
876 OS << " " << (Node->getValue() ? "true" : "false");
877 }
878
879 void TextNodeDumper::VisitCXXThisExpr(const CXXThisExpr *Node) {
880 if (Node->isImplicit())
881 OS << " implicit";
882 OS << " this";
883 }
884
885 void TextNodeDumper::VisitCXXFunctionalCastExpr(
886 const CXXFunctionalCastExpr *Node) {
887 OS << " functional cast to " << Node->getTypeAsWritten().getAsString() << " <"
888 << Node->getCastKindName() << ">";
889 }
890
891 void TextNodeDumper::VisitCXXUnresolvedConstructExpr(
892 const CXXUnresolvedConstructExpr *Node) {
893 dumpType(Node->getTypeAsWritten());
894 if (Node->isListInitialization())
895 OS << " list";
896 }
897
898 void TextNodeDumper::VisitCXXConstructExpr(const CXXConstructExpr *Node) {
899 CXXConstructorDecl *Ctor = Node->getConstructor();
900 dumpType(Ctor->getType());
901 if (Node->isElidable())
902 OS << " elidable";
903 if (Node->isListInitialization())
904 OS << " list";
905 if (Node->isStdInitListInitialization())
906 OS << " std::initializer_list";
907 if (Node->requiresZeroInitialization())
908 OS << " zeroing";
909 }
910
911 void TextNodeDumper::VisitCXXBindTemporaryExpr(
912 const CXXBindTemporaryExpr *Node) {
913 OS << " (CXXTemporary";
914 dumpPointer(Node);
915 OS << ")";
916 }
917
918 void TextNodeDumper::VisitCXXNewExpr(const CXXNewExpr *Node) {
919 if (Node->isGlobalNew())
920 OS << " global";
921 if (Node->isArray())
922 OS << " array";
923 if (Node->getOperatorNew()) {
924 OS << ' ';
925 dumpBareDeclRef(Node->getOperatorNew());
926 }
927 // We could dump the deallocation function used in case of error, but it's
928 // usually not that interesting.
929 }
930
931 void TextNodeDumper::VisitCXXDeleteExpr(const CXXDeleteExpr *Node) {
932 if (Node->isGlobalDelete())
933 OS << " global";
934 if (Node->isArrayForm())
935 OS << " array";
936 if (Node->getOperatorDelete()) {
937 OS << ' ';
938 dumpBareDeclRef(Node->getOperatorDelete());
939 }
940 }
941
942 void TextNodeDumper::VisitMaterializeTemporaryExpr(
943 const MaterializeTemporaryExpr *Node) {
944 if (const ValueDecl *VD = Node->getExtendingDecl()) {
945 OS << " extended by ";
946 dumpBareDeclRef(VD);
947 }
948 }
949
950 void TextNodeDumper::VisitExprWithCleanups(const ExprWithCleanups *Node) {
951 for (unsigned i = 0, e = Node->getNumObjects(); i != e; ++i)
952 dumpDeclRef(Node->getObject(i), "cleanup");
953 }
954
955 void TextNodeDumper::VisitSizeOfPackExpr(const SizeOfPackExpr *Node) {
956 dumpPointer(Node->getPack());
957 dumpName(Node->getPack());
958 }
959
960 void TextNodeDumper::VisitCXXDependentScopeMemberExpr(
961 const CXXDependentScopeMemberExpr *Node) {
962 OS << " " << (Node->isArrow() ? "->" : ".") << Node->getMember();
963 }
964
965 void TextNodeDumper::VisitObjCMessageExpr(const ObjCMessageExpr *Node) {
966 OS << " selector=";
967 Node->getSelector().print(OS);
968 switch (Node->getReceiverKind()) {
969 case ObjCMessageExpr::Instance:
970 break;
971
972 case ObjCMessageExpr::Class:
973 OS << " class=";
974 dumpBareType(Node->getClassReceiver());
975 break;
976
977 case ObjCMessageExpr::SuperInstance:
978 OS << " super (instance)";
979 break;
980
981 case ObjCMessageExpr::SuperClass:
982 OS << " super (class)";
983 break;
984 }
985 }
986
987 void TextNodeDumper::VisitObjCBoxedExpr(const ObjCBoxedExpr *Node) {
988 if (auto *BoxingMethod = Node->getBoxingMethod()) {
989 OS << " selector=";
990 BoxingMethod->getSelector().print(OS);
991 }
992 }
993
994 void TextNodeDumper::VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node) {
995 if (!Node->getCatchParamDecl())
996 OS << " catch all";
997 }
998
999 void TextNodeDumper::VisitObjCEncodeExpr(const ObjCEncodeExpr *Node) {
1000 dumpType(Node->getEncodedType());
1001 }
1002
1003 void TextNodeDumper::VisitObjCSelectorExpr(const ObjCSelectorExpr *Node) {
1004 OS << " ";
1005 Node->getSelector().print(OS);
1006 }
1007
1008 void TextNodeDumper::VisitObjCProtocolExpr(const ObjCProtocolExpr *Node) {
1009 OS << ' ' << *Node->getProtocol();
1010 }
1011
1012 void TextNodeDumper::VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *Node) {
1013 if (Node->isImplicitProperty()) {
1014 OS << " Kind=MethodRef Getter=\"";
1015 if (Node->getImplicitPropertyGetter())
1016 Node->getImplicitPropertyGetter()->getSelector().print(OS);
1017 else
1018 OS << "(null)";
1019
1020 OS << "\" Setter=\"";
1021 if (ObjCMethodDecl *Setter = Node->getImplicitPropertySetter())
1022 Setter->getSelector().print(OS);
1023 else
1024 OS << "(null)";
1025 OS << "\"";
1026 } else {
1027 OS << " Kind=PropertyRef Property=\"" << *Node->getExplicitProperty()
1028 << '"';
1029 }
1030
1031 if (Node->isSuperReceiver())
1032 OS << " super";
1033
1034 OS << " Messaging=";
1035 if (Node->isMessagingGetter() && Node->isMessagingSetter())
1036 OS << "Getter&Setter";
1037 else if (Node->isMessagingGetter())
1038 OS << "Getter";
1039 else if (Node->isMessagingSetter())
1040 OS << "Setter";
1041 }
1042
1043 void TextNodeDumper::VisitObjCSubscriptRefExpr(
1044 const ObjCSubscriptRefExpr *Node) {
1045 if (Node->isArraySubscriptRefExpr())
1046 OS << " Kind=ArraySubscript GetterForArray=\"";
1047 else
1048 OS << " Kind=DictionarySubscript GetterForDictionary=\"";
1049 if (Node->getAtIndexMethodDecl())
1050 Node->getAtIndexMethodDecl()->getSelector().print(OS);
1051 else
1052 OS << "(null)";
1053
1054 if (Node->isArraySubscriptRefExpr())
1055 OS << "\" SetterForArray=\"";
1056 else
1057 OS << "\" SetterForDictionary=\"";
1058 if (Node->setAtIndexMethodDecl())
1059 Node->setAtIndexMethodDecl()->getSelector().print(OS);
1060 else
1061 OS << "(null)";
1062 }
1063
1064 void TextNodeDumper::VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *Node) {
1065 OS << " " << (Node->getValue() ? "__objc_yes" : "__objc_no");
1066 }
1067
1068 void TextNodeDumper::VisitRValueReferenceType(const ReferenceType *T) {
1069 if (T->isSpelledAsLValue())
1070 OS << " written as lvalue reference";
1071 }
1072
1073 void TextNodeDumper::VisitArrayType(const ArrayType *T) {
1074 switch (T->getSizeModifier()) {
1075 case ArrayType::Normal:
1076 break;
1077 case ArrayType::Static:
1078 OS << " static";
1079 break;
1080 case ArrayType::Star:
1081 OS << " *";
1082 break;
1083 }
1084 OS << " " << T->getIndexTypeQualifiers().getAsString();
1085 }
1086
1087 void TextNodeDumper::VisitConstantArrayType(const ConstantArrayType *T) {
1088 OS << " " << T->getSize();
1089 VisitArrayType(T);
1090 }
1091
1092 void TextNodeDumper::VisitVariableArrayType(const VariableArrayType *T) {
1093 OS << " ";
1094 dumpSourceRange(T->getBracketsRange());
1095 VisitArrayType(T);
1096 }
1097
1098 void TextNodeDumper::VisitDependentSizedArrayType(
1099 const DependentSizedArrayType *T) {
1100 VisitArrayType(T);
1101 OS << " ";
1102 dumpSourceRange(T->getBracketsRange());
1103 }
1104
1105 void TextNodeDumper::VisitDependentSizedExtVectorType(
1106 const DependentSizedExtVectorType *T) {
1107 OS << " ";
1108 dumpLocation(T->getAttributeLoc());
1109 }
1110
1111 void TextNodeDumper::VisitVectorType(const VectorType *T) {
1112 switch (T->getVectorKind()) {
1113 case VectorType::GenericVector:
1114 break;
1115 case VectorType::AltiVecVector:
1116 OS << " altivec";
1117 break;
1118 case VectorType::AltiVecPixel:
1119 OS << " altivec pixel";
1120 break;
1121 case VectorType::AltiVecBool:
1122 OS << " altivec bool";
1123 break;
1124 case VectorType::NeonVector:
1125 OS << " neon";
1126 break;
1127 case VectorType::NeonPolyVector:
1128 OS << " neon poly";
1129 break;
1130 }
1131 OS << " " << T->getNumElements();
1132 }
1133
1134 void TextNodeDumper::VisitFunctionType(const FunctionType *T) {
1135 auto EI = T->getExtInfo();
1136 if (EI.getNoReturn())
1137 OS << " noreturn";
1138 if (EI.getProducesResult())
1139 OS << " produces_result";
1140 if (EI.getHasRegParm())
1141 OS << " regparm " << EI.getRegParm();
1142 OS << " " << FunctionType::getNameForCallConv(EI.getCC());
1143 }
1144
1145 void TextNodeDumper::VisitFunctionProtoType(const FunctionProtoType *T) {
1146 auto EPI = T->getExtProtoInfo();
1147 if (EPI.HasTrailingReturn)
1148 OS << " trailing_return";
1149 if (T->isConst())
1150 OS << " const";
1151 if (T->isVolatile())
1152 OS << " volatile";
1153 if (T->isRestrict())
1154 OS << " restrict";
1155 if (T->getExtProtoInfo().Variadic)
1156 OS << " variadic";
1157 switch (EPI.RefQualifier) {
1158 case RQ_None:
1159 break;
1160 case RQ_LValue:
1161 OS << " &";
1162 break;
1163 case RQ_RValue:
1164 OS << " &&";
1165 break;
1166 }
1167 // FIXME: Exception specification.
1168 // FIXME: Consumed parameters.
1169 VisitFunctionType(T);
1170 }
1171
1172 void TextNodeDumper::VisitUnresolvedUsingType(const UnresolvedUsingType *T) {
1173 dumpDeclRef(T->getDecl());
1174 }
1175
1176 void TextNodeDumper::VisitTypedefType(const TypedefType *T) {
1177 dumpDeclRef(T->getDecl());
1178 }
1179
1180 void TextNodeDumper::VisitUnaryTransformType(const UnaryTransformType *T) {
1181 switch (T->getUTTKind()) {
1182 case UnaryTransformType::EnumUnderlyingType:
1183 OS << " underlying_type";
1184 break;
1185 }
1186 }
1187
1188 void TextNodeDumper::VisitTagType(const TagType *T) {
1189 dumpDeclRef(T->getDecl());
1190 }
1191
1192 void TextNodeDumper::VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
1193 OS << " depth " << T->getDepth() << " index " << T->getIndex();
1194 if (T->isParameterPack())
1195 OS << " pack";
1196 dumpDeclRef(T->getDecl());
1197 }
1198
1199 void TextNodeDumper::VisitAutoType(const AutoType *T) {
1200 if (T->isDecltypeAuto())
1201 OS << " decltype(auto)";
1202 if (!T->isDeduced())
1203 OS << " undeduced";
1204 if (T->isConstrained()) {
1205 dumpDeclRef(T->getTypeConstraintConcept());
1206 for (const auto &Arg : T->getTypeConstraintArguments())
1207 VisitTemplateArgument(Arg);
1208 }
1209 }
1210
1211 void TextNodeDumper::VisitTemplateSpecializationType(
1212 const TemplateSpecializationType *T) {
1213 if (T->isTypeAlias())
1214 OS << " alias";
1215 OS << " ";
1216 T->getTemplateName().dump(OS);
1217 }
1218
1219 void TextNodeDumper::VisitInjectedClassNameType(
1220 const InjectedClassNameType *T) {
1221 dumpDeclRef(T->getDecl());
1222 }
1223
1224 void TextNodeDumper::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
1225 dumpDeclRef(T->getDecl());
1226 }
1227
1228 void TextNodeDumper::VisitPackExpansionType(const PackExpansionType *T) {
1229 if (auto N = T->getNumExpansions())
1230 OS << " expansions " << *N;
1231 }
1232
1233 void TextNodeDumper::VisitLabelDecl(const LabelDecl *D) { dumpName(D); }
1234
1235 void TextNodeDumper::VisitTypedefDecl(const TypedefDecl *D) {
1236 dumpName(D);
1237 dumpType(D->getUnderlyingType());
1238 if (D->isModulePrivate())
1239 OS << " __module_private__";
1240 }
1241
1242 void TextNodeDumper::VisitEnumDecl(const EnumDecl *D) {
1243 if (D->isScoped()) {
1244 if (D->isScopedUsingClassTag())
1245 OS << " class";
1246 else
1247 OS << " struct";
1248 }
1249 dumpName(D);
1250 if (D->isModulePrivate())
1251 OS << " __module_private__";
1252 if (D->isFixed())
1253 dumpType(D->getIntegerType());
1254 }
1255
1256 void TextNodeDumper::VisitRecordDecl(const RecordDecl *D) {
1257 OS << ' ' << D->getKindName();
1258 dumpName(D);
1259 if (D->isModulePrivate())
1260 OS << " __module_private__";
1261 if (D->isCompleteDefinition())
1262 OS << " definition";
1263 }
1264
1265 void TextNodeDumper::VisitEnumConstantDecl(const EnumConstantDecl *D) {
1266 dumpName(D);
1267 dumpType(D->getType());
1268 }
1269
1270 void TextNodeDumper::VisitIndirectFieldDecl(const IndirectFieldDecl *D) {
1271 dumpName(D);
1272 dumpType(D->getType());
1273
1274 for (const auto *Child : D->chain())
1275 dumpDeclRef(Child);
1276 }
1277
1278 void TextNodeDumper::VisitFunctionDecl(const FunctionDecl *D) {
1279 dumpName(D);
1280 dumpType(D->getType());
1281
1282 StorageClass SC = D->getStorageClass();
1283 if (SC != SC_None)
1284 OS << ' ' << VarDecl::getStorageClassSpecifierString(SC);
1285 if (D->isInlineSpecified())
1286 OS << " inline";
1287 if (D->isVirtualAsWritten())
1288 OS << " virtual";
1289 if (D->isModulePrivate())
1290 OS << " __module_private__";
1291
1292 if (D->isPure())
1293 OS << " pure";
1294 if (D->isDefaulted()) {
1295 OS << " default";
1296 if (D->isDeleted())
1297 OS << "_delete";
1298 }
1299 if (D->isDeletedAsWritten())
1300 OS << " delete";
1301 if (D->isTrivial())
1302 OS << " trivial";
1303
1304 if (const auto *FPT = D->getType()->getAs<FunctionProtoType>()) {
1305 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
1306 switch (EPI.ExceptionSpec.Type) {
1307 default:
1308 break;
1309 case EST_Unevaluated:
1310 OS << " noexcept-unevaluated " << EPI.ExceptionSpec.SourceDecl;
1311 break;
1312 case EST_Uninstantiated:
1313 OS << " noexcept-uninstantiated " << EPI.ExceptionSpec.SourceTemplate;
1314 break;
1315 }
1316 }
1317
1318 if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
1319 if (MD->size_overridden_methods() != 0) {
1320 auto dumpOverride = [=](const CXXMethodDecl *D) {
1321 SplitQualType T_split = D->getType().split();
1322 OS << D << " " << D->getParent()->getName()
1323 << "::" << D->getNameAsString() << " '"
1324 << QualType::getAsString(T_split, PrintPolicy) << "'";
1325 };
1326
1327 AddChild([=] {
1328 auto Overrides = MD->overridden_methods();
1329 OS << "Overrides: [ ";
1330 dumpOverride(*Overrides.begin());
1331 for (const auto *Override :
1332 llvm::make_range(Overrides.begin() + 1, Overrides.end())) {
1333 OS << ", ";
1334 dumpOverride(Override);
1335 }
1336 OS << " ]";
1337 });
1338 }
1339 }
1340
1341 // Since NumParams comes from the FunctionProtoType of the FunctionDecl and
1342 // the Params are set later, it is possible for a dump during debugging to
1343 // encounter a FunctionDecl that has been created but hasn't been assigned
1344 // ParmVarDecls yet.
1345 if (!D->param_empty() && !D->param_begin())
1346 OS << " <<<NULL params x " << D->getNumParams() << ">>>";
1347 }
1348
1349 void TextNodeDumper::VisitLifetimeExtendedTemporaryDecl(
1350 const LifetimeExtendedTemporaryDecl *D) {
1351 OS << " extended by ";
1352 dumpBareDeclRef(D->getExtendingDecl());
1353 OS << " mangling ";
1354 {
1355 ColorScope Color(OS, ShowColors, ValueColor);
1356 OS << D->getManglingNumber();
1357 }
1358 }
1359
1360 void TextNodeDumper::VisitFieldDecl(const FieldDecl *D) {
1361 dumpName(D);
1362 dumpType(D->getType());
1363 if (D->isMutable())
1364 OS << " mutable";
1365 if (D->isModulePrivate())
1366 OS << " __module_private__";
1367 }
1368
1369 void TextNodeDumper::VisitVarDecl(const VarDecl *D) {
1370 dumpName(D);
1371 dumpType(D->getType());
1372 StorageClass SC = D->getStorageClass();
1373 if (SC != SC_None)
1374 OS << ' ' << VarDecl::getStorageClassSpecifierString(SC);
1375 switch (D->getTLSKind()) {
1376 case VarDecl::TLS_None:
1377 break;
1378 case VarDecl::TLS_Static:
1379 OS << " tls";
1380 break;
1381 case VarDecl::TLS_Dynamic:
1382 OS << " tls_dynamic";
1383 break;
1384 }
1385 if (D->isModulePrivate())
1386 OS << " __module_private__";
1387 if (D->isNRVOVariable())
1388 OS << " nrvo";
1389 if (D->isInline())
1390 OS << " inline";
1391 if (D->isConstexpr())
1392 OS << " constexpr";
1393 if (D->hasInit()) {
1394 switch (D->getInitStyle()) {
1395 case VarDecl::CInit:
1396 OS << " cinit";
1397 break;
1398 case VarDecl::CallInit:
1399 OS << " callinit";
1400 break;
1401 case VarDecl::ListInit:
1402 OS << " listinit";
1403 break;
1404 }
1405 }
1406 if (D->needsDestruction(D->getASTContext()))
1407 OS << " destroyed";
1408 if (D->isParameterPack())
1409 OS << " pack";
1410 }
1411
1412 void TextNodeDumper::VisitBindingDecl(const BindingDecl *D) {
1413 dumpName(D);
1414 dumpType(D->getType());
1415 }
1416
1417 void TextNodeDumper::VisitCapturedDecl(const CapturedDecl *D) {
1418 if (D->isNothrow())
1419 OS << " nothrow";
1420 }
1421
1422 void TextNodeDumper::VisitImportDecl(const ImportDecl *D) {
1423 OS << ' ' << D->getImportedModule()->getFullModuleName();
1424
1425 for (Decl *InitD :
1426 D->getASTContext().getModuleInitializers(D->getImportedModule()))
1427 dumpDeclRef(InitD, "initializer");
1428 }
1429
1430 void TextNodeDumper::VisitPragmaCommentDecl(const PragmaCommentDecl *D) {
1431 OS << ' ';
1432 switch (D->getCommentKind()) {
1433 case PCK_Unknown:
1434 llvm_unreachable("unexpected pragma comment kind");
1435 case PCK_Compiler:
1436 OS << "compiler";
1437 break;
1438 case PCK_ExeStr:
1439 OS << "exestr";
1440 break;
1441 case PCK_Lib:
1442 OS << "lib";
1443 break;
1444 case PCK_Linker:
1445 OS << "linker";
1446 break;
1447 case PCK_User:
1448 OS << "user";
1449 break;
1450 }
1451 StringRef Arg = D->getArg();
1452 if (!Arg.empty())
1453 OS << " \"" << Arg << "\"";
1454 }
1455
1456 void TextNodeDumper::VisitPragmaDetectMismatchDecl(
1457 const PragmaDetectMismatchDecl *D) {
1458 OS << " \"" << D->getName() << "\" \"" << D->getValue() << "\"";
1459 }
1460
1461 void TextNodeDumper::VisitOMPExecutableDirective(
1462 const OMPExecutableDirective *D) {
1463 if (D->isStandaloneDirective())
1464 OS << " openmp_standalone_directive";
1465 }
1466
1467 void TextNodeDumper::VisitOMPDeclareReductionDecl(
1468 const OMPDeclareReductionDecl *D) {
1469 dumpName(D);
1470 dumpType(D->getType());
1471 OS << " combiner";
1472 dumpPointer(D->getCombiner());
1473 if (const auto *Initializer = D->getInitializer()) {
1474 OS << " initializer";
1475 dumpPointer(Initializer);
1476 switch (D->getInitializerKind()) {
1477 case OMPDeclareReductionDecl::DirectInit:
1478 OS << " omp_priv = ";
1479 break;
1480 case OMPDeclareReductionDecl::CopyInit:
1481 OS << " omp_priv ()";
1482 break;
1483 case OMPDeclareReductionDecl::CallInit:
1484 break;
1485 }
1486 }
1487 }
1488
1489 void TextNodeDumper::VisitOMPRequiresDecl(const OMPRequiresDecl *D) {
1490 for (const auto *C : D->clauselists()) {
1491 AddChild([=] {
1492 if (!C) {
1493 ColorScope Color(OS, ShowColors, NullColor);
1494 OS << "<<<NULL>>> OMPClause";
1495 return;
1496 }
1497 {
1498 ColorScope Color(OS, ShowColors, AttrColor);
1499 StringRef ClauseName(getOpenMPClauseName(C->getClauseKind()));
1500 OS << "OMP" << ClauseName.substr(/*Start=*/0, /*N=*/1).upper()
1501 << ClauseName.drop_front() << "Clause";
1502 }
1503 dumpPointer(C);
1504 dumpSourceRange(SourceRange(C->getBeginLoc(), C->getEndLoc()));
1505 });
1506 }
1507 }
1508
1509 void TextNodeDumper::VisitOMPCapturedExprDecl(const OMPCapturedExprDecl *D) {
1510 dumpName(D);
1511 dumpType(D->getType());
1512 }
1513
1514 void TextNodeDumper::VisitNamespaceDecl(const NamespaceDecl *D) {
1515 dumpName(D);
1516 if (D->isInline())
1517 OS << " inline";
1518 if (!D->isOriginalNamespace())
1519 dumpDeclRef(D->getOriginalNamespace(), "original");
1520 }
1521
1522 void TextNodeDumper::VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
1523 OS << ' ';
1524 dumpBareDeclRef(D->getNominatedNamespace());
1525 }
1526
1527 void TextNodeDumper::VisitNamespaceAliasDecl(const NamespaceAliasDecl *D) {
1528 dumpName(D);
1529 dumpDeclRef(D->getAliasedNamespace());
1530 }
1531
1532 void TextNodeDumper::VisitTypeAliasDecl(const TypeAliasDecl *D) {
1533 dumpName(D);
1534 dumpType(D->getUnderlyingType());
1535 }
1536
1537 void TextNodeDumper::VisitTypeAliasTemplateDecl(
1538 const TypeAliasTemplateDecl *D) {
1539 dumpName(D);
1540 }
1541
1542 void TextNodeDumper::VisitCXXRecordDecl(const CXXRecordDecl *D) {
1543 VisitRecordDecl(D);
1544 if (!D->isCompleteDefinition())
1545 return;
1546
1547 AddChild([=] {
1548 {
1549 ColorScope Color(OS, ShowColors, DeclKindNameColor);
1550 OS << "DefinitionData";
1551 }
1552 #define FLAG(fn, name) \
1553 if (D->fn()) \
1554 OS << " " #name;
1555 FLAG(isParsingBaseSpecifiers, parsing_base_specifiers);
1556
1557 FLAG(isGenericLambda, generic);
1558 FLAG(isLambda, lambda);
1559
1560 FLAG(isAnonymousStructOrUnion, is_anonymous);
1561 FLAG(canPassInRegisters, pass_in_registers);
1562 FLAG(isEmpty, empty);
1563 FLAG(isAggregate, aggregate);
1564 FLAG(isStandardLayout, standard_layout);
1565 FLAG(isTriviallyCopyable, trivially_copyable);
1566 FLAG(isPOD, pod);
1567 FLAG(isTrivial, trivial);
1568 FLAG(isPolymorphic, polymorphic);
1569 FLAG(isAbstract, abstract);
1570 FLAG(isLiteral, literal);
1571
1572 FLAG(hasUserDeclaredConstructor, has_user_declared_ctor);
1573 FLAG(hasConstexprNonCopyMoveConstructor, has_constexpr_non_copy_move_ctor);
1574 FLAG(hasMutableFields, has_mutable_fields);
1575 FLAG(hasVariantMembers, has_variant_members);
1576 FLAG(allowConstDefaultInit, can_const_default_init);
1577
1578 AddChild([=] {
1579 {
1580 ColorScope Color(OS, ShowColors, DeclKindNameColor);
1581 OS << "DefaultConstructor";
1582 }
1583 FLAG(hasDefaultConstructor, exists);
1584 FLAG(hasTrivialDefaultConstructor, trivial);
1585 FLAG(hasNonTrivialDefaultConstructor, non_trivial);
1586 FLAG(hasUserProvidedDefaultConstructor, user_provided);
1587 FLAG(hasConstexprDefaultConstructor, constexpr);
1588 FLAG(needsImplicitDefaultConstructor, needs_implicit);
1589 FLAG(defaultedDefaultConstructorIsConstexpr, defaulted_is_constexpr);
1590 });
1591
1592 AddChild([=] {
1593 {
1594 ColorScope Color(OS, ShowColors, DeclKindNameColor);
1595 OS << "CopyConstructor";
1596 }
1597 FLAG(hasSimpleCopyConstructor, simple);
1598 FLAG(hasTrivialCopyConstructor, trivial);
1599 FLAG(hasNonTrivialCopyConstructor, non_trivial);
1600 FLAG(hasUserDeclaredCopyConstructor, user_declared);
1601 FLAG(hasCopyConstructorWithConstParam, has_const_param);
1602 FLAG(needsImplicitCopyConstructor, needs_implicit);
1603 FLAG(needsOverloadResolutionForCopyConstructor,
1604 needs_overload_resolution);
1605 if (!D->needsOverloadResolutionForCopyConstructor())
1606 FLAG(defaultedCopyConstructorIsDeleted, defaulted_is_deleted);
1607 FLAG(implicitCopyConstructorHasConstParam, implicit_has_const_param);
1608 });
1609
1610 AddChild([=] {
1611 {
1612 ColorScope Color(OS, ShowColors, DeclKindNameColor);
1613 OS << "MoveConstructor";
1614 }
1615 FLAG(hasMoveConstructor, exists);
1616 FLAG(hasSimpleMoveConstructor, simple);
1617 FLAG(hasTrivialMoveConstructor, trivial);
1618 FLAG(hasNonTrivialMoveConstructor, non_trivial);
1619 FLAG(hasUserDeclaredMoveConstructor, user_declared);
1620 FLAG(needsImplicitMoveConstructor, needs_implicit);
1621 FLAG(needsOverloadResolutionForMoveConstructor,
1622 needs_overload_resolution);
1623 if (!D->needsOverloadResolutionForMoveConstructor())
1624 FLAG(defaultedMoveConstructorIsDeleted, defaulted_is_deleted);
1625 });
1626
1627 AddChild([=] {
1628 {
1629 ColorScope Color(OS, ShowColors, DeclKindNameColor);
1630 OS << "CopyAssignment";
1631 }
1632 FLAG(hasTrivialCopyAssignment, trivial);
1633 FLAG(hasNonTrivialCopyAssignment, non_trivial);
1634 FLAG(hasCopyAssignmentWithConstParam, has_const_param);
1635 FLAG(hasUserDeclaredCopyAssignment, user_declared);
1636 FLAG(needsImplicitCopyAssignment, needs_implicit);
1637 FLAG(needsOverloadResolutionForCopyAssignment, needs_overload_resolution);
1638 FLAG(implicitCopyAssignmentHasConstParam, implicit_has_const_param);
1639 });
1640
1641 AddChild([=] {
1642 {
1643 ColorScope Color(OS, ShowColors, DeclKindNameColor);
1644 OS << "MoveAssignment";
1645 }
1646 FLAG(hasMoveAssignment, exists);
1647 FLAG(hasSimpleMoveAssignment, simple);
1648 FLAG(hasTrivialMoveAssignment, trivial);
1649 FLAG(hasNonTrivialMoveAssignment, non_trivial);
1650 FLAG(hasUserDeclaredMoveAssignment, user_declared);
1651 FLAG(needsImplicitMoveAssignment, needs_implicit);
1652 FLAG(needsOverloadResolutionForMoveAssignment, needs_overload_resolution);
1653 });
1654
1655 AddChild([=] {
1656 {
1657 ColorScope Color(OS, ShowColors, DeclKindNameColor);
1658 OS << "Destructor";
1659 }
1660 FLAG(hasSimpleDestructor, simple);
1661 FLAG(hasIrrelevantDestructor, irrelevant);
1662 FLAG(hasTrivialDestructor, trivial);
1663 FLAG(hasNonTrivialDestructor, non_trivial);
1664 FLAG(hasUserDeclaredDestructor, user_declared);
1665 FLAG(hasConstexprDestructor, constexpr);
1666 FLAG(needsImplicitDestructor, needs_implicit);
1667 FLAG(needsOverloadResolutionForDestructor, needs_overload_resolution);
1668 if (!D->needsOverloadResolutionForDestructor())
1669 FLAG(defaultedDestructorIsDeleted, defaulted_is_deleted);
1670 });
1671 });
1672
1673 for (const auto &I : D->bases()) {
1674 AddChild([=] {
1675 if (I.isVirtual())
1676 OS << "virtual ";
1677 dumpAccessSpecifier(I.getAccessSpecifier());
1678 dumpType(I.getType());
1679 if (I.isPackExpansion())
1680 OS << "...";
1681 });
1682 }
1683 }
1684
1685 void TextNodeDumper::VisitFunctionTemplateDecl(const FunctionTemplateDecl *D) {
1686 dumpName(D);
1687 }
1688
1689 void TextNodeDumper::VisitClassTemplateDecl(const ClassTemplateDecl *D) {
1690 dumpName(D);
1691 }
1692
1693 void TextNodeDumper::VisitVarTemplateDecl(const VarTemplateDecl *D) {
1694 dumpName(D);
1695 }
1696
1697 void TextNodeDumper::VisitBuiltinTemplateDecl(const BuiltinTemplateDecl *D) {
1698 dumpName(D);
1699 }
1700
1701 void TextNodeDumper::VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) {
1702 if (const auto *TC = D->getTypeConstraint()) {
1703 OS << " ";
1704 dumpBareDeclRef(TC->getNamedConcept());
1705 if (TC->getNamedConcept() != TC->getFoundDecl()) {
1706 OS << " (";
1707 dumpBareDeclRef(TC->getFoundDecl());
1708 OS << ")";
1709 }
1710 Visit(TC->getImmediatelyDeclaredConstraint());
1711 } else if (D->wasDeclaredWithTypename())
1712 OS << " typename";
1713 else
1714 OS << " class";
1715 OS << " depth " << D->getDepth() << " index " << D->getIndex();
1716 if (D->isParameterPack())
1717 OS << " ...";
1718 dumpName(D);
1719 }
1720
1721 void TextNodeDumper::VisitNonTypeTemplateParmDecl(
1722 const NonTypeTemplateParmDecl *D) {
1723 dumpType(D->getType());
1724 OS << " depth " << D->getDepth() << " index " << D->getIndex();
1725 if (D->isParameterPack())
1726 OS << " ...";
1727 dumpName(D);
1728 }
1729
1730 void TextNodeDumper::VisitTemplateTemplateParmDecl(
1731 const TemplateTemplateParmDecl *D) {
1732 OS << " depth " << D->getDepth() << " index " << D->getIndex();
1733 if (D->isParameterPack())
1734 OS << " ...";
1735 dumpName(D);
1736 }
1737
1738 void TextNodeDumper::VisitUsingDecl(const UsingDecl *D) {
1739 OS << ' ';
1740 if (D->getQualifier())
1741 D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
1742 OS << D->getNameAsString();
1743 }
1744
1745 void TextNodeDumper::VisitUnresolvedUsingTypenameDecl(
1746 const UnresolvedUsingTypenameDecl *D) {
1747 OS << ' ';
1748 if (D->getQualifier())
1749 D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
1750 OS << D->getNameAsString();
1751 }
1752
1753 void TextNodeDumper::VisitUnresolvedUsingValueDecl(
1754 const UnresolvedUsingValueDecl *D) {
1755 OS << ' ';
1756 if (D->getQualifier())
1757 D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
1758 OS << D->getNameAsString();
1759 dumpType(D->getType());
1760 }
1761
1762 void TextNodeDumper::VisitUsingShadowDecl(const UsingShadowDecl *D) {
1763 OS << ' ';
1764 dumpBareDeclRef(D->getTargetDecl());
1765 }
1766
1767 void TextNodeDumper::VisitConstructorUsingShadowDecl(
1768 const ConstructorUsingShadowDecl *D) {
1769 if (D->constructsVirtualBase())
1770 OS << " virtual";
1771
1772 AddChild([=] {
1773 OS << "target ";
1774 dumpBareDeclRef(D->getTargetDecl());
1775 });
1776
1777 AddChild([=] {
1778 OS << "nominated ";
1779 dumpBareDeclRef(D->getNominatedBaseClass());
1780 OS << ' ';
1781 dumpBareDeclRef(D->getNominatedBaseClassShadowDecl());
1782 });
1783
1784 AddChild([=] {
1785 OS << "constructed ";
1786 dumpBareDeclRef(D->getConstructedBaseClass());
1787 OS << ' ';
1788 dumpBareDeclRef(D->getConstructedBaseClassShadowDecl());
1789 });
1790 }
1791
1792 void TextNodeDumper::VisitLinkageSpecDecl(const LinkageSpecDecl *D) {
1793 switch (D->getLanguage()) {
1794 case LinkageSpecDecl::lang_c:
1795 OS << " C";
1796 break;
1797 case LinkageSpecDecl::lang_cxx:
1798 OS << " C++";
1799 break;
1800 }
1801 }
1802
1803 void TextNodeDumper::VisitAccessSpecDecl(const AccessSpecDecl *D) {
1804 OS << ' ';
1805 dumpAccessSpecifier(D->getAccess());
1806 }
1807
1808 void TextNodeDumper::VisitFriendDecl(const FriendDecl *D) {
1809 if (TypeSourceInfo *T = D->getFriendType())
1810 dumpType(T->getType());
1811 }
1812
1813 void TextNodeDumper::VisitObjCIvarDecl(const ObjCIvarDecl *D) {
1814 dumpName(D);
1815 dumpType(D->getType());
1816 if (D->getSynthesize())
1817 OS << " synthesize";
1818
1819 switch (D->getAccessControl()) {
1820 case ObjCIvarDecl::None:
1821 OS << " none";
1822 break;
1823 case ObjCIvarDecl::Private:
1824 OS << " private";
1825 break;
1826 case ObjCIvarDecl::Protected:
1827 OS << " protected";
1828 break;
1829 case ObjCIvarDecl::Public:
1830 OS << " public";
1831 break;
1832 case ObjCIvarDecl::Package:
1833 OS << " package";
1834 break;
1835 }
1836 }
1837
1838 void TextNodeDumper::VisitObjCMethodDecl(const ObjCMethodDecl *D) {
1839 if (D->isInstanceMethod())
1840 OS << " -";
1841 else
1842 OS << " +";
1843 dumpName(D);
1844 dumpType(D->getReturnType());
1845
1846 if (D->isVariadic())
1847 OS << " variadic";
1848 }
1849
1850 void TextNodeDumper::VisitObjCTypeParamDecl(const ObjCTypeParamDecl *D) {
1851 dumpName(D);
1852 switch (D->getVariance()) {
1853 case ObjCTypeParamVariance::Invariant:
1854 break;
1855
1856 case ObjCTypeParamVariance::Covariant:
1857 OS << " covariant";
1858 break;
1859
1860 case ObjCTypeParamVariance::Contravariant:
1861 OS << " contravariant";
1862 break;
1863 }
1864
1865 if (D->hasExplicitBound())
1866 OS << " bounded";
1867 dumpType(D->getUnderlyingType());
1868 }
1869
1870 void TextNodeDumper::VisitObjCCategoryDecl(const ObjCCategoryDecl *D) {
1871 dumpName(D);
1872 dumpDeclRef(D->getClassInterface());
1873 dumpDeclRef(D->getImplementation());
1874 for (const auto *P : D->protocols())
1875 dumpDeclRef(P);
1876 }
1877
1878 void TextNodeDumper::VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D) {
1879 dumpName(D);
1880 dumpDeclRef(D->getClassInterface());
1881 dumpDeclRef(D->getCategoryDecl());
1882 }
1883
1884 void TextNodeDumper::VisitObjCProtocolDecl(const ObjCProtocolDecl *D) {
1885 dumpName(D);
1886
1887 for (const auto *Child : D->protocols())
1888 dumpDeclRef(Child);
1889 }
1890
1891 void TextNodeDumper::VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) {
1892 dumpName(D);
1893 dumpDeclRef(D->getSuperClass(), "super");
1894
1895 dumpDeclRef(D->getImplementation());
1896 for (const auto *Child : D->protocols())
1897 dumpDeclRef(Child);
1898 }
1899
1900 void TextNodeDumper::VisitObjCImplementationDecl(
1901 const ObjCImplementationDecl *D) {
1902 dumpName(D);
1903 dumpDeclRef(D->getSuperClass(), "super");
1904 dumpDeclRef(D->getClassInterface());
1905 }
1906
1907 void TextNodeDumper::VisitObjCCompatibleAliasDecl(
1908 const ObjCCompatibleAliasDecl *D) {
1909 dumpName(D);
1910 dumpDeclRef(D->getClassInterface());
1911 }
1912
1913 void TextNodeDumper::VisitObjCPropertyDecl(const ObjCPropertyDecl *D) {
1914 dumpName(D);
1915 dumpType(D->getType());
1916
1917 if (D->getPropertyImplementation() == ObjCPropertyDecl::Required)
1918 OS << " required";
1919 else if (D->getPropertyImplementation() == ObjCPropertyDecl::Optional)
1920 OS << " optional";
1921
1922 ObjCPropertyDecl::PropertyAttributeKind Attrs = D->getPropertyAttributes();
1923 if (Attrs != ObjCPropertyDecl::OBJC_PR_noattr) {
1924 if (Attrs & ObjCPropertyDecl::OBJC_PR_readonly)
1925 OS << " readonly";
1926 if (Attrs & ObjCPropertyDecl::OBJC_PR_assign)
1927 OS << " assign";
1928 if (Attrs & ObjCPropertyDecl::OBJC_PR_readwrite)
1929 OS << " readwrite";
1930 if (Attrs & ObjCPropertyDecl::OBJC_PR_retain)
1931 OS << " retain";
1932 if (Attrs & ObjCPropertyDecl::OBJC_PR_copy)
1933 OS << " copy";
1934 if (Attrs & ObjCPropertyDecl::OBJC_PR_nonatomic)
1935 OS << " nonatomic";
1936 if (Attrs & ObjCPropertyDecl::OBJC_PR_atomic)
1937 OS << " atomic";
1938 if (Attrs & ObjCPropertyDecl::OBJC_PR_weak)
1939 OS << " weak";
1940 if (Attrs & ObjCPropertyDecl::OBJC_PR_strong)
1941 OS << " strong";
1942 if (Attrs & ObjCPropertyDecl::OBJC_PR_unsafe_unretained)
1943 OS << " unsafe_unretained";
1944 if (Attrs & ObjCPropertyDecl::OBJC_PR_class)
1945 OS << " class";
1946 if (Attrs & ObjCPropertyDecl::OBJC_PR_direct)
1947 OS << " direct";
1948 if (Attrs & ObjCPropertyDecl::OBJC_PR_getter)
1949 dumpDeclRef(D->getGetterMethodDecl(), "getter");
1950 if (Attrs & ObjCPropertyDecl::OBJC_PR_setter)
1951 dumpDeclRef(D->getSetterMethodDecl(), "setter");
1952 }
1953 }
1954
1955 void TextNodeDumper::VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D) {
1956 dumpName(D->getPropertyDecl());
1957 if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize)
1958 OS << " synthesize";
1959 else
1960 OS << " dynamic";
1961 dumpDeclRef(D->getPropertyDecl());
1962 dumpDeclRef(D->getPropertyIvarDecl());
1963 }
1964
1965 void TextNodeDumper::VisitBlockDecl(const BlockDecl *D) {
1966 if (D->isVariadic())
1967 OS << " variadic";
1968
1969 if (D->capturesCXXThis())
1970 OS << " captures_this";
1971 }
1972
1973 void TextNodeDumper::VisitConceptDecl(const ConceptDecl *D) {
1974 dumpName(D);
1975 }
clang::ObjCPropertyRefExpr
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
Definition: ExprObjC.h:614
clang::CXXCtorInitializer::isBaseInitializer
bool isBaseInitializer() const
Determine whether this initializer is initializing a base class.
Definition: DeclCXX.h:2224
clang::ObjCMessageExpr::SuperInstance
The receiver is the instance of the superclass object.
Definition: ExprObjC.h:1107
clang::TextNodeDumper::VisitObjCIvarRefExpr
void VisitObjCIvarRefExpr(const ObjCIvarRefExpr *Node)
Definition: TextNodeDumper.cpp:749
clang::CastExpr::path_empty
bool path_empty() const
Definition: Expr.h:3220
clang::comments::ParamCommandComment::hasParamName
bool hasParamName() const
Definition: Comment.h:760
clang::TextNodeDumper::VisitVarTemplateDecl
void VisitVarTemplateDecl(const VarTemplateDecl *D)
Definition: TextNodeDumper.cpp:1693
clang::UsingShadowDecl::getTargetDecl
NamedDecl * getTargetDecl() const
Gets the underlying declaration which has been brought into the local scope.
Definition: DeclCXX.h:3224
clang::FunctionDecl
Represents a function declaration or definition.
Definition: Decl.h:1783
clang::StmtColor
static const TerminalColor StmtColor
Definition: ASTDumperUtils.h:49
clang::DeclRefExpr::getFoundDecl
NamedDecl * getFoundDecl()
Get the NamedDecl through which this reference occurred.
Definition: Expr.h:1284
clang::TextNodeDumper::VisitGenericSelectionExpr
void VisitGenericSelectionExpr(const GenericSelectionExpr *E)
Definition: TextNodeDumper.cpp:798
clang::ObjCBoolLiteralExpr::getValue
bool getValue() const
Definition: ExprObjC.h:97
clang::comments::ParamCommandComment::isVarArgParam
bool isVarArgParam() const LLVM_READONLY
Definition: Comment.h:778
clang::ObjCMessageExpr::Instance
The receiver is an object instance.
Definition: ExprObjC.h:1101
clang::TextNodeDumper::VisitCXXDeleteExpr
void VisitCXXDeleteExpr(const CXXDeleteExpr *Node)
Definition: TextNodeDumper.cpp:931
clang::ObjCInterfaceDecl::protocols
protocol_range protocols() const
Definition: DeclObjC.h:1380
clang::DynamicInitKind::Initializer
clang::comments::InlineCommandComment::RenderAnchor
Definition: Comment.h:315
clang::BlockDecl::Capture
A class which contains all the information about a particular captured value.
Definition: Decl.h:4043
clang::Decl::getOwningModule
Module * getOwningModule() const
Get the module that owns this declaration (for visibility purposes).
Definition: DeclBase.h:759
clang::UnresolvedUsingType
Represents the dependent type named by a dependently-scoped typename using declaration, e.g.
Definition: Type.h:4210
clang::TextNodeDumper::VisitIfStmt
void VisitIfStmt(const IfStmt *Node)
Definition: TextNodeDumper.cpp:654
clang::comments::BlockCommandComment::getArgText
StringRef getArgText(unsigned Idx) const
Definition: Comment.h:674
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:654
clang::TextNodeDumper::VisitNullPtrTemplateArgument
void VisitNullPtrTemplateArgument(const TemplateArgument &TA)
Definition: TextNodeDumper.cpp:602
clang::Decl::getDeclKindName
const char * getDeclKindName() const
Definition: DeclBase.cpp:123
clang::templateargumentvisitor::Base< llvm::make_const_ref, TextNodeDumper, void, ParamTys... >::VisitTemplateArgument
void VisitTemplateArgument(REF(TemplateArgument), ParamTys...)
Definition: TemplateArgumentVisitor.h:67
clang::CXXRecordDecl::bases
base_class_range bases()
Definition: DeclCXX.h:587
clang::MemberExpr::getMemberDecl
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Definition: Expr.h:2919
clang::comments::BlockCommandComment::getCommandID
unsigned getCommandID() const
Definition: Comment.h:652
clang::ObjCSubscriptRefExpr::getAtIndexMethodDecl
ObjCMethodDecl * getAtIndexMethodDecl() const
Definition: ExprObjC.h:896
clang::comments::InlineCommandComment::RenderEmphasized
Definition: Comment.h:314
clang::ObjCCategoryDecl::getClassInterface
ObjCInterfaceDecl * getClassInterface()
Definition: DeclObjC.h:2339
clang::ObjCMessageExpr::getSelector
Selector getSelector() const
Definition: ExprObjC.cpp:337
clang::TextNodeDumper::VisitCXXConstructExpr
void VisitCXXConstructExpr(const CXXConstructExpr *Node)
Definition: TextNodeDumper.cpp:898
clang::ObjCPropertyImplDecl::getPropertyIvarDecl
ObjCIvarDecl * getPropertyIvarDecl() const
Definition: DeclObjC.h:2846
clang::ObjCPropertyRefExpr::isSuperReceiver
bool isSuperReceiver() const
Definition: ExprObjC.h:776
clang::OMPDeclareReductionDecl::CallInit
Definition: DeclOpenMP.h:107
clang::IfStmt::hasVarStorage
bool hasVarStorage() const
True if this IfStmt has storage for a variable declaration.
Definition: Stmt.h:1904
dumpPreviousDeclImpl
static void dumpPreviousDeclImpl(raw_ostream &OS,...)
Definition: TextNodeDumper.cpp:21
clang::CXXUnresolvedConstructExpr::isListInitialization
bool isListInitialization() const
Determine whether this expression models list-initialization.
Definition: ExprCXX.h:3444
clang::comments::TParamCommandComment::isPositionValid
bool isPositionValid() const LLVM_READONLY
Definition: Comment.h:844
clang::templateargumentvisitor::Base< llvm::make_const_ref, ImplClass, RetTy, ParamTys... >::Visit
RetTy Visit(REF(TemplateArgument) TA, ParamTys... P)
Definition: TemplateArgumentVisitor.h:33
clang::AutoType::getTypeConstraintArguments
ArrayRef< TemplateArgument > getTypeConstraintArguments() const
Definition: Type.h:4904
clang::TextNodeDumper::VisitOMPCapturedExprDecl
void VisitOMPCapturedExprDecl(const OMPCapturedExprDecl *D)
Definition: TextNodeDumper.cpp:1509
clang::ObjCProtocolExpr::getProtocol
ObjCProtocolDecl * getProtocol() const
Definition: ExprObjC.h:519
clang::Stmt
Stmt - This represents one statement.
Definition: Stmt.h:66
clang::OMPExecutableDirective::isStandaloneDirective
bool isStandaloneDirective() const
Returns whether or not this is a Standalone directive.
Definition: StmtOpenMP.cpp:26
clang::FunctionType
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3422
clang::IfStmt
IfStmt - This represents an if/then/else.
Definition: Stmt.h:1834
clang::TextTreeStructure
Definition: TextNodeDumper.h:29
clang::ObjCSubscriptRefExpr::setAtIndexMethodDecl
ObjCMethodDecl * setAtIndexMethodDecl() const
Definition: ExprObjC.h:900
clang::EnumConstantDecl
An instance of this object exists for each enum constant that is defined.
Definition: Decl.h:2941
clang::VarDecl::getStorageClass
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:1029
Base
clang::TypedefDecl
Represents the declaration of a typedef-name via the &#39;typedef&#39; type specifier.
Definition: Decl.h:3173
clang::comments::VerbatimBlockComment::getCloseName
StringRef getCloseName() const
Definition: Comment.h:929
clang::TextNodeDumper::VisitOMPRequiresDecl
void VisitOMPRequiresDecl(const OMPRequiresDecl *D)
Definition: TextNodeDumper.cpp:1489
clang::AutoType::isDecltypeAuto
bool isDecltypeAuto() const
Definition: Type.h:4916
clang::TextNodeDumper::VisitPredefinedExpr
void VisitPredefinedExpr(const PredefinedExpr *Node)
Definition: TextNodeDumper.cpp:760
clang::TextNodeDumper::VisitCompoundAssignOperator
void VisitCompoundAssignOperator(const CompoundAssignOperator *Node)
Definition: TextNodeDumper.cpp:853
clang::PCK_Compiler
Definition: PragmaKinds.h:18
clang::TextNodeDumper::VisitFriendDecl
void VisitFriendDecl(const FriendDecl *D)
Definition: TextNodeDumper.cpp:1808
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
clang::CXXRecordDecl::needsOverloadResolutionForDestructor
bool needsOverloadResolutionForDestructor() const
Determine whether we need to eagerly declare a destructor for this class.
Definition: DeclCXX.h:955
clang::TagType::getDecl
TagDecl * getDecl() const
Definition: Type.cpp:3296
clang::TextNodeDumper::VisitObjCProtocolExpr
void VisitObjCProtocolExpr(const ObjCProtocolExpr *Node)
Definition: TextNodeDumper.cpp:1008
clang::ObjCPropertyRefExpr::getImplicitPropertySetter
ObjCMethodDecl * getImplicitPropertySetter() const
Definition: ExprObjC.h:717
clang::TextNodeDumper::VisitObjCCategoryDecl
void VisitObjCCategoryDecl(const ObjCCategoryDecl *D)
Definition: TextNodeDumper.cpp:1870
clang::CapturedDecl::isNothrow
bool isNothrow() const
Definition: Decl.cpp:4751
clang::CXXNewExpr::getOperatorNew
FunctionDecl * getOperatorNew() const
Definition: ExprCXX.h:2218
clang::CXXBaseSpecifier::isVirtual
bool isVirtual() const
Determines whether the base class is a virtual base class (or not).
Definition: DeclCXX.h:198
clang::UnresolvedLookupExpr
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
Definition: ExprCXX.h:3037
DeclTemplate.h
Defines the C++ template declaration subclasses.
clang::BinaryOperator::getOpcode
Opcode getOpcode() const
Definition: Expr.h:3469
clang::AutoType
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
Definition: Type.h:4874
clang::TextNodeDumper::visitTParamCommandComment
void visitTParamCommandComment(const comments::TParamCommandComment *C, const comments::FullComment *FC)
Definition: TextNodeDumper.cpp:548
clang::TextNodeDumper::VisitCaseStmt
void VisitCaseStmt(const CaseStmt *Node)
Definition: TextNodeDumper.cpp:684
clang::IntegerLiteral
Definition: Expr.h:1446
clang::Type
The base class of the type hierarchy.
Definition: Type.h:1450
clang::CXXConstructExpr::requiresZeroInitialization
bool requiresZeroInitialization() const
Whether this construction first requires zero-initialization before the initializer is called...
Definition: ExprCXX.h:1533
clang::TextNodeDumper::VisitCastExpr
void VisitCastExpr(const CastExpr *Node)
Definition: TextNodeDumper.cpp:702
clang::ObjCTypeParamVariance::Covariant
The parameter is covariant, e.g., X<T> is a subtype of X<U> when the type parameter is covariant and ...
clang::VarTemplateDecl
Declaration of a variable template.
Definition: DeclTemplate.h:3070
clang::ArrayType
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2889
clang::TextNodeDumper::VisitImportDecl
void VisitImportDecl(const ImportDecl *D)
Definition: TextNodeDumper.cpp:1422
clang::NamespaceDecl
Represent a C++ namespace.
Definition: Decl.h:497
clang::CXXConstructExpr
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1422
clang::ObjCSubscriptRefExpr
ObjCSubscriptRefExpr - used for array and dictionary subscripting.
Definition: ExprObjC.h:845
clang::TypeVisitor::Visit
RetTy Visit(const Type *T)
Performs the operation associated with this visitor object.
Definition: TypeVisitor.h:68
clang::AccessSpecifier
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:113
clang::comments::ParamCommandComment::getParamName
StringRef getParamName(const FullComment *FC) const
Definition: Comment.cpp:371
clang::TypeSourceInfo
A container of type source information.
Definition: Type.h:6227
clang::TextNodeDumper::VisitFunctionTemplateDecl
void VisitFunctionTemplateDecl(const FunctionTemplateDecl *D)
Definition: TextNodeDumper.cpp:1685
clang::SwitchStmt::hasVarStorage
bool hasVarStorage() const
True if this SwitchStmt has storage for a condition variable.
Definition: Stmt.h:2101
clang::PredefinedExpr::getIdentKind
IdentKind getIdentKind() const
Definition: Expr.h:1951
clang::TextNodeDumper::VisitObjCBoolLiteralExpr
void VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *Node)
Definition: TextNodeDumper.cpp:1064
clang::TemplateTypeParmType::getDecl
TemplateTypeParmDecl * getDecl() const
Definition: Type.h:4694
clang::CXXConstructorDecl
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2383
clang::MaterializeTemporaryExpr
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
Definition: ExprCXX.h:4419
clang::FunctionDecl::isVirtualAsWritten
bool isVirtualAsWritten() const
Whether this function is marked as virtual explicitly.
Definition: Decl.h:2096
clang::CXXRecordDecl::needsOverloadResolutionForCopyConstructor
bool needsOverloadResolutionForCopyConstructor() const
Determine whether we need to eagerly declare a defaulted copy constructor for this class...
Definition: DeclCXX.h:772
clang::TextNodeDumper::VisitObjCProtocolDecl
void VisitObjCProtocolDecl(const ObjCProtocolDecl *D)
Definition: TextNodeDumper.cpp:1884
clang::ObjectKindColor
static const TerminalColor ObjectKindColor
Definition: ASTDumperUtils.h:64
clang::NOUR_Unevaluated
This name appears in an unevaluated operand.
Definition: Specifiers.h:164
clang::TextNodeDumper::dumpSourceRange
void dumpSourceRange(SourceRange R)
Definition: TextNodeDumper.cpp:370
clang::TagDecl::isCompleteDefinition
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition: Decl.h:3324
clang::PragmaCommentDecl
Represents a #pragma comment line.
Definition: Decl.h:114
clang::TextNodeDumper::VisitSizeOfPackExpr
void VisitSizeOfPackExpr(const SizeOfPackExpr *Node)
Definition: TextNodeDumper.cpp:955
clang::TextNodeDumper::VisitTypedefDecl
void VisitTypedefDecl(const TypedefDecl *D)
Definition: TextNodeDumper.cpp:1235
clang::CastExpr::path_const_iterator
const CXXBaseSpecifier *const * path_const_iterator
Definition: Expr.h:3219
clang::TemplateParmPosition::getDepth
unsigned getDepth() const
Get the nesting depth of the template parameter.
Definition: DeclTemplate.h:1160
clang::FriendDecl
FriendDecl - Represents the declaration of a friend entity, which can be a function, a type, or a templated function or type.
Definition: DeclFriend.h:53
clang::OK_ObjCSubscript
An Objective-C array/dictionary subscripting which reads an object or writes at the subscripted array...
Definition: Specifiers.h:156
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:820
clang::comments::InlineCommandComment::getArgText
StringRef getArgText(unsigned Idx) const
Definition: Comment.h:362
clang::TextNodeDumper::VisitTagType
void VisitTagType(const TagType *T)
Definition: TextNodeDumper.cpp:1188
clang::SC_None
Definition: Specifiers.h:237
clang::ObjCPropertyDecl::PropertyAttributeKind
PropertyAttributeKind
Definition: DeclObjC.h:745
clang::EnumDecl::isFixed
bool isFixed() const
Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...
Definition: Decl.h:3684
clang::Type::getAs
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:7002
clang::ObjCCategoryDecl::getImplementation
ObjCCategoryImplDecl * getImplementation() const
Definition: DeclObjC.cpp:2045
clang::TextNodeDumper::VisitExtVectorElementExpr
void VisitExtVectorElementExpr(const ExtVectorElementExpr *Node)
Definition: TextNodeDumper.cpp:844
clang::FunctionProtoType::ExtProtoInfo
Extra information about a function prototype.
Definition: Type.h:3837
clang::APValue::dump
void dump() const
Definition: APValue.cpp:381
clang::ObjCMethodDecl
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:138
clang::SwitchStmt::hasInitStorage
bool hasInitStorage() const
True if this SwitchStmt has storage for an init statement.
Definition: Stmt.h:2098
clang::TextNodeDumper::VisitObjCInterfaceDecl
void VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D)
Definition: TextNodeDumper.cpp:1891
clang::TextNodeDumper::VisitVectorType
void VisitVectorType(const VectorType *T)
Definition: TextNodeDumper.cpp:1111
clang::TextNodeDumper::VisitClassTemplateDecl
void VisitClassTemplateDecl(const ClassTemplateDecl *D)
Definition: TextNodeDumper.cpp:1689
clang::OverloadExpr::getName
DeclarationName getName() const
Gets the name looked up.
Definition: ExprCXX.h:2953
clang::FunctionType::isConst
bool isConst() const
Definition: Type.h:3697
clang::LabelStmt::getName
const char * getName() const
Definition: Stmt.cpp:352
clang::Decl::isInvalidDecl
bool isInvalidDecl() const
Definition: DeclBase.h:553
clang::UnresolvedLookupExpr::requiresADL
bool requiresADL() const
True if this declaration should be extended by argument-dependent lookup.
Definition: ExprCXX.h:3105
clang::VarDecl::TLS_None
Not a TLS variable.
Definition: Decl.h:837
clang::PrintingPolicy
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:47
clang::comments::TParamCommandComment::getIndex
unsigned getIndex(unsigned Depth) const
Definition: Comment.h:853
clang::ObjCProtocolDecl::protocols
protocol_range protocols() const
Definition: DeclObjC.h:2143
clang::ExprWithCleanups
Represents an expression – generally a full-expression – that introduces cleanups to be run at the ...
Definition: ExprCXX.h:3306
clang::BuiltinTemplateDecl
Represents the builtin template declaration which is used to implement __make_integer_seq and other b...
Definition: DeclTemplate.h:1763
clang::TextNodeDumper::VisitBindingDecl
void VisitBindingDecl(const BindingDecl *D)
Definition: TextNodeDumper.cpp:1412
clang::ObjCImplementationDecl::getSuperClass
const ObjCInterfaceDecl * getSuperClass() const
Definition: DeclObjC.h:2703
clang::ObjCPropertyRefExpr::getExplicitProperty
ObjCPropertyDecl * getExplicitProperty() const
Definition: ExprObjC.h:707
clang::TextNodeDumper::VisitDeclarationTemplateArgument
void VisitDeclarationTemplateArgument(const TemplateArgument &TA)
Definition: TextNodeDumper.cpp:596
clang::comments::TParamCommandComment::getDepth
unsigned getDepth() const
Definition: Comment.h:848
clang::TextNodeDumper::VisitTemplateSpecializationType
void VisitTemplateSpecializationType(const TemplateSpecializationType *T)
Definition: TextNodeDumper.cpp:1211
clang::comments::CommandInfo
Information about a single command.
Definition: CommentCommandTraits.h:32
clang::Stmt::getStmtClassName
const char * getStmtClassName() const
Definition: Stmt.cpp:76
clang::DependentSizedExtVectorType::getAttributeLoc
SourceLocation getAttributeLoc() const
Definition: Type.h:3212
clang::LabelStmt
LabelStmt - Represents a label, which has a substatement.
Definition: Stmt.h:1732
clang::RecordDecl
Represents a struct/union/class.
Definition: Decl.h:3748
clang::TextNodeDumper::VisitCXXNamedCastExpr
void VisitCXXNamedCastExpr(const CXXNamedCastExpr *Node)
Definition: TextNodeDumper.cpp:867
clang::OMPRequiresDecl::clauselists
clauselist_range clauselists()
Definition: DeclOpenMP.h:390
clang::LinkageSpecDecl::getLanguage
LanguageIDs getLanguage() const
Return the language specified by this linkage specification.
Definition: DeclCXX.h:2807
clang::TextNodeDumper::VisitBuiltinTemplateDecl
void VisitBuiltinTemplateDecl(const BuiltinTemplateDecl *D)
Definition: TextNodeDumper.cpp:1697
clang::NamedDecl::getDeclName
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:272
clang::getOpenMPClauseName
const char * getOpenMPClauseName(OpenMPClauseKind Kind)
Definition: OpenMPKinds.cpp:82
clang::Redeclarable
Provides common interface for the Decls that can be redeclared.
Definition: Redeclarable.h:84
clang::TextNodeDumper::VisitMaterializeTemporaryExpr
void VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *Node)
Definition: TextNodeDumper.cpp:942
clang::FriendDecl::getFriendType
TypeSourceInfo * getFriendType() const
If this friend declaration names an (untemplated but possibly dependent) type, return the type; other...
Definition: DeclFriend.h:123
clang::TemplateTypeParmDecl::getDepth
unsigned getDepth() const
Retrieve the depth of the template parameter.
Definition: DeclTemplate.cpp:642
clang::OMPDeclareReductionDecl::CopyInit
Definition: DeclOpenMP.h:109
clang::comments::VerbatimLineComment::getText
StringRef getText() const
Definition: Comment.h:972
clang::LifetimeExtendedTemporaryDecl::getExtendingDecl
ValueDecl * getExtendingDecl()
Definition: DeclCXX.h:3112
clang::CompoundAssignOperator::getComputationResultType
QualType getComputationResultType() const
Definition: Expr.h:3680
clang::VarDecl::needsDestruction
QualType::DestructionKind needsDestruction(const ASTContext &Ctx) const
Would the destruction of this variable have any effect, and if so, what kind?
Definition: Decl.cpp:2613
clang::Attr::isImplicit
bool isImplicit() const
Returns true if the attribute has been implicitly created instead of explicitly written by the user...
Definition: Attr.h:98
clang::TextNodeDumper::VisitObjCIvarDecl
void VisitObjCIvarDecl(const ObjCIvarDecl *D)
Definition: TextNodeDumper.cpp:1813
clang::OK_VectorComponent
A vector component is an element or range of elements on a vector.
Definition: Specifiers.h:147
clang::NamespaceDecl::isInline
bool isInline() const
Returns true if this is an inline namespace declaration.
Definition: Decl.h:558
clang::VectorType::NeonVector
is ARM Neon vector
Definition: Type.h:3251
clang::comments::InlineCommandComment::getRenderKind
RenderKind getRenderKind() const
Definition: Comment.h:354
clang::ObjCPropertyDecl::Required
Definition: DeclObjC.h:774
clang::UETT_PreferredAlignOf
Used for GCC&#39;s __alignof.
Definition: TypeTraits.h:106
clang::ObjCTypeParamVariance::Contravariant
The parameter is contravariant, e.g., X<T> is a subtype of X<U> when the type parameter is covariant ...
clang::ReferenceType::isSpelledAsLValue
bool isSpelledAsLValue() const
Definition: Type.h:2766
clang::comments::InlineCommandComment::RenderBold
Definition: Comment.h:312
clang::TextNodeDumper::VisitPackTemplateArgument
void VisitPackTemplateArgument(const TemplateArgument &TA)
Definition: TextNodeDumper.cpp:625
clang::FieldDecl
Represents a member of a struct/union/class.
Definition: Decl.h:2729
clang::TextNodeDumper::VisitEnumConstantDecl
void VisitEnumConstantDecl(const EnumConstantDecl *D)
Definition: TextNodeDumper.cpp:1265
clang::TemplateSpecializationType::getTemplateName
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
Definition: Type.h:5059
clang::CXXCtorInitializer::getTypeSourceInfo
TypeSourceInfo * getTypeSourceInfo() const
Returns the declarator information for a base class or delegating initializer.
Definition: DeclCXX.h:2285
clang::ArrayType::Static
Definition: Type.h:2896
clang::TextNodeDumper::VisitUnresolvedUsingValueDecl
void VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl *D)
Definition: TextNodeDumper.cpp:1753
clang::comments::VerbatimBlockLineComment::getText
StringRef getText() const LLVM_READONLY
Definition: Comment.h:885
clang::PragmaDetectMismatchDecl::getValue
StringRef getValue() const
Definition: Decl.h:172
clang::TextNodeDumper::VisitTypeAliasDecl
void VisitTypeAliasDecl(const TypeAliasDecl *D)
Definition: TextNodeDumper.cpp:1532
clang::OMPDeclareReductionDecl::getInitializerKind
InitKind getInitializerKind() const
Get initializer kind.
Definition: DeclOpenMP.h:173
clang::ObjCPropertyDecl::getSetterMethodDecl
ObjCMethodDecl * getSetterMethodDecl() const
Definition: DeclObjC.h:939
clang::UnresolvedSetIterator
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:32
clang::TextNodeDumper::VisitFunctionProtoType
void VisitFunctionProtoType(const FunctionProtoType *T)
Definition: TextNodeDumper.cpp:1145
clang::Decl::getSourceRange
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
Definition: DeclBase.h:417
clang::FixedPointLiteral
Definition: Expr.h:1489
clang::TextNodeDumper::VisitObjCPropertyImplDecl
void VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D)
Definition: TextNodeDumper.cpp:1955
clang::ExtVectorElementExpr
ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...
Definition: Expr.h:5518
clang::AccessSpecDecl
Represents an access specifier followed by colon &#39;:&#39;.
Definition: DeclCXX.h:85
clang::TextNodeDumper::VisitUsingDecl
void VisitUsingDecl(const UsingDecl *D)
Definition: TextNodeDumper.cpp:1738
clang::Module
Describes a module or submodule.
Definition: Module.h:64
LocInfoType.h
clang::VK_RValue
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:125
clang::ObjCSelectorExpr::getSelector
Selector getSelector() const
Definition: ExprObjC.h:467
clang::ObjCAtCatchStmt
Represents Objective-C&#39;s @catch statement.
Definition: StmtObjC.h:77
clang::TextNodeDumper::VisitTemplateTemplateParmDecl
void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D)
Definition: TextNodeDumper.cpp:1730
clang::BinaryOperator::getOpcodeStr
StringRef getOpcodeStr() const
Definition: Expr.h:3490
clang::TextNodeDumper::VisitSwitchStmt
void VisitSwitchStmt(const SwitchStmt *Node)
Definition: TextNodeDumper.cpp:663
clang::comments::InlineCommandComment
A command with word-like arguments that is considered inline content.
Definition: Comment.h:299
clang::InitListExpr
Describes an C or C++ initializer list.
Definition: Expr.h:4403
clang::UsingDecl
Represents a C++ using-declaration.
Definition: DeclCXX.h:3369
clang::TextNodeDumper::VisitRecordDecl
void VisitRecordDecl(const RecordDecl *D)
Definition: TextNodeDumper.cpp:1256
clang::TextNodeDumper::VisitCXXBindTemporaryExpr
void VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *Node)
Definition: TextNodeDumper.cpp:911
clang::OMPDeclareReductionDecl::getInitializer
Expr * getInitializer()
Get initializer expression (if specified) of the declare reduction construct.
Definition: DeclOpenMP.h:170
clang::UnresolvedUsingType::getDecl
UnresolvedUsingTypenameDecl * getDecl() const
Definition: Type.h:4221
clang::GenericSelectionExpr::ConstAssociation
AssociationTy< true > ConstAssociation
Definition: Expr.h:5394
clang::TextNodeDumper::VisitPragmaDetectMismatchDecl
void VisitPragmaDetectMismatchDecl(const PragmaDetectMismatchDecl *D)
Definition: TextNodeDumper.cpp:1456
clang::RQ_LValue
An lvalue ref-qualifier was provided (&).
Definition: Type.h:1406
clang::comments::VerbatimBlockLineComment
A line of text contained in a verbatim block.
Definition: Comment.h:865
clang::ObjCPropertyRefExpr::isMessagingSetter
bool isMessagingSetter() const
True if the property reference will result in a message to the setter.
Definition: ExprObjC.h:744
clang::CXXDeleteExpr::getOperatorDelete
FunctionDecl * getOperatorDelete() const
Definition: ExprCXX.h:2399
clang::LinkageSpecDecl::lang_c
Definition: DeclCXX.h:2787
clang::TextNodeDumper::VisitOMPDeclareReductionDecl
void VisitOMPDeclareReductionDecl(const OMPDeclareReductionDecl *D)
Definition: TextNodeDumper.cpp:1467
clang::AS_private
Definition: Specifiers.h:116
clang::Module::getFullModuleName
std::string getFullModuleName(bool AllowStringLiterals=false) const
Retrieve the full name of this module, including the path from its top-level module.
Definition: Module.cpp:213
clang::CXXConstructExpr::isElidable
bool isElidable() const
Whether this construction is elidable.
Definition: ExprCXX.h:1500
clang::CXXNewExpr::isGlobalNew
bool isGlobalNew() const
Definition: ExprCXX.h:2259
clang::comments::TextComment
Plain text.
Definition: Comment.h:263
clang::comments::VerbatimLineComment
A verbatim line command.
Definition: Comment.h:945
clang::TextNodeDumper::VisitUnresolvedLookupExpr
void VisitUnresolvedLookupExpr(const UnresolvedLookupExpr *Node)
Definition: TextNodeDumper.cpp:734
clang::TemplateTypeParmDecl::getTypeConstraint
const TypeConstraint * getTypeConstraint() const
Returns the type constraint associated with this template parameter (if any).
Definition: DeclTemplate.h:1345
clang::IndirectFieldDecl::chain
ArrayRef< NamedDecl * > chain() const
Definition: Decl.h:3002
clang::VK_XValue
An x-value expression is a reference to an object with independent storage but which can be "moved"...
Definition: Specifiers.h:134
clang::ComparisonCategoryType::First
clang::TemplateSpecializationType::isTypeAlias
bool isTypeAlias() const
Determine if this template specialization type is for a type alias template that has been substituted...
Definition: Type.h:5044
clang::CastExpr::path_begin
path_iterator path_begin()
Definition: Expr.h:3222
clang::ObjCPropertyDecl::getPropertyAttributes
PropertyAttributeKind getPropertyAttributes() const
Definition: DeclObjC.h:853
clang::TextNodeDumper::VisitObjCSubscriptRefExpr
void VisitObjCSubscriptRefExpr(const ObjCSubscriptRefExpr *Node)
Definition: TextNodeDumper.cpp:1043
clang::AutoType::isConstrained
bool isConstrained() const
Definition: Type.h:4912
clang::ASTContext::getPrintingPolicy
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:671
clang::BlockDecl::Capture::isByRef
bool isByRef() const
Whether this is a "by ref" capture, i.e.
Definition: Decl.h:4068
clang::Type::containsUnexpandedParameterPack
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
Definition: Type.h:1896
clang::BinaryOperator
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3434
clang::ObjCPropertyDecl::OBJC_PR_nonatomic
Definition: DeclObjC.h:753
clang::UnaryOperator::isPostfix
static bool isPostfix(Opcode Op)
isPostfix - Return true if this is a postfix operation, like x++.
Definition: Expr.h:2093
clang::comments::Comment
Any part of the comment.
Definition: Comment.h:52
clang::TextNodeDumper::VisitObjCAtCatchStmt
void VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node)
Definition: TextNodeDumper.cpp:994
clang::IfStmt::hasElseStorage
bool hasElseStorage() const
True if this IfStmt has storage for an else statement.
Definition: Stmt.h:1907
clang::InjectedClassNameType::getDecl
CXXRecordDecl * getDecl() const
Definition: Type.cpp:3386
clang::MemberExpr::isArrow
bool isArrow() const
Definition: Expr.h:3020
clang::VarDecl::isConstexpr
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition: Decl.h:1412
clang::DeclNameColor
static const TerminalColor DeclNameColor
Definition: ASTDumperUtils.h:79
clang::PCK_Lib
Definition: PragmaKinds.h:17
clang::TextNodeDumper::VisitTemplateTypeParmType
void VisitTemplateTypeParmType(const TemplateTypeParmType *T)
Definition: TextNodeDumper.cpp:1192
clang::TextNodeDumper::VisitTemplateExpansionTemplateArgument
void VisitTemplateExpansionTemplateArgument(const TemplateArgument &TA)
Definition: TextNodeDumper.cpp:615
clang::LocationColor
static const TerminalColor LocationColor
Definition: ASTDumperUtils.h:59
clang::TextNodeDumper::VisitExpressionTemplateArgument
void VisitExpressionTemplateArgument(const TemplateArgument &TA)
Definition: TextNodeDumper.cpp:621
clang::CaseStmt
CaseStmt - Represent a case statement.
Definition: Stmt.h:1500
clang::TemplateParmPosition::getIndex
unsigned getIndex() const
Get the index of the template parameter within its parameter list.
Definition: DeclTemplate.h:1168
clang::CXXCtorInitializer::isAnyMemberInitializer
bool isAnyMemberInitializer() const
Definition: DeclCXX.h:2232
clang::TextNodeDumper::dumpLocation
void dumpLocation(SourceLocation Loc)
Definition: TextNodeDumper.cpp:341
clang::CastExpr
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:3150
clang::ObjCProtocolDecl
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:2078
clang::comments::ParamCommandComment::getParamIndex
unsigned getParamIndex() const LLVM_READONLY
Definition: Comment.h:787
clang::CXXBindTemporaryExpr
Represents binding an expression to a temporary.
Definition: ExprCXX.h:1373
clang::Decl::getLexicalDeclContext
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC)...
Definition: DeclBase.h:828
clang::SourceManager::getSpellingLoc
SourceLocation getSpellingLoc(SourceLocation Loc) const
Given a SourceLocation object, return the spelling location referenced by the ID. ...
Definition: SourceManager.h:1207
clang::CXXCtorInitializer::getAnyMember
FieldDecl * getAnyMember() const
Definition: DeclCXX.h:2297
clang::ObjCPropertyDecl::getPropertyImplementation
PropertyControl getPropertyImplementation() const
Definition: DeclObjC.h:947
clang::QualType::getAsOpaquePtr
void * getAsOpaquePtr() const
Definition: Type.h:699
clang::TextNodeDumper::VisitLabelStmt
void VisitLabelStmt(const LabelStmt *Node)
Definition: TextNodeDumper.cpp:675
clang::OK_Ordinary
An ordinary object is located at an address in memory.
Definition: Specifiers.h:141
clang::ObjCTypeParamDecl::hasExplicitBound
bool hasExplicitBound() const
Whether this type parameter has an explicitly-written type bound, e.g., "T : NSView".
Definition: DeclObjC.h:631
clang::CXXDependentScopeMemberExpr
Represents a C++ member access expression where the actual member referenced could not be resolved be...
Definition: ExprCXX.h:3511
clang::FloatingLiteral
Definition: Expr.h:1583
clang::CapturedDecl
Represents the body of a CapturedStmt, and serves as its DeclContext.
Definition: Decl.h:4226
clang::ObjCInterfaceDecl
Represents an ObjC class declaration.
Definition: DeclObjC.h:1186
clang::NOUR_None
This is an odr-use.
Definition: Specifiers.h:162
clang::LinkageSpecDecl
Represents a linkage specification.
Definition: DeclCXX.h:2778
clang::ObjCMethodDecl::getReturnType
QualType getReturnType() const
Definition: DeclObjC.h:324
clang::NestedNameSpecifier::print
void print(raw_ostream &OS, const PrintingPolicy &Policy, bool ResolveTemplateArguments=false) const
Print this nested name specifier to the given output stream.
Definition: NestedNameSpecifier.cpp:273
clang::TextNodeDumper::VisitObjCImplementationDecl
void VisitObjCImplementationDecl(const ObjCImplementationDecl *D)
Definition: TextNodeDumper.cpp:1900
clang::VectorType::NeonPolyVector
is ARM Neon polynomial vector
Definition: Type.h:3254
clang::TemplateTemplateParmDecl::isParameterPack
bool isParameterPack() const
Whether this template template parameter is a template parameter pack.
Definition: DeclTemplate.h:1669
clang::FunctionProtoType::ExceptionSpecInfo::SourceDecl
FunctionDecl * SourceDecl
The function whose exception specification this is, for EST_Unevaluated and EST_Uninstantiated.
Definition: Type.h:3823
clang::QualType::getSplitDesugaredType
SplitQualType getSplitDesugaredType() const
Definition: Type.h:958
clang::BindingDecl
A binding in a decomposition declaration.
Definition: DeclCXX.h:3812
clang::comments::HTMLStartTagComment::isSelfClosing
bool isSelfClosing() const
Definition: Comment.h:499
clang::TextNodeDumper::visitHTMLStartTagComment
void visitHTMLStartTagComment(const comments::HTMLStartTagComment *C, const comments::FullComment *)
Definition: TextNodeDumper.cpp:501
clang::DependentSizedExtVectorType
Represents an extended vector type where either the type or size is dependent.
Definition: Type.h:3195
clang::TextNodeDumper::visitVerbatimBlockComment
void visitVerbatimBlockComment(const comments::VerbatimBlockComment *C, const comments::FullComment *)
Definition: TextNodeDumper.cpp:568
clang::FunctionDecl::param_begin
param_iterator param_begin()
Definition: Decl.h:2411
clang::CXXThisExpr
Represents the this expression in C++.
Definition: ExprCXX.h:1097
clang::ImportDecl::getImportedModule
Module * getImportedModule() const
Retrieve the module that was imported by the import declaration.
Definition: Decl.h:4375
clang::ObjCIvarRefExpr::getDecl
ObjCIvarDecl * getDecl()
Definition: ExprObjC.h:576
clang::AS_none
Definition: Specifiers.h:117
clang::PragmaCommentDecl::getArg
StringRef getArg() const
Definition: Decl.h:139
clang::CXXDeleteExpr::isArrayForm
bool isArrayForm() const
Definition: ExprCXX.h:2386
canPassInRegisters
static bool canPassInRegisters(Sema &S, CXXRecordDecl *D, TargetInfo::CallingConvKind CCK)
Determine whether a type is permitted to be passed or returned in registers, per C++ [class...
Definition: SemaDeclCXX.cpp:6204
clang::ObjCPropertyImplDecl
ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category imp...
Definition: DeclObjC.h:2773
FLAG
#define FLAG(fn, name)
clang::ExplicitCastExpr::getTypeAsWritten
QualType getTypeAsWritten() const
getTypeAsWritten - Returns the type that this expression is casting to, as written in the source code...
Definition: Expr.h:3360
clang::comments::CommandInfo::Name
const char * Name
Definition: CommentCommandTraits.h:37
clang::Mergeable::getFirstDecl
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
Definition: Redeclarable.h:318
clang::comments::VerbatimBlockComment
A verbatim block command (e.
Definition: Comment.h:893
clang::TextNodeDumper::VisitInjectedClassNameType
void VisitInjectedClassNameType(const InjectedClassNameType *T)
Definition: TextNodeDumper.cpp:1219
clang::TextNodeDumper::VisitDependentSizedExtVectorType
void VisitDependentSizedExtVectorType(const DependentSizedExtVectorType *T)
Definition: TextNodeDumper.cpp:1105
clang::TextNodeDumper::VisitTemplateTemplateArgument
void VisitTemplateTemplateArgument(const TemplateArgument &TA)
Definition: TextNodeDumper.cpp:610
clang::comments::TextComment::getText
StringRef getText() const LLVM_READONLY
Definition: Comment.h:283
clang::CXXConstructExpr::isStdInitListInitialization
bool isStdInitListInitialization() const
Whether this constructor call was written as list-initialization, but was interpreted as forming a st...
Definition: ExprCXX.h:1524
clang::TypeAliasDecl
Represents the declaration of a typedef-name via a C++11 alias-declaration.
Definition: Decl.h:3193
clang::ASTContext::getModulesWithMergedDefinition
ArrayRef< Module * > getModulesWithMergedDefinition(const NamedDecl *Def)
Get the additional modules in which the definition Def has been merged.
Definition: ASTContext.h:990
clang::FunctionProtoType
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3754
clang::TextNodeDumper::VisitImplicitCastExpr
void VisitImplicitCastExpr(const ImplicitCastExpr *Node)
Definition: TextNodeDumper.cpp:712
clang::MaterializeTemporaryExpr::getExtendingDecl
ValueDecl * getExtendingDecl()
Get the declaration which triggered the lifetime-extension of this temporary, if any.
Definition: ExprCXX.h:4469
clang::CXXConstructExpr::getConstructor
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Definition: ExprCXX.h:1494
clang::comments::InlineCommandComment::getCommandID
unsigned getCommandID() const
Definition: Comment.h:342
clang::CompoundAssignOperator::getComputationLHSType
QualType getComputationLHSType() const
Definition: Expr.h:3677
clang::OMPClause::getClauseKind
OpenMPClauseKind getClauseKind() const
Returns kind of OpenMP clause (private, shared, reduction, etc.).
Definition: OpenMPClause.h:79
clang::CXXCtorInitializer::isDelegatingInitializer
bool isDelegatingInitializer() const
Determine whether this initializer is creating a delegating constructor.
Definition: DeclCXX.h:2252
clang::UnaryExprOrTypeTraitExpr
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand...
Definition: Expr.h:2372
clang::TextNodeDumper::VisitObjCPropertyRefExpr
void VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *Node)
Definition: TextNodeDumper.cpp:1012
clang::NonTypeTemplateParmDecl::isParameterPack
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
Definition: DeclTemplate.h:1497
clang::ConstantExpr
ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...
Definition: Expr.h:978
clang::TextNodeDumper::VisitCXXRecordDecl
void VisitCXXRecordDecl(const CXXRecordDecl *D)
Definition: TextNodeDumper.cpp:1542
clang::OMPDeclareReductionDecl::getCombiner
Expr * getCombiner()
Get combiner expression of the declare reduction construct.
Definition: DeclOpenMP.h:152
clang::ObjCPropertyDecl::OBJC_PR_atomic
Definition: DeclObjC.h:755
clang::TemplateArgument::getAsDecl
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
Definition: TemplateBase.h:263
clang::StringLiteral::outputString
void outputString(raw_ostream &OS) const
Definition: Expr.cpp:1106
clang::ArrayType::Normal
Definition: Type.h:2896
clang::OMPRequiresDecl
This represents &#39;#pragma omp requires...&#39; directive.
Definition: DeclOpenMP.h:345
clang::OMPDeclareReductionDecl::DirectInit
Definition: DeclOpenMP.h:108
clang::CharacterLiteral::getValue
unsigned getValue() const
Definition: Expr.h:1564
clang::ArrayType::Star
Definition: Type.h:2896
clang::OK_ObjCProperty
An Objective-C property is a logical field of an Objective-C object which is read and written via Obj...
Definition: Specifiers.h:151
clang::DependentSizedArrayType
Represents an array type in C++ whose size is a value-dependent expression.
Definition: Type.h:3093
clang::ObjCBoxedExpr::getBoxingMethod
ObjCMethodDecl * getBoxingMethod() const
Definition: ExprObjC.h:145
clang::ValueColor
static const TerminalColor ValueColor
Definition: ASTDumperUtils.h:77
clang::FunctionDecl::isInlineSpecified
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
Definition: Decl.h:2499
clang::ConstructorUsingShadowDecl
Represents a shadow constructor declaration introduced into a class by a C++11 using-declaration that...
Definition: DeclCXX.h:3263
clang::BlockDecl
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:4037
clang::CommentColor
static const TerminalColor CommentColor
Definition: ASTDumperUtils.h:51
clang::ValueDecl
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:619
clang::TagDecl::getKindName
StringRef getKindName() const
Definition: Decl.h:3394
clang::TextNodeDumper::visitParamCommandComment
void visitParamCommandComment(const comments::ParamCommandComment *C, const comments::FullComment *FC)
Definition: TextNodeDumper.cpp:527
clang::TextNodeDumper::visitInlineCommandComment
void visitInlineCommandComment(const comments::InlineCommandComment *C, const comments::FullComment *)
Definition: TextNodeDumper.cpp:476
clang::FunctionDecl::isDefaulted
bool isDefaulted() const
Whether this function is defaulted per C++0x.
Definition: Decl.h:2130
clang::PresumedLoc::isInvalid
bool isInvalid() const
Return true if this object is invalid or uninitialized.
Definition: SourceLocation.h:315
Label
std::string Label
Definition: UsingDeclarationsSorter.cpp:69
TextNodeDumper.h
clang::EnumDecl::isScopedUsingClassTag
bool isScopedUsingClassTag() const
Returns true if this is a C++11 scoped enumeration.
Definition: Decl.h:3678
clang::TemplateTypeParmDecl
Declaration of a template type parameter.
Definition: DeclTemplate.h:1177
clang::TemplateTypeParmType::getIndex
unsigned getIndex() const
Definition: Type.h:4691
clang::Type::castAs
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:7067
clang::MemberExpr::isNonOdrUse
NonOdrUseReason isNonOdrUse() const
Is this expression a non-odr-use reference, and if so, why? This is only meaningful if the named memb...
Definition: Expr.h:3060
clang::TextNodeDumper::VisitObjCSelectorExpr
void VisitObjCSelectorExpr(const ObjCSelectorExpr *Node)
Definition: TextNodeDumper.cpp:1003
clang::PresumedLoc::getLine
unsigned getLine() const
Return the presumed line number of this location.
Definition: SourceLocation.h:334
clang::TextNodeDumper::VisitOMPExecutableDirective
void VisitOMPExecutableDirective(const OMPExecutableDirective *D)
Definition: TextNodeDumper.cpp:1461
clang::NOUR_Constant
This name appears as a potential result of an lvalue-to-rvalue conversion that is a constant expressi...
Definition: Specifiers.h:167
clang::TextNodeDumper::visitVerbatimBlockLineComment
void visitVerbatimBlockLineComment(const comments::VerbatimBlockLineComment *C, const comments::FullComment *)
Definition: TextNodeDumper.cpp:576
clang::TextNodeDumper::VisitCXXFunctionalCastExpr
void VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *Node)
Definition: TextNodeDumper.cpp:885
clang::Decl::isImplicit
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:558
clang::TextNodeDumper::TextNodeDumper
TextNodeDumper(raw_ostream &OS, bool ShowColors, const SourceManager *SM, const PrintingPolicy &PrintPolicy, const comments::CommandTraits *Traits)
Definition: TextNodeDumper.cpp:50
clang::Type::getTypeClassName
const char * getTypeClassName() const
Definition: Type.cpp:2751
clang::UnaryExprOrTypeTraitExpr::getArgumentType
QualType getArgumentType() const
Definition: Expr.h:2409
clang::comments::BlockCommandComment
A command that has zero or more word-like arguments (number of word-like arguments depends on command...
Definition: Comment.h:598
clang::Decl::getDeclContext
DeclContext * getDeclContext()
Definition: DeclBase.h:438
clang::ObjCPropertyDecl::OBJC_PR_weak
Definition: DeclObjC.h:756
clang::ObjCInterfaceDecl::getSuperClass
ObjCInterfaceDecl * getSuperClass() const
Definition: DeclObjC.cpp:337
clang::ObjCSelectorExpr
ObjCSelectorExpr used for @selector in Objective-C.
Definition: ExprObjC.h:454
clang::VarDecl::getTLSKind
TLSKind getTLSKind() const
Definition: Decl.cpp:1998
clang::SizeOfPackExpr
Represents an expression that computes the length of a parameter pack.
Definition: ExprCXX.h:4091
clang::FunctionDecl::getStorageClass
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:2488
clang::NonTypeTemplateParmDecl
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
Definition: DeclTemplate.h:1383
clang::ConstructorUsingShadowDecl::getNominatedBaseClassShadowDecl
ConstructorUsingShadowDecl * getNominatedBaseClassShadowDecl() const
Get the inheriting constructor declaration for the direct base class from which this using shadow dec...
Definition: DeclCXX.h:3330
clang::ExtVectorElementExpr::getAccessor
IdentifierInfo & getAccessor() const
Definition: Expr.h:5540
clang::TextNodeDumper::VisitUnresolvedUsingTypenameDecl
void VisitUnresolvedUsingTypenameDecl(const UnresolvedUsingTypenameDecl *D)
Definition: TextNodeDumper.cpp:1745
clang::OverloadExpr::decls_begin
decls_iterator decls_begin() const
Definition: ExprCXX.h:2936
clang::ConstructorUsingShadowDecl::getConstructedBaseClass
CXXRecordDecl * getConstructedBaseClass() const
Get the base class whose constructor or constructor shadow declaration is passed the constructor argu...
Definition: DeclCXX.h:3346
clang::Stmt::isOMPStructuredBlock
bool isOMPStructuredBlock() const
Definition: Stmt.h:1115
clang::SplitQualType
A std::pair-like structure for storing a qualified type split into its local qualifiers and its local...
Definition: Type.h:593
clang::TextNodeDumper::VisitObjCTypeParamDecl
void VisitObjCTypeParamDecl(const ObjCTypeParamDecl *D)
Definition: TextNodeDumper.cpp:1850
clang::Type::isSignedIntegerType
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], or an enum decl which has a signed representation.
Definition: Type.cpp:1928
clang::Selector::print
void print(llvm::raw_ostream &OS) const
Prints the full selector name (e.g. "foo:bar:").
Definition: IdentifierTable.cpp:492
clang::ObjCIvarDecl::Public
Definition: DeclObjC.h:1964
clang::Expr::getType
QualType getType() const
Definition: Expr.h:137
clang::ValueKindColor
static const TerminalColor ValueKindColor
Definition: ASTDumperUtils.h:62
clang::StorageClass
StorageClass
Storage classes.
Definition: Specifiers.h:235
clang::UnaryTransformType
A unary type transform, which is a type constructed from another.
Definition: Type.h:4413
clang::TextNodeDumper::VisitGotoStmt
void VisitGotoStmt(const GotoStmt *Node)
Definition: TextNodeDumper.cpp:679
clang::TemplateName::dump
void dump(raw_ostream &OS) const
Debugging aid that dumps the template name.
Definition: TemplateName.cpp:281
clang::VarDecl::ListInit
Direct list-initialization (C++11)
Definition: Decl.h:831
clang::SplitQualType::Quals
Qualifiers Quals
The local qualifiers.
Definition: Type.h:598
clang::comments::ParamCommandComment::isDirectionExplicit
bool isDirectionExplicit() const LLVM_READONLY
Definition: Comment.h:751
clang::TypeAliasTemplateDecl
Declaration of an alias template.
Definition: DeclTemplate.h:2511
clang::DeclContext::getParent
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1784
clang::GotoStmt::getLabel
LabelDecl * getLabel() const
Definition: Stmt.h:2494
clang::ObjCEncodeExpr::getEncodedType
QualType getEncodedType() const
Definition: ExprObjC.h:428
clang::ObjCMessageExpr
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:950
clang::TextNodeDumper::VisitTypedefType
void VisitTypedefType(const TypedefType *T)
Definition: TextNodeDumper.cpp:1176
clang::PresumedLoc
Represents an unpacked "presumed" location which can be presented to the user.
Definition: SourceLocation.h:299
clang::ObjCPropertyRefExpr::getImplicitPropertyGetter
ObjCMethodDecl * getImplicitPropertyGetter() const
Definition: ExprObjC.h:712
clang::comments::HTMLStartTagComment::getNumAttrs
unsigned getNumAttrs() const
Definition: Comment.h:474
clang::SourceRange::getEnd
SourceLocation getEnd() const
Definition: SourceLocation.h:217
clang::UnaryOperator
UnaryOperator - This represents the unary-expression&#39;s (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:2046
clang::ObjCMethodDecl::isInstanceMethod
bool isInstanceMethod() const
Definition: DeclObjC.h:423
clang::TextNodeDumper::dumpBareType
void dumpBareType(QualType T, bool Desugar=true)
Definition: TextNodeDumper.cpp:386
clang::VectorType
Represents a GCC generic vector type.
Definition: Type.h:3235
clang::ObjCMessageExpr::getReceiverKind
ReceiverKind getReceiverKind() const
Determine the kind of receiver that this message is being sent to.
Definition: ExprObjC.h:1234
clang::comments::HTMLStartTagComment
An opening HTML tag with attributes.
Definition: Comment.h:415
clang::ArrayType::getSizeModifier
ArraySizeModifier getSizeModifier() const
Definition: Type.h:2912
clang::TemplateTemplateParmDecl
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
Definition: DeclTemplate.h:1600
clang::UnaryTransformType::getUTTKind
UTTKind getUTTKind() const
Definition: Type.h:4441
clang::PragmaDetectMismatchDecl::getName
StringRef getName() const
Definition: Decl.h:171
clang::comments::BlockCommandComment::getNumArgs
unsigned getNumArgs() const
Definition: Comment.h:670
clang::DeclRefExpr::getDecl
ValueDecl * getDecl()
Definition: Expr.h:1247
clang::TextNodeDumper::VisitPragmaCommentDecl
void VisitPragmaCommentDecl(const PragmaCommentDecl *D)
Definition: TextNodeDumper.cpp:1430
clang::ObjCMethodDecl::getSelector
Selector getSelector() const
Definition: DeclObjC.h:322
clang::QualType::getAsString
std::string getAsString() const
Definition: TypePrinter.cpp:1877
Desugar
static QualType Desugar(ASTContext &Context, QualType QT, bool &ShouldAKA)
Definition: ASTDiagnostic.cpp:28
clang::FunctionDecl::isTrivial
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition: Decl.h:2122
clang::TextNodeDumper::VisitExprWithCleanups
void VisitExprWithCleanups(const ExprWithCleanups *Node)
Definition: TextNodeDumper.cpp:950
clang::ObjCIvarDecl::Protected
Definition: DeclObjC.h:1964
clang::QualType::isNull
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:719
clang::VarDecl::getInitStyle
InitializationStyle getInitStyle() const
The style of initialization for this declaration.
Definition: Decl.h:1309
clang::TextNodeDumper::visitBlockCommandComment
void visitBlockCommandComment(const comments::BlockCommandComment *C, const comments::FullComment *)
Definition: TextNodeDumper.cpp:520
clang::TextNodeDumper::VisitFloatingLiteral
void VisitFloatingLiteral(const FloatingLiteral *Node)
Definition: TextNodeDumper.cpp:780
clang::ObjCPropertyDecl::getType
QualType getType() const
Definition: DeclObjC.h:842
clang::CXXBoolLiteralExpr::getValue
bool getValue() const
Definition: ExprCXX.h:657
clang::ObjCPropertyDecl::OBJC_PR_direct
Definition: DeclObjC.h:764
SM
const SourceManager & SM
Definition: Format.cpp:1685
clang::TextNodeDumper::VisitObjCMethodDecl
void VisitObjCMethodDecl(const ObjCMethodDecl *D)
Definition: TextNodeDumper.cpp:1838
clang::comments::ParamCommandComment::getDirectionAsString
static const char * getDirectionAsString(PassDirection D)
Definition: Comment.cpp:192
clang::TextNodeDumper::VisitConstructorUsingShadowDecl
void VisitConstructorUsingShadowDecl(const ConstructorUsingShadowDecl *D)
Definition: TextNodeDumper.cpp:1767
clang::TextNodeDumper::VisitCapturedDecl
void VisitCapturedDecl(const CapturedDecl *D)
Definition: TextNodeDumper.cpp:1417
clang::ConstantExpr::getAPValueResult
APValue getAPValueResult() const
Definition: Expr.cpp:354
clang::comments::InlineCommandComment::getNumArgs
unsigned getNumArgs() const
Definition: Comment.h:358
clang::ObjCPropertyDecl::OBJC_PR_noattr
Definition: DeclObjC.h:746
clang::UnresolvedUsingTypenameDecl::getQualifier
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the name.
Definition: DeclCXX.h:3723
clang::TextNodeDumper::VisitNamespaceAliasDecl
void VisitNamespaceAliasDecl(const NamespaceAliasDecl *D)
Definition: TextNodeDumper.cpp:1527
clang::QualType::split
SplitQualType split() const
Divides a QualType into its unqualified type and a set of local qualifiers.
Definition: Type.h:6264
clang::PresumedLoc::getFilename
const char * getFilename() const
Return the presumed filename of this location.
Definition: SourceLocation.h:321
clang::comments::HTMLStartTagComment::Attribute
Definition: Comment.h:417
clang::comments::CommandTraits
This class provides information about commands that can be used in comments.
Definition: CommentCommandTraits.h:127
clang::AS_protected
Definition: Specifiers.h:115
clang::ObjCIvarDecl::None
Definition: DeclObjC.h:1964
clang::ObjCIvarDecl::Private
Definition: DeclObjC.h:1964
clang::attrvisitor::Base< llvm::make_const_ptr, ImplClass, RetTy, ParamTys... >::Visit
RetTy Visit(PTR(Attr) A)
Definition: AttrVisitor.h:31
clang::PCK_Unknown
Definition: PragmaKinds.h:15
clang::TextNodeDumper::VisitIndirectFieldDecl
void VisitIndirectFieldDecl(const IndirectFieldDecl *D)
Definition: TextNodeDumper.cpp:1270
clang::VectorType::AltiVecPixel
is AltiVec &#39;vector Pixel&#39;
Definition: Type.h:3245
clang::PredefinedExpr::getIdentKindName
static StringRef getIdentKindName(IdentKind IK)
Definition: Expr.cpp:649
clang::VectorType::GenericVector
not a target-specific vector type
Definition: Type.h:3239
clang::FunctionProtoType::ExceptionSpecInfo::Type
ExceptionSpecificationType Type
The kind of exception specification this is.
Definition: Type.h:3813
clang::ObjCPropertyRefExpr::isImplicitProperty
bool isImplicitProperty() const
Definition: ExprObjC.h:704
clang::Redeclarable::getPreviousDecl
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Definition: Redeclarable.h:203
clang::TextNodeDumper::VisitNullTemplateArgument
void VisitNullTemplateArgument(const TemplateArgument &TA)
Definition: TextNodeDumper.cpp:587
clang::FunctionProtoType::getExtProtoInfo
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3975
clang::PresumedLoc::getColumn
unsigned getColumn() const
Return the presumed column number of this location.
Definition: SourceLocation.h:342
clang::LinkageSpecDecl::lang_cxx
Definition: DeclCXX.h:2787
clang::TemplateTypeParmDecl::isParameterPack
bool isParameterPack() const
Returns whether this is a parameter pack.
Definition: DeclTemplate.cpp:650
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:86
clang::ObjCIvarDecl::getSynthesize
bool getSynthesize() const
Definition: DeclObjC.h:2005
clang::ObjCInterfaceType::getDecl
ObjCInterfaceDecl * getDecl() const
Get the declaration of this interface.
Definition: Type.h:5908
clang::TextNodeDumper::VisitIntegralTemplateArgument
void VisitIntegralTemplateArgument(const TemplateArgument &TA)
Definition: TextNodeDumper.cpp:606
clang::FunctionDecl::isPure
bool isPure() const
Whether this virtual function is pure, i.e.
Definition: Decl.h:2105
clang::TextNodeDumper::VisitDependentSizedArrayType
void VisitDependentSizedArrayType(const DependentSizedArrayType *T)
Definition: TextNodeDumper.cpp:1098
clang::WhileStmt::hasVarStorage
bool hasVarStorage() const
True if this WhileStmt has storage for a condition variable.
Definition: Stmt.h:2273
clang::OMPDeclareReductionDecl
This represents &#39;#pragma omp declare reduction ...&#39; directive.
Definition: DeclOpenMP.h:102
clang::UnresolvedUsingValueDecl::getQualifier
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the name.
Definition: DeclCXX.h:3633
clang::TextNodeDumper::dumpPointer
void dumpPointer(const void *Ptr)
Definition: TextNodeDumper.cpp:336
clang::OMPCapturedExprDecl
Pseudo declaration for capturing expressions.
Definition: DeclOpenMP.h:312
clang::TextNodeDumper::VisitFixedPointLiteral
void VisitFixedPointLiteral(const FixedPointLiteral *Node)
Definition: TextNodeDumper.cpp:775
clang::ObjCInterfaceType
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5894
clang::Type::isVariablyModifiedType
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: Type.h:2166
clang::TextNodeDumper::VisitUsingDirectiveDecl
void VisitUsingDirectiveDecl(const UsingDirectiveDecl *D)
Definition: TextNodeDumper.cpp:1522
clang::OMPExecutableDirective
This is a basic class for representing single OpenMP executable directive.
Definition: StmtOpenMP.h:33
clang::NamedDecl::getNameAsString
std::string getNameAsString() const
Get a human-readable name for the declaration, even if it is one of the special kinds of names (C++ c...
Definition: Decl.h:266
clang::CXXNewExpr
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)"...
Definition: ExprCXX.h:2100
clang::TemplateTypeParmDecl::wasDeclaredWithTypename
bool wasDeclaredWithTypename() const
Whether this template type parameter was declared with the &#39;typename&#39; keyword.
Definition: DeclTemplate.h:1240
clang::comments::Comment::getSourceRange
SourceRange getSourceRange() const LLVM_READONLY
Definition: Comment.h:216
clang::Decl::getASTContext
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:377
clang::ObjCCategoryImplDecl::getCategoryDecl
ObjCCategoryDecl * getCategoryDecl() const
Definition: DeclObjC.cpp:2089
clang::TextNodeDumper::VisitNonTypeTemplateParmDecl
void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D)
Definition: TextNodeDumper.cpp:1721
clang::comments::ParamCommandComment::isParamIndexValid
bool isParamIndexValid() const LLVM_READONLY
Definition: Comment.h:774
clang::LabelDecl
Represents the declaration of a label.
Definition: Decl.h:451
clang::UnresolvedUsingValueDecl
Represents a dependent using declaration which was not marked with typename.
Definition: DeclCXX.h:3588
clang::TextNodeDumper::VisitCXXBoolLiteralExpr
void VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *Node)
Definition: TextNodeDumper.cpp:875
dumpBasePath
static void dumpBasePath(raw_ostream &OS, const CastExpr *Node)
Definition: TextNodeDumper.cpp:629
clang::comments::CommandTraits::getCommandInfo
const CommandInfo * getCommandInfo(StringRef Name) const
Definition: CommentCommandTraits.h:145
clang::FunctionType::isRestrict
bool isRestrict() const
Definition: Type.h:3699
clang::CXXMethodDecl
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1931
clang::AS_public
Definition: Specifiers.h:114
clang::Type::getLocallyUnqualifiedSingleStepDesugaredType
QualType getLocallyUnqualifiedSingleStepDesugaredType() const
Pull a single level of sugar off of this locally-unqualified type.
Definition: Type.cpp:354
clang::FixedPointLiteral::getValueAsString
std::string getValueAsString(unsigned Radix) const
Definition: Expr.cpp:958
clang::TextNodeDumper::VisitMemberExpr
void VisitMemberExpr(const MemberExpr *Node)
Definition: TextNodeDumper.cpp:833
clang::TextNodeDumper::VisitCallExpr
void VisitCallExpr(const CallExpr *Node)
Definition: TextNodeDumper.cpp:697
clang::UnaryOperator::canOverflow
bool canOverflow() const
Returns true if the unary operator can cause an overflow.
Definition: Expr.h:2089
clang::EST_Uninstantiated
not instantiated yet
Definition: ExceptionSpecificationType.h:31
clang::RQ_None
No ref-qualifier was provided.
Definition: Type.h:1403
clang::VarDecl::CInit
C-style initialization with assignment.
Definition: Decl.h:825
clang::IdentifierInfo::getNameStart
const char * getNameStart() const
Return the beginning of the actual null-terminated string for this identifier.
Definition: IdentifierTable.h:149
DeclOpenMP.h
This file defines OpenMP nodes for declarative directives.
clang::TemplateTypeParmType::isParameterPack
bool isParameterPack() const
Definition: Type.h:4692
clang::tok::isLiteral
bool isLiteral(TokenKind K)
Return true if this is a "literal" kind, like a numeric constant, string, etc.
Definition: TokenKinds.h:85
clang::TextNodeDumper::VisitBlockDecl
void VisitBlockDecl(const BlockDecl *D)
Definition: TextNodeDumper.cpp:1965
clang::ObjCCategoryDecl
ObjCCategoryDecl - Represents a category declaration.
Definition: DeclObjC.h:2294
clang::OMPClause
This is a basic class for representing single OpenMP clause.
Definition: OpenMPClause.h:51
clang::UnaryExprOrTypeTraitExpr::getKind
UnaryExprOrTypeTrait getKind() const
Definition: Expr.h:2403
clang::CXXNewExpr::isArray
bool isArray() const
Definition: ExprCXX.h:2223
clang::EnumDecl::isScoped
bool isScoped() const
Returns true if this is a C++11 scoped enumeration.
Definition: Decl.h:3675
clang::NullColor
static const TerminalColor NullColor
Definition: ASTDumperUtils.h:67
clang::TextNodeDumper::VisitVarDecl
void VisitVarDecl(const VarDecl *D)
Definition: TextNodeDumper.cpp:1369
clang::ObjCProtocolExpr
ObjCProtocolExpr used for protocol expression in Objective-C.
Definition: ExprObjC.h:503
clang::comments::TParamCommandComment::getParamNameAsWritten
StringRef getParamNameAsWritten() const
Definition: Comment.h:836
clang::VectorType::AltiVecBool
is AltiVec &#39;vector bool ...&#39;
Definition: Type.h:3248
clang::AttributeCommonInfo::getRange
SourceRange getRange() const
Definition: AttributeCommonInfo.h:130
clang::ConstructorUsingShadowDecl::getConstructedBaseClassShadowDecl
ConstructorUsingShadowDecl * getConstructedBaseClassShadowDecl() const
Get the inheriting constructor declaration for the base class for which we don&#39;t have an explicit ini...
Definition: DeclCXX.h:3336
clang::comments::CommentVisitorBase< llvm::make_const_ptr, TextNodeDumper, void, ParamTys... >::visit
void visit(PTR(Comment) C, ParamTys... P)
Definition: CommentVisitor.h:27
clang::ObjCPropertyDecl
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:741
clang::ImplicitCastExpr
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:3274
clang::Decl::isFromASTFile
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
Definition: DeclBase.h:702
clang::TextNodeDumper::dumpDeclRef
void dumpDeclRef(const Decl *D, StringRef Label={})
Definition: TextNodeDumper.cpp:450
clang::ObjCPropertyRefExpr::isMessagingGetter
bool isMessagingGetter() const
True if the property reference will result in a message to the getter.
Definition: ExprObjC.h:737
clang::VectorType::AltiVecVector
is AltiVec vector
Definition: Type.h:3242
clang::comments::ParamCommandComment::getDirection
PassDirection getDirection() const LLVM_READONLY
Definition: Comment.h:747
clang::TextNodeDumper::VisitCXXNewExpr
void VisitCXXNewExpr(const CXXNewExpr *Node)
Definition: TextNodeDumper.cpp:918
clang::ArrayType::getIndexTypeQualifiers
Qualifiers getIndexTypeQualifiers() const
Definition: Type.h:2916
clang::UETT_AlignOf
Used for C&#39;s _Alignof and C++&#39;s alignof.
Definition: TypeTraits.h:100
clang::PCK_ExeStr
Definition: PragmaKinds.h:19
clang::TextNodeDumper::VisitVariableArrayType
void VisitVariableArrayType(const VariableArrayType *T)
Definition: TextNodeDumper.cpp:1092
clang::Decl::isUsed
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required...
Definition: DeclBase.cpp:398
clang::NamespaceDecl::isOriginalNamespace
bool isOriginalNamespace() const
Return true if this declaration is an original (first) declaration of the namespace.
Definition: DeclCXX.cpp:2774
clang::BlockDecl::Capture::getVariable
VarDecl * getVariable() const
The variable being captured.
Definition: Decl.h:4064
clang::TemplateArgument::getAsIntegral
llvm::APSInt getAsIntegral() const
Retrieve the template argument as an integral value.
Definition: TemplateBase.h:300
clang::CharacterLiteral
Definition: Expr.h:1530
clang::TextNodeDumper::VisitInitListExpr
void VisitInitListExpr(const InitListExpr *ILE)
Definition: TextNodeDumper.cpp:791
clang::TextNodeDumper::VisitFieldDecl
void VisitFieldDecl(const FieldDecl *D)
Definition: TextNodeDumper.cpp:1360
clang::ObjCPropertyDecl::OBJC_PR_copy
Definition: DeclObjC.h:752
clang::comments::HTMLEndTagComment
A closing HTML tag.
Definition: Comment.h:509
clang::RQ_RValue
An rvalue ref-qualifier was provided (&&).
Definition: Type.h:1409
clang::DependentSizedArrayType::getBracketsRange
SourceRange getBracketsRange() const
Definition: Type.h:3121
clang::TextNodeDumper::VisitPackExpansionType
void VisitPackExpansionType(const PackExpansionType *T)
Definition: TextNodeDumper.cpp:1228
clang::ObjCBoxedExpr
ObjCBoxedExpr - used for generalized expression boxing.
Definition: ExprObjC.h:124
clang::UnaryExprOrTypeTraitExpr::isArgumentType
bool isArgumentType() const
Definition: Expr.h:2408
clang::PCK_Linker
Definition: PragmaKinds.h:16
clang::ObjCInterfaceDecl::getImplementation
ObjCImplementationDecl * getImplementation() const
Definition: DeclObjC.cpp:1574
clang::PackExpansionType::getNumExpansions
Optional< unsigned > getNumExpansions() const
Retrieve the number of expansions that this pack expansion will generate, if known.
Definition: Type.h:5536
clang::ImplicitCastExpr::isPartOfExplicitCast
bool isPartOfExplicitCast() const
Definition: Expr.h:3293
clang::Qualifiers::getAsString
std::string getAsString() const
Definition: TypePrinter.cpp:1751
clang::Type::isInstantiationDependentType
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
Definition: Type.h:2156
clang::TextNodeDumper::VisitObjCEncodeExpr
void VisitObjCEncodeExpr(const ObjCEncodeExpr *Node)
Definition: TextNodeDumper.cpp:999
clang::ImportDecl
Describes a module import declaration, which makes the contents of the named module visible in the cu...
Definition: Decl.h:4331
clang::comments::TParamCommandComment
Doxygen \tparam command, describes a template parameter.
Definition: Comment.h:801
clang::ObjCCategoryDecl::protocols
protocol_range protocols() const
Definition: DeclObjC.h:2370
clang::DeclRefExpr::isNonOdrUse
NonOdrUseReason isNonOdrUse() const
Is this expression a non-odr-use reference, and if so, why?
Definition: Expr.h:1371
clang::InjectedClassNameType
The injected class name of a C++ class template or class template partial specialization.
Definition: Type.h:5133
clang::PackExpansionType
Represents a pack expansion of types.
Definition: Type.h:5511
clang::CompoundAssignOperator
CompoundAssignOperator - For compound assignments (e.g.
Definition: Expr.h:3654
clang::ASTContext::getModuleInitializers
ArrayRef< Decl * > getModuleInitializers(Module *M)
Get the initializations to perform when importing a module, if any.
Definition: ASTContext.cpp:1234
clang::VarDecl::getStorageClassSpecifierString
static const char * getStorageClassSpecifierString(StorageClass SC)
Return the string used to specify the storage class SC.
Definition: Decl.cpp:1950
clang::TextNodeDumper::VisitArrayType
void VisitArrayType(const ArrayType *T)
Definition: TextNodeDumper.cpp:1073
clang::GenericSelectionExpr
Represents a C11 generic selection.
Definition: Expr.h:5234
clang::TextNodeDumper::VisitIntegerLiteral
void VisitIntegerLiteral(const IntegerLiteral *Node)
Definition: TextNodeDumper.cpp:769
clang::AddrLabelExpr
AddrLabelExpr - The GNU address of label extension, representing &&label.
Definition: Expr.h:3910
Node
ast_type_traits::DynTypedNode Node
Definition: ASTMatchFinder.cpp:60
clang::TextNodeDumper::dumpAccessSpecifier
void dumpAccessSpecifier(AccessSpecifier AS)
Definition: TextNodeDumper.cpp:434
clang::VarDecl::TLS_Dynamic
TLS with a dynamic initializer.
Definition: Decl.h:843
clang::TemplateArgument
Represents a template argument.
Definition: TemplateBase.h:50
clang::Decl::isThisDeclarationReferenced
bool isThisDeclarationReferenced() const
Whether this declaration was referenced.
Definition: DeclBase.h:586
clang::DeducedType::isDeduced
bool isDeduced() const
Definition: Type.h:4862
clang::NOUR_Discarded
This name appears as a potential result of a discarded value expression.
Definition: Specifiers.h:170
clang::ObjCImplDecl::getClassInterface
const ObjCInterfaceDecl * getClassInterface() const
Definition: DeclObjC.h:2454
clang::UsingDirectiveDecl::getNominatedNamespace
NamespaceDecl * getNominatedNamespace()
Returns the namespace nominated by this using-directive.
Definition: DeclCXX.cpp:2729
clang
Dataflow Directional Tag Classes.
Definition: CFGReachabilityAnalysis.h:21
clang::GenericSelectionExpr::isResultDependent
bool isResultDependent() const
Whether this generic selection is result-dependent.
Definition: Expr.h:5414
clang::LifetimeExtendedTemporaryDecl::getManglingNumber
unsigned getManglingNumber() const
Definition: DeclCXX.h:3126
clang::ObjCPropertyDecl::OBJC_PR_readonly
Definition: DeclObjC.h:747
clang::FunctionType::getExtInfo
ExtInfo getExtInfo() const
Definition: Type.h:3691
clang::ConceptDecl
Definition: DeclTemplate.h:3226
clang::EST_Unevaluated
not evaluated yet, for special member function
Definition: ExceptionSpecificationType.h:30
clang::PredefinedExpr
[C99 6.4.2.2] - A predefined identifier such as func.
Definition: Expr.h:1903
clang::DeclContext
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1271
clang::AttrColor
static const TerminalColor AttrColor
Definition: ASTDumperUtils.h:47
clang::CXXDeleteExpr
Represents a delete expression for memory deallocation and destructor calls, e.g. ...
Definition: ExprCXX.h:2359
clang::BlockDecl::Capture::isNested
bool isNested() const
Whether this is a nested capture, i.e.
Definition: Decl.h:4080
clang::PCK_User
Definition: PragmaKinds.h:20
clang::BlockDecl::isVariadic
bool isVariadic() const
Definition: Decl.h:4112
clang::ObjCPropertyImplDecl::getPropertyImplementation
Kind getPropertyImplementation() const
Definition: DeclObjC.h:2842
clang::CXXThisExpr::isImplicit
bool isImplicit() const
Definition: ExprCXX.h:1118
clang::IfStmt::hasInitStorage
bool hasInitStorage() const
True if this IfStmt has the storage for an init statement.
Definition: Stmt.h:1901
clang::IndirectFieldDecl
Represents a field injected from an anonymous union/struct into the parent scope. ...
Definition: Decl.h:2980
clang::TextNodeDumper::visitTextComment
void visitTextComment(const comments::TextComment *C, const comments::FullComment *)
Definition: TextNodeDumper.cpp:471
clang::TypedefNameDecl::getUnderlyingType
QualType getUnderlyingType() const
Definition: Decl.h:3126
clang::Decl::getAccess
AccessSpecifier getAccess() const
Definition: DeclBase.h:473
clang::NamespaceDecl::getOriginalNamespace
NamespaceDecl * getOriginalNamespace()
Get the original (first) namespace declaration.
Definition: DeclCXX.cpp:2760
clang::TemplateTypeParmDecl::getIndex
unsigned getIndex() const
Retrieve the index of the template parameter.
Definition: DeclTemplate.cpp:646
clang::CallExpr::usesADL
bool usesADL() const
Definition: Expr.h:2673
clang::CXXDependentScopeMemberExpr::getMember
DeclarationName getMember() const
Retrieve the name of the member that this expression refers to.
Definition: ExprCXX.h:3657
clang::UnresolvedUsingTypenameDecl
Represents a dependent using declaration which was marked with typename.
Definition: DeclCXX.h:3684
clang::OMPClause::isImplicit
bool isImplicit() const
Definition: OpenMPClause.h:81
clang::ObjCTypeParamDecl
Represents the declaration of an Objective-C type parameter.
Definition: DeclObjC.h:571
clang::VectorType::getVectorKind
VectorKind getVectorKind() const
Definition: Type.h:3280
clang::ObjCPropertyDecl::OBJC_PR_retain
Definition: DeclObjC.h:751
clang::QualType::getAsString
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
Definition: Type.h:990
clang::Decl::getKind
Kind getKind() const
Definition: DeclBase.h:432
clang::TextNodeDumper::VisitUnresolvedUsingType
void VisitUnresolvedUsingType(const UnresolvedUsingType *T)
Definition: TextNodeDumper.cpp:1172
clang::CXXConstructExpr::isListInitialization
bool isListInitialization() const
Whether this constructor call was written as list-initialization.
Definition: ExprCXX.h:1513
clang::CXXCtorInitializer::getBaseClass
const Type * getBaseClass() const
If this is a base class initializer, returns the type of the base class.
Definition: DeclCXX.cpp:2418
clang::TextNodeDumper::VisitDeclRefExpr
void VisitDeclRefExpr(const DeclRefExpr *Node)
Definition: TextNodeDumper.cpp:718
clang::EnumDecl
Represents an enum.
Definition: Decl.h:3481
clang::SourceManager::getPresumedLoc
PresumedLoc getPresumedLoc(SourceLocation Loc, bool UseLineDirectives=true) const
Returns the "presumed" location of a SourceLocation specifies.
Definition: SourceManager.cpp:1443
clang::VarDecl::isParameterPack
bool isParameterPack() const
Determine whether this variable is actually a function parameter pack or init-capture pack...
Definition: Decl.cpp:2464
clang::TextNodeDumper::VisitObjCMessageExpr
void VisitObjCMessageExpr(const ObjCMessageExpr *Node)
Definition: TextNodeDumper.cpp:965
clang::OMPClause::getBeginLoc
SourceLocation getBeginLoc() const
Returns the starting location of the clause.
Definition: OpenMPClause.h:67
clang::TextNodeDumper::VisitUsingShadowDecl
void VisitUsingShadowDecl(const UsingShadowDecl *D)
Definition: TextNodeDumper.cpp:1762
clang::ObjCCompatibleAliasDecl::getClassInterface
const ObjCInterfaceDecl * getClassInterface() const
Definition: DeclObjC.h:2761
clang::comments::InlineCommandComment::RenderNormal
Definition: Comment.h:311
clang::ObjCPropertyDecl::Optional
Definition: DeclObjC.h:774
clang::APIntStorage::getValue
llvm::APInt getValue() const
Definition: Expr.h:1430
clang::AddrLabelExpr::getLabel
LabelDecl * getLabel() const
Definition: Expr.h:3932
clang::TextNodeDumper::VisitTypeTemplateArgument
void VisitTypeTemplateArgument(const TemplateArgument &TA)
Definition: TextNodeDumper.cpp:591
clang::OMPClause::getEndLoc
SourceLocation getEndLoc() const
Returns the ending location of the clause.
Definition: OpenMPClause.h:70
clang::ObjCMessageExpr::getClassReceiver
QualType getClassReceiver() const
Returns the type of a class message send, or NULL if the message is not a class message.
Definition: ExprObjC.h:1279
clang::CastExpr::path_end
path_iterator path_end()
Definition: Expr.h:3223
clang::comments::HTMLTagComment::getTagName
StringRef getTagName() const LLVM_READONLY
Definition: Comment.h:397
clang::TextNodeDumper::VisitAddrLabelExpr
void VisitAddrLabelExpr(const AddrLabelExpr *Node)
Definition: TextNodeDumper.cpp:862
clang::SwitchStmt
SwitchStmt - This represents a &#39;switch&#39; stmt.
Definition: Stmt.h:2043
clang::CXXRecordDecl::needsOverloadResolutionForMoveConstructor
bool needsOverloadResolutionForMoveConstructor() const
Determine whether we need to eagerly declare a defaulted move constructor for this class...
Definition: DeclCXX.h:862
clang::TextNodeDumper::Visit
void Visit(const comments::Comment *C, const comments::FullComment *FC)
Definition: TextNodeDumper.cpp:57
clang::ObjCImplementationDecl
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2566
clang::FunctionProtoType::ExceptionSpecInfo::SourceTemplate
FunctionDecl * SourceTemplate
The function template whose exception specification this is instantiated from, for EST_Uninstantiated...
Definition: Type.h:3827
clang::Mergeable
Provides common interface for the Decls that cannot be redeclared, but can be merged if the same decl...
Definition: Redeclarable.h:312
clang::RecordType
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4495
clang::declvisitor::Base< llvm::make_const_ptr, ImplClass, RetTy >::Visit
RetTy Visit(PTR(Decl) D)
Definition: DeclVisitor.h:37
clang::TextNodeDumper::VisitCXXDependentScopeMemberExpr
void VisitCXXDependentScopeMemberExpr(const CXXDependentScopeMemberExpr *Node)
Definition: TextNodeDumper.cpp:960
clang::comments::CommandTraits::getBuiltinCommandInfo
static const CommandInfo * getBuiltinCommandInfo(StringRef Name)
DeclFriend.h
clang::TextNodeDumper::VisitFunctionType
void VisitFunctionType(const FunctionType *T)
Definition: TextNodeDumper.cpp:1134
clang::CXXCtorInitializer
Represents a C++ base or member initializer.
Definition: DeclCXX.h:2155
clang::ExprWithCleanups::getNumObjects
unsigned getNumObjects() const
Definition: ExprCXX.h:3337
clang::ObjCEncodeExpr
ObjCEncodeExpr, used for @encode in Objective-C.
Definition: ExprObjC.h:407
clang::Type::isFromAST
bool isFromAST() const
Whether this type comes from an AST file.
Definition: Type.h:1879
clang::TextNodeDumper::VisitConstantArrayType
void VisitConstantArrayType(const ConstantArrayType *T)
Definition: TextNodeDumper.cpp:1087
dumpPreviousDecl
static void dumpPreviousDecl(raw_ostream &OS, const Decl *D)
Dump the previous declaration in the redeclaration chain for a declaration, if any.
Definition: TextNodeDumper.cpp:39
clang::CastColor
static const TerminalColor CastColor
Definition: ASTDumperUtils.h:74
clang::ConstantArrayType::getSize
const llvm::APInt & getSize() const
Definition: Type.h:2958
clang::TypeColor
static const TerminalColor TypeColor
Definition: ASTDumperUtils.h:54
clang::UnaryOperator::getOpcode
Opcode getOpcode() const
Definition: Expr.h:2071
clang::ReferenceType
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2750
clang::DeclKindNameColor
static const TerminalColor DeclKindNameColor
Definition: ASTDumperUtils.h:45
clang::VariableArrayType::getBracketsRange
SourceRange getBracketsRange() const
Definition: Type.h:3064
clang::ObjCPropertyDecl::OBJC_PR_strong
Definition: DeclObjC.h:757
clang::CastExpr::getCastKindName
static const char * getCastKindName(CastKind CK)
Definition: Expr.cpp:1894
clang::FunctionType::isVolatile
bool isVolatile() const
Definition: Type.h:3698
clang::ObjCPropertyDecl::OBJC_PR_setter
Definition: DeclObjC.h:754
clang::TextNodeDumper::VisitCXXUnresolvedConstructExpr
void VisitCXXUnresolvedConstructExpr(const CXXUnresolvedConstructExpr *Node)
Definition: TextNodeDumper.cpp:891
clang::ObjCPropertyDecl::OBJC_PR_getter
Definition: DeclObjC.h:748
clang::CXXDependentScopeMemberExpr::isArrow
bool isArrow() const
Determine whether this member expression used the &#39;->&#39; operator; otherwise, it used the &#39;...
Definition: ExprCXX.h:3618
clang::CXXBaseSpecifier
Represents a base class of a C++ class.
Definition: DeclCXX.h:145
clang::OK_BitField
A bitfield object is a bitfield on a C or C++ record.
Definition: Specifiers.h:144
clang::TextNodeDumper::VisitCharacterLiteral
void VisitCharacterLiteral(const CharacterLiteral *Node)
Definition: TextNodeDumper.cpp:764
clang::TextNodeDumper::VisitLifetimeExtendedTemporaryDecl
void VisitLifetimeExtendedTemporaryDecl(const LifetimeExtendedTemporaryDecl *D)
Definition: TextNodeDumper.cpp:1349
clang::TextNodeDumper::VisitConceptDecl
void VisitConceptDecl(const ConceptDecl *D)
Definition: TextNodeDumper.cpp:1973
clang::ObjCIvarRefExpr
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:546
clang::comments::HTMLStartTagComment::Attribute::Value
StringRef Value
Definition: Comment.h:425
clang::BlockDecl::capturesCXXThis
bool capturesCXXThis() const
Definition: Decl.h:4169
clang::CXXUnresolvedConstructExpr
Describes an explicit type conversion that uses functional notion but could not be resolved because o...
Definition: ExprCXX.h:3390
clang::GotoStmt
GotoStmt - This represents a direct goto.
Definition: Stmt.h:2481
clang::TextNodeDumper::VisitBinaryOperator
void VisitBinaryOperator(const BinaryOperator *Node)
Definition: TextNodeDumper.cpp:849
clang::ObjCPropertyDecl::OBJC_PR_readwrite
Definition: DeclObjC.h:750
clang::ObjCPropertyImplDecl::Synthesize
Definition: DeclObjC.h:2776
clang::TypedefType::getDecl
TypedefNameDecl * getDecl() const
Definition: Type.h:4256
clang::TextNodeDumper::VisitTemplateTypeParmDecl
void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D)
Definition: TextNodeDumper.cpp:1701
clang::ColorScope
Definition: ASTDumperUtils.h:84
clang::TemplateTypeParmType::getDepth
unsigned getDepth() const
Definition: Type.h:4690
clang::ObjCIvarRefExpr::isFreeIvar
bool isFreeIvar() const
Definition: ExprObjC.h:585
clang::VarDecl::CallInit
Call-style initialization (C++98)
Definition: Decl.h:828
clang::TextNodeDumper::dumpName
void dumpName(const NamedDecl *ND)
Definition: TextNodeDumper.cpp:427
clang::MemberExpr
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:2836
clang::UETT_SizeOf
Definition: TypeTraits.h:97
clang::FieldDecl::isMutable
bool isMutable() const
Determines whether this field is mutable (C++ only).
Definition: Decl.h:2804
isTrivial
static bool isTrivial(ASTContext &Ctx, const Expr *E)
Checks if the expression is constant or does not have non-trivial function calls. ...
Definition: CGOpenMPRuntime.cpp:6524
clang::CXXRecordDecl
Represents a C++ struct/union/class.
Definition: DeclCXX.h:253
clang::comments::Comment::getCommentKindName
const char * getCommentKindName() const
Definition: Comment.cpp:35
clang::SourceRange::isValid
bool isValid() const
Definition: SourceLocation.h:222
clang::VarDecl::isNRVOVariable
bool isNRVOVariable() const
Determine whether this local variable can be used with the named return value optimization (NRVO)...
Definition: Decl.h:1355
clang::TextNodeDumper::VisitUnaryTransformType
void VisitUnaryTransformType(const UnaryTransformType *T)
Definition: TextNodeDumper.cpp:1180
clang::ObjCPropertyDecl::OBJC_PR_class
Definition: DeclObjC.h:763
clang::TextNodeDumper::VisitObjCCategoryImplDecl
void VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D)
Definition: TextNodeDumper.cpp:1878
clang::CXXFunctionalCastExpr
Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr.type.conv]).
Definition: ExprCXX.h:1688
clang::ObjCIvarDecl
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1959
clang::UETT_VecStep
Definition: TypeTraits.h:101
clang::APValue::None
There is no such object (it&#39;s outside its lifetime).
Definition: APValue.h:121
clang::WhileStmt
WhileStmt - This represents a &#39;while&#39; stmt.
Definition: Stmt.h:2226
clang::AttrSyntax::C
clang::TextNodeDumper::dumpBareDeclRef
void dumpBareDeclRef(const Decl *D)
Definition: TextNodeDumper.cpp:405
clang::ExprWithCleanups::getObject
CleanupObject getObject(unsigned i) const
Definition: ExprCXX.h:3339
clang::Attr::isInherited
bool isInherited() const
Definition: Attr.h:94
clang::ObjCPropertyDecl::OBJC_PR_assign
Definition: DeclObjC.h:749
clang::UnaryTransformType::EnumUnderlyingType
Definition: Type.h:4416
clang::comments::HTMLStartTagComment::getAttr
const Attribute & getAttr(unsigned Idx) const
Definition: Comment.h:478
clang::ClassTemplateDecl
Declaration of a class template.
Definition: DeclTemplate.h:2238
clang::TextNodeDumper::VisitObjCCompatibleAliasDecl
void VisitObjCCompatibleAliasDecl(const ObjCCompatibleAliasDecl *D)
Definition: TextNodeDumper.cpp:1907
clang::TextNodeDumper::VisitLinkageSpecDecl
void VisitLinkageSpecDecl(const LinkageSpecDecl *D)
Definition: TextNodeDumper.cpp:1792
clang::comments::TParamCommandComment::hasParamName
bool hasParamName() const
Definition: Comment.h:830
clang::ObjCMethodDecl::isVariadic
bool isVariadic() const
Definition: DeclObjC.h:428
clang::ObjCMessageExpr::Class
The receiver is a class.
Definition: ExprObjC.h:1098
clang::Stmt::getSourceRange
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:263
clang::CXXDeleteExpr::isGlobalDelete
bool isGlobalDelete() const
Definition: ExprCXX.h:2385
clang::TextNodeDumper::VisitObjCInterfaceType
void VisitObjCInterfaceType(const ObjCInterfaceType *T)
Definition: TextNodeDumper.cpp:1224
clang::StringLiteral
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1711
clang::TextNodeDumper::dumpType
void dumpType(QualType T)
Definition: TextNodeDumper.cpp:400
clang::LifetimeExtendedTemporaryDecl
Implicit declaration of a temporary that was materialized by a MaterializeTemporaryExpr and lifetime-...
Definition: DeclCXX.h:3075
clang::CallExpr
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2546
clang::VarDecl::TLS_Static
TLS with a known-constant initializer.
Definition: Decl.h:840
clang::EnumDecl::getIntegerType
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
Definition: Decl.h:3635
clang::NamedDecl::getName
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:250
clang::TextNodeDumper::VisitEnumDecl
void VisitEnumDecl(const EnumDecl *D)
Definition: TextNodeDumper.cpp:1242
clang::comments::ParamCommandComment::getParamNameAsWritten
StringRef getParamNameAsWritten() const
Definition: Comment.h:766
clang::StmtVisitorBase< llvm::make_const_ptr, ImplClass, RetTy, ParamTys... >::Visit
RetTy Visit(PTR(Stmt) S, ParamTys... P)
Definition: StmtVisitor.h:43
clang::UsingDecl::getQualifier
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the name.
Definition: DeclCXX.h:3412
clang::ObjCIvarDecl::Package
Definition: DeclObjC.h:1964
clang::ConstructorUsingShadowDecl::constructsVirtualBase
bool constructsVirtualBase() const
Returns true if the constructed base class is a virtual base class subobject of this declaration&#39;s cl...
Definition: DeclCXX.h:3355
clang::CXXNamedCastExpr
Abstract class common to all of the C++ "named"/"keyword" casts.
Definition: ExprCXX.h:353
clang::VectorType::getNumElements
unsigned getNumElements() const
Definition: Type.h:3271
clang::ObjCBoolLiteralExpr
ObjCBoolLiteralExpr - Objective-C Boolean Literal.
Definition: ExprObjC.h:85
clang::Type::isDependentType
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:2150
clang::TemplateArgument::getAsType
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:256
clang::comments::HTMLStartTagComment::Attribute::Name
StringRef Name
Definition: Comment.h:420
clang::DeclRefExpr
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1171
clang::TemplateSpecializationType
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4996
clang::ObjCPropertyImplDecl::getPropertyDecl
ObjCPropertyDecl * getPropertyDecl() const
Definition: DeclObjC.h:2837
clang::ObjCTypeParamDecl::getVariance
ObjCTypeParamVariance getVariance() const
Determine the variance of this type parameter.
Definition: DeclObjC.h:614
clang::comments::ParamCommandComment
Doxygen \param command.
Definition: Comment.h:713
clang::FunctionDecl::isDeleted
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:2259
clang::TextNodeDumper::VisitAccessSpecDecl
void VisitAccessSpecDecl(const AccessSpecDecl *D)
Definition: TextNodeDumper.cpp:1803
clang::TypedefType
Definition: Type.h:4240
clang::ObjCAtCatchStmt::getCatchParamDecl
const VarDecl * getCatchParamDecl() const
Definition: StmtObjC.h:97
clang::CXXNamedCastExpr::getCastName
const char * getCastName() const
getCastName - Get the name of the C++ cast being used, e.g., "static_cast", "dynamic_cast", "reinterpret_cast", or "const_cast".
Definition: ExprCXX.cpp:764
clang::InitListExpr::getInitializedFieldInUnion
FieldDecl * getInitializedFieldInUnion()
If this initializes a union, specifies which field in the union to initialize.
Definition: Expr.h:4515
clang::ObjCSubscriptRefExpr::isArraySubscriptRefExpr
bool isArraySubscriptRefExpr() const
Definition: ExprObjC.h:904
clang::CXXUnresolvedConstructExpr::getTypeAsWritten
QualType getTypeAsWritten() const
Retrieve the type that is being constructed, as specified in the source code.
Definition: ExprCXX.h:3425
clang::FunctionType::getNameForCallConv
static StringRef getNameForCallConv(CallingConv CC)
Definition: Type.cpp:2931
clang::ValueDecl::getType
QualType getType() const
Definition: Decl.h:630
clang::VK_LValue
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:129
clang::TextNodeDumper::VisitNamespaceDecl
void VisitNamespaceDecl(const NamespaceDecl *D)
Definition: TextNodeDumper.cpp:1514
clang::TextNodeDumper::VisitAutoType
void VisitAutoType(const AutoType *T)
Definition: TextNodeDumper.cpp:1199
clang::TextNodeDumper::VisitConstantExpr
void VisitConstantExpr(const ConstantExpr *Node)
Definition: TextNodeDumper.cpp:689
clang::AddressColor
static const TerminalColor AddressColor
Definition: ASTDumperUtils.h:57
clang::SourceRange
A trivial tuple used to represent a source range.
Definition: SourceLocation.h:207
clang::Decl::isModulePrivate
bool isModulePrivate() const
Whether this declaration was marked as being private to the module in which it was defined...
Definition: DeclBase.h:607
clang::FunctionProtoType::ExtProtoInfo::Variadic
bool Variadic
Definition: Type.h:3839
clang::UnaryOperator::getOpcodeStr
static StringRef getOpcodeStr(Opcode Op)
getOpcodeStr - Turn an Opcode enum value into the punctuation char it corresponds to...
Definition: Expr.cpp:1294
clang::ObjCPropertyDecl::getGetterMethodDecl
ObjCMethodDecl * getGetterMethodDecl() const
Definition: DeclObjC.h:936
clang::ConstructorUsingShadowDecl::getNominatedBaseClass
CXXRecordDecl * getNominatedBaseClass() const
Get the base class that was named in the using declaration.
Definition: DeclCXX.cpp:2898
clang::NamedDecl
This represents a decl that may have a name.
Definition: Decl.h:223
clang::TagType
Definition: Type.h:4471
clang::CXXBoolLiteralExpr
A boolean literal, per ([C++ lex.bool] Boolean literals).
Definition: ExprCXX.h:645
clang::comments::TParamCommandComment::getParamName
StringRef getParamName(const FullComment *FC) const
Definition: Comment.cpp:378
clang::TemplateTypeParmType
Definition: Type.h:4647
clang::comments::InlineCommandComment::RenderMonospaced
Definition: Comment.h:313
clang::VariableArrayType
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:3039
clang::TextNodeDumper::VisitObjCPropertyDecl
void VisitObjCPropertyDecl(const ObjCPropertyDecl *D)
Definition: TextNodeDumper.cpp:1913
clang::NamespaceAliasDecl
Represents a C++ namespace alias.
Definition: DeclCXX.h:2967
clang::ConstantExpr::getResultAPValueKind
APValue::ValueKind getResultAPValueKind() const
Definition: Expr.h:1050
clang::TextNodeDumper::VisitCXXThisExpr
void VisitCXXThisExpr(const CXXThisExpr *Node)
Definition: TextNodeDumper.cpp:879
clang::VarDecl::isInline
bool isInline() const
Whether this variable is (C++1z) inline.
Definition: Decl.h:1394
clang::TemplateArgument::getAsTemplate
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
Definition: TemplateBase.h:280
clang::ObjCIvarDecl::getAccessControl
AccessControl getAccessControl() const
Definition: DeclObjC.h:1998
clang::TextNodeDumper::VisitUnaryExprOrTypeTraitExpr
void VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *Node)
Definition: TextNodeDumper.cpp:810
clang::TextNodeDumper::visitHTMLEndTagComment
void visitHTMLEndTagComment(const comments::HTMLEndTagComment *C, const comments::FullComment *)
Definition: TextNodeDumper.cpp:515
clang::UsingDirectiveDecl
Represents C++ using-directive.
Definition: DeclCXX.h:2863
clang::PragmaDetectMismatchDecl
Represents a #pragma detect_mismatch line.
Definition: Decl.h:148
clang::TextNodeDumper::visitVerbatimLineComment
void visitVerbatimLineComment(const comments::VerbatimLineComment *C, const comments::FullComment *)
Definition: TextNodeDumper.cpp:582
clang::FloatingLiteral::getValueAsApproximateDouble
double getValueAsApproximateDouble() const
getValueAsApproximateDouble - This returns the value as an inaccurate double.
Definition: Expr.cpp:997
clang::AutoType::getTypeConstraintConcept
ConceptDecl * getTypeConstraintConcept() const
Definition: Type.h:4908
clang::Attr::getKind
attr::Kind getKind() const
Definition: Attr.h:85
clang::ObjCMessageExpr::SuperClass
The receiver is a superclass.
Definition: ExprObjC.h:1104
clang::TemplateArgument::getAsTemplateOrTemplatePattern
TemplateName getAsTemplateOrTemplatePattern() const
Retrieve the template argument as a template name; if the argument is a pack expansion, return the pattern as a template name.
Definition: TemplateBase.h:287
clang::FunctionDecl::getNumParams
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Definition: Decl.cpp:3242
clang::VarDecl::hasInit
bool hasInit() const
Definition: Decl.cpp:2226
clang::SourceRange::getBegin
SourceLocation getBegin() const
Definition: SourceLocation.h:216
clang::SizeOfPackExpr::getPack
NamedDecl * getPack() const
Retrieve the parameter pack.
Definition: ExprCXX.h:4162
clang::OverloadExpr::decls_end
decls_iterator decls_end() const
Definition: ExprCXX.h:2939
clang::ObjCCategoryImplDecl
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration...
Definition: DeclObjC.h:2513
clang::CaseStmt::caseStmtIsGNURange
bool caseStmtIsGNURange() const
True if this case statement is of the form case LHS ...
Definition: Stmt.h:1569
clang::ConstantArrayType
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2935
clang::SourceManager
This class handles loading and caching of source files into memory.
Definition: SourceManager.h:596
clang::ObjCTypeParamVariance::Invariant
The parameter is invariant: must match exactly.
clang::FunctionProtoType::ExtProtoInfo::ExceptionSpec
ExceptionSpecInfo ExceptionSpec
Definition: Type.h:3843
clang::TextNodeDumper::VisitUnaryOperator
void VisitUnaryOperator(const UnaryOperator *Node)
Definition: TextNodeDumper.cpp:803
clang::TextNodeDumper::VisitLabelDecl
void VisitLabelDecl(const LabelDecl *D)
Definition: TextNodeDumper.cpp:1233
clang::FunctionTemplateDecl
Declaration of a template function.
Definition: DeclTemplate.h:977
clang::TextTreeStructure::AddChild
void AddChild(Fn DoAddChild)
Add a child of the current node. Calls DoAddChild without arguments.
Definition: TextNodeDumper.h:47
clang::TextNodeDumper::VisitFunctionDecl
void VisitFunctionDecl(const FunctionDecl *D)
Definition: TextNodeDumper.cpp:1278
clang::ObjCPropertyDecl::OBJC_PR_unsafe_unretained
Definition: DeclObjC.h:758
clang::Attr
Attr - This represents one attribute.
Definition: Attr.h:45
clang::FunctionDecl::isDeletedAsWritten
bool isDeletedAsWritten() const
Definition: Decl.h:2263
clang::Decl::getLocation
SourceLocation getLocation() const
Definition: DeclBase.h:429
clang::TextNodeDumper::VisitTypeAliasTemplateDecl
void VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D)
Definition: TextNodeDumper.cpp:1537
clang::UsingShadowDecl
Represents a shadow declaration introduced into a scope by a (resolved) using declaration.
Definition: DeclCXX.h:3162
clang::comments::FullComment
A full comment attached to a declaration, contains block content.
Definition: Comment.h:1093
clang::UETT_OpenMPRequiredSimdAlign
Definition: TypeTraits.h:102
clang::TypeSourceInfo::getType
QualType getType() const
Return the type wrapped by this type source info.
Definition: Type.h:6238
clang::TextNodeDumper::VisitObjCBoxedExpr
void VisitObjCBoxedExpr(const ObjCBoxedExpr *Node)
Definition: TextNodeDumper.cpp:987
clang::StmtVisitorBase< llvm::make_const_ptr, TextNodeDumper, void, ParamTys... >::P
ParamTys P
Definition: StmtVisitor.h:171
clang::NamespaceAliasDecl::getAliasedNamespace
NamedDecl * getAliasedNamespace() const
Retrieve the namespace that this alias refers to, which may either be a NamespaceDecl or a NamespaceA...
Definition: DeclCXX.h:3063
clang::PragmaCommentDecl::getCommentKind
PragmaMSCommentKind getCommentKind() const
Definition: Decl.h:137
clang::ObjCCompatibleAliasDecl
ObjCCompatibleAliasDecl - Represents alias of a class.
Definition: DeclObjC.h:2743
clang::FunctionDecl::param_empty
bool param_empty() const
Definition: Decl.h:2410
clang::UndeserializedColor
static const TerminalColor UndeserializedColor
Definition: ASTDumperUtils.h:70
clang::TextNodeDumper::VisitWhileStmt
void VisitWhileStmt(const WhileStmt *Node)
Definition: TextNodeDumper.cpp:670
clang::TextNodeDumper::VisitStringLiteral
void VisitStringLiteral(const StringLiteral *Str)
Definition: TextNodeDumper.cpp:785
clang::CXXBaseSpecifier::getType
QualType getType() const
Retrieves the type of the base class.
Definition: DeclCXX.h:244
clang::TextNodeDumper::VisitRValueReferenceType
void VisitRValueReferenceType(const ReferenceType *T)
Definition: TextNodeDumper.cpp:1068