14 #ifndef LLVM_CLANG_AST_RECURSIVEASTVISITOR_H
15 #define LLVM_CLANG_AST_RECURSIVEASTVISITOR_H
41 #define UNARYOP_LIST() \
42 OPERATOR(PostInc) OPERATOR(PostDec) OPERATOR(PreInc) OPERATOR(PreDec) \
43 OPERATOR(AddrOf) OPERATOR(Deref) OPERATOR(Plus) OPERATOR(Minus) \
44 OPERATOR(Not) OPERATOR(LNot) OPERATOR(Real) OPERATOR(Imag) \
48 #define BINOP_LIST() \
49 OPERATOR(PtrMemD) OPERATOR(PtrMemI) OPERATOR(Mul) OPERATOR(Div) \
50 OPERATOR(Rem) OPERATOR(Add) OPERATOR(Sub) OPERATOR(Shl) OPERATOR(Shr) \
51 OPERATOR(LT) OPERATOR(GT) OPERATOR(LE) OPERATOR(GE) OPERATOR(EQ) \
52 OPERATOR(NE) OPERATOR(And) OPERATOR(Xor) OPERATOR(Or) OPERATOR(LAnd) \
53 OPERATOR(LOr) OPERATOR(Assign) OPERATOR(Comma)
57 OPERATOR(Mul) OPERATOR(Div) OPERATOR(Rem) OPERATOR(Add) OPERATOR(Sub) \
58 OPERATOR(Shl) OPERATOR(Shr) OPERATOR(And) OPERATOR(Or) OPERATOR(Xor)
66 #define TRY_TO(CALL_EXPR) \
68 if (!getDerived().CALL_EXPR) \
136 Derived &
getDerived() {
return *
static_cast<Derived *
>(
this); }
153 return isa<BinaryOperator>(
S) || isa<UnaryOperator>(S) ||
154 isa<CaseStmt>(
S) || isa<CXXOperatorCallExpr>(S);
263 #define ATTR_VISITOR_DECLS_ONLY
264 #include "clang/AST/AttrVisitor.inc"
265 #undef ATTR_VISITOR_DECLS_ONLY
270 #define ABSTRACT_STMT(STMT)
271 #define STMT(CLASS, PARENT) bool Traverse##CLASS(CLASS *S);
272 #include "clang/AST/StmtNodes.inc"
278 #define STMT(CLASS, PARENT) \
279 bool WalkUpFrom##CLASS(CLASS *S) { \
280 TRY_TO(WalkUpFrom##PARENT(S)); \
281 TRY_TO(Visit##CLASS(S)); \
284 bool Visit##CLASS(CLASS *S) { return true; }
285 #include "clang/AST/StmtNodes.inc"
290 #define OPERATOR(NAME) \
291 bool TraverseUnary##NAME(UnaryOperator *S) { \
292 TRY_TO(WalkUpFromUnary##NAME(S)); \
293 TRY_TO(TraverseStmt(S->getSubExpr())); \
296 bool WalkUpFromUnary##NAME(UnaryOperator *S) { \
297 TRY_TO(WalkUpFromUnaryOperator(S)); \
298 TRY_TO(VisitUnary##NAME(S)); \
301 bool VisitUnary##NAME(UnaryOperator *S) { return true; }
309 #define GENERAL_BINOP_FALLBACK(NAME, BINOP_TYPE) \
310 bool TraverseBin##NAME(BINOP_TYPE *S) { \
311 TRY_TO(WalkUpFromBin##NAME(S)); \
312 TRY_TO(TraverseStmt(S->getLHS())); \
313 TRY_TO(TraverseStmt(S->getRHS())); \
316 bool WalkUpFromBin##NAME(BINOP_TYPE *S) { \
317 TRY_TO(WalkUpFrom##BINOP_TYPE(S)); \
318 TRY_TO(VisitBin##NAME(S)); \
321 bool VisitBin##NAME(BINOP_TYPE *S) { return true; }
323 #define OPERATOR(NAME) GENERAL_BINOP_FALLBACK(NAME, BinaryOperator)
331 #define OPERATOR(NAME) \
332 GENERAL_BINOP_FALLBACK(NAME##Assign, CompoundAssignOperator)
336 #undef GENERAL_BINOP_FALLBACK
342 #define ABSTRACT_TYPE(CLASS, BASE)
343 #define TYPE(CLASS, BASE) bool Traverse##CLASS##Type(CLASS##Type *T);
344 #include "clang/AST/TypeNodes.def"
350 #define TYPE(CLASS, BASE) \
351 bool WalkUpFrom##CLASS##Type(CLASS##Type *T) { \
352 TRY_TO(WalkUpFrom##BASE(T)); \
353 TRY_TO(Visit##CLASS##Type(T)); \
356 bool Visit##CLASS##Type(CLASS##Type *T) { return true; }
357 #include "clang/AST/TypeNodes.def"
363 #define ABSTRACT_TYPELOC(CLASS, BASE)
364 #define TYPELOC(CLASS, BASE) bool Traverse##CLASS##TypeLoc(CLASS##TypeLoc TL);
365 #include "clang/AST/TypeLocNodes.def"
384 #define TYPE(CLASS, BASE) \
385 bool WalkUpFrom##CLASS##TypeLoc(CLASS##TypeLoc TL) { \
386 TRY_TO(WalkUpFrom##BASE##Loc(TL)); \
387 TRY_TO(Visit##CLASS##TypeLoc(TL)); \
390 bool Visit##CLASS##TypeLoc(CLASS##TypeLoc TL) { return true; }
391 #include "clang/AST/TypeNodes.def"
396 #define ABSTRACT_DECL(DECL)
397 #define DECL(CLASS, BASE) bool Traverse##CLASS##Decl(CLASS##Decl *D);
398 #include "clang/AST/DeclNodes.inc"
404 #define DECL(CLASS, BASE) \
405 bool WalkUpFrom##CLASS##Decl(CLASS##Decl *D) { \
406 TRY_TO(WalkUpFrom##BASE(D)); \
407 TRY_TO(Visit##CLASS##Decl(D)); \
410 bool Visit##CLASS##Decl(CLASS##Decl *D) { return true; }
411 #include "clang/AST/DeclNodes.inc"
415 bool TraverseTemplateParameterListHelper(TemplateParameterList *TPL);
416 #define DEF_TRAVERSE_TMPL_INST(TMPLDECLKIND) \
417 bool TraverseTemplateInstantiations(TMPLDECLKIND##TemplateDecl *D);
421 #undef DEF_TRAVERSE_TMPL_INST
422 bool TraverseTemplateArgumentLocsHelper(
const TemplateArgumentLoc *TAL,
424 bool TraverseArrayTypeLocHelper(ArrayTypeLoc TL);
425 bool TraverseRecordHelper(RecordDecl *D);
426 bool TraverseCXXRecordHelper(CXXRecordDecl *D);
427 bool TraverseDeclaratorHelper(DeclaratorDecl *D);
428 bool TraverseDeclContextHelper(DeclContext *DC);
429 bool TraverseFunctionHelper(FunctionDecl *D);
430 bool TraverseVarHelper(VarDecl *D);
431 bool TraverseOMPExecutableDirective(OMPExecutableDirective *
S);
432 bool TraverseOMPLoopDirective(OMPLoopDirective *
S);
433 bool TraverseOMPClause(OMPClause *
C);
434 #define OPENMP_CLAUSE(Name, Class) bool Visit##Class(Class *C);
435 #include "clang/Basic/OpenMPKinds.def"
437 template <
typename T>
bool VisitOMPClauseList(T *
Node);
441 Stmt::child_iterator StmtIt;
443 EnqueueJob(
Stmt *
S) : S(S), StmtIt() {}
445 bool dataTraverse(
Stmt *
S);
446 bool dataTraverseNode(
Stmt *
S,
bool &EnqueueChildren);
449 template <
typename Derived>
450 bool RecursiveASTVisitor<Derived>::dataTraverse(
Stmt *
S) {
452 SmallVector<EnqueueJob, 16> Queue;
455 while (!Queue.empty()) {
456 EnqueueJob &job = Queue.back();
463 if (getDerived().shouldUseDataRecursionFor(CurrS)) {
464 if (job.StmtIt == Stmt::child_iterator()) {
465 bool EnqueueChildren =
true;
466 if (!dataTraverseNode(CurrS, EnqueueChildren))
468 if (!EnqueueChildren) {
472 job.StmtIt = CurrS->child_begin();
477 if (job.StmtIt != CurrS->child_end())
478 Queue.push_back(*job.StmtIt);
485 TRY_TO(TraverseStmt(CurrS));
491 template <
typename Derived>
492 bool RecursiveASTVisitor<Derived>::dataTraverseNode(
Stmt *S,
493 bool &EnqueueChildren) {
497 #define DISPATCH_WALK(NAME, CLASS, VAR) \
499 bool (Derived::*DerivedFn)(CLASS *) = &Derived::Traverse##NAME; \
500 bool (Derived::*BaseFn)(CLASS *) = &RecursiveASTVisitor::Traverse##NAME; \
501 if (DerivedFn == BaseFn) \
502 return getDerived().WalkUpFrom##NAME(static_cast<CLASS *>(VAR)); \
504 EnqueueChildren = false; \
505 return getDerived().Traverse##NAME(static_cast<CLASS *>(VAR));
507 if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(S)) {
508 switch (BinOp->getOpcode()) {
509 #define OPERATOR(NAME) \
511 DISPATCH_WALK(Bin##NAME, BinaryOperator, S);
516 #define OPERATOR(NAME) \
517 case BO_##NAME##Assign: \
518 DISPATCH_WALK(Bin##NAME##Assign, CompoundAssignOperator, S);
523 }
else if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(S)) {
524 switch (UnOp->getOpcode()) {
525 #define OPERATOR(NAME) \
527 DISPATCH_WALK(Unary##NAME, UnaryOperator, S);
535 switch (S->getStmtClass()) {
536 case Stmt::NoStmtClass:
538 #define ABSTRACT_STMT(STMT)
539 #define STMT(CLASS, PARENT) \
540 case Stmt::CLASS##Class: \
541 DISPATCH_WALK(CLASS, CLASS, S);
542 #include "clang/AST/StmtNodes.inc"
550 #define DISPATCH(NAME, CLASS, VAR) \
551 return getDerived().Traverse##NAME(static_cast<CLASS *>(VAR))
553 template <
typename Derived>
558 #define DISPATCH_STMT(NAME, CLASS, VAR) DISPATCH(NAME, CLASS, VAR)
560 if (getDerived().shouldUseDataRecursionFor(S))
561 return dataTraverse(S);
566 if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(S)) {
567 switch (BinOp->getOpcode()) {
568 #define OPERATOR(NAME) \
570 DISPATCH_STMT(Bin##NAME, BinaryOperator, S);
576 #define OPERATOR(NAME) \
577 case BO_##NAME##Assign: \
578 DISPATCH_STMT(Bin##NAME##Assign, CompoundAssignOperator, S);
584 }
else if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(S)) {
585 switch (UnOp->getOpcode()) {
586 #define OPERATOR(NAME) \
588 DISPATCH_STMT(Unary##NAME, UnaryOperator, S);
597 switch (S->getStmtClass()) {
598 case Stmt::NoStmtClass:
600 #define ABSTRACT_STMT(STMT)
601 #define STMT(CLASS, PARENT) \
602 case Stmt::CLASS##Class: \
603 DISPATCH_STMT(CLASS, CLASS, S);
604 #include "clang/AST/StmtNodes.inc"
612 template <
typename Derived>
617 switch (T->getTypeClass()) {
618 #define ABSTRACT_TYPE(CLASS, BASE)
619 #define TYPE(CLASS, BASE) \
621 DISPATCH(CLASS##Type, CLASS##Type, const_cast<Type *>(T.getTypePtr()));
622 #include "clang/AST/TypeNodes.def"
628 template <
typename Derived>
633 switch (TL.getTypeLocClass()) {
634 #define ABSTRACT_TYPELOC(CLASS, BASE)
635 #define TYPELOC(CLASS, BASE) \
636 case TypeLoc::CLASS: \
637 return getDerived().Traverse##CLASS##TypeLoc(TL.castAs<CLASS##TypeLoc>());
638 #include "clang/AST/TypeLocNodes.def"
645 #define VISITORCLASS RecursiveASTVisitor
646 #include "clang/AST/AttrVisitor.inc"
649 template <
typename Derived>
656 if (!getDerived().shouldVisitImplicitCode() && D->isImplicit())
659 switch (D->getKind()) {
660 #define ABSTRACT_DECL(DECL)
661 #define DECL(CLASS, BASE) \
663 if (!getDerived().Traverse##CLASS##Decl(static_cast<CLASS##Decl *>(D))) \
666 #include "clang/AST/DeclNodes.inc"
670 for (
auto *I : D->attrs()) {
671 if (!getDerived().TraverseAttr(I))
679 template <
typename Derived>
681 NestedNameSpecifier *NNS) {
685 if (NNS->getPrefix())
686 TRY_TO(TraverseNestedNameSpecifier(NNS->getPrefix()));
688 switch (NNS->getKind()) {
698 TRY_TO(TraverseType(QualType(NNS->getAsType(), 0)));
704 template <
typename Derived>
706 NestedNameSpecifierLoc NNS) {
710 if (NestedNameSpecifierLoc Prefix = NNS.getPrefix())
711 TRY_TO(TraverseNestedNameSpecifierLoc(Prefix));
713 switch (NNS.getNestedNameSpecifier()->getKind()) {
723 TRY_TO(TraverseTypeLoc(NNS.getTypeLoc()));
730 template <
typename Derived>
732 DeclarationNameInfo NameInfo) {
733 switch (NameInfo.getName().getNameKind()) {
737 if (TypeSourceInfo *TSInfo = NameInfo.getNamedTypeInfo())
738 TRY_TO(TraverseTypeLoc(TSInfo->getTypeLoc()));
755 template <
typename Derived>
757 if (DependentTemplateName *DTN = Template.getAsDependentTemplateName())
758 TRY_TO(TraverseNestedNameSpecifier(DTN->getQualifier()));
759 else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
760 TRY_TO(TraverseNestedNameSpecifier(QTN->getQualifier()));
765 template <
typename Derived>
767 const TemplateArgument &Arg) {
768 switch (Arg.getKind()) {
776 return getDerived().TraverseType(Arg.getAsType());
780 return getDerived().TraverseTemplateName(
781 Arg.getAsTemplateOrTemplatePattern());
784 return getDerived().TraverseStmt(Arg.getAsExpr());
787 return getDerived().TraverseTemplateArguments(Arg.pack_begin(),
796 template <
typename Derived>
798 const TemplateArgumentLoc &ArgLoc) {
799 const TemplateArgument &Arg = ArgLoc.getArgument();
801 switch (Arg.getKind()) {
810 if (TypeSourceInfo *TSI = ArgLoc.getTypeSourceInfo())
811 return getDerived().TraverseTypeLoc(TSI->getTypeLoc());
813 return getDerived().TraverseType(Arg.getAsType());
818 if (ArgLoc.getTemplateQualifierLoc())
819 TRY_TO(getDerived().TraverseNestedNameSpecifierLoc(
820 ArgLoc.getTemplateQualifierLoc()));
821 return getDerived().TraverseTemplateName(
822 Arg.getAsTemplateOrTemplatePattern());
825 return getDerived().TraverseStmt(ArgLoc.getSourceExpression());
828 return getDerived().TraverseTemplateArguments(Arg.pack_begin(),
835 template <
typename Derived>
837 const TemplateArgument *Args,
unsigned NumArgs) {
838 for (
unsigned I = 0; I != NumArgs; ++I) {
839 TRY_TO(TraverseTemplateArgument(Args[I]));
845 template <
typename Derived>
847 CXXCtorInitializer *Init) {
848 if (TypeSourceInfo *TInfo = Init->getTypeSourceInfo())
849 TRY_TO(TraverseTypeLoc(TInfo->getTypeLoc()));
851 if (Init->isWritten() || getDerived().shouldVisitImplicitCode())
852 TRY_TO(TraverseStmt(Init->getInit()));
856 template <
typename Derived>
859 const LambdaCapture *
C) {
860 if (LE->isInitCapture(C))
861 TRY_TO(TraverseDecl(C->getCapturedVar()));
865 template <
typename Derived>
867 TRY_TO(TraverseStmt(LE->getBody()));
874 #define DEF_TRAVERSE_TYPE(TYPE, CODE) \
875 template <typename Derived> \
876 bool RecursiveASTVisitor<Derived>::Traverse##TYPE(TYPE *T) { \
877 TRY_TO(WalkUpFrom##TYPE(T)); \
889 {
TRY_TO(TraverseType(T->getPointeeType())); })
892 {
TRY_TO(TraverseType(T->getPointeeType())); })
895 {
TRY_TO(TraverseType(T->getPointeeType())); })
898 TRY_TO(TraverseType(QualType(T->getClass(), 0)));
899 TRY_TO(TraverseType(T->getPointeeType()));
907 {
TRY_TO(TraverseType(T->getElementType())); })
910 {
TRY_TO(TraverseType(T->getElementType())); })
913 TRY_TO(TraverseType(T->getElementType()));
914 TRY_TO(TraverseStmt(T->getSizeExpr()));
918 TRY_TO(TraverseType(T->getElementType()));
919 if (T->getSizeExpr())
920 TRY_TO(TraverseStmt(T->getSizeExpr()));
924 if (T->getSizeExpr())
925 TRY_TO(TraverseStmt(T->getSizeExpr()));
926 TRY_TO(TraverseType(T->getElementType()));
934 {
TRY_TO(TraverseType(T->getReturnType())); })
937 TRY_TO(TraverseType(T->getReturnType()));
939 for (
const auto &A : T->param_types()) {
943 for (
const auto &E : T->exceptions()) {
947 if (Expr *NE = T->getNoexceptExpr())
955 {
TRY_TO(TraverseStmt(T->getUnderlyingExpr())); })
960 {
TRY_TO(TraverseStmt(T->getUnderlyingExpr())); })
963 TRY_TO(TraverseType(T->getBaseType()));
964 TRY_TO(TraverseType(T->getUnderlyingType()));
976 TRY_TO(TraverseTemplateName(T->getTemplateName()));
977 TRY_TO(TraverseTemplateArguments(T->getArgs(), T->getNumArgs()));
983 {
TRY_TO(TraverseType(T->getModifiedType())); })
988 if (T->getQualifier()) {
989 TRY_TO(TraverseNestedNameSpecifier(T->getQualifier()));
991 TRY_TO(TraverseType(T->getNamedType()));
995 {
TRY_TO(TraverseNestedNameSpecifier(T->getQualifier())); })
998 TRY_TO(TraverseNestedNameSpecifier(T->getQualifier()));
999 TRY_TO(TraverseTemplateArguments(T->getArgs(), T->getNumArgs()));
1009 if (T->getBaseType().getTypePtr() != T)
1010 TRY_TO(TraverseType(T->getBaseType()));
1011 for (
auto typeArg : T->getTypeArgsAsWritten()) {
1012 TRY_TO(TraverseType(typeArg));
1017 {
TRY_TO(TraverseType(T->getPointeeType())); })
1031 template <typename Derived>
\
1032 bool RecursiveASTVisitor<Derived>::Traverse##
TYPE##Loc(
TYPE##Loc TL) {
\
1033 if (getDerived().shouldWalkTypesOfTypeLocs())
\
1034 TRY_TO(WalkUpFrom##
TYPE(const_cast<TYPE *>(TL.getTypePtr())));
\
1040 template <
typename Derived>
1042 RecursiveASTVisitor<Derived>::TraverseQualifiedTypeLoc(QualifiedTypeLoc TL) {
1058 return TraverseTypeLoc(TL.getUnqualifiedLoc());
1065 TRY_TO(TraverseType(TL.getTypePtr()->getElementType()));
1069 {
TRY_TO(TraverseTypeLoc(TL.getPointeeLoc())); })
1072 {
TRY_TO(TraverseTypeLoc(TL.getPointeeLoc())); })
1075 {
TRY_TO(TraverseTypeLoc(TL.getPointeeLoc())); })
1078 {
TRY_TO(TraverseTypeLoc(TL.getPointeeLoc())); })
1084 TRY_TO(TraverseType(QualType(TL.getTypePtr()->getClass(), 0)));
1085 TRY_TO(TraverseTypeLoc(TL.getPointeeLoc()));
1089 {
TRY_TO(TraverseTypeLoc(TL.getOriginalLoc())); })
1092 {
TRY_TO(TraverseTypeLoc(TL.getOriginalLoc())); })
1094 template <typename Derived>
1097 TRY_TO(TraverseStmt(TL.getSizeExpr()));
1102 TRY_TO(TraverseTypeLoc(TL.getElementLoc()));
1107 TRY_TO(TraverseTypeLoc(TL.getElementLoc()));
1112 TRY_TO(TraverseTypeLoc(TL.getElementLoc()));
1117 TRY_TO(TraverseTypeLoc(TL.getElementLoc()));
1124 if (TL.getTypePtr()->getSizeExpr())
1125 TRY_TO(TraverseStmt(TL.getTypePtr()->getSizeExpr()));
1126 TRY_TO(TraverseType(TL.getTypePtr()->getElementType()));
1131 TRY_TO(TraverseType(TL.getTypePtr()->getElementType()));
1137 TRY_TO(TraverseType(TL.getTypePtr()->getElementType()));
1141 {
TRY_TO(TraverseTypeLoc(TL.getReturnLoc())); })
1145 TRY_TO(TraverseTypeLoc(TL.getReturnLoc()));
1147 const FunctionProtoType *T = TL.getTypePtr();
1149 for (
unsigned I = 0, E = TL.getNumParams(); I != E; ++I) {
1150 if (TL.getParam(I)) {
1151 TRY_TO(TraverseDecl(TL.getParam(I)));
1152 }
else if (I < T->getNumParams()) {
1153 TRY_TO(TraverseType(T->getParamType(I)));
1157 for (
const auto &E : T->exceptions()) {
1161 if (Expr *NE = T->getNoexceptExpr())
1162 TRY_TO(TraverseStmt(NE));
1169 {
TRY_TO(TraverseStmt(TL.getUnderlyingExpr())); })
1172 TRY_TO(TraverseTypeLoc(TL.getUnderlyingTInfo()->getTypeLoc()));
1177 TRY_TO(TraverseStmt(TL.getTypePtr()->getUnderlyingExpr()));
1181 TRY_TO(TraverseTypeLoc(TL.getUnderlyingTInfo()->getTypeLoc()));
1185 TRY_TO(TraverseType(TL.getTypePtr()->getDeducedType()));
1196 TRY_TO(TraverseTemplateName(TL.getTypePtr()->getTemplateName()));
1197 for (
unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) {
1198 TRY_TO(TraverseTemplateArgumentLoc(TL.getArgLoc(I)));
1207 {
TRY_TO(TraverseTypeLoc(TL.getModifiedLoc())); })
1210 if (TL.getQualifierLoc()) {
1211 TRY_TO(TraverseNestedNameSpecifierLoc(TL.getQualifierLoc()));
1213 TRY_TO(TraverseTypeLoc(TL.getNamedTypeLoc()));
1217 TRY_TO(TraverseNestedNameSpecifierLoc(TL.getQualifierLoc()));
1221 if (TL.getQualifierLoc()) {
1222 TRY_TO(TraverseNestedNameSpecifierLoc(TL.getQualifierLoc()));
1225 for (
unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) {
1226 TRY_TO(TraverseTemplateArgumentLoc(TL.getArgLoc(I)));
1231 {
TRY_TO(TraverseTypeLoc(TL.getPatternLoc())); })
1238 if (TL.getTypePtr()->getBaseType().getTypePtr() != TL.getTypePtr())
1239 TRY_TO(TraverseTypeLoc(TL.getBaseLoc()));
1240 for (
unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i)
1241 TRY_TO(TraverseTypeLoc(TL.getTypeArgTInfo(i)->getTypeLoc()));
1245 {
TRY_TO(TraverseTypeLoc(TL.getPointeeLoc())); })
1258 template <typename Derived>
1259 bool RecursiveASTVisitor<Derived>::TraverseDeclContextHelper(DeclContext *DC) {
1263 for (
auto *Child : DC->decls()) {
1266 if (!isa<BlockDecl>(Child) && !isa<CapturedDecl>(Child))
1267 TRY_TO(TraverseDecl(Child));
1274 #define DEF_TRAVERSE_DECL(DECL, CODE) \
1275 template <typename Derived> \
1276 bool RecursiveASTVisitor<Derived>::Traverse##DECL(DECL *D) { \
1277 TRY_TO(WalkUpFrom##DECL(D)); \
1279 TRY_TO(TraverseDeclContextHelper(dyn_cast<DeclContext>(D))); \
1286 if (TypeSourceInfo *TInfo = D->getSignatureAsWritten())
1287 TRY_TO(TraverseTypeLoc(TInfo->getTypeLoc()));
1288 TRY_TO(TraverseStmt(D->getBody()));
1289 for (
const auto &I : D->captures()) {
1290 if (I.hasCopyExpr()) {
1291 TRY_TO(TraverseStmt(I.getCopyExpr()));
1301 TRY_TO(TraverseStmt(D->getBody()));
1311 {
TRY_TO(TraverseStmt(D->getAsmString())); })
1317 if (D->getFriendType())
1318 TRY_TO(TraverseTypeLoc(D->getFriendType()->getTypeLoc()));
1320 TRY_TO(TraverseDecl(D->getFriendDecl()));
1324 if (D->getFriendType())
1325 TRY_TO(TraverseTypeLoc(D->getFriendType()->getTypeLoc()));
1327 TRY_TO(TraverseDecl(D->getFriendDecl()));
1328 for (
unsigned I = 0, E = D->getNumTemplateParameters(); I < E; ++I) {
1329 TemplateParameterList *TPL = D->getTemplateParameterList(I);
1331 ITPL != ETPL; ++ITPL) {
1332 TRY_TO(TraverseDecl(*ITPL));
1338 TRY_TO(TraverseDecl(D->getSpecialization()));
1340 if (D->hasExplicitTemplateArgs()) {
1341 const TemplateArgumentListInfo &args = D->templateArgs();
1342 TRY_TO(TraverseTemplateArgumentLocsHelper(args.getArgumentArray(),
1353 TRY_TO(TraverseStmt(D->getAssertExpr()));
1354 TRY_TO(TraverseStmt(D->getMessage()));
1358 TranslationUnitDecl,
1390 if (ObjCTypeParamList *typeParamList = D->getTypeParamList()) {
1391 for (
auto typeParam : *typeParamList) {
1392 TRY_TO(TraverseObjCTypeParamDecl(typeParam));
1404 if (ObjCTypeParamList *typeParamList = D->getTypeParamListAsWritten()) {
1405 for (
auto typeParam : *typeParamList) {
1406 TRY_TO(TraverseObjCTypeParamDecl(typeParam));
1410 if (TypeSourceInfo *superTInfo = D->getSuperClassTInfo()) {
1411 TRY_TO(TraverseTypeLoc(superTInfo->getTypeLoc()));
1419 if (D->getReturnTypeSourceInfo()) {
1420 TRY_TO(TraverseTypeLoc(D->getReturnTypeSourceInfo()->getTypeLoc()));
1424 TRY_TO(TraverseDecl(*I));
1426 if (D->isThisDeclarationADefinition()) {
1427 TRY_TO(TraverseStmt(D->getBody()));
1433 if (D->hasExplicitBound()) {
1434 TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc()));
1442 if (D->getTypeSourceInfo())
1443 TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc()));
1445 TRY_TO(TraverseType(D->getType()));
1450 TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
1451 TRY_TO(TraverseDeclarationNameInfo(D->getNameInfo()));
1455 TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
1461 for (
auto *I : D->varlists()) {
1467 template <typename Derived>
1468 bool RecursiveASTVisitor<Derived>::TraverseTemplateParameterListHelper(
1469 TemplateParameterList *TPL) {
1473 TRY_TO(TraverseDecl(*I));
1479 template <
typename Derived>
1480 bool RecursiveASTVisitor<Derived>::TraverseTemplateInstantiations(
1481 ClassTemplateDecl *D) {
1482 for (
auto *SD : D->specializations()) {
1483 for (
auto *RD : SD->redecls()) {
1485 if (cast<CXXRecordDecl>(RD)->isInjectedClassName())
1489 cast<ClassTemplateSpecializationDecl>(RD)->getSpecializationKind()) {
1493 TRY_TO(TraverseDecl(RD));
1510 template <
typename Derived>
1511 bool RecursiveASTVisitor<Derived>::TraverseTemplateInstantiations(
1512 VarTemplateDecl *D) {
1513 for (
auto *SD : D->specializations()) {
1514 for (
auto *RD : SD->redecls()) {
1516 cast<VarTemplateSpecializationDecl>(RD)->getSpecializationKind()) {
1519 TRY_TO(TraverseDecl(RD));
1535 template <
typename Derived>
1536 bool RecursiveASTVisitor<Derived>::TraverseTemplateInstantiations(
1537 FunctionTemplateDecl *D) {
1538 for (
auto *FD : D->specializations()) {
1539 for (
auto *RD : FD->redecls()) {
1540 switch (RD->getTemplateSpecializationKind()) {
1544 TRY_TO(TraverseDecl(RD));
1551 TRY_TO(TraverseDecl(RD));
1565 #define DEF_TRAVERSE_TMPL_DECL(TMPLDECLKIND) \
1566 DEF_TRAVERSE_DECL(TMPLDECLKIND##TemplateDecl, { \
1567 TRY_TO(TraverseDecl(D->getTemplatedDecl())); \
1568 TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters())); \
1576 if (getDerived().shouldVisitTemplateInstantiations() && \
1577 D == D->getCanonicalDecl()) \
1578 TRY_TO(TraverseTemplateInstantiations(D)); \
1592 TRY_TO(TraverseDecl(D->getTemplatedDecl()));
1593 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
1594 TRY_TO(TraverseTemplateArgumentLoc(D->getDefaultArgument()));
1596 TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));
1601 if (D->getTypeForDecl())
1602 TRY_TO(TraverseType(QualType(D->getTypeForDecl(), 0)));
1603 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
1604 TRY_TO(TraverseTypeLoc(D->getDefaultArgumentInfo()->getTypeLoc()));
1608 TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc()));
1615 TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc()));
1622 TRY_TO(TraverseDecl(D->getTemplatedDecl()));
1623 TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));
1629 TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
1636 if (D->getTypeForDecl())
1637 TRY_TO(TraverseType(QualType(D->getTypeForDecl(), 0)));
1639 TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
1645 template <typename Derived>
1646 bool RecursiveASTVisitor<Derived>::TraverseRecordHelper(RecordDecl *D) {
1650 TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
1654 template <
typename Derived>
1655 bool RecursiveASTVisitor<Derived>::TraverseCXXRecordHelper(CXXRecordDecl *D) {
1656 if (!TraverseRecordHelper(D))
1658 if (D->isCompleteDefinition()) {
1659 for (
const auto &I : D->bases()) {
1660 TRY_TO(TraverseTypeLoc(I.getTypeSourceInfo()->getTypeLoc()));
1682 if (TypeSourceInfo *TSI = D->getTypeAsWritten()) \
1683 TRY_TO(TraverseTypeLoc(TSI->getTypeLoc()));
\
1685 if (!getDerived().shouldVisitTemplateInstantiations() && \
1697 template <typename Derived>
1699 const TemplateArgumentLoc *TAL,
unsigned Count) {
1700 for (
unsigned I = 0; I <
Count; ++I) {
1701 TRY_TO(TraverseTemplateArgumentLoc(TAL[I]));
1706 #define DEF_TRAVERSE_TMPL_PART_SPEC_DECL(TMPLDECLKIND, DECLKIND) \
1707 DEF_TRAVERSE_DECL(TMPLDECLKIND##TemplatePartialSpecializationDecl, { \
1709 if (TemplateParameterList *TPL = D->getTemplateParameters()) { \
1710 for (TemplateParameterList::iterator I = TPL->begin(), E = TPL->end(); \
1712 TRY_TO(TraverseDecl(*I)); \
1716 TRY_TO(TraverseTemplateArgumentLocsHelper( \
1717 D->getTemplateArgsAsWritten()->getTemplateArgs(), \
1718 D->getTemplateArgsAsWritten()->NumTemplateArgs)); \
1723 TRY_TO(Traverse##DECLKIND##Helper(D)); \
1736 TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
1737 TRY_TO(TraverseDeclarationNameInfo(D->getNameInfo()));
1742 template <typename Derived>
1743 bool RecursiveASTVisitor<Derived>::TraverseDeclaratorHelper(DeclaratorDecl *D) {
1744 TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
1745 if (D->getTypeSourceInfo())
1746 TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc()));
1748 TRY_TO(TraverseType(D->getType()));
1755 TRY_TO(TraverseDeclaratorHelper(D));
1756 if (D->isBitField())
1757 TRY_TO(TraverseStmt(D->getBitWidth()));
1758 else if (D->hasInClassInitializer())
1759 TRY_TO(TraverseStmt(D->getInClassInitializer()));
1763 TRY_TO(TraverseDeclaratorHelper(D));
1764 if (D->isBitField())
1765 TRY_TO(TraverseStmt(D->getBitWidth()));
1770 TRY_TO(TraverseDeclaratorHelper(D));
1771 if (D->isBitField())
1772 TRY_TO(TraverseStmt(D->getBitWidth()));
1776 template <typename Derived>
1777 bool RecursiveASTVisitor<Derived>::TraverseFunctionHelper(FunctionDecl *D) {
1778 TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
1779 TRY_TO(TraverseDeclarationNameInfo(D->getNameInfo()));
1786 if (
const FunctionTemplateSpecializationInfo *FTSI =
1787 D->getTemplateSpecializationInfo()) {
1792 if (
const ASTTemplateArgumentListInfo *TALI =
1793 FTSI->TemplateArgumentsAsWritten) {
1794 TRY_TO(TraverseTemplateArgumentLocsHelper(TALI->getTemplateArgs(),
1795 TALI->NumTemplateArgs));
1804 if (TypeSourceInfo *TSI = D->getTypeSourceInfo()) {
1805 TRY_TO(TraverseTypeLoc(TSI->getTypeLoc()));
1806 }
else if (getDerived().shouldVisitImplicitCode()) {
1814 TRY_TO(TraverseDecl(*I));
1817 if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(D)) {
1819 for (
auto *I : Ctor->inits()) {
1820 TRY_TO(TraverseConstructorInitializer(I));
1824 if (D->isThisDeclarationADefinition()) {
1825 TRY_TO(TraverseStmt(D->getBody()));
1833 return TraverseFunctionHelper(D);
1839 return TraverseFunctionHelper(D);
1845 return TraverseFunctionHelper(D);
1853 return TraverseFunctionHelper(D);
1859 return TraverseFunctionHelper(D);
1862 template <typename Derived>
1863 bool RecursiveASTVisitor<Derived>::TraverseVarHelper(VarDecl *D) {
1864 TRY_TO(TraverseDeclaratorHelper(D));
1866 if (!isa<ParmVarDecl>(D) &&
1867 (!D->isCXXForRangeDecl() || getDerived().shouldVisitImplicitCode()))
1868 TRY_TO(TraverseStmt(D->getInit()));
1878 TRY_TO(TraverseDeclaratorHelper(D));
1879 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
1880 TRY_TO(TraverseStmt(D->getDefaultArgument()));
1884 TRY_TO(TraverseVarHelper(D));
1886 if (D->hasDefaultArg() && D->hasUninstantiatedDefaultArg() &&
1887 !D->hasUnparsedDefaultArg())
1888 TRY_TO(TraverseStmt(D->getUninstantiatedDefaultArg()));
1890 if (D->hasDefaultArg() && !D->hasUninstantiatedDefaultArg() &&
1891 !D->hasUnparsedDefaultArg())
1892 TRY_TO(TraverseStmt(D->getDefaultArg()));
1908 template <typename Derived>
\
1909 bool RecursiveASTVisitor<Derived>::Traverse##
STMT(
STMT *S) {
\
1912 for (
Stmt *SubStmt : S->children()) {
\
1913 TRY_TO(TraverseStmt(SubStmt)); \
1919 TRY_TO(TraverseStmt(S->getAsmString()));
1920 for (
unsigned I = 0, E = S->getNumInputs(); I < E; ++I) {
1921 TRY_TO(TraverseStmt(S->getInputConstraintLiteral(I)));
1923 for (
unsigned I = 0, E = S->getNumOutputs(); I < E; ++I) {
1924 TRY_TO(TraverseStmt(S->getOutputConstraintLiteral(I)));
1926 for (
unsigned I = 0, E = S->getNumClobbers(); I < E; ++I) {
1927 TRY_TO(TraverseStmt(S->getClobberStringLiteral(I)));
1939 TRY_TO(TraverseDecl(S->getExceptionDecl()));
1944 for (
auto *I : S->decls()) {
1979 if (!getDerived().shouldVisitImplicitCode()) {
1980 TRY_TO(TraverseStmt(S->getLoopVarStmt()));
1981 TRY_TO(TraverseStmt(S->getRangeInit()));
1982 TRY_TO(TraverseStmt(S->getBody()));
1988 TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
1989 TRY_TO(TraverseDeclarationNameInfo(S->getNameInfo()));
1996 TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
1997 TRY_TO(TraverseDeclarationNameInfo(S->getMemberNameInfo()));
1998 if (S->hasExplicitTemplateArgs()) {
1999 TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(),
2000 S->getNumTemplateArgs()));
2005 TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
2006 TRY_TO(TraverseDeclarationNameInfo(S->getNameInfo()));
2007 TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(),
2008 S->getNumTemplateArgs()));
2012 TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
2013 TRY_TO(TraverseDeclarationNameInfo(S->getNameInfo()));
2014 if (S->hasExplicitTemplateArgs()) {
2015 TRY_TO(TraverseTemplateArgumentLocsHelper(
2016 S->getExplicitTemplateArgs().getTemplateArgs(),
2017 S->getNumTemplateArgs()));
2022 TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
2023 TRY_TO(TraverseDeclarationNameInfo(S->getMemberNameInfo()));
2024 TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(),
2025 S->getNumTemplateArgs()));
2035 TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
2039 TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
2043 TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
2047 TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
2051 TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
2055 TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
2063 template <typename Derived>
2064 bool RecursiveASTVisitor<Derived>::TraverseInitListExpr(InitListExpr *S) {
2065 InitListExpr *Syn = S->isSemanticForm() ? S->getSyntacticForm() :
S;
2067 TRY_TO(WalkUpFromInitListExpr(Syn));
2069 for (
Stmt *SubStmt : Syn->children()) {
2070 TRY_TO(TraverseStmt(SubStmt));
2073 InitListExpr *Sem = S->isSemanticForm() ? S : S->getSemanticForm();
2075 TRY_TO(WalkUpFromInitListExpr(Sem));
2076 for (
Stmt *SubStmt : Sem->children()) {
2077 TRY_TO(TraverseStmt(SubStmt));
2086 template <
typename Derived>
2087 bool RecursiveASTVisitor<Derived>::TraverseGenericSelectionExpr(
2088 GenericSelectionExpr *S) {
2089 TRY_TO(WalkUpFromGenericSelectionExpr(S));
2090 TRY_TO(TraverseStmt(S->getControllingExpr()));
2091 for (
unsigned i = 0; i != S->getNumAssocs(); ++i) {
2092 if (TypeSourceInfo *TS = S->getAssocTypeSourceInfo(i))
2093 TRY_TO(TraverseTypeLoc(TS->getTypeLoc()));
2094 TRY_TO(TraverseStmt(S->getAssocExpr(i)));
2101 template <
typename Derived>
2103 RecursiveASTVisitor<Derived>::TraversePseudoObjectExpr(PseudoObjectExpr *S) {
2104 TRY_TO(WalkUpFromPseudoObjectExpr(S));
2105 TRY_TO(TraverseStmt(S->getSyntacticForm()));
2107 e = S->semantics_end();
2110 if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(sub))
2111 sub = OVE->getSourceExpr();
2112 TRY_TO(TraverseStmt(sub));
2120 TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));
2125 TRY_TO(TraverseTypeLoc(S->getAllocatedTypeSourceInfo()->getTypeLoc()));
2133 TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));
2139 if (S->isArgumentType())
2140 TRY_TO(TraverseTypeLoc(S->getArgumentTypeInfo()->getTypeLoc()));
2146 if (S->isTypeOperand())
2147 TRY_TO(TraverseTypeLoc(S->getTypeOperandSourceInfo()->getTypeLoc()));
2151 TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
2157 if (S->isTypeOperand())
2158 TRY_TO(TraverseTypeLoc(S->getTypeOperandSourceInfo()->getTypeLoc()));
2162 for (
unsigned I = 0, N = S->getNumArgs(); I != N; ++I)
2163 TRY_TO(TraverseTypeLoc(S->getArg(I)->getTypeLoc()));
2167 TRY_TO(TraverseTypeLoc(S->getQueriedTypeSourceInfo()->getTypeLoc()));
2171 {
TRY_TO(TraverseStmt(S->getQueriedExpression())); })
2175 TRY_TO(TraverseTypeLoc(S->getWrittenTypeInfo()->getTypeLoc()));
2180 TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));
2184 template <typename Derived>
2185 bool RecursiveASTVisitor<Derived>::TraverseLambdaExpr(LambdaExpr *S) {
2186 TRY_TO(WalkUpFromLambdaExpr(S));
2189 CEnd = S->explicit_capture_end();
2191 TRY_TO(TraverseLambdaCapture(S, C));
2194 TypeLoc TL = S->getCallOperator()->getTypeSourceInfo()->getTypeLoc();
2195 FunctionProtoTypeLoc Proto = TL.castAs<FunctionProtoTypeLoc>();
2197 if (S->hasExplicitParameters() && S->hasExplicitResultType()) {
2199 TRY_TO(TraverseTypeLoc(TL));
2201 if (S->hasExplicitParameters()) {
2203 for (
unsigned I = 0, N = Proto.getNumParams(); I != N; ++I) {
2204 TRY_TO(TraverseDecl(Proto.getParam(I)));
2206 }
else if (S->hasExplicitResultType()) {
2207 TRY_TO(TraverseTypeLoc(Proto.getReturnLoc()));
2210 auto *T = Proto.getTypePtr();
2211 for (
const auto &E : T->exceptions()) {
2215 if (Expr *NE = T->getNoexceptExpr())
2216 TRY_TO(TraverseStmt(NE));
2219 TRY_TO(TraverseLambdaBody(S));
2225 TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));
2239 TRY_TO(TraverseDecl(S->getBlockDecl()));
2244 TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));
2255 TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
2256 if (TypeSourceInfo *ScopeInfo = S->getScopeTypeInfo())
2257 TRY_TO(TraverseTypeLoc(ScopeInfo->getTypeLoc()));
2258 if (TypeSourceInfo *DestroyedTypeInfo = S->getDestroyedTypeInfo())
2259 TRY_TO(TraverseTypeLoc(DestroyedTypeInfo->getTypeLoc()));
2272 if (TypeSourceInfo *TInfo = S->getEncodedTypeSourceInfo())
2273 TRY_TO(TraverseTypeLoc(TInfo->getTypeLoc()));
2278 if (TypeSourceInfo *TInfo = S->getClassReceiverTypeInfo())
2279 TRY_TO(TraverseTypeLoc(TInfo->getTypeLoc()));
2287 TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
2296 TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
2297 if (S->hasExplicitTemplateArgs()) {
2298 TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(),
2299 S->getNumTemplateArgs()));
2304 TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
2305 if (S->hasExplicitTemplateArgs()) {
2306 TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(),
2307 S->getNumTemplateArgs()));
2354 template <typename Derived>
2355 bool RecursiveASTVisitor<Derived>::TraverseOMPExecutableDirective(
2356 OMPExecutableDirective *S) {
2357 for (
auto *C : S->clauses()) {
2358 TRY_TO(TraverseOMPClause(C));
2363 template <
typename Derived>
2365 RecursiveASTVisitor<Derived>::TraverseOMPLoopDirective(OMPLoopDirective *S) {
2366 return TraverseOMPExecutableDirective(S);
2370 {
TRY_TO(TraverseOMPExecutableDirective(S)); })
2373 {
TRY_TO(TraverseOMPExecutableDirective(S)); })
2376 {
TRY_TO(TraverseOMPExecutableDirective(S)); })
2379 {
TRY_TO(TraverseOMPExecutableDirective(S)); })
2382 {
TRY_TO(TraverseOMPExecutableDirective(S)); })
2385 {
TRY_TO(TraverseOMPExecutableDirective(S)); })
2388 {
TRY_TO(TraverseOMPExecutableDirective(S)); })
2391 {
TRY_TO(TraverseOMPExecutableDirective(S)); })
2394 TRY_TO(TraverseDeclarationNameInfo(S->getDirectiveName()));
2395 TRY_TO(TraverseOMPExecutableDirective(S));
2399 {
TRY_TO(TraverseOMPExecutableDirective(S)); })
2402 {
TRY_TO(TraverseOMPExecutableDirective(S)); })
2405 {
TRY_TO(TraverseOMPExecutableDirective(S)); })
2408 {
TRY_TO(TraverseOMPExecutableDirective(S)); })
2411 {
TRY_TO(TraverseOMPExecutableDirective(S)); })
2414 {
TRY_TO(TraverseOMPExecutableDirective(S)); })
2417 {
TRY_TO(TraverseOMPExecutableDirective(S)); })
2420 {
TRY_TO(TraverseOMPExecutableDirective(S)); })
2423 {
TRY_TO(TraverseOMPExecutableDirective(S)); })
2426 {
TRY_TO(TraverseOMPExecutableDirective(S)); })
2429 {
TRY_TO(TraverseOMPExecutableDirective(S)); })
2432 {
TRY_TO(TraverseOMPExecutableDirective(S)); })
2435 {
TRY_TO(TraverseOMPExecutableDirective(S)); })
2438 {
TRY_TO(TraverseOMPExecutableDirective(S)); })
2441 {
TRY_TO(TraverseOMPExecutableDirective(S)); })
2444 template <typename Derived>
2445 bool RecursiveASTVisitor<Derived>::TraverseOMPClause(OMPClause *C) {
2448 switch (C->getClauseKind()) {
2449 #define OPENMP_CLAUSE(Name, Class) \
2451 TRY_TO(Visit##Class(static_cast<Class *>(C))); \
2453 #include "clang/Basic/OpenMPKinds.def"
2461 template <
typename Derived>
2462 bool RecursiveASTVisitor<Derived>::VisitOMPIfClause(OMPIfClause *C) {
2463 TRY_TO(TraverseStmt(C->getCondition()));
2467 template <
typename Derived>
2468 bool RecursiveASTVisitor<Derived>::VisitOMPFinalClause(OMPFinalClause *C) {
2469 TRY_TO(TraverseStmt(C->getCondition()));
2473 template <
typename Derived>
2475 RecursiveASTVisitor<Derived>::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) {
2476 TRY_TO(TraverseStmt(C->getNumThreads()));
2480 template <
typename Derived>
2481 bool RecursiveASTVisitor<Derived>::VisitOMPSafelenClause(OMPSafelenClause *C) {
2482 TRY_TO(TraverseStmt(C->getSafelen()));
2486 template <
typename Derived>
2488 RecursiveASTVisitor<Derived>::VisitOMPCollapseClause(OMPCollapseClause *C) {
2489 TRY_TO(TraverseStmt(C->getNumForLoops()));
2493 template <
typename Derived>
2494 bool RecursiveASTVisitor<Derived>::VisitOMPDefaultClause(OMPDefaultClause *) {
2498 template <
typename Derived>
2499 bool RecursiveASTVisitor<Derived>::VisitOMPProcBindClause(OMPProcBindClause *) {
2503 template <
typename Derived>
2505 RecursiveASTVisitor<Derived>::VisitOMPScheduleClause(OMPScheduleClause *C) {
2506 TRY_TO(TraverseStmt(C->getChunkSize()));
2507 TRY_TO(TraverseStmt(C->getHelperChunkSize()));
2511 template <
typename Derived>
2512 bool RecursiveASTVisitor<Derived>::VisitOMPOrderedClause(OMPOrderedClause *) {
2516 template <
typename Derived>
2517 bool RecursiveASTVisitor<Derived>::VisitOMPNowaitClause(OMPNowaitClause *) {
2521 template <
typename Derived>
2522 bool RecursiveASTVisitor<Derived>::VisitOMPUntiedClause(OMPUntiedClause *) {
2526 template <
typename Derived>
2528 RecursiveASTVisitor<Derived>::VisitOMPMergeableClause(OMPMergeableClause *) {
2532 template <
typename Derived>
2533 bool RecursiveASTVisitor<Derived>::VisitOMPReadClause(OMPReadClause *) {
2537 template <
typename Derived>
2538 bool RecursiveASTVisitor<Derived>::VisitOMPWriteClause(OMPWriteClause *) {
2542 template <
typename Derived>
2543 bool RecursiveASTVisitor<Derived>::VisitOMPUpdateClause(OMPUpdateClause *) {
2547 template <
typename Derived>
2548 bool RecursiveASTVisitor<Derived>::VisitOMPCaptureClause(OMPCaptureClause *) {
2552 template <
typename Derived>
2553 bool RecursiveASTVisitor<Derived>::VisitOMPSeqCstClause(OMPSeqCstClause *) {
2557 template <
typename Derived>
2558 template <
typename T>
2559 bool RecursiveASTVisitor<Derived>::VisitOMPClauseList(T *
Node) {
2560 for (
auto *E : Node->varlists()) {
2566 template <
typename Derived>
2567 bool RecursiveASTVisitor<Derived>::VisitOMPPrivateClause(OMPPrivateClause *C) {
2568 TRY_TO(VisitOMPClauseList(C));
2569 for (
auto *E : C->private_copies()) {
2575 template <
typename Derived>
2576 bool RecursiveASTVisitor<Derived>::VisitOMPFirstprivateClause(
2577 OMPFirstprivateClause *C) {
2578 TRY_TO(VisitOMPClauseList(C));
2579 for (
auto *E : C->private_copies()) {
2582 for (
auto *E : C->inits()) {
2588 template <
typename Derived>
2589 bool RecursiveASTVisitor<Derived>::VisitOMPLastprivateClause(
2590 OMPLastprivateClause *C) {
2591 TRY_TO(VisitOMPClauseList(C));
2592 for (
auto *E : C->private_copies()) {
2595 for (
auto *E : C->source_exprs()) {
2598 for (
auto *E : C->destination_exprs()) {
2601 for (
auto *E : C->assignment_ops()) {
2607 template <
typename Derived>
2608 bool RecursiveASTVisitor<Derived>::VisitOMPSharedClause(OMPSharedClause *C) {
2609 TRY_TO(VisitOMPClauseList(C));
2613 template <
typename Derived>
2614 bool RecursiveASTVisitor<Derived>::VisitOMPLinearClause(
OMPLinearClause *C) {
2615 TRY_TO(TraverseStmt(C->getStep()));
2616 TRY_TO(TraverseStmt(C->getCalcStep()));
2617 TRY_TO(VisitOMPClauseList(C));
2618 for (
auto *E : C->inits()) {
2621 for (
auto *E : C->updates()) {
2624 for (
auto *E : C->finals()) {
2630 template <
typename Derived>
2631 bool RecursiveASTVisitor<Derived>::VisitOMPAlignedClause(
OMPAlignedClause *C) {
2633 TRY_TO(VisitOMPClauseList(C));
2637 template <
typename Derived>
2638 bool RecursiveASTVisitor<Derived>::VisitOMPCopyinClause(
OMPCopyinClause *C) {
2639 TRY_TO(VisitOMPClauseList(C));
2652 template <
typename Derived>
2653 bool RecursiveASTVisitor<Derived>::VisitOMPCopyprivateClause(
2655 TRY_TO(VisitOMPClauseList(C));
2668 template <
typename Derived>
2670 RecursiveASTVisitor<Derived>::VisitOMPReductionClause(OMPReductionClause *C) {
2671 TRY_TO(TraverseNestedNameSpecifierLoc(C->getQualifierLoc()));
2672 TRY_TO(TraverseDeclarationNameInfo(C->getNameInfo()));
2673 TRY_TO(VisitOMPClauseList(C));
2674 for (
auto *E : C->lhs_exprs()) {
2677 for (
auto *E : C->rhs_exprs()) {
2680 for (
auto *E : C->reduction_ops()) {
2686 template <
typename Derived>
2687 bool RecursiveASTVisitor<Derived>::VisitOMPFlushClause(
OMPFlushClause *C) {
2688 TRY_TO(VisitOMPClauseList(C));
2692 template <
typename Derived>
2693 bool RecursiveASTVisitor<Derived>::VisitOMPDependClause(
OMPDependClause *C) {
2694 TRY_TO(VisitOMPClauseList(C));
2715 #undef DEF_TRAVERSE_STMT
2721 #endif // LLVM_CLANG_AST_RECURSIVEASTVISITOR_H
ParmVarDecl *const * param_const_iterator
This represents clause 'copyin' in the '#pragma omp ...' directives.
helper_expr_const_range source_exprs() const
bool TraverseLambdaBody(LambdaExpr *LE)
Recursively visit the body of a lambda expression.
#define DEF_TRAVERSE_TMPL_SPEC_DECL(TMPLDECLKIND)
Expr *const * semantics_iterator
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in...
Defines the C++ template declaration subclasses.
bool VisitTypeLoc(TypeLoc TL)
bool TraverseTemplateName(TemplateName Template)
Recursively visit a template name and dispatch to the appropriate method.
Describes the capture of a variable or of this, or of a C++1y init-capture.
Expr * getAlignment()
Returns alignment.
An identifier, stored as an IdentifierInfo*.
TRY_TO(TraverseType(T->getPointeeType()))
Wrapper of type source information for a type with non-trivial direct qualifiers. ...
Derived & getDerived()
Return a reference to the derived class.
Represents an empty template argument, e.g., one that has not been deduced.
A namespace, stored as a NamespaceDecl*.
This represents implicit clause 'flush' for the '#pragma omp flush' directive. This clause does not e...
Defines the Objective-C statement AST node classes.
Defines the clang::Expr interface and subclasses for C++ expressions.
bool TraverseDecl(Decl *D)
Recursively visit a declaration, by dispatching to Traverse*Decl() based on the argument's dynamic ty...
Base wrapper for a particular "section" of type source info.
A C++ nested-name-specifier augmented with source location information.
#define TYPE(CLASS, BASE)
bool shouldVisitTemplateInstantiations() const
Return whether this visitor should recurse into template instantiations.
bool TraverseLambdaCapture(LambdaExpr *LE, const LambdaCapture *C)
Recursively visit a lambda capture.
Wrapper of type source information for a type with no direct qualifiers.
#define DEF_TRAVERSE_TMPL_DECL(TMPLDECLKIND)
This represents clause 'copyprivate' in the '#pragma omp ...' directives.
bool shouldUseDataRecursionFor(Stmt *S) const
Return whether.
#define RecursiveASTVisitor
NamedDecl ** iterator
Iterates through the template parameters in this list.
bool TraverseDeclarationNameInfo(DeclarationNameInfo NameInfo)
Recursively visit a name with its location information.
#define DEF_TRAVERSE_DECL(DECL, CODE)
bool WalkUpFromType(Type *T)
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
bool WalkUpFromStmt(Stmt *S)
#define DEF_TRAVERSE_TMPL_PART_SPEC_DECL(TMPLDECLKIND, DECLKIND)
bool WalkUpFromTypeLoc(TypeLoc TL)
This represents clause 'aligned' in the '#pragma omp ...' directives.
DEF_TRAVERSE_TYPE(ComplexType,{TRY_TO(TraverseType(T->getElementType()));}) DEF_TRAVERSE_TYPE(PointerType
This represents implicit clause 'depend' for the '#pragma omp task' directive.
bool TraverseConstructorInitializer(CXXCtorInitializer *Init)
Recursively visit a constructor initializer. This automatically dispatches to another visitor for the...
helper_expr_const_range assignment_ops() const
bool WalkUpFromDecl(Decl *D)
bool WalkUpFromQualifiedTypeLoc(QualifiedTypeLoc TL)
bool shouldVisitImplicitCode() const
Return whether this visitor should recurse into implicit code, e.g., implicit constructors and destru...
ParmVarDecl *const * param_iterator
bool VisitQualifiedTypeLoc(QualifiedTypeLoc TL)
Represents a C++ template name within the type system.
Defines the clang::TypeLoc interface and its subclasses.
A namespace alias, stored as a NamespaceAliasDecl*.
OMPLinearClause(SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, unsigned NumVars)
Build 'linear' clause with given number of variables NumVars.
A type, stored as a Type*.
DEF_TRAVERSE_TYPELOC(ComplexType,{TRY_TO(TraverseType(TL.getTypePtr() ->getElementType()));}) DEF_TRAVERSE_TYPELOC(PointerType
return TraverseArrayTypeLocHelper(TL)
helper_expr_const_range destination_exprs() const
bool WalkUpFromUnqualTypeLoc(UnqualTypeLoc TL)
bool TraverseTypeLoc(TypeLoc TL)
Recursively visit a type with location, by dispatching to Traverse*TypeLoc() based on the argument ty...
bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS)
Recursively visit a C++ nested-name-specifier with location information.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
This file defines OpenMP nodes for declarative directives.
bool TraverseType(QualType T)
Recursively visit a type, by dispatching to Traverse*Type() based on the argument's getTypeClass() pr...
ast_type_traits::DynTypedNode Node
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T-> getSizeExpr()))
Represents a template argument.
return(x >> y)|(x<< (32-y))
#define DEF_TRAVERSE_TMPL_INST(TMPLDECLKIND)
const internal::VariadicDynCastAllOfMatcher< Stmt, CUDAKernelCallExpr > CUDAKernelCallExpr
Matches CUDA kernel call expression.
for(auto typeArg:T->getTypeArgsAsWritten())
A type that was preceded by the 'template' keyword, stored as a Type*.
This file defines OpenMP AST classes for executable directives and clauses.
bool TraverseTemplateArgument(const TemplateArgument &Arg)
Recursively visit a template argument and dispatch to the appropriate method for the argument type...
Represents a C++ base or member initializer.
UnqualTypeLoc getUnqualifiedLoc() const
The template argument is a type.
bool TraverseNestedNameSpecifier(NestedNameSpecifier *NNS)
Recursively visit a C++ nested-name-specifier.
helper_expr_const_range destination_exprs() const
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
const Capture * capture_iterator
An iterator that walks over the captures of the lambda, both implicit and explicit.
bool TraverseTemplateArguments(const TemplateArgument *Args, unsigned NumArgs)
Recursively visit a set of template arguments. This can be overridden by a subclass, but it's not expected that will be needed – this visitor always dispatches to another.
#define DEF_TRAVERSE_STMT(STMT, CODE)
bool TraverseAttr(Attr *At)
Recursively visit an attribute, by dispatching to Traverse*Attr() based on the argument's dynamic typ...
UnqualTypeLoc getUnqualifiedLoc() const
Skips past any qualifiers, if this is qualified.
bool VisitUnqualTypeLoc(UnqualTypeLoc TL)
The global specifier '::'. There is no stored value.
bool shouldWalkTypesOfTypeLocs() const
Return whether this visitor should recurse into the types of TypeLocs.
bool TraverseStmt(Stmt *S)
Recursively visit a statement or expression, by dispatching to Traverse*() based on the argument's dy...
bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &ArgLoc)
Recursively visit a template argument location and dispatch to the appropriate method for the argumen...
Attr - This represents one attribute.
helper_expr_const_range assignment_ops() const
#define STMT(CLASS, PARENT)
helper_expr_const_range source_exprs() const