#include "clang/AST/ASTConcept.h"
#include "clang/AST/Attr.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclBase.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclFriend.h"
#include "clang/AST/DeclObjC.h"
#include "clang/AST/DeclOpenMP.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/AST/DeclarationName.h"
#include "clang/AST/Expr.h"
#include "clang/AST/ExprCXX.h"
#include "clang/AST/ExprConcepts.h"
#include "clang/AST/ExprObjC.h"
#include "clang/AST/ExprOpenMP.h"
#include "clang/AST/LambdaCapture.h"
#include "clang/AST/NestedNameSpecifier.h"
#include "clang/AST/OpenMPClause.h"
#include "clang/AST/Stmt.h"
#include "clang/AST/StmtCXX.h"
#include "clang/AST/StmtObjC.h"
#include "clang/AST/StmtOpenMP.h"
#include "clang/AST/TemplateBase.h"
#include "clang/AST/TemplateName.h"
#include "clang/AST/Type.h"
#include "clang/AST/TypeLoc.h"
#include "clang/Basic/LLVM.h"
#include "clang/Basic/OpenMPKinds.h"
#include "clang/Basic/Specifiers.h"
#include "llvm/ADT/PointerIntPair.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/Casting.h"
#include <algorithm>
#include <cstddef>
#include <type_traits>
#include "clang/AST/AttrVisitor.inc"
#include "clang/AST/StmtNodes.inc"
#include "clang/AST/TypeNodes.inc"
#include "clang/AST/TypeLocNodes.def"
#include "clang/AST/DeclNodes.inc"
#include "llvm/Frontend/OpenMP/OMP.inc"

Include dependency graph for RecursiveASTVisitor.h:

Classes
struct	clang::detail::has_same_member_pointer_type< T, U >

struct	clang::detail::has_same_member_pointer_type< R(T::)(P...), R(U::)(P...)>

class	clang::RecursiveASTVisitor< Derived >
	A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each node. More...

Namespaces
namespace	clang

namespace	clang::detail

Macros
#define	TRY_TO(CALL_EXPR)

#define	ATTR_VISITOR_DECLS_ONLY

#define	TRAVERSE_STMT_BASE(NAME, CLASS, VAR, QUEUE)

#define	TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S)

#define	ABSTRACT_STMT(STMT)

#define	STMT(CLASS, PARENT) bool Traverse##CLASS(CLASS S, DataRecursionQueue Queue = nullptr);

#define	STMT(CLASS, PARENT)

#define	ABSTRACT_TYPE(CLASS, BASE)

#define	TYPE(CLASS, BASE) bool Traverse##CLASS##Type(CLASS##Type *T);

#define	TYPE(CLASS, BASE)

#define	ABSTRACT_TYPELOC(CLASS, BASE)

#define	TYPELOC(CLASS, BASE) bool Traverse##CLASS##TypeLoc(CLASS##TypeLoc TL);

#define	TYPE(CLASS, BASE)

#define	ABSTRACT_DECL(DECL)

#define	DECL(CLASS, BASE) bool Traverse##CLASS##Decl(CLASS##Decl *D);

#define	DECL(CLASS, BASE)

#define	DEF_TRAVERSE_TMPL_INST(TMPLDECLKIND) bool TraverseTemplateInstantiations(TMPLDECLKIND##TemplateDecl *D);

#define	GEN_CLANG_CLAUSE_CLASS

#define	CLAUSE_CLASS(Enum, Str, Class) bool Visit##Class(Class *C);

#define	ABSTRACT_STMT(STMT)

#define	STMT(CLASS, PARENT)

#define	ABSTRACT_STMT(STMT)

#define	STMT(CLASS, PARENT)

#define	INITLISTEXPR(CLASS, PARENT)

#define	ABSTRACT_TYPE(CLASS, BASE)

#define	TYPE(CLASS, BASE)

#define	ABSTRACT_TYPELOC(CLASS, BASE)

#define	TYPELOC(CLASS, BASE)

#define	VISITORCLASS RecursiveASTVisitor

#define	ABSTRACT_DECL(DECL)

#define	DECL(CLASS, BASE)

#define	DEF_TRAVERSE_TYPE(TYPE, CODE)

#define	DEF_TRAVERSE_TYPELOC(TYPE, CODE)

#define	DEF_TRAVERSE_DECL(DECL, CODE)

#define	DEF_TRAVERSE_TMPL_DECL(TMPLDECLKIND)

#define	DEF_TRAVERSE_TMPL_SPEC_DECL(TMPLDECLKIND, DECLKIND)

#define	DEF_TRAVERSE_TMPL_PART_SPEC_DECL(TMPLDECLKIND, DECLKIND)

#define	DEF_TRAVERSE_STMT(STMT, CODE)

#define	GEN_CLANG_CLAUSE_CLASS

#define	CLAUSE_CLASS(Enum, Str, Class)

#define	CLAUSE_NO_CLASS(Enum, Str)

Functions
template<typename FirstMethodPtrTy , typename SecondMethodPtrTy >
LLVM_ATTRIBUTE_ALWAYS_INLINE LLVM_ATTRIBUTE_NODEBUG auto	clang::detail::isSameMethod (FirstMethodPtrTy FirstMethodPtr, SecondMethodPtrTy SecondMethodPtr) -> bool
	Returns true if and only if `FirstMethodPtr` and `SecondMethodPtr` are pointers to the same non-static member function.

	clang::DEF_TRAVERSE_TYPE (ComplexType, { TRY_TO(TraverseType(T->getElementType()));}) DEF_TRAVERSE_TYPE(PointerType

	clang::DEF_TRAVERSE_TYPE (BlockPointerType, { TRY_TO(TraverseType(T->getPointeeType()));}) DEF_TRAVERSE_TYPE(LValueReferenceType

	clang::DEF_TRAVERSE_TYPE (RValueReferenceType, { TRY_TO(TraverseType(T->getPointeeType()));}) DEF_TRAVERSE_TYPE(MemberPointerType

	clang::TRY_TO (TraverseType(T->getPointeeType()))

	clang::DEF_TRAVERSE_TYPE (AdjustedType, { TRY_TO(TraverseType(T->getOriginalType()));}) DEF_TRAVERSE_TYPE(DecayedType

	clang::DEF_TRAVERSE_TYPE (ConstantArrayType, { TRY_TO(TraverseType(T->getElementType()));if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T->getSizeExpr())));}) DEF_TRAVERSE_TYPE(IncompleteArrayType

	clang::DEF_TRAVERSE_TYPE (VariableArrayType, { TRY_TO(TraverseType(T->getElementType()));TRY_TO(TraverseStmt(T->getSizeExpr()));}) DEF_TRAVERSE_TYPE(DependentSizedArrayType

	clang::if (T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))

	clang::DEF_TRAVERSE_TYPE (DependentAddressSpaceType, { TRY_TO(TraverseStmt(T->getAddrSpaceExpr()));TRY_TO(TraverseType(T->getPointeeType()));}) DEF_TRAVERSE_TYPE(DependentVectorType

	clang::TRY_TO (TraverseType(T->getElementType()))

	clang::DEF_TRAVERSE_TYPE (DependentSizedExtVectorType, { if(T->getSizeExpr()) TRY_TO(TraverseStmt(T->getSizeExpr()));TRY_TO(TraverseType(T->getElementType()));}) DEF_TRAVERSE_TYPE(VectorType

	clang::DEF_TRAVERSE_TYPE (ExtVectorType, { TRY_TO(TraverseType(T->getElementType()));}) DEF_TRAVERSE_TYPE(ConstantMatrixType

	clang::DEF_TRAVERSE_TYPE (DependentSizedMatrixType, { if(T->getRowExpr()) TRY_TO(TraverseStmt(T->getRowExpr()));if(T->getColumnExpr()) TRY_TO(TraverseStmt(T->getColumnExpr()));TRY_TO(TraverseType(T->getElementType()));}) DEF_TRAVERSE_TYPE(FunctionNoProtoType

	clang::DEF_TRAVERSE_TYPE (FunctionProtoType, { TRY_TO(TraverseType(T->getReturnType()));for(const auto &A :T->param_types()) { TRY_TO(TraverseType(A));} for(const auto &E :T->exceptions()) { TRY_TO(TraverseType(E));} if(Expr *NE=T->getNoexceptExpr()) TRY_TO(TraverseStmt(NE));}) DEF_TRAVERSE_TYPE(TypeOfExprType

	clang::DEF_TRAVERSE_TYPE (TypeOfType, { TRY_TO(TraverseType(T->getUnmodifiedType()));}) DEF_TRAVERSE_TYPE(DecltypeType

	clang::DEF_TRAVERSE_TYPE (UnaryTransformType, { TRY_TO(TraverseType(T->getBaseType()));TRY_TO(TraverseType(T->getUnderlyingType()));}) DEF_TRAVERSE_TYPE(AutoType

	clang::DEF_TRAVERSE_TYPE (DeducedTemplateSpecializationType, { TRY_TO(TraverseTemplateName(T->getTemplateName()));TRY_TO(TraverseType(T->getDeducedType()));}) DEF_TRAVERSE_TYPE(SubstTemplateTypeParmType

	clang::DEF_TRAVERSE_TYPE (SubstTemplateTypeParmPackType, { TRY_TO(TraverseTemplateArgument(T->getArgumentPack()));}) DEF_TRAVERSE_TYPE(TemplateSpecializationType

	clang::TRY_TO (TraverseTemplateArguments(T->template_arguments()))

	clang::DEF_TRAVERSE_TYPE (AttributedType, { TRY_TO(TraverseType(T->getModifiedType()));}) DEF_TRAVERSE_TYPE(BTFTagAttributedType

	clang::DEF_TRAVERSE_TYPE (ParenType, { TRY_TO(TraverseType(T->getInnerType()));}) DEF_TRAVERSE_TYPE(MacroQualifiedType

	clang::DEF_TRAVERSE_TYPE (ElaboratedType, { if(T->getQualifier()) { TRY_TO(TraverseNestedNameSpecifier(T->getQualifier()));} TRY_TO(TraverseType(T->getNamedType()));}) DEF_TRAVERSE_TYPE(DependentNameType

	clang::DEF_TRAVERSE_TYPE (DependentTemplateSpecializationType, { TRY_TO(TraverseNestedNameSpecifier(T->getQualifier()));TRY_TO(TraverseTemplateArguments(T->template_arguments()));}) DEF_TRAVERSE_TYPE(PackExpansionType

	clang::DEF_TRAVERSE_TYPE (ObjCObjectType, { if(T->getBaseType().getTypePtr() !=T) TRY_TO(TraverseType(T->getBaseType()));for(auto typeArg :T->getTypeArgsAsWritten()) { TRY_TO(TraverseType(typeArg));} }) DEF_TRAVERSE_TYPE(ObjCObjectPointerType

	clang::DEF_TRAVERSE_TYPE (AtomicType, { TRY_TO(TraverseType(T->getValueType()));}) DEF_TRAVERSE_TYPE(PipeType

	clang::DEF_TRAVERSE_TYPE (DependentBitIntType, { TRY_TO(TraverseStmt(T->getNumBitsExpr()));}) template< typename Derived > bool RecursiveASTVisitor< Derived >

	clang::DEF_TRAVERSE_TYPELOC (ComplexType, { TRY_TO(TraverseType(TL.getTypePtr() ->getElementType()));}) DEF_TRAVERSE_TYPELOC(PointerType

	clang::DEF_TRAVERSE_TYPELOC (BlockPointerType, { TRY_TO(TraverseTypeLoc(TL.getPointeeLoc()));}) DEF_TRAVERSE_TYPELOC(LValueReferenceType

	clang::DEF_TRAVERSE_TYPELOC (RValueReferenceType, { TRY_TO(TraverseTypeLoc(TL.getPointeeLoc()));}) DEF_TRAVERSE_TYPELOC(MemberPointerType

else	clang::TRY_TO (TraverseType(QualType(TL.getTypePtr() ->getClass(), 0)))

	clang::TRY_TO (TraverseTypeLoc(TL.getPointeeLoc()))

	clang::DEF_TRAVERSE_TYPELOC (AdjustedType, { TRY_TO(TraverseTypeLoc(TL.getOriginalLoc()));}) DEF_TRAVERSE_TYPELOC(DecayedType

	clang::DEF_TRAVERSE_TYPELOC (ConstantArrayType, { TRY_TO(TraverseTypeLoc(TL.getElementLoc()));TRY_TO(TraverseArrayTypeLocHelper(TL));}) DEF_TRAVERSE_TYPELOC(IncompleteArrayType

	clang::TRY_TO (TraverseArrayTypeLocHelper(TL))

	clang::DEF_TRAVERSE_TYPELOC (VariableArrayType, { TRY_TO(TraverseTypeLoc(TL.getElementLoc()));TRY_TO(TraverseArrayTypeLocHelper(TL));}) DEF_TRAVERSE_TYPELOC(DependentSizedArrayType

	clang::DEF_TRAVERSE_TYPELOC (DependentAddressSpaceType, { TRY_TO(TraverseStmt(TL.getTypePtr() ->getAddrSpaceExpr()));TRY_TO(TraverseType(TL.getTypePtr() ->getPointeeType()));}) DEF_TRAVERSE_TYPELOC(DependentSizedExtVectorType

	clang::TRY_TO (TraverseType(TL.getTypePtr() ->getElementType()))

	clang::DEF_TRAVERSE_TYPELOC (VectorType, { TRY_TO(TraverseType(TL.getTypePtr() ->getElementType()));}) DEF_TRAVERSE_TYPELOC(DependentVectorType

	clang::DEF_TRAVERSE_TYPELOC (ExtVectorType, { TRY_TO(TraverseType(TL.getTypePtr() ->getElementType()));}) DEF_TRAVERSE_TYPELOC(ConstantMatrixType

	clang::TRY_TO (TraverseStmt(TL.getAttrColumnOperand()))

	clang::DEF_TRAVERSE_TYPELOC (DependentSizedMatrixType, { TRY_TO(TraverseStmt(TL.getAttrRowOperand()));TRY_TO(TraverseStmt(TL.getAttrColumnOperand()));TRY_TO(TraverseType(TL.getTypePtr() ->getElementType()));}) DEF_TRAVERSE_TYPELOC(FunctionNoProtoType

	clang::DEF_TRAVERSE_TYPELOC (FunctionProtoType, { TRY_TO(TraverseTypeLoc(TL.getReturnLoc()));const FunctionProtoType T=TL.getTypePtr();for(unsigned I=0, E=TL.getNumParams();I !=E;++I) { if(TL.getParam(I)) { TRY_TO(TraverseDecl(TL.getParam(I)));} else if(I< T->getNumParams()) { TRY_TO(TraverseType(T->getParamType(I)));} } for(const auto &E :T->exceptions()) { TRY_TO(TraverseType(E));} if(Expr NE=T->getNoexceptExpr()) TRY_TO(TraverseStmt(NE));}) DEF_TRAVERSE_TYPELOC(TypeOfExprType

	clang::DEF_TRAVERSE_TYPELOC (TypeOfType, { TRY_TO(TraverseTypeLoc(TL.getUnmodifiedTInfo() ->getTypeLoc()));}) DEF_TRAVERSE_TYPELOC(DecltypeType

	clang::DEF_TRAVERSE_TYPELOC (UnaryTransformType, { TRY_TO(TraverseTypeLoc(TL.getUnderlyingTInfo() ->getTypeLoc()));}) DEF_TRAVERSE_TYPELOC(AutoType

	clang::if (TL.isConstrained())

	clang::DEF_TRAVERSE_TYPELOC (DeducedTemplateSpecializationType, { TRY_TO(TraverseTemplateName(TL.getTypePtr() ->getTemplateName()));TRY_TO(TraverseType(TL.getTypePtr() ->getDeducedType()));}) DEF_TRAVERSE_TYPELOC(SubstTemplateTypeParmType

	clang::DEF_TRAVERSE_TYPELOC (SubstTemplateTypeParmPackType, { TRY_TO(TraverseTemplateArgument(TL.getTypePtr() ->getArgumentPack()));}) DEF_TRAVERSE_TYPELOC(TemplateSpecializationType

	clang::for (unsigned I=0, E=TL.getNumArgs();I !=E;++I)

	clang::DEF_TRAVERSE_TYPELOC (ParenType, { TRY_TO(TraverseTypeLoc(TL.getInnerLoc()));}) DEF_TRAVERSE_TYPELOC(MacroQualifiedType

	clang::DEF_TRAVERSE_TYPELOC (AttributedType, { TRY_TO(TraverseTypeLoc(TL.getModifiedLoc()));}) DEF_TRAVERSE_TYPELOC(BTFTagAttributedType

	clang::DEF_TRAVERSE_TYPELOC (ElaboratedType, { if(TL.getQualifierLoc()) { TRY_TO(TraverseNestedNameSpecifierLoc(TL.getQualifierLoc()));} TRY_TO(TraverseTypeLoc(TL.getNamedTypeLoc()));}) DEF_TRAVERSE_TYPELOC(DependentNameType

	clang::DEF_TRAVERSE_TYPELOC (DependentTemplateSpecializationType, { if(TL.getQualifierLoc()) { TRY_TO(TraverseNestedNameSpecifierLoc(TL.getQualifierLoc()));} for(unsigned I=0, E=TL.getNumArgs();I !=E;++I) { TRY_TO(TraverseTemplateArgumentLoc(TL.getArgLoc(I)));} }) DEF_TRAVERSE_TYPELOC(PackExpansionType

	clang::DEF_TRAVERSE_TYPELOC (ObjCTypeParamType, { for(unsigned I=0, N=TL.getNumProtocols();I !=N;++I) { ObjCProtocolLoc ProtocolLoc(TL.getProtocol(I), TL.getProtocolLoc(I));TRY_TO(TraverseObjCProtocolLoc(ProtocolLoc));} }) DEF_TRAVERSE_TYPELOC(ObjCObjectType

	clang::for (unsigned i=0, n=TL.getNumTypeArgs();i !=n;++i) TRY_TO(TraverseTypeLoc(TL.getTypeArgTInfo(i) -> getTypeLoc()))

	clang::for (unsigned I=0, N=TL.getNumProtocols();I !=N;++I)

	clang::DEF_TRAVERSE_TYPELOC (ObjCObjectPointerType, { TRY_TO(TraverseTypeLoc(TL.getPointeeLoc()));}) DEF_TRAVERSE_TYPELOC(AtomicType

	clang::DEF_TRAVERSE_TYPELOC (PipeType, { TRY_TO(TraverseTypeLoc(TL.getValueLoc()));}) DEF_TRAVERSE_TYPELOC(DependentBitIntType

	clang::DEF_TRAVERSE_DECL (BlockDecl, { if(TypeSourceInfo *TInfo=D->getSignatureAsWritten()) TRY_TO(TraverseTypeLoc(TInfo->getTypeLoc()));TRY_TO(TraverseStmt(D->getBody()));for(const auto &I :D->captures()) { if(I.hasCopyExpr()) { TRY_TO(TraverseStmt(I.getCopyExpr()));} } ShouldVisitChildren=false;}) DEF_TRAVERSE_DECL(CapturedDecl

	clang::DEF_TRAVERSE_DECL (LifetimeExtendedTemporaryDecl, { TRY_TO(TraverseStmt(D->getTemporaryExpr()));}) DEF_TRAVERSE_DECL(FileScopeAsmDecl

	clang::DEF_TRAVERSE_DECL (TopLevelStmtDecl, { TRY_TO(TraverseStmt(D->getStmt()));}) DEF_TRAVERSE_DECL(FriendDecl

Variables
	clang::ShouldVisitChildren = false

Macro Definition Documentation

◆ ABSTRACT_DECL [1/2]

#define ABSTRACT_DECL ( DECL )

Definition at line 434 of file RecursiveASTVisitor.h.

◆ ABSTRACT_DECL [2/2]

#define ABSTRACT_DECL ( DECL )

Definition at line 434 of file RecursiveASTVisitor.h.

◆ ABSTRACT_STMT [1/3]

#define ABSTRACT_STMT ( STMT )

Definition at line 358 of file RecursiveASTVisitor.h.

◆ ABSTRACT_STMT [2/3]

#define ABSTRACT_STMT ( STMT )

Definition at line 358 of file RecursiveASTVisitor.h.

◆ ABSTRACT_STMT [3/3]

#define ABSTRACT_STMT ( STMT )

Definition at line 358 of file RecursiveASTVisitor.h.

◆ ABSTRACT_TYPE [1/2]

#define ABSTRACT_TYPE	(	CLASS,
		BASE
	)

Definition at line 380 of file RecursiveASTVisitor.h.

◆ ABSTRACT_TYPE [2/2]

#define ABSTRACT_TYPE	(	CLASS,
		BASE
	)

Definition at line 380 of file RecursiveASTVisitor.h.

◆ ABSTRACT_TYPELOC [1/2]

#define ABSTRACT_TYPELOC	(	CLASS,
		BASE
	)

Definition at line 401 of file RecursiveASTVisitor.h.

◆ ABSTRACT_TYPELOC [2/2]

#define ABSTRACT_TYPELOC	(	CLASS,
		BASE
	)

Definition at line 401 of file RecursiveASTVisitor.h.

◆ ATTR_VISITOR_DECLS_ONLY

#define ATTR_VISITOR_DECLS_ONLY

Definition at line 321 of file RecursiveASTVisitor.h.

◆ CLAUSE_CLASS [1/2]

#define CLAUSE_CLASS	(	Enum,
		Str,
		Class
	)	bool Visit##Class(Class *C);

Definition at line 495 of file RecursiveASTVisitor.h.

◆ CLAUSE_CLASS [2/2]

#define CLAUSE_CLASS	(	Enum,
		Str,
		Class
	)

Value:

  case llvm::omp::Clause::Enum:                                                \
    TRY_TO(Visit##Class(static_cast<Class *>(C)));                             \
    break;

Definition at line 495 of file RecursiveASTVisitor.h.

◆ CLAUSE_NO_CLASS

#define CLAUSE_NO_CLASS	(	Enum,
		Str
	)

Value:

case llvm::omp::Clause::Enum: \

break;

◆ DECL [1/3]

#define DECL	(	CLASS,
		BASE
	)	bool Traverse##CLASS##Decl(CLASS##Decl *D);

Definition at line 442 of file RecursiveASTVisitor.h.

◆ DECL [2/3]

#define DECL	(	CLASS,
		BASE
	)

Value:

  bool WalkUpFrom##CLASS##Decl(CLASS##Decl *D) {                               \
    TRY_TO(WalkUpFrom##BASE(D));                                               \
    TRY_TO(Visit##CLASS##Decl(D));                                             \
    return true;                                                               \
  }                                                                            \
  bool Visit##CLASS##Decl(CLASS##Decl *D) { return true; }

Definition at line 442 of file RecursiveASTVisitor.h.

◆ DECL [3/3]

#define DECL	(	CLASS,
		BASE
	)

Value:

  case Decl::CLASS:                                                            \
    if (!getDerived().Traverse##CLASS##Decl(static_cast<CLASS##Decl *>(D)))    \
      return false;                                                            \
    break;

Definition at line 442 of file RecursiveASTVisitor.h.

◆ DEF_TRAVERSE_DECL

#define DEF_TRAVERSE_DECL	(	DECL,
		CODE
	)

Value:

  template <typename Derived>                                                  \
  bool RecursiveASTVisitor<Derived>::Traverse##DECL(DECL *D) {                 \
    bool ShouldVisitChildren = true;                                           \
    bool ReturnValue = true;                                                   \
    if (!getDerived().shouldTraversePostOrder())                               \
      TRY_TO(WalkUpFrom##DECL(D));                                             \
    { CODE; }                                                                  \
    if (ReturnValue && ShouldVisitChildren)                                    \
      TRY_TO(TraverseDeclContextHelper(dyn_cast<DeclContext>(D)));             \
    if (ReturnValue) {                                                         \
      /* Visit any attributes attached to this declaration. */                 \
      for (auto *I : D->attrs())                                               \
        TRY_TO(getDerived().TraverseAttr(I));                                  \
    }                                                                          \
    if (ReturnValue && getDerived().shouldTraversePostOrder())                 \
      TRY_TO(WalkUpFrom##DECL(D));                                             \
    return ReturnValue;                                                        \
  }

Definition at line 1496 of file RecursiveASTVisitor.h.

◆ DEF_TRAVERSE_STMT

#define DEF_TRAVERSE_STMT	(	STMT,
		CODE
	)

Value:

  template <typename Derived>                                                  \
  bool RecursiveASTVisitor<Derived>::Traverse##STMT(                           \
      STMT *S, DataRecursionQueue *Queue) {                                    \
    bool ShouldVisitChildren = true;                                           \
    bool ReturnValue = true;                                                   \
    if (!getDerived().shouldTraversePostOrder())                               \
      TRY_TO(WalkUpFrom##STMT(S));                                             \
    { CODE; }                                                                  \
    if (ShouldVisitChildren) {                                                 \
      for (Stmt * SubStmt : getDerived().getStmtChildren(S)) {                 \
        TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(SubStmt);                              \
      }                                                                        \
    }                                                                          \
    /* Call WalkUpFrom if TRY_TO_TRAVERSE_OR_ENQUEUE_STMT has traversed the    \
     * children already. If TRY_TO_TRAVERSE_OR_ENQUEUE_STMT only enqueued the  \
     * children, PostVisitStmt will call WalkUpFrom after we are done visiting \
     * children. */                                                            \
    if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) {     \
      TRY_TO(WalkUpFrom##STMT(S));                                             \
    }                                                                          \
    return ReturnValue;                                                        \
  }

◆ DEF_TRAVERSE_TMPL_DECL

#define DEF_TRAVERSE_TMPL_DECL ( TMPLDECLKIND )

Value:

  DEF_TRAVERSE_DECL(TMPLDECLKIND##TemplateDecl, {                              \
    TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));   \
    TRY_TO(TraverseDecl(D->getTemplatedDecl()));                               \
                                                                               \
    /* By default, we do not traverse the instantiations of                    \
       class templates since they do not appear in the user code. The          \
       following code optionally traverses them.                               \
                                                                               \
       We only traverse the class instantiations when we see the canonical     \
       declaration of the template, to ensure we only visit them once. */      \
    if (getDerived().shouldVisitTemplateInstantiations() &&                    \
        D == D->getCanonicalDecl())                                            \
      TRY_TO(TraverseTemplateInstantiations(D));                               \
                                                                               \
    /* Note that getInstantiatedFromMemberTemplate() is just a link            \
       from a template instantiation back to the template from which           \
       it was instantiated, and thus should not be traversed. */               \
  })

◆ DEF_TRAVERSE_TMPL_INST

#define DEF_TRAVERSE_TMPL_INST ( TMPLDECLKIND ) bool TraverseTemplateInstantiations(TMPLDECLKIND##TemplateDecl *D);

Definition at line 453 of file RecursiveASTVisitor.h.

◆ DEF_TRAVERSE_TMPL_PART_SPEC_DECL

#define DEF_TRAVERSE_TMPL_PART_SPEC_DECL	(	TMPLDECLKIND,
		DECLKIND
	)

Value:

  DEF_TRAVERSE_DECL(TMPLDECLKIND##TemplatePartialSpecializationDecl, {         \
    /* The partial specialization. */                                          \
    if (TemplateParameterList *TPL = D->getTemplateParameters()) {             \
      for (TemplateParameterList::iterator I = TPL->begin(), E = TPL->end();   \
           I != E; ++I) {                                                      \
        TRY_TO(TraverseDecl(*I));                                              \
      }                                                                        \
    }                                                                          \
    /* The args that remains unspecialized. */                                 \
    TRY_TO(TraverseTemplateArgumentLocsHelper(                                 \
        D->getTemplateArgsAsWritten()->getTemplateArgs(),                      \
        D->getTemplateArgsAsWritten()->NumTemplateArgs));                      \
                                                                               \
    /* Don't need the *TemplatePartialSpecializationHelper, even               \
       though that's our parent class -- we already visit all the              \
       template args here. */                                                  \
    TRY_TO(Traverse##DECLKIND##Helper(D));                                     \
                                                                               \
    /* Instantiations will have been visited with the primary template. */     \
  })

◆ DEF_TRAVERSE_TMPL_SPEC_DECL

#define DEF_TRAVERSE_TMPL_SPEC_DECL	(	TMPLDECLKIND,
		DECLKIND
	)

Value:

  DEF_TRAVERSE_DECL(TMPLDECLKIND##TemplateSpecializationDecl, {                \
    /* For implicit instantiations ("set<int> x;"), we don't want to           \
       recurse at all, since the instatiated template isn't written in         \
       the source code anywhere.  (Note the instatiated *type* --              \
       set<int> -- is written, and will still get a callback of                \
       TemplateSpecializationType).  For explicit instantiations               \
       ("template set<int>;"), we do need a callback, since this               \
       is the only callback that's made for this instantiation.                \
       We use getTypeAsWritten() to distinguish. */                            \
    if (TypeSourceInfo *TSI = D->getTypeAsWritten())                           \
      TRY_TO(TraverseTypeLoc(TSI->getTypeLoc()));                              \
                                                                               \
    if (getDerived().shouldVisitTemplateInstantiations() ||                    \
        D->getTemplateSpecializationKind() == TSK_ExplicitSpecialization) {    \
      /* Traverse base definition for explicit specializations */              \
      TRY_TO(Traverse##DECLKIND##Helper(D));                                   \
    } else {                                                                   \
      TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));            \
                                                                               \
      /* Returning from here skips traversing the                              \
         declaration context of the *TemplateSpecializationDecl                \
         (embedded in the DEF_TRAVERSE_DECL() macro)                           \
         which contains the instantiated members of the template. */           \
      return true;                                                             \
    }                                                                          \
  })

◆ DEF_TRAVERSE_TYPE

#define DEF_TRAVERSE_TYPE	(	TYPE,
		CODE
	)

Value:

  template <typename Derived>                                                  \
  bool RecursiveASTVisitor<Derived>::Traverse##TYPE(TYPE *T) {                 \
    if (!getDerived().shouldTraversePostOrder())                               \
      TRY_TO(WalkUpFrom##TYPE(T));                                             \
    { CODE; }                                                                  \
    if (getDerived().shouldTraversePostOrder())                                \
      TRY_TO(WalkUpFrom##TYPE(T));                                             \
    return true;                                                               \
  }

Definition at line 957 of file RecursiveASTVisitor.h.

◆ DEF_TRAVERSE_TYPELOC

#define DEF_TRAVERSE_TYPELOC	(	TYPE,
		CODE
	)

Value:

  template <typename Derived>                                                  \
  bool RecursiveASTVisitor<Derived>::Traverse##TYPE##Loc(TYPE##Loc TL) {       \
    if (!getDerived().shouldTraversePostOrder()) {                             \
      TRY_TO(WalkUpFrom##TYPE##Loc(TL));                                       \
      if (getDerived().shouldWalkTypesOfTypeLocs())                            \
        TRY_TO(WalkUpFrom##TYPE(const_cast<TYPE *>(TL.getTypePtr())));         \
    }                                                                          \
    { CODE; }                                                                  \
    if (getDerived().shouldTraversePostOrder()) {                              \
      TRY_TO(WalkUpFrom##TYPE##Loc(TL));                                       \
      if (getDerived().shouldWalkTypesOfTypeLocs())                            \
        TRY_TO(WalkUpFrom##TYPE(const_cast<TYPE *>(TL.getTypePtr())));         \
    }                                                                          \
    return true;                                                               \
  }

◆ GEN_CLANG_CLAUSE_CLASS [1/2]

#define GEN_CLANG_CLAUSE_CLASS

Definition at line 494 of file RecursiveASTVisitor.h.

◆ GEN_CLANG_CLAUSE_CLASS [2/2]

#define GEN_CLANG_CLAUSE_CLASS

Definition at line 494 of file RecursiveASTVisitor.h.

◆ INITLISTEXPR

#define INITLISTEXPR	(	CLASS,
		PARENT
	)

Value:

  case Stmt::CLASS##Class:                                                     \
    if (::clang::detail::isSameMethod(&RecursiveASTVisitor::Traverse##CLASS,   \
                                      &Derived::Traverse##CLASS)) {            \
      auto ILE = static_cast<CLASS *>(S);                                      \
      if (auto Syn = ILE->isSemanticForm() ? ILE->getSyntacticForm() : ILE)    \
        TRY_TO(WalkUpFrom##CLASS(Syn));                                        \
      if (auto Sem = ILE->isSemanticForm() ? ILE : ILE->getSemanticForm())     \
        TRY_TO(WalkUpFrom##CLASS(Sem));                                        \
    }                                                                          \
    break;

◆ STMT [1/4]

#define STMT	(	CLASS,
		PARENT
	)	bool Traverse##CLASS(CLASS S, DataRecursionQueue Queue = nullptr);

Definition at line 367 of file RecursiveASTVisitor.h.

◆ STMT [2/4]

#define STMT	(	CLASS,
		PARENT
	)

Value:

  bool WalkUpFrom##CLASS(CLASS *S) {                                           \
    TRY_TO(WalkUpFrom##PARENT(S));                                             \
    TRY_TO(Visit##CLASS(S));                                                   \
    return true;                                                               \
  }                                                                            \
  bool Visit##CLASS(CLASS *S) { return true; }

Definition at line 367 of file RecursiveASTVisitor.h.

◆ STMT [3/4]

#define STMT	(	CLASS,
		PARENT
	)

Value:

case Stmt::CLASS##Class: \

return TRAVERSE_STMT_BASE(CLASS, CLASS, S, Queue);

TRAVERSE_STMT_BASE

#define TRAVERSE_STMT_BASE(NAME, CLASS, VAR, QUEUE)

Definition: RecursiveASTVisitor.h:335

Definition at line 367 of file RecursiveASTVisitor.h.

◆ STMT [4/4]

#define STMT	(	CLASS,
		PARENT
	)

Value:

  case Stmt::CLASS##Class:                                                     \
    if (::clang::detail::isSameMethod(&RecursiveASTVisitor::Traverse##CLASS,   \
                                      &Derived::Traverse##CLASS)) {            \
      TRY_TO(WalkUpFrom##CLASS(static_cast<CLASS *>(S)));                      \
    }                                                                          \
    break;

Definition at line 367 of file RecursiveASTVisitor.h.

◆ TRAVERSE_STMT_BASE

#define TRAVERSE_STMT_BASE	(	NAME,
		CLASS,
		VAR,
		QUEUE
	)

Value:

  (::clang::detail::has_same_member_pointer_type<                              \
       decltype(&RecursiveASTVisitor::Traverse##NAME),                         \
       decltype(&Derived::Traverse##NAME)>::value                              \
       ? static_cast<std::conditional_t<                                       \
             ::clang::detail::has_same_member_pointer_type<                    \
                 decltype(&RecursiveASTVisitor::Traverse##NAME),               \
                 decltype(&Derived::Traverse##NAME)>::value,                   \
             Derived &, RecursiveASTVisitor &>>(*this)                         \
             .Traverse##NAME(static_cast<CLASS *>(VAR), QUEUE)                 \
       : getDerived().Traverse##NAME(static_cast<CLASS *>(VAR)))

Definition at line 335 of file RecursiveASTVisitor.h.

◆ TRY_TO

#define TRY_TO ( CALL_EXPR )

Value:

  do {                                                                         \
    if (!getDerived().CALL_EXPR)                                               \
      return false;                                                            \
  } while (false)

Definition at line 58 of file RecursiveASTVisitor.h.

◆ TRY_TO_TRAVERSE_OR_ENQUEUE_STMT

#define TRY_TO_TRAVERSE_OR_ENQUEUE_STMT ( S )

Value:

  do {                                                                         \
    if (!TRAVERSE_STMT_BASE(Stmt, Stmt, S, Queue))                             \
      return false;                                                            \
  } while (false)

Definition at line 350 of file RecursiveASTVisitor.h.

◆ TYPE [1/4]

#define TYPE	(	CLASS,
		BASE
	)	bool Traverse##CLASS##Type(CLASS##Type *T);

Definition at line 422 of file RecursiveASTVisitor.h.

◆ TYPE [2/4]

#define TYPE	(	CLASS,
		BASE
	)

Value:

  bool WalkUpFrom##CLASS##Type(CLASS##Type *T) {                               \
    TRY_TO(WalkUpFrom##BASE(T));                                               \
    TRY_TO(Visit##CLASS##Type(T));                                             \
    return true;                                                               \
  }                                                                            \
  bool Visit##CLASS##Type(CLASS##Type *T) { return true; }

Definition at line 422 of file RecursiveASTVisitor.h.

◆ TYPE [3/4]

#define TYPE	(	CLASS,
		BASE
	)

Value:

  bool WalkUpFrom##CLASS##TypeLoc(CLASS##TypeLoc TL) {                         \
    TRY_TO(WalkUpFrom##BASE##Loc(TL));                                         \
    TRY_TO(Visit##CLASS##TypeLoc(TL));                                         \
    return true;                                                               \
  }                                                                            \
  bool Visit##CLASS##TypeLoc(CLASS##TypeLoc TL) { return true; }

Definition at line 422 of file RecursiveASTVisitor.h.

◆ TYPE [4/4]

#define TYPE	(	CLASS,
		BASE
	)

Value:

  case Type::CLASS:                                                            \
    return getDerived().Traverse##CLASS##Type(                                 \
        static_cast<CLASS##Type *>(const_cast<Type *>(T.getTypePtr())));

Definition at line 422 of file RecursiveASTVisitor.h.

◆ TYPELOC [1/2]

#define TYPELOC	(	CLASS,
		BASE
	)	bool Traverse##CLASS##TypeLoc(CLASS##TypeLoc TL);

Definition at line 402 of file RecursiveASTVisitor.h.

◆ TYPELOC [2/2]

#define TYPELOC	(	CLASS,
		BASE
	)

Value:

case TypeLoc::CLASS: \

return getDerived().Traverse##CLASS##TypeLoc(TL.castAs<CLASS##TypeLoc>());

Definition at line 402 of file RecursiveASTVisitor.h.

◆ VISITORCLASS

#define VISITORCLASS RecursiveASTVisitor

Definition at line 731 of file RecursiveASTVisitor.h.

Classes

Namespaces

Macros

Functions

Variables

Macro Definition Documentation

◆ ABSTRACT_DECL [1/2]

◆ ABSTRACT_DECL [2/2]

◆ ABSTRACT_STMT [1/3]

◆ ABSTRACT_STMT [2/3]

◆ ABSTRACT_STMT [3/3]

◆ ABSTRACT_TYPE [1/2]

◆ ABSTRACT_TYPE [2/2]

◆ ABSTRACT_TYPELOC [1/2]

◆ ABSTRACT_TYPELOC [2/2]

◆ ATTR_VISITOR_DECLS_ONLY

◆ CLAUSE_CLASS [1/2]

◆ CLAUSE_CLASS [2/2]

◆ CLAUSE_NO_CLASS

◆ DECL [1/3]

◆ DECL [2/3]

◆ DECL [3/3]

◆ DEF_TRAVERSE_DECL

◆ DEF_TRAVERSE_STMT

◆ DEF_TRAVERSE_TMPL_DECL

◆ DEF_TRAVERSE_TMPL_INST

◆ DEF_TRAVERSE_TMPL_PART_SPEC_DECL

◆ DEF_TRAVERSE_TMPL_SPEC_DECL

◆ DEF_TRAVERSE_TYPE

◆ DEF_TRAVERSE_TYPELOC

◆ GEN_CLANG_CLAUSE_CLASS [1/2]

◆ GEN_CLANG_CLAUSE_CLASS [2/2]

◆ INITLISTEXPR

◆ STMT [1/4]

◆ STMT [2/4]

◆ STMT [3/4]

◆ STMT [4/4]

◆ TRAVERSE_STMT_BASE

◆ TRY_TO

◆ TRY_TO_TRAVERSE_OR_ENQUEUE_STMT

◆ TYPE [1/4]

◆ TYPE [2/4]

◆ TYPE [3/4]

◆ TYPE [4/4]

◆ TYPELOC [1/2]

◆ TYPELOC [2/2]

◆ VISITORCLASS