clang  15.0.0git
ASTNodeTraverser.h
Go to the documentation of this file.
1 //===--- ASTNodeTraverser.h - Traversal 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 the AST traversal facilities. Other users
10 // of this class may make use of the same traversal logic by inheriting it,
11 // similar to RecursiveASTVisitor.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_CLANG_AST_ASTNODETRAVERSER_H
16 #define LLVM_CLANG_AST_ASTNODETRAVERSER_H
17 
19 #include "clang/AST/AttrVisitor.h"
21 #include "clang/AST/DeclVisitor.h"
22 #include "clang/AST/LocInfoType.h"
23 #include "clang/AST/StmtVisitor.h"
25 #include "clang/AST/Type.h"
26 #include "clang/AST/TypeVisitor.h"
27 
28 namespace clang {
29 
30 class APValue;
31 
32 /**
33 
34 ASTNodeTraverser traverses the Clang AST for dumping purposes.
35 
36 The `Derived::doGetNodeDelegate()` method is required to be an accessible member
37 which returns a reference of type `NodeDelegateType &` which implements the
38 following interface:
39 
40 struct {
41  template <typename Fn> void AddChild(Fn DoAddChild);
42  template <typename Fn> void AddChild(StringRef Label, Fn DoAddChild);
43 
44  void Visit(const comments::Comment *C, const comments::FullComment *FC);
45  void Visit(const Attr *A);
46  void Visit(const TemplateArgument &TA, SourceRange R = {},
47  const Decl *From = nullptr, StringRef Label = {});
48  void Visit(const Stmt *Node);
49  void Visit(const Type *T);
50  void Visit(QualType T);
51  void Visit(const Decl *D);
52  void Visit(const CXXCtorInitializer *Init);
53  void Visit(const OMPClause *C);
54  void Visit(const BlockDecl::Capture &C);
55  void Visit(const GenericSelectionExpr::ConstAssociation &A);
56  void Visit(const concepts::Requirement *R);
57  void Visit(const APValue &Value, QualType Ty);
58 };
59 */
60 template <typename Derived, typename NodeDelegateType>
62  : public ConstDeclVisitor<Derived>,
63  public ConstStmtVisitor<Derived>,
64  public comments::ConstCommentVisitor<Derived, void,
65  const comments::FullComment *>,
66  public TypeVisitor<Derived>,
67  public ConstAttrVisitor<Derived>,
68  public ConstTemplateArgumentVisitor<Derived> {
69 
70  /// Indicates whether we should trigger deserialization of nodes that had
71  /// not already been loaded.
72  bool Deserialize = false;
73 
75 
76  NodeDelegateType &getNodeDelegate() {
77  return getDerived().doGetNodeDelegate();
78  }
79  Derived &getDerived() { return *static_cast<Derived *>(this); }
80 
81 public:
82  void setDeserialize(bool D) { Deserialize = D; }
83  bool getDeserialize() const { return Deserialize; }
84 
87 
88  void Visit(const Decl *D) {
90  return;
91 
92  getNodeDelegate().AddChild([=] {
93  getNodeDelegate().Visit(D);
94  if (!D)
95  return;
96 
98 
99  for (const auto &A : D->attrs())
100  Visit(A);
101 
102  if (const comments::FullComment *Comment =
104  Visit(Comment, Comment);
105 
106  // Decls within functions are visited by the body.
107  if (!isa<FunctionDecl>(*D) && !isa<ObjCMethodDecl>(*D)) {
108  if (Traversal != TK_AsIs) {
109  if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
110  auto SK = CTSD->getSpecializationKind();
113  return;
114  }
115  }
116  if (const auto *DC = dyn_cast<DeclContext>(D))
117  dumpDeclContext(DC);
118  }
119  });
120  }
121 
122  void Visit(const Stmt *Node, StringRef Label = {}) {
123  getNodeDelegate().AddChild(Label, [=] {
124  const Stmt *S = Node;
125 
126  if (auto *E = dyn_cast_or_null<Expr>(S)) {
127  switch (Traversal) {
128  case TK_AsIs:
129  break;
131  S = E->IgnoreUnlessSpelledInSource();
132  break;
133  }
134  }
135 
136  getNodeDelegate().Visit(S);
137 
138  if (!S) {
139  return;
140  }
141 
143 
144  // Some statements have custom mechanisms for dumping their children.
145  if (isa<DeclStmt>(S) || isa<GenericSelectionExpr>(S) ||
146  isa<RequiresExpr>(S))
147  return;
148 
149  if (Traversal == TK_IgnoreUnlessSpelledInSource &&
150  isa<LambdaExpr, CXXForRangeStmt, CallExpr,
151  CXXRewrittenBinaryOperator>(S))
152  return;
153 
154  for (const Stmt *SubStmt : S->children())
155  Visit(SubStmt);
156  });
157  }
158 
159  void Visit(QualType T) {
160  SplitQualType SQT = T.split();
161  if (!SQT.Quals.hasQualifiers())
162  return Visit(SQT.Ty);
163 
164  getNodeDelegate().AddChild([=] {
165  getNodeDelegate().Visit(T);
166  Visit(T.split().Ty);
167  });
168  }
169 
170  void Visit(const Type *T) {
171  getNodeDelegate().AddChild([=] {
172  getNodeDelegate().Visit(T);
173  if (!T)
174  return;
176 
177  QualType SingleStepDesugar =
179  if (SingleStepDesugar != QualType(T, 0))
180  Visit(SingleStepDesugar);
181  });
182  }
183 
184  void Visit(const Attr *A) {
185  getNodeDelegate().AddChild([=] {
186  getNodeDelegate().Visit(A);
188  });
189  }
190 
191  void Visit(const CXXCtorInitializer *Init) {
192  if (Traversal == TK_IgnoreUnlessSpelledInSource && !Init->isWritten())
193  return;
194  getNodeDelegate().AddChild([=] {
195  getNodeDelegate().Visit(Init);
196  Visit(Init->getInit());
197  });
198  }
199 
200  void Visit(const TemplateArgument &A, SourceRange R = {},
201  const Decl *From = nullptr, const char *Label = nullptr) {
202  getNodeDelegate().AddChild([=] {
203  getNodeDelegate().Visit(A, R, From, Label);
205  });
206  }
207 
208  void Visit(const BlockDecl::Capture &C) {
209  getNodeDelegate().AddChild([=] {
210  getNodeDelegate().Visit(C);
211  if (C.hasCopyExpr())
212  Visit(C.getCopyExpr());
213  });
214  }
215 
216  void Visit(const OMPClause *C) {
217  getNodeDelegate().AddChild([=] {
218  getNodeDelegate().Visit(C);
219  for (const auto *S : C->children())
220  Visit(S);
221  });
222  }
223 
225  getNodeDelegate().AddChild([=] {
226  getNodeDelegate().Visit(A);
227  if (const TypeSourceInfo *TSI = A.getTypeSourceInfo())
228  Visit(TSI->getType());
229  Visit(A.getAssociationExpr());
230  });
231  }
232 
233  void Visit(const concepts::Requirement *R) {
234  getNodeDelegate().AddChild([=] {
235  getNodeDelegate().Visit(R);
236  if (!R)
237  return;
238  if (auto *TR = dyn_cast<concepts::TypeRequirement>(R)) {
239  if (!TR->isSubstitutionFailure())
240  Visit(TR->getType()->getType().getTypePtr());
241  } else if (auto *ER = dyn_cast<concepts::ExprRequirement>(R)) {
242  if (!ER->isExprSubstitutionFailure())
243  Visit(ER->getExpr());
244  if (!ER->getReturnTypeRequirement().isEmpty())
245  Visit(ER->getReturnTypeRequirement()
246  .getTypeConstraint()
247  ->getImmediatelyDeclaredConstraint());
248  } else if (auto *NR = dyn_cast<concepts::NestedRequirement>(R)) {
249  if (!NR->isSubstitutionFailure())
250  Visit(NR->getConstraintExpr());
251  }
252  });
253  }
254 
255  void Visit(const APValue &Value, QualType Ty) {
256  getNodeDelegate().AddChild([=] { getNodeDelegate().Visit(Value, Ty); });
257  }
258 
259  void Visit(const comments::Comment *C, const comments::FullComment *FC) {
260  getNodeDelegate().AddChild([=] {
261  getNodeDelegate().Visit(C, FC);
262  if (!C) {
263  return;
264  }
265  comments::ConstCommentVisitor<Derived, void,
266  const comments::FullComment *>::visit(C,
267  FC);
268  for (comments::Comment::child_iterator I = C->child_begin(),
269  E = C->child_end();
270  I != E; ++I)
271  Visit(*I, FC);
272  });
273  }
274 
275  void Visit(const DynTypedNode &N) {
276  // FIXME: Improve this with a switch or a visitor pattern.
277  if (const auto *D = N.get<Decl>())
278  Visit(D);
279  else if (const auto *S = N.get<Stmt>())
280  Visit(S);
281  else if (const auto *QT = N.get<QualType>())
282  Visit(*QT);
283  else if (const auto *T = N.get<Type>())
284  Visit(T);
285  else if (const auto *C = N.get<CXXCtorInitializer>())
286  Visit(C);
287  else if (const auto *C = N.get<OMPClause>())
288  Visit(C);
289  else if (const auto *T = N.get<TemplateArgument>())
290  Visit(*T);
291  }
292 
293  void dumpDeclContext(const DeclContext *DC) {
294  if (!DC)
295  return;
296 
297  for (const auto *D : (Deserialize ? DC->decls() : DC->noload_decls()))
298  Visit(D);
299  }
300 
302  if (!TPL)
303  return;
304 
305  for (const auto &TP : *TPL)
306  Visit(TP);
307 
308  if (const Expr *RC = TPL->getRequiresClause())
309  Visit(RC);
310  }
311 
312  void
314  if (!TALI)
315  return;
316 
317  for (const auto &TA : TALI->arguments())
319  }
320 
322  const Decl *From = nullptr,
323  const char *Label = nullptr) {
324  Visit(A.getArgument(), A.getSourceRange(), From, Label);
325  }
326 
328  for (unsigned i = 0, e = TAL.size(); i < e; ++i)
329  Visit(TAL[i]);
330  }
331 
332  void dumpObjCTypeParamList(const ObjCTypeParamList *typeParams) {
333  if (!typeParams)
334  return;
335 
336  for (const auto &typeParam : *typeParams) {
337  Visit(typeParam);
338  }
339  }
340 
342  void VisitLocInfoType(const LocInfoType *T) {
344  }
347  Visit(T->getPointeeType());
348  }
350  Visit(T->getPointeeType());
351  }
353  Visit(T->getClass());
354  Visit(T->getPointeeType());
355  }
356  void VisitArrayType(const ArrayType *T) { Visit(T->getElementType()); }
358  VisitArrayType(T);
359  Visit(T->getSizeExpr());
360  }
362  Visit(T->getElementType());
363  Visit(T->getSizeExpr());
364  }
366  Visit(T->getElementType());
367  Visit(T->getSizeExpr());
368  }
369  void VisitVectorType(const VectorType *T) { Visit(T->getElementType()); }
373  for (const QualType &PT : T->getParamTypes())
374  Visit(PT);
375  }
377  Visit(T->getUnderlyingExpr());
378  }
380  Visit(T->getUnderlyingExpr());
381  }
383  Visit(T->getBaseType());
384  }
386  // FIXME: AttrKind
387  Visit(T->getModifiedType());
388  }
390  Visit(T->getWrappedType());
391  }
394  }
395  void
398  Visit(T->getArgumentPack());
399  }
401  for (const auto &Arg : *T)
402  Visit(Arg);
403  }
405  Visit(T->getPointeeType());
406  }
407  void VisitAtomicType(const AtomicType *T) { Visit(T->getValueType()); }
408  void VisitPipeType(const PipeType *T) { Visit(T->getElementType()); }
411  if (!T->isSugared())
412  Visit(T->getPattern());
413  }
414  // FIXME: ElaboratedType, DependentNameType,
415  // DependentTemplateSpecializationType, ObjCObjectType
416 
418 
420  if (const Expr *Init = D->getInitExpr())
421  Visit(Init);
422  }
423 
425  if (const auto *FTSI = D->getTemplateSpecializationInfo())
426  dumpTemplateArgumentList(*FTSI->TemplateArguments);
427 
428  if (D->param_begin())
429  for (const auto *Parameter : D->parameters())
430  Visit(Parameter);
431 
432  if (const Expr *TRC = D->getTrailingRequiresClause())
433  Visit(TRC);
434 
436  return;
437 
438  if (const auto *C = dyn_cast<CXXConstructorDecl>(D))
439  for (const auto *I : C->inits())
440  Visit(I);
441 
443  Visit(D->getBody());
444  }
445 
446  void VisitFieldDecl(const FieldDecl *D) {
447  if (D->isBitField())
448  Visit(D->getBitWidth());
449  if (Expr *Init = D->getInClassInitializer())
450  Visit(Init);
451  }
452 
453  void VisitVarDecl(const VarDecl *D) {
455  return;
456 
457  if (D->hasInit())
458  Visit(D->getInit());
459  }
460 
462  VisitVarDecl(D);
463  for (const auto *B : D->bindings())
464  Visit(B);
465  }
466 
467  void VisitBindingDecl(const BindingDecl *D) {
469  return;
470  if (const auto *E = D->getBinding())
471  Visit(E);
472  }
473 
475  Visit(D->getAsmString());
476  }
477 
478  void VisitCapturedDecl(const CapturedDecl *D) { Visit(D->getBody()); }
479 
481  for (const auto *E : D->varlists())
482  Visit(E);
483  }
484 
486  Visit(D->getCombiner());
487  if (const auto *Initializer = D->getInitializer())
489  }
490 
492  for (const auto *C : D->clauselists())
493  Visit(C);
494  }
495 
497  Visit(D->getInit());
498  }
499 
501  for (const auto *E : D->varlists())
502  Visit(E);
503  for (const auto *C : D->clauselists())
504  Visit(C);
505  }
506 
507  template <typename SpecializationDecl>
508  void dumpTemplateDeclSpecialization(const SpecializationDecl *D) {
509  for (const auto *RedeclWithBadType : D->redecls()) {
510  // FIXME: The redecls() range sometimes has elements of a less-specific
511  // type. (In particular, ClassTemplateSpecializationDecl::redecls() gives
512  // us TagDecls, and should give CXXRecordDecls).
513  auto *Redecl = dyn_cast<SpecializationDecl>(RedeclWithBadType);
514  if (!Redecl) {
515  // Found the injected-class-name for a class template. This will be
516  // dumped as part of its surrounding class so we don't need to dump it
517  // here.
518  assert(isa<CXXRecordDecl>(RedeclWithBadType) &&
519  "expected an injected-class-name");
520  continue;
521  }
522  Visit(Redecl);
523  }
524  }
525 
526  template <typename TemplateDecl>
529 
530  Visit(D->getTemplatedDecl());
531 
532  if (Traversal == TK_AsIs) {
533  for (const auto *Child : D->specializations())
535  }
536  }
537 
539  Visit(D->getUnderlyingType());
540  }
541 
544  Visit(D->getTemplatedDecl());
545  }
546 
548  Visit(D->getAssertExpr());
549  Visit(D->getMessage());
550  }
551 
553  dumpTemplateDecl(D);
554  }
555 
557  dumpTemplateDecl(D);
558  }
559 
563  }
564 
569  }
570 
573  Visit(D->getSpecialization());
575  }
577 
580  }
581 
582  void
585  VisitVarDecl(D);
586  }
587 
592  }
593 
595  if (const auto *TC = D->getTypeConstraint())
596  Visit(TC->getImmediatelyDeclaredConstraint());
597  if (D->hasDefaultArgument())
600  D->defaultArgumentWasInherited() ? "inherited from" : "previous");
601  }
602 
604  if (const auto *E = D->getPlaceholderTypeConstraint())
605  Visit(E);
606  if (D->hasDefaultArgument())
609  D->defaultArgumentWasInherited() ? "inherited from" : "previous");
610  }
611 
614  if (D->hasDefaultArgument())
617  D->defaultArgumentWasInherited() ? "inherited from" : "previous");
618  }
619 
620  void VisitConceptDecl(const ConceptDecl *D) {
622  Visit(D->getConstraintExpr());
623  }
624 
626  if (CSE->hasExplicitTemplateArgs())
627  for (const auto &ArgLoc : CSE->getTemplateArgsAsWritten()->arguments())
628  dumpTemplateArgumentLoc(ArgLoc);
629  }
630 
632  if (auto *TD = dyn_cast<TypeDecl>(D->getUnderlyingDecl()))
633  Visit(TD->getTypeForDecl());
634  }
635 
636  void VisitFriendDecl(const FriendDecl *D) {
637  if (!D->getFriendType())
638  Visit(D->getFriendDecl());
639  }
640 
643  dumpDeclContext(D);
644  else
645  for (const ParmVarDecl *Parameter : D->parameters())
646  Visit(Parameter);
647 
648  if (D->hasBody())
649  Visit(D->getBody());
650  }
651 
654  }
655 
658  }
659 
661  for (const auto &I : D->inits())
662  Visit(I);
663  }
664 
665  void VisitBlockDecl(const BlockDecl *D) {
666  for (const auto &I : D->parameters())
667  Visit(I);
668 
669  for (const auto &I : D->captures())
670  Visit(I);
671  Visit(D->getBody());
672  }
673 
674  void VisitDeclStmt(const DeclStmt *Node) {
675  for (const auto &D : Node->decls())
676  Visit(D);
677  }
678 
680  for (const auto *A : Node->getAttrs())
681  Visit(A);
682  }
683 
685  Visit(Node->getExceptionDecl());
686  }
687 
689  Visit(Node->getCapturedDecl());
690  }
691 
693  for (const auto *C : Node->clauses())
694  Visit(C);
695  }
696 
697  void VisitInitListExpr(const InitListExpr *ILE) {
698  if (auto *Filler = ILE->getArrayFiller()) {
699  Visit(Filler, "array_filler");
700  }
701  }
702 
703  void VisitBlockExpr(const BlockExpr *Node) { Visit(Node->getBlockDecl()); }
704 
706  if (Expr *Source = Node->getSourceExpr())
707  Visit(Source);
708  }
709 
712  Visit(E->getControllingExpr()->getType()); // FIXME: remove
713 
714  for (const auto Assoc : E->associations()) {
715  Visit(Assoc);
716  }
717  }
718 
720  for (auto *D : E->getLocalParameters())
721  Visit(D);
722  for (auto *R : E->getRequirements())
723  Visit(R);
724  }
725 
728  for (unsigned I = 0, N = Node->capture_size(); I != N; ++I) {
729  const auto *C = Node->capture_begin() + I;
730  if (!C->isExplicit())
731  continue;
732  if (Node->isInitCapture(C))
733  Visit(C->getCapturedVar());
734  else
735  Visit(Node->capture_init_begin()[I]);
736  }
737  dumpTemplateParameters(Node->getTemplateParameterList());
738  for (const auto *P : Node->getCallOperator()->parameters())
739  Visit(P);
740  Visit(Node->getBody());
741  } else {
742  return Visit(Node->getLambdaClass());
743  }
744  }
745 
747  if (Node->isPartiallySubstituted())
748  for (const auto &A : Node->getPartialArguments())
749  Visit(A);
750  }
751 
753  Visit(E->getParameter());
754  }
757  Visit(E->getParameterPack());
758  Visit(E->getArgumentPack());
759  }
760 
762  if (const VarDecl *CatchParam = Node->getCatchParamDecl())
763  Visit(CatchParam);
764  }
765 
768  Visit(Node->getInit());
769  Visit(Node->getLoopVariable());
770  Visit(Node->getRangeInit());
771  Visit(Node->getBody());
772  }
773  }
774 
775  void VisitCallExpr(const CallExpr *Node) {
776  for (const auto *Child :
777  make_filter_range(Node->children(), [this](const Stmt *Child) {
778  if (Traversal != TK_IgnoreUnlessSpelledInSource)
779  return false;
780  return !isa<CXXDefaultArgExpr>(Child);
781  })) {
782  Visit(Child);
783  }
784  }
785 
788  Visit(Node->getLHS());
789  Visit(Node->getRHS());
790  } else {
792  }
793  }
794 
796  Visit(TA.getAsExpr());
797  }
798 
800  Visit(TA.getAsType());
801  }
802 
804  for (const auto &TArg : TA.pack_elements())
805  Visit(TArg);
806  }
807 
808  // Implements Visit methods for Attrs.
809 #include "clang/AST/AttrNodeTraverse.inc"
810 };
811 
812 } // namespace clang
813 
814 #endif // LLVM_CLANG_AST_ASTNODETRAVERSER_H
clang::VarTemplatePartialSpecializationDecl::getTemplateParameters
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:2994
clang::TemplateDecl::getTemplatedDecl
NamedDecl * getTemplatedDecl() const
Get the underlying, templated declaration.
Definition: DeclTemplate.h:432
clang::ObjCInterfaceDecl
Represents an ObjC class declaration.
Definition: DeclObjC.h:1150
clang::OMPAllocateDecl
This represents '#pragma omp allocate ...' directive.
Definition: DeclOpenMP.h:473
clang::SubstNonTypeTemplateParmExpr
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Definition: ExprCXX.h:4262
clang::TraversalKind
TraversalKind
Defines how we descend a level in the AST when we pass through expressions.
Definition: ASTTypeTraits.h:38
clang::comments::CommentVisitorBase< llvm::make_const_ptr, Derived, void, ParamTys... >::visit
void visit(PTR(Comment) C, ParamTys... P)
Definition: CommentVisitor.h:27
clang::ConceptDecl::getConstraintExpr
Expr * getConstraintExpr() const
Definition: DeclTemplate.h:3267
clang::OMPDeclareReductionDecl::getInitializer
Expr * getInitializer()
Get initializer expression (if specified) of the declare reduction construct.
Definition: DeclOpenMP.h:239
clang::FunctionDecl::doesThisDeclarationHaveABody
bool doesThisDeclarationHaveABody() const
Returns whether this specific declaration of the function has a body.
Definition: Decl.h:2179
clang::Decl::getASTContext
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:414
clang::FunctionDecl::isDefaulted
bool isDefaulted() const
Whether this function is defaulted.
Definition: Decl.h:2231
clang::BlockDecl::parameters
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:4287
clang::ASTNodeTraverser::VisitConceptSpecializationExpr
void VisitConceptSpecializationExpr(const ConceptSpecializationExpr *CSE)
Definition: ASTNodeTraverser.h:625
clang::ASTNodeTraverser::VisitCXXCatchStmt
void VisitCXXCatchStmt(const CXXCatchStmt *Node)
Definition: ASTNodeTraverser.h:684
clang::ASTNodeTraverser::VisitOMPAllocateDecl
void VisitOMPAllocateDecl(const OMPAllocateDecl *D)
Definition: ASTNodeTraverser.h:500
clang::DeclContext::decls
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition: DeclBase.h:2131
clang::ASTNodeTraverser::Visit
void Visit(const DynTypedNode &N)
Definition: ASTNodeTraverser.h:275
clang::DependentSizedExtVectorType::getSizeExpr
Expr * getSizeExpr() const
Definition: Type.h:3217
clang::NonTypeTemplateParmDecl::getDefaultArgStorage
const DefArgStorage & getDefaultArgStorage() const
Definition: DeclTemplate.h:1476
clang::TypeSourceInfo::getType
QualType getType() const
Return the type wrapped by this type source info.
Definition: Type.h:6482
clang::TemplateTemplateParmDecl::hasDefaultArgument
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
Definition: DeclTemplate.h:1736
clang::TemplateTypeParmDecl::defaultArgumentWasInherited
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template.
Definition: DeclTemplate.h:1283
clang::ASTNodeTraverser::VisitConceptDecl
void VisitConceptDecl(const ConceptDecl *D)
Definition: ASTNodeTraverser.h:620
clang::AttributedType
An attributed type is a type to which a type attribute has been applied.
Definition: Type.h:4702
clang::ASTNodeTraverser::VisitInitListExpr
void VisitInitListExpr(const InitListExpr *ILE)
Definition: ASTNodeTraverser.h:697
clang::GenericSelectionExpr::ConstAssociation
AssociationTy< true > ConstAssociation
Definition: Expr.h:5786
clang::SubstTemplateTypeParmPackType::getArgumentPack
TemplateArgument getArgumentPack() const
Definition: Type.cpp:3656
clang::ASTNodeTraverser::VisitFunctionTemplateDecl
void VisitFunctionTemplateDecl(const FunctionTemplateDecl *D)
Definition: ASTNodeTraverser.h:552
clang::SourceRange
A trivial tuple used to represent a source range.
Definition: SourceLocation.h:210
clang::DecompositionDecl::bindings
ArrayRef< BindingDecl * > bindings() const
Definition: DeclCXX.h:4070
clang::DeclContext
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1356
clang::ASTNodeTraverser::VisitNonTypeTemplateParmDecl
void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D)
Definition: ASTNodeTraverser.h:603
clang::ASTNodeTraverser::dumpTemplateParameters
void dumpTemplateParameters(const TemplateParameterList *TPL)
Definition: ASTNodeTraverser.h:301
clang::ObjCSubstitutionContext::Parameter
@ Parameter
The parameter type of a method or function.
clang::TemplateTypeParmDecl::getDefaultArgument
QualType getDefaultArgument() const
Retrieve the default argument, if any.
Definition: DeclTemplate.h:1269
clang::ASTNodeTraverser::VisitBTFTagAttributedType
void VisitBTFTagAttributedType(const BTFTagAttributedType *T)
Definition: ASTNodeTraverser.h:389
clang::ASTNodeTraverser::VisitAttributedStmt
void VisitAttributedStmt(const AttributedStmt *Node)
Definition: ASTNodeTraverser.h:679
clang::PipeType::getElementType
QualType getElementType() const
Definition: Type.h:6359
clang::ASTNodeTraverser::dumpDeclContext
void dumpDeclContext(const DeclContext *DC)
Definition: ASTNodeTraverser.h:293
clang::TemplateArgument::pack_elements
ArrayRef< TemplateArgument > pack_elements() const
Iterator range referencing all of the elements of a template argument pack.
Definition: TemplateBase.h:365
clang::ObjCImplementationDecl
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2548
clang::ClassTemplatePartialSpecializationDecl::getTemplateParameters
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:2149
TemplateArgumentVisitor.h
clang::DependentSizedArrayType::getSizeExpr
Expr * getSizeExpr() const
Definition: Type.h:3122
clang::ASTNodeTraverser::VisitUsingShadowDecl
void VisitUsingShadowDecl(const UsingShadowDecl *D)
Definition: ASTNodeTraverser.h:631
clang::RequiresExpr::getRequirements
ArrayRef< concepts::Requirement * > getRequirements() const
Definition: ExprConcepts.h:520
clang::BindingDecl
A binding in a decomposition declaration.
Definition: DeclCXX.h:3979
clang::SubstNonTypeTemplateParmPackExpr
Represents a reference to a non-type template parameter pack that has been substituted with a non-tem...
Definition: ExprCXX.h:4329
clang::OMPThreadPrivateDecl
This represents '#pragma omp threadprivate ...' directive.
Definition: DeclOpenMP.h:110
clang::ASTNodeTraverser::VisitCXXForRangeStmt
void VisitCXXForRangeStmt(const CXXForRangeStmt *Node)
Definition: ASTNodeTraverser.h:766
clang::ASTNodeTraverser::VisitDeclStmt
void VisitDeclStmt(const DeclStmt *Node)
Definition: ASTNodeTraverser.h:674
clang::ASTNodeTraverser::VisitVectorType
void VisitVectorType(const VectorType *T)
Definition: ASTNodeTraverser.h:369
clang::NamedDecl::getUnderlyingDecl
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:457
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:675
clang::NonTypeTemplateParmDecl
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
Definition: DeclTemplate.h:1401
clang::DynamicInitKind::Initializer
@ Initializer
clang::TemplateTemplateParmDecl::getDefaultArgStorage
const DefArgStorage & getDefaultArgStorage() const
Definition: DeclTemplate.h:1732
clang::ClassScopeFunctionSpecializationDecl
Declaration of a function specialization at template class scope.
Definition: DeclTemplate.h:2621
clang::DecltypeType::getUnderlyingExpr
Expr * getUnderlyingExpr() const
Definition: Type.h:4532
clang::FieldDecl
Represents a member of a struct/union/class.
Definition: Decl.h:2855
clang::RequiresExpr
C++2a [expr.prim.req]: A requires-expression provides a concise way to express requirements on templa...
Definition: ExprConcepts.h:477
clang::ASTNodeTraverser::VisitObjCMethodDecl
void VisitObjCMethodDecl(const ObjCMethodDecl *D)
Definition: ASTNodeTraverser.h:641
clang::GenericSelectionExpr::associations
association_range associations()
Definition: Expr.h:5855
clang::FieldDecl::getInClassInitializer
Expr * getInClassInitializer() const
Get the C++11 default member initializer for this member, or null if one has not been set.
Definition: Decl.h:3002
clang::PipeType
PipeType - OpenCL20.
Definition: Type.h:6348
clang::ParmVarDecl
Represents a parameter to a function.
Definition: Decl.h:1680
clang::ObjCObjectPointerType::getPointeeType
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:6160
clang::EnumConstantDecl::getInitExpr
const Expr * getInitExpr() const
Definition: Decl.h:3089
clang::UsingShadowDecl
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
Definition: DeclCXX.h:3207
clang::TemplateSpecializationType
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:5179
clang::BlockDecl::getBody
Stmt * getBody() const override
getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...
Definition: Decl.h:4280
clang::LocInfoType
Holds a QualType and a TypeSourceInfo* that came out of a declarator parsing.
Definition: LocInfoType.h:28
clang::FunctionDecl::getTemplateSpecializationInfo
FunctionTemplateSpecializationInfo * getTemplateSpecializationInfo() const
If this function is actually a function template specialization, retrieve information about this func...
Definition: Decl.cpp:3884
clang::ComplexType::getElementType
QualType getElementType() const
Definition: Type.h:2610
clang::InitListExpr
Describes an C or C++ initializer list.
Definition: Expr.h:4791
clang::ASTNodeTraverser::VisitCXXRewrittenBinaryOperator
void VisitCXXRewrittenBinaryOperator(const CXXRewrittenBinaryOperator *Node)
Definition: ASTNodeTraverser.h:786
clang::ASTNodeTraverser::VisitObjCAtCatchStmt
void VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node)
Definition: ASTNodeTraverser.h:761
clang::OMPAllocateDecl::clauselists
clauselist_range clauselists()
Definition: DeclOpenMP.h:526
TypeVisitor.h
clang::ASTNodeTraverser::VisitUnaryTransformType
void VisitUnaryTransformType(const UnaryTransformType *T)
Definition: ASTNodeTraverser.h:382
clang::NonTypeTemplateParmDecl::hasDefaultArgument
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
Definition: DeclTemplate.h:1480
clang::ASTNodeTraverser::VisitBlockExpr
void VisitBlockExpr(const BlockExpr *Node)
Definition: ASTNodeTraverser.h:703
clang::VarTemplateSpecializationDecl::getTemplateArgs
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the variable template specialization.
Definition: DeclTemplate.h:2772
clang::ASTNodeTraverser::VisitObjCObjectPointerType
void VisitObjCObjectPointerType(const ObjCObjectPointerType *T)
Definition: ASTNodeTraverser.h:404
clang::ASTNodeTraverser::Visit
void Visit(QualType T)
Definition: ASTNodeTraverser.h:159
clang::OMPAllocateDecl::varlists
varlist_range varlists()
Definition: DeclOpenMP.h:515
clang::ClassTemplatePartialSpecializationDecl
Definition: DeclTemplate.h:2092
clang::ASTNodeTraverser::VisitFunctionProtoType
void VisitFunctionProtoType(const FunctionProtoType *T)
Definition: ASTNodeTraverser.h:371
LocInfoType.h
clang::ASTNodeTraverser::VisitFunctionType
void VisitFunctionType(const FunctionType *T)
Definition: ASTNodeTraverser.h:370
clang::GenericSelectionExpr::getControllingExpr
Expr * getControllingExpr()
Return the controlling expression of this generic selection expression.
Definition: Expr.h:5809
clang::FunctionType
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3559
clang::VarTemplateSpecializationDecl
Represents a variable template specialization, which refers to a variable template with a given set o...
Definition: DeclTemplate.h:2681
clang::ASTContext::getLocalCommentForDeclUncached
comments::FullComment * getLocalCommentForDeclUncached(const Decl *D) const
Return parsed documentation comment attached to a given declaration.
Definition: ASTContext.cpp:552
clang::CapturedDecl
Represents the body of a CapturedStmt, and serves as its DeclContext.
Definition: Decl.h:4390
clang::ASTNodeTraverser::VisitDecltypeType
void VisitDecltypeType(const DecltypeType *T)
Definition: ASTNodeTraverser.h:379
clang::SubstTemplateTypeParmType::getReplacedParameter
const TemplateTypeParmType * getReplacedParameter() const
Gets the template parameter that was substituted for.
Definition: Type.h:4924
clang::TemplateArgument::getAsExpr
Expr * getAsExpr() const
Retrieve the template argument as an expression.
Definition: TemplateBase.h:341
clang::ASTNodeTraverser::getDeserialize
bool getDeserialize() const
Definition: ASTNodeTraverser.h:83
clang::ASTTemplateArgumentListInfo::arguments
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
Definition: TemplateBase.h:640
clang::BTFTagAttributedType
Definition: Type.h:4799
clang::ASTNodeTraverser::VisitPointerType
void VisitPointerType(const PointerType *T)
Definition: ASTNodeTraverser.h:345
clang::ASTNodeTraverser::VisitClassTemplateDecl
void VisitClassTemplateDecl(const ClassTemplateDecl *D)
Definition: ASTNodeTraverser.h:556
clang::OpaqueValueExpr
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
Definition: Expr.h:1135
clang::Type
The base class of the type hierarchy.
Definition: Type.h:1500
clang::TemplateTypeParmDecl::hasDefaultArgument
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
Definition: DeclTemplate.h:1266
clang::SubstTemplateTypeParmPackType::getReplacedParameter
const TemplateTypeParmType * getReplacedParameter() const
Gets the template parameter that was substituted for.
Definition: Type.h:4983
clang::ASTNodeTraverser::VisitMemberPointerType
void VisitMemberPointerType(const MemberPointerType *T)
Definition: ASTNodeTraverser.h:352
clang::DeclContext::noload_decls
decl_range noload_decls() const
noload_decls_begin/end - Iterate over the declarations stored in this context that are currently load...
Definition: DeclBase.h:2139
clang::ASTNodeTraverser::VisitSizeOfPackExpr
void VisitSizeOfPackExpr(const SizeOfPackExpr *Node)
Definition: ASTNodeTraverser.h:746
clang::BlockDecl::captures
ArrayRef< Capture > captures() const
Definition: Decl.h:4328
clang::ReferenceType::getPointeeType
QualType getPointeeType() const
Definition: Type.h:2782
clang::TypeAliasTemplateDecl::getTemplatedDecl
TypeAliasDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Definition: DeclTemplate.h:2558
clang::ASTNodeTraverser::Visit
void Visit(const Type *T)
Definition: ASTNodeTraverser.h:170
clang::ASTNodeTraverser::VisitObjCInterfaceDecl
void VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D)
Definition: ASTNodeTraverser.h:656
clang::ASTNodeTraverser::VisitEnumConstantDecl
void VisitEnumConstantDecl(const EnumConstantDecl *D)
Definition: ASTNodeTraverser.h:419
clang::ASTNodeTraverser::VisitBlockDecl
void VisitBlockDecl(const BlockDecl *D)
Definition: ASTNodeTraverser.h:665
clang::FunctionTemplateDecl
Declaration of a template function.
Definition: DeclTemplate.h:979
clang::AttributedStmt
Represents an attribute applied to a statement.
Definition: Stmt.h:1850
clang::comments::Comment
Any part of the comment.
Definition: Comment.h:52
clang::TSK_ExplicitInstantiationDeclaration
@ TSK_ExplicitInstantiationDeclaration
This template specialization was instantiated from a template due to an explicit instantiation declar...
Definition: Specifiers.h:187
clang::VarDecl::hasInit
bool hasInit() const
Definition: Decl.cpp:2303
clang::PackExpansionType::getPattern
QualType getPattern() const
Retrieve the pattern of this pack expansion, which is the type that will be repeatedly instantiated w...
Definition: Type.h:5729
clang::NonTypeTemplateParmDecl::defaultArgumentWasInherited
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template.
Definition: DeclTemplate.h:1490
clang::ObjCAtCatchStmt
Represents Objective-C's @catch statement.
Definition: StmtObjC.h:77
clang::ConceptReference::getTemplateArgsAsWritten
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Definition: ASTConcept.h:156
clang::ConstTemplateArgumentVisitor
A simple visitor class that helps create template argument visitors.
Definition: TemplateArgumentVisitor.h:92
clang::ASTNodeTraverser::VisitAtomicType
void VisitAtomicType(const AtomicType *T)
Definition: ASTNodeTraverser.h:407
clang::ClassTemplateSpecializationDecl::getTemplateArgs
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
Definition: DeclTemplate.h:1908
clang::PackExpansionType
Represents a pack expansion of types.
Definition: Type.h:5708
clang::OMPDeclareReductionDecl
This represents '#pragma omp declare reduction ...' directive.
Definition: DeclOpenMP.h:171
clang::CXXRewrittenBinaryOperator
A rewritten comparison expression that was originally written using operator syntax.
Definition: ExprCXX.h:284
clang::SizeOfPackExpr
Represents an expression that computes the length of a parameter pack.
Definition: ExprCXX.h:4144
Node
DynTypedNode Node
Definition: ASTMatchFinder.cpp:68
Traversal
TraversalKind Traversal
Definition: ASTMatchFinder.cpp:70
clang::BlockDecl
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:4201
clang::ASTNodeTraverser::VisitReferenceType
void VisitReferenceType(const ReferenceType *T)
Definition: ASTNodeTraverser.h:349
clang::ASTNodeTraverser::VisitClassScopeFunctionSpecializationDecl
void VisitClassScopeFunctionSpecializationDecl(const ClassScopeFunctionSpecializationDecl *D)
Definition: ASTNodeTraverser.h:571
clang::ASTNodeTraverser::Visit
void Visit(const comments::Comment *C, const comments::FullComment *FC)
Definition: ASTNodeTraverser.h:259
clang::OMPClause
This is a basic class for representing single OpenMP clause.
Definition: OpenMPClause.h:55
clang::ASTNodeTraverser::VisitDependentSizedArrayType
void VisitDependentSizedArrayType(const DependentSizedArrayType *T)
Definition: ASTNodeTraverser.h:361
clang::SubstNonTypeTemplateParmPackExpr::getParameterPack
NonTypeTemplateParmDecl * getParameterPack() const
Retrieve the non-type template parameter pack being substituted.
Definition: ExprCXX.h:4357
clang::LambdaExpr
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1865
clang::ConceptDecl
Declaration of a C++2a concept.
Definition: DeclTemplate.h:3252
clang::ASTNodeTraverser::VisitFriendDecl
void VisitFriendDecl(const FriendDecl *D)
Definition: ASTNodeTraverser.h:636
clang::VectorType
Represents a GCC generic vector type.
Definition: Type.h:3242
clang::FieldDecl::getBitWidth
Expr * getBitWidth() const
Definition: Decl.h:2944
clang::ClassScopeFunctionSpecializationDecl::getTemplateArgsAsWritten
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Definition: DeclTemplate.h:2642
clang::ConceptSpecializationExpr
Represents the specialization of a concept - evaluates to a prvalue of type bool.
Definition: ExprConcepts.h:40
clang::FriendDecl::getFriendDecl
NamedDecl * getFriendDecl() const
If this friend declaration doesn't name a type, return the inner declaration.
Definition: DeclFriend.h:138
clang::ASTNodeTraverser::VisitFileScopeAsmDecl
void VisitFileScopeAsmDecl(const FileScopeAsmDecl *D)
Definition: ASTNodeTraverser.h:474
clang::ArrayType
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2896
clang::ASTNodeTraverser
ASTNodeTraverser traverses the Clang AST for dumping purposes.
Definition: ASTNodeTraverser.h:61
clang::ASTNodeTraverser::VisitOpaqueValueExpr
void VisitOpaqueValueExpr(const OpaqueValueExpr *Node)
Definition: ASTNodeTraverser.h:705
clang::MemberPointerType::getPointeeType
QualType getPointeeType() const
Definition: Type.h:2860
clang::ASTNodeTraverser::VisitCapturedDecl
void VisitCapturedDecl(const CapturedDecl *D)
Definition: ASTNodeTraverser.h:478
clang::DecompositionDecl
A decomposition declaration.
Definition: DeclCXX.h:4036
clang::FunctionDecl::getBody
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
Definition: Decl.cpp:3092
clang::ASTNodeTraverser::VisitSubstTemplateTypeParmPackType
void VisitSubstTemplateTypeParmPackType(const SubstTemplateTypeParmPackType *T)
Definition: ASTNodeTraverser.h:396
clang::TemplateArgument
Represents a template argument.
Definition: TemplateBase.h:61
clang::concepts::Requirement
A static requirement that can be used in a requires-expression to check properties of types and expre...
Definition: ExprConcepts.h:151
clang::StaticAssertDecl::getMessage
StringLiteral * getMessage()
Definition: DeclCXX.h:3956
clang::ASTNodeTraverser::dumpTemplateDecl
void dumpTemplateDecl(const TemplateDecl *D)
Definition: ASTNodeTraverser.h:527
clang::StmtVisitorBase< llvm::make_const_ptr, ImplClass, void, ParamTys... >::Visit
void Visit(PTR(Stmt) S, ParamTys... P)
Definition: StmtVisitor.h:43
clang::ASTNodeTraverser::VisitSubstNonTypeTemplateParmPackExpr
void VisitSubstNonTypeTemplateParmPackExpr(const SubstNonTypeTemplateParmPackExpr *E)
Definition: ASTNodeTraverser.h:755
clang::ASTNodeTraverser::dumpTemplateArgumentLoc
void dumpTemplateArgumentLoc(const TemplateArgumentLoc &A, const Decl *From=nullptr, const char *Label=nullptr)
Definition: ASTNodeTraverser.h:321
clang::LocInfoType::getTypeSourceInfo
TypeSourceInfo * getTypeSourceInfo() const
Definition: LocInfoType.h:45
clang::ASTNodeTraverser::VisitClassTemplateSpecializationDecl
void VisitClassTemplateSpecializationDecl(const ClassTemplateSpecializationDecl *D)
Definition: ASTNodeTraverser.h:560
clang::comments::FullComment
A full comment attached to a declaration, contains block content.
Definition: Comment.h:1077
clang::TypedefNameDecl::getUnderlyingType
QualType getUnderlyingType() const
Definition: Decl.h:3255
clang::isa
bool isa(CodeGen::Address addr)
Definition: Address.h:177
clang::VariableArrayType::getSizeExpr
Expr * getSizeExpr() const
Definition: Type.h:3065
clang::TemplateArgumentLoc::getSourceRange
SourceRange getSourceRange() const LLVM_READONLY
Definition: TemplateBase.cpp:502
clang::TemplateArgumentLoc
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:457
Type.h
clang::ASTNodeTraverser::Visit
void Visit(const CXXCtorInitializer *Init)
Definition: ASTNodeTraverser.h:191
clang::FriendDecl
FriendDecl - Represents the declaration of a friend entity, which can be a function,...
Definition: DeclFriend.h:53
clang::TemplateTemplateParmDecl
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
Definition: DeclTemplate.h:1618
clang::ASTNodeTraverser::VisitTemplateTypeParmDecl
void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D)
Definition: ASTNodeTraverser.h:594
clang::ASTNodeTraverser::VisitPipeType
void VisitPipeType(const PipeType *T)
Definition: ASTNodeTraverser.h:408
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:874
clang::TemplateArgumentLoc::getArgument
const TemplateArgument & getArgument() const
Definition: TemplateBase.h:506
clang::FunctionProtoType::getParamTypes
ArrayRef< QualType > getParamTypes() const
Definition: Type.h:4115
clang::ASTNodeTraverser::VisitPackTemplateArgument
void VisitPackTemplateArgument(const TemplateArgument &TA)
Definition: ASTNodeTraverser.h:803
clang::ConceptReference::hasExplicitTemplateArgs
bool hasExplicitTemplateArgs() const
Whether or not template arguments were explicitly specified in the concept reference (they might not ...
Definition: ASTConcept.h:162
clang::OMPDeclareMapperDecl
This represents '#pragma omp declare mapper ...' directive.
Definition: DeclOpenMP.h:286
clang::TemplateParameterList
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:69
clang::TSK_ExplicitInstantiationDefinition
@ TSK_ExplicitInstantiationDefinition
This template specialization was instantiated from a template due to an explicit instantiation defini...
Definition: Specifiers.h:191
clang::ASTNodeTraverser::VisitObjCCategoryDecl
void VisitObjCCategoryDecl(const ObjCCategoryDecl *D)
Definition: ASTNodeTraverser.h:652
clang::CapturedStmt
This captures a statement into a function.
Definition: Stmt.h:3504
clang::DeclaratorDecl::getTrailingRequiresClause
Expr * getTrailingRequiresClause()
Get the constraint-expression introduced by the trailing requires-clause in the function/member decla...
Definition: Decl.h:802
clang::SplitQualType::Ty
const Type * Ty
The locally-unqualified type.
Definition: Type.h:616
clang::ASTNodeTraverser::VisitTemplateTemplateParmDecl
void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D)
Definition: ASTNodeTraverser.h:612
clang::ASTNodeTraverser::VisitTypedefDecl
void VisitTypedefDecl(const TypedefDecl *D)
Definition: ASTNodeTraverser.h:417
clang::SubstTemplateTypeParmType
Represents the result of substituting a type for a template type parameter.
Definition: Type.h:4912
clang::EnumConstantDecl
An instance of this object exists for each enum constant that is defined.
Definition: Decl.h:3070
clang::ObjCInterfaceDecl::getTypeParamListAsWritten
ObjCTypeParamList * getTypeParamListAsWritten() const
Retrieve the type parameters written on this particular declaration of the class.
Definition: DeclObjC.h:1289
clang::MemberPointerType::getClass
const Type * getClass() const
Definition: Type.h:2874
clang::Type::getLocallyUnqualifiedSingleStepDesugaredType
QualType getLocallyUnqualifiedSingleStepDesugaredType() const
Pull a single level of sugar off of this locally-unqualified type.
Definition: Type.cpp:422
clang::ASTNodeTraverser::Visit
void Visit(const TemplateArgument &A, SourceRange R={}, const Decl *From=nullptr, const char *Label=nullptr)
Definition: ASTNodeTraverser.h:200
clang::TypeVisitor
An operation on a type.
Definition: TypeVisitor.h:64
clang::ASTNodeTraverser::VisitLocInfoType
void VisitLocInfoType(const LocInfoType *T)
Definition: ASTNodeTraverser.h:342
Label
std::string Label
Definition: UsingDeclarationsSorter.cpp:69
clang::RequiresExpr::getLocalParameters
ArrayRef< ParmVarDecl * > getLocalParameters() const
Definition: ExprConcepts.h:514
clang::SubstTemplateTypeParmPackType
Represents the result of substituting a set of types for a template type parameter pack.
Definition: Type.h:4965
clang::ASTNodeTraverser::VisitBindingDecl
void VisitBindingDecl(const BindingDecl *D)
Definition: ASTNodeTraverser.h:467
clang::ASTNodeTraverser::VisitStaticAssertDecl
void VisitStaticAssertDecl(const StaticAssertDecl *D)
Definition: ASTNodeTraverser.h:547
clang::AtomicType::getValueType
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Definition: Type.h:6329
clang::ConstAttrVisitor
A simple visitor class that helps create attribute visitors.
Definition: AttrVisitor.h:69
clang::BlockPointerType
Pointer to a block type.
Definition: Type.h:2733
clang::TemplateTypeParmDecl
Declaration of a template type parameter.
Definition: DeclTemplate.h:1196
clang::AdjustedType
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons.
Definition: Type.h:2682
clang::UnaryTransformType::getBaseType
QualType getBaseType() const
Definition: Type.h:4591
clang::Decl::isImplicit
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:558
clang::QualType::split
SplitQualType split() const
Divides a QualType into its unqualified type and a set of local qualifiers.
Definition: Type.h:6508
clang::TemplateDecl::getTemplateParameters
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:419
clang::ASTNodeTraverser::VisitArrayType
void VisitArrayType(const ArrayType *T)
Definition: ASTNodeTraverser.h:356
clang::ASTNodeTraverser::VisitTypeAliasDecl
void VisitTypeAliasDecl(const TypeAliasDecl *D)
Definition: ASTNodeTraverser.h:538
clang::ObjCCategoryDecl
ObjCCategoryDecl - Represents a category declaration.
Definition: DeclObjC.h:2276
clang::UnaryTransformType
A unary type transform, which is a type constructed from another.
Definition: Type.h:4565
clang::ASTNodeTraverser::VisitAdjustedType
void VisitAdjustedType(const AdjustedType *T)
Definition: ASTNodeTraverser.h:409
clang::ASTNodeTraverser::VisitDecompositionDecl
void VisitDecompositionDecl(const DecompositionDecl *D)
Definition: ASTNodeTraverser.h:461
clang::StaticAssertDecl::getAssertExpr
Expr * getAssertExpr()
Definition: DeclCXX.h:3953
clang::ObjCObjectPointerType
Represents a pointer to an Objective C object.
Definition: Type.h:6148
clang::ASTNodeTraverser::VisitTypeTemplateArgument
void VisitTypeTemplateArgument(const TemplateArgument &TA)
Definition: ASTNodeTraverser.h:799
clang::TemplateTemplateParmDecl::defaultArgumentWasInherited
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template.
Definition: DeclTemplate.h:1749
clang::ASTNodeTraverser::VisitOMPThreadPrivateDecl
void VisitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D)
Definition: ASTNodeTraverser.h:480
clang::ObjCImplementationDecl::inits
init_range inits()
Definition: DeclObjC.h:2610
clang::ASTNodeTraverser::VisitClassTemplatePartialSpecializationDecl
void VisitClassTemplatePartialSpecializationDecl(const ClassTemplatePartialSpecializationDecl *D)
Definition: ASTNodeTraverser.h:565
clang::declvisitor::Base< llvm::make_const_ptr, ImplClass, void >::Visit
void Visit(PTR(Decl) D)
Definition: DeclVisitor.h:37
clang::ASTNodeTraverser::VisitCallExpr
void VisitCallExpr(const CallExpr *Node)
Definition: ASTNodeTraverser.h:775
clang::DependentSizedArrayType
Represents an array type in C++ whose size is a value-dependent expression.
Definition: Type.h:3100
clang::ASTNodeTraverser::dumpObjCTypeParamList
void dumpObjCTypeParamList(const ObjCTypeParamList *typeParams)
Definition: ASTNodeTraverser.h:332
clang::VariableArrayType
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:3046
clang::FieldDecl::isBitField
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2933
clang::ASTNodeTraverser::GetTraversalKind
TraversalKind GetTraversalKind() const
Definition: ASTNodeTraverser.h:86
clang::ASTNodeTraverser::VisitLambdaExpr
void VisitLambdaExpr(const LambdaExpr *Node)
Definition: ASTNodeTraverser.h:726
clang::NonTypeTemplateParmDecl::getDefaultArgument
Expr * getDefaultArgument() const
Retrieve the default argument, if any.
Definition: DeclTemplate.h:1483
clang::TemplateTypeParmDecl::getTypeConstraint
const TypeConstraint * getTypeConstraint() const
Returns the type constraint associated with this template parameter (if any).
Definition: DeclTemplate.h:1363
clang::StaticAssertDecl
Represents a C++11 static_assert declaration.
Definition: DeclCXX.h:3930
clang::ClassTemplateDecl
Declaration of a class template.
Definition: DeclTemplate.h:2264
clang::ComplexType
Complex values, per C99 6.2.5p11.
Definition: Type.h:2600
clang::ConstDeclVisitor
A simple visitor class that helps create declaration visitors.
Definition: DeclVisitor.h:73
clang::BTFTagAttributedType::getWrappedType
QualType getWrappedType() const
Definition: Type.h:4812
clang::DecltypeType
Represents the type decltype(expr) (C++11).
Definition: Type.h:4522
clang::SubstNonTypeTemplateParmExpr::getParameter
NonTypeTemplateParmDecl * getParameter() const
Definition: ExprCXX.h:4296
clang::FunctionProtoType
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3898
clang::OMPCapturedExprDecl
Pseudo declaration for capturing expressions.
Definition: DeclOpenMP.h:383
clang::TK_AsIs
@ TK_AsIs
Will traverse all child nodes.
Definition: ASTTypeTraits.h:40
clang::TypeOfExprType::getUnderlyingExpr
Expr * getUnderlyingExpr() const
Definition: Type.h:4465
clang::ASTNodeTraverser::VisitVarDecl
void VisitVarDecl(const VarDecl *D)
Definition: ASTNodeTraverser.h:453
clang::TemplateDecl
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:400
clang::BlockPointerType::getPointeeType
QualType getPointeeType() const
Definition: Type.h:2745
clang::VarTemplatePartialSpecializationDecl
Definition: DeclTemplate.h:2942
clang::BlockExpr
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:5970
DeclVisitor.h
Value
Value
Definition: UninitializedValues.cpp:102
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:83
clang::ASTNodeTraverser::VisitOMPExecutableDirective
void VisitOMPExecutableDirective(const OMPExecutableDirective *Node)
Definition: ASTNodeTraverser.h:692
clang::ASTNodeTraverser::dumpTemplateArgumentList
void dumpTemplateArgumentList(const TemplateArgumentList &TAL)
Definition: ASTNodeTraverser.h:327
clang::ClassScopeFunctionSpecializationDecl::getSpecialization
CXXMethodDecl * getSpecialization() const
Definition: DeclTemplate.h:2640
clang::CapturedDecl::getBody
Stmt * getBody() const override
getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...
Definition: Decl.cpp:5011
clang::ASTNodeTraverser::VisitBuiltinTemplateDecl
void VisitBuiltinTemplateDecl(const BuiltinTemplateDecl *D)
Definition: ASTNodeTraverser.h:578
clang::DependentSizedExtVectorType::getElementType
QualType getElementType() const
Definition: Type.h:3218
StmtVisitor.h
clang::ASTNodeTraverser::Visit
void Visit(const Attr *A)
Definition: ASTNodeTraverser.h:184
clang::StmtVisitorBase< llvm::make_const_ptr, Derived, void, ParamTys... >::P
ParamTys P
Definition: StmtVisitor.h:171
clang::InitListExpr::getArrayFiller
Expr * getArrayFiller()
If this initializer list initializes an array with more elements than there are initializers in the l...
Definition: Expr.h:4887
clang::ASTNodeTraverser::Visit
void Visit(const Decl *D)
Definition: ASTNodeTraverser.h:88
clang::Decl::attrs
attr_range attrs() const
Definition: DeclBase.h:501
clang::Qualifiers::hasQualifiers
bool hasQualifiers() const
Return true if the set contains any qualifiers.
Definition: Type.h:424
clang::TK_IgnoreUnlessSpelledInSource
@ TK_IgnoreUnlessSpelledInSource
Ignore AST nodes not written in the source.
Definition: ASTTypeTraits.h:43
clang::TemplateArgumentList
A template argument list.
Definition: DeclTemplate.h:237
clang::templateargumentvisitor::Base< llvm::make_const_ref, ImplClass, void, ParamTys... >::Visit
void Visit(REF(TemplateArgument) TA, ParamTys... P)
Definition: TemplateArgumentVisitor.h:33
clang::VarDecl::getInit
const Expr * getInit() const
Definition: Decl.h:1283
clang::SplitQualType
A std::pair-like structure for storing a qualified type split into its local qualifiers and its local...
Definition: Type.h:614
clang::ConstStmtVisitor
ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:193
ASTTypeTraits.h
clang::TypedefDecl
Represents the declaration of a typedef-name via the 'typedef' type specifier.
Definition: Decl.h:3302
clang::OMPDeclareReductionDecl::getCombiner
Expr * getCombiner()
Get combiner expression of the declare reduction construct.
Definition: DeclOpenMP.h:221
clang::OMPExecutableDirective
This is a basic class for representing single OpenMP executable directive.
Definition: StmtOpenMP.h:266
clang::TypeOfExprType
Represents a typeof (or typeof) expression (a GCC extension).
Definition: Type.h:4456
clang::ASTNodeTraverser::VisitGenericSelectionExpr
void VisitGenericSelectionExpr(const GenericSelectionExpr *E)
Definition: ASTNodeTraverser.h:710
clang::CXXForRangeStmt
CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (ra...
Definition: StmtCXX.h:134
clang::MemberPointerType
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2844
clang::TemplateTypeParmDecl::getDefaultArgStorage
const DefArgStorage & getDefaultArgStorage() const
Definition: DeclTemplate.h:1262
clang::ASTNodeTraverser::VisitComplexType
void VisitComplexType(const ComplexType *T)
Definition: ASTNodeTraverser.h:341
clang::DeclStmt
DeclStmt - Adaptor class for mixing declarations with statements and expressions.
Definition: Stmt.h:1294
clang::ObjCMethodDecl::getBody
Stmt * getBody() const override
Retrieve the body of this method, if it has one.
Definition: DeclObjC.cpp:874
clang::VarDecl::isCXXForRangeDecl
bool isCXXForRangeDecl() const
Determine whether this variable is the for-range-declaration in a C++0x for-range statement.
Definition: Decl.h:1430
clang::ASTNodeTraverser::VisitOMPCapturedExprDecl
void VisitOMPCapturedExprDecl(const OMPCapturedExprDecl *D)
Definition: ASTNodeTraverser.h:496
clang::ASTNodeTraverser::setDeserialize
void setDeserialize(bool D)
Definition: ASTNodeTraverser.h:82
clang::ObjCMethodDecl
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:139
clang::PointerType
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2653
clang::ASTNodeTraverser::VisitAttributedType
void VisitAttributedType(const AttributedType *T)
Definition: ASTNodeTraverser.h:385
clang::ObjCMethodDecl::hasBody
bool hasBody() const override
Determine whether this method has a body.
Definition: DeclObjC.h:527
clang::ASTNodeTraverser::VisitFieldDecl
void VisitFieldDecl(const FieldDecl *D)
Definition: ASTNodeTraverser.h:446
clang::ASTNodeTraverser::VisitFunctionDecl
void VisitFunctionDecl(const FunctionDecl *D)
Definition: ASTNodeTraverser.h:424
clang::FileScopeAsmDecl
Definition: Decl.h:4166
clang::ASTNodeTraverser::SetTraversalKind
void SetTraversalKind(TraversalKind TK)
Definition: ASTNodeTraverser.h:85
clang::ObjCTypeParamList
Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereo...
Definition: DeclObjC.h:660
clang::TemplateTemplateParmDecl::getDefaultArgument
const TemplateArgumentLoc & getDefaultArgument() const
Retrieve the default argument, if any.
Definition: DeclTemplate.h:1739
clang
Definition: CalledOnceCheck.h:17
clang::ASTNodeTraverser::VisitExpressionTemplateArgument
void VisitExpressionTemplateArgument(const TemplateArgument &TA)
Definition: ASTNodeTraverser.h:795
clang::ASTNodeTraverser::Visit
void Visit(const APValue &Value, QualType Ty)
Definition: ASTNodeTraverser.h:255
clang::VectorType::getElementType
QualType getElementType() const
Definition: Type.h:3283
clang::ASTNodeTraverser::VisitOMPDeclareReductionDecl
void VisitOMPDeclareReductionDecl(const OMPDeclareReductionDecl *D)
Definition: ASTNodeTraverser.h:485
clang::FileScopeAsmDecl::getAsmString
const StringLiteral * getAsmString() const
Definition: Decl.h:4190
clang::Stmt
Stmt - This represents one statement.
Definition: Stmt.h:69
clang::ASTNodeTraverser::Visit
void Visit(const BlockDecl::Capture &C)
Definition: ASTNodeTraverser.h:208
clang::ASTNodeTraverser::Visit
void Visit(const Stmt *Node, StringRef Label={})
Definition: ASTNodeTraverser.h:122
clang::CXXCatchStmt
CXXCatchStmt - This represents a C++ catch block.
Definition: StmtCXX.h:28
clang::GenericSelectionExpr
Represents a C11 generic selection.
Definition: Expr.h:5628
clang::ASTNodeTraverser::Visit
void Visit(const GenericSelectionExpr::ConstAssociation &A)
Definition: ASTNodeTraverser.h:224
clang::Expr::getType
QualType getType() const
Definition: Expr.h:141
clang::ASTNodeTraverser::VisitTemplateSpecializationType
void VisitTemplateSpecializationType(const TemplateSpecializationType *T)
Definition: ASTNodeTraverser.h:400
clang::Attr
Attr - This represents one attribute.
Definition: Attr.h:41
clang::TypeSourceInfo
A container of type source information.
Definition: Type.h:6471
clang::FunctionType::getReturnType
QualType getReturnType() const
Definition: Type.h:3822
clang::NonTypeTemplateParmDecl::getPlaceholderTypeConstraint
Expr * getPlaceholderTypeConstraint() const
Return the constraint introduced by the placeholder type of this non-type template parameter (if any)...
Definition: DeclTemplate.h:1579
clang::ObjCCategoryDecl::getTypeParamList
ObjCTypeParamList * getTypeParamList() const
Retrieve the type parameter list associated with this category or extension.
Definition: DeclObjC.h:2326
clang::ASTNodeTraverser::VisitOMPDeclareMapperDecl
void VisitOMPDeclareMapperDecl(const OMPDeclareMapperDecl *D)
Definition: ASTNodeTraverser.h:491
clang::ASTNodeTraverser::VisitVarTemplateDecl
void VisitVarTemplateDecl(const VarTemplateDecl *D)
Definition: ASTNodeTraverser.h:576
clang::ASTNodeTraverser::VisitSubstNonTypeTemplateParmExpr
void VisitSubstNonTypeTemplateParmExpr(const SubstNonTypeTemplateParmExpr *E)
Definition: ASTNodeTraverser.h:752
clang::DynTypedNode::get
const T * get() const
Retrieve the stored node as type T.
Definition: ASTTypeTraits.h:269
clang::TypeVisitor::Visit
RetTy Visit(const Type *T)
Performs the operation associated with this visitor object.
Definition: TypeVisitor.h:68
clang::BuiltinTemplateDecl
Represents the builtin template declaration which is used to implement __make_integer_seq and other b...
Definition: DeclTemplate.h:1781
clang::FunctionDecl::param_begin
param_iterator param_begin()
Definition: Decl.h:2515
clang::ASTNodeTraverser::VisitDependentSizedExtVectorType
void VisitDependentSizedExtVectorType(const DependentSizedExtVectorType *T)
Definition: ASTNodeTraverser.h:365
clang::ASTNodeTraverser::VisitRequiresExpr
void VisitRequiresExpr(const RequiresExpr *E)
Definition: ASTNodeTraverser.h:719
AttrVisitor.h
clang::OMPThreadPrivateDecl::varlists
varlist_range varlists()
Definition: DeclOpenMP.h:146
clang::TypeAliasTemplateDecl
Declaration of an alias template.
Definition: DeclTemplate.h:2537
clang::ASTNodeTraverser::Visit
void Visit(const OMPClause *C)
Definition: ASTNodeTraverser.h:216
clang::DynTypedNode
A dynamically typed AST node container.
Definition: ASTTypeTraits.h:249
CommentVisitor.h
clang::BindingDecl::getBinding
Expr * getBinding() const
Get the expression to which this declaration is bound.
Definition: DeclCXX.h:4003
clang::ObjCMethodDecl::parameters
ArrayRef< ParmVarDecl * > parameters() const
Definition: DeclObjC.h:376
clang::PackExpansionType::isSugared
bool isSugared() const
Definition: Type.h:5739
clang::ReferenceType
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2764
clang::PointerType::getPointeeType
QualType getPointeeType() const
Definition: Type.h:2663
clang::APValue
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Definition: APValue.h:122
clang::AtomicType
Definition: Type.h:6318
clang::comments::Comment::child_iterator
Comment *const * child_iterator
Definition: Comment.h:227
clang::ASTTemplateArgumentListInfo
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
Definition: TemplateBase.h:612
clang::DefaultArgStorage::getInheritedFrom
const ParmDecl * getInheritedFrom() const
Get the parameter from which we inherit the default argument, if any.
Definition: DeclTemplate.h:360
clang::ASTNodeTraverser::VisitVarTemplateSpecializationDecl
void VisitVarTemplateSpecializationDecl(const VarTemplateSpecializationDecl *D)
Definition: ASTNodeTraverser.h:583
clang::SubstNonTypeTemplateParmPackExpr::getArgumentPack
TemplateArgument getArgumentPack() const
Retrieve the template argument pack containing the substituted template arguments.
Definition: ExprCXX.cpp:1596
clang::TypeAliasDecl
Represents the declaration of a typedef-name via a C++11 alias-declaration.
Definition: Decl.h:3322
clang::VarTemplateDecl
Declaration of a variable template.
Definition: DeclTemplate.h:3096
clang::ASTNodeTraverser::VisitVariableArrayType
void VisitVariableArrayType(const VariableArrayType *T)
Definition: ASTNodeTraverser.h:357
clang::ArrayType::getElementType
QualType getElementType() const
Definition: Type.h:2917
clang::Expr
This represents one expression.
Definition: Expr.h:109
clang::ASTNodeTraverser::dumpASTTemplateArgumentListInfo
void dumpASTTemplateArgumentListInfo(const ASTTemplateArgumentListInfo *TALI)
Definition: ASTNodeTraverser.h:313
clang::ASTNodeTraverser::VisitBlockPointerType
void VisitBlockPointerType(const BlockPointerType *T)
Definition: ASTNodeTraverser.h:346
clang::CXXCtorInitializer
Represents a C++ base or member initializer.
Definition: DeclCXX.h:2192
clang::BlockDecl::Capture
A class which contains all the information about a particular captured value.
Definition: Decl.h:4207
clang::ASTNodeTraverser::VisitTypeAliasTemplateDecl
void VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D)
Definition: ASTNodeTraverser.h:542
clang::OMPDeclareMapperDecl::clauselists
clauselist_range clauselists()
Definition: DeclOpenMP.h:333
clang::ClassTemplateSpecializationDecl
Represents a class template specialization, which refers to a class template with a given set of temp...
Definition: DeclTemplate.h:1820
clang::ObjCMethodDecl::isThisDeclarationADefinition
bool isThisDeclarationADefinition() const
Returns whether this specific method is a definition.
Definition: DeclObjC.h:538
clang::DependentSizedExtVectorType
Represents an extended vector type where either the type or size is dependent.
Definition: Type.h:3202
clang::comments::ConstCommentVisitor
Definition: CommentVisitor.h:62
clang::FunctionDecl::parameters
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2503
clang::AttributedType::getModifiedType
QualType getModifiedType() const
Definition: Type.h:4724
clang::SplitQualType::Quals
Qualifiers Quals
The local qualifiers.
Definition: Type.h:619
clang::attrvisitor::Base< llvm::make_const_ptr, ImplClass, void, ParamTys... >::Visit
void Visit(PTR(Attr) A)
Definition: AttrVisitor.h:31
clang::TemplateArgumentList::size
unsigned size() const
Retrieve the number of template arguments in this template argument list.
Definition: DeclTemplate.h:297
clang::FunctionDecl
Represents a function declaration or definition.
Definition: Decl.h:1872
clang::ASTNodeTraverser::VisitVarTemplatePartialSpecializationDecl
void VisitVarTemplatePartialSpecializationDecl(const VarTemplatePartialSpecializationDecl *D)
Definition: ASTNodeTraverser.h:588
clang::ASTNodeTraverser::VisitObjCImplementationDecl
void VisitObjCImplementationDecl(const ObjCImplementationDecl *D)
Definition: ASTNodeTraverser.h:660
clang::CallExpr
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2801
clang::ASTNodeTraverser::VisitSubstTemplateTypeParmType
void VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T)
Definition: ASTNodeTraverser.h:392
clang::ASTNodeTraverser::dumpTemplateDeclSpecialization
void dumpTemplateDeclSpecialization(const SpecializationDecl *D)
Definition: ASTNodeTraverser.h:508
clang::AdjustedType::getOriginalType
QualType getOriginalType() const
Definition: Type.h:2695
clang::ASTNodeTraverser::VisitCapturedStmt
void VisitCapturedStmt(const CapturedStmt *Node)
Definition: ASTNodeTraverser.h:688
clang::ASTNodeTraverser::Visit
void Visit(const concepts::Requirement *R)
Definition: ASTNodeTraverser.h:233
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::ASTNodeTraverser::VisitTypeOfExprType
void VisitTypeOfExprType(const TypeOfExprType *T)
Definition: ASTNodeTraverser.h:376
clang::TemplateArgument::getAsType
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:268
clang::ASTNodeTraverser::VisitPackExpansionType
void VisitPackExpansionType(const PackExpansionType *T)
Definition: ASTNodeTraverser.h:410