Created
July 18, 2022 17:07
-
-
Save vitonzhangtt/8a1434c22d956bad8cd52259fc7044b0 to your computer and use it in GitHub Desktop.
The result of preprocessing RecursiveASTVisitor.h using clang -E.
This file has been truncated, but you can view the full file.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
namespace clang { | |
namespace detail { | |
template <typename T, typename U> | |
struct has_same_member_pointer_type : std::false_type {}; | |
template <typename T, typename U, typename R, typename... P> | |
struct has_same_member_pointer_type<R (T::*)(P...), R (U::*)(P...)> | |
: std::true_type {}; | |
template <bool has_same_type> struct is_same_method_impl { | |
template <typename FirstMethodPtrTy, typename SecondMethodPtrTy> | |
static bool isSameMethod(FirstMethodPtrTy FirstMethodPtr, | |
SecondMethodPtrTy SecondMethodPtr) { | |
return false; | |
} | |
}; | |
template <> struct is_same_method_impl<true> { | |
template <typename FirstMethodPtrTy, typename SecondMethodPtrTy> | |
static bool isSameMethod(FirstMethodPtrTy FirstMethodPtr, | |
SecondMethodPtrTy SecondMethodPtr) { | |
return FirstMethodPtr == SecondMethodPtr; | |
} | |
}; | |
template <typename FirstMethodPtrTy, typename SecondMethodPtrTy> | |
bool isSameMethod(FirstMethodPtrTy FirstMethodPtr, | |
SecondMethodPtrTy SecondMethodPtr) { | |
return is_same_method_impl<has_same_member_pointer_type< | |
FirstMethodPtrTy, | |
SecondMethodPtrTy>::value>::isSameMethod(FirstMethodPtr, SecondMethodPtr); | |
} | |
} | |
template <typename Derived> class RecursiveASTVisitor { | |
public: | |
typedef SmallVectorImpl<llvm::PointerIntPair<Stmt *, 1, bool>> | |
DataRecursionQueue; | |
Derived &getDerived() { return *static_cast<Derived *>(this); } | |
bool shouldVisitTemplateInstantiations() const { return false; } | |
bool shouldWalkTypesOfTypeLocs() const { return true; } | |
bool shouldVisitImplicitCode() const { return false; } | |
bool shouldVisitLambdaBody() const { return true; } | |
bool shouldTraversePostOrder() const { return false; } | |
bool TraverseAST(ASTContext &AST) { | |
return getDerived().TraverseDecl(AST.getTranslationUnitDecl()); | |
} | |
bool TraverseStmt(Stmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool dataTraverseStmtPre(Stmt *S) { return true; } | |
bool dataTraverseStmtPost(Stmt *S) { return true; } | |
bool TraverseType(QualType T); | |
bool TraverseTypeLoc(TypeLoc TL); | |
bool TraverseAttr(Attr *At); | |
bool TraverseDecl(Decl *D); | |
bool TraverseNestedNameSpecifier(NestedNameSpecifier *NNS); | |
bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS); | |
bool TraverseDeclarationNameInfo(DeclarationNameInfo NameInfo); | |
bool TraverseTemplateName(TemplateName Template); | |
bool TraverseTemplateArgument(const TemplateArgument &Arg); | |
bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &ArgLoc); | |
bool TraverseTemplateArguments(const TemplateArgument *Args, | |
unsigned NumArgs); | |
bool TraverseCXXBaseSpecifier(const CXXBaseSpecifier &Base); | |
bool TraverseConstructorInitializer(CXXCtorInitializer *Init); | |
bool TraverseLambdaCapture(LambdaExpr *LE, const LambdaCapture *C, | |
Expr *Init); | |
bool TraverseSynOrSemInitListExpr(InitListExpr *S, | |
DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseConceptReference(const ConceptReference &C); | |
bool VisitAttr(Attr *A) { return true; } | |
bool TraverseAArch64VectorPcsAttr(AArch64VectorPcsAttr *A); | |
bool VisitAArch64VectorPcsAttr(AArch64VectorPcsAttr *A) { | |
return true; | |
} | |
bool TraverseAMDGPUFlatWorkGroupSizeAttr(AMDGPUFlatWorkGroupSizeAttr *A); | |
bool VisitAMDGPUFlatWorkGroupSizeAttr(AMDGPUFlatWorkGroupSizeAttr *A) { | |
return true; | |
} | |
bool TraverseAMDGPUNumSGPRAttr(AMDGPUNumSGPRAttr *A); | |
bool VisitAMDGPUNumSGPRAttr(AMDGPUNumSGPRAttr *A) { | |
return true; | |
} | |
bool TraverseAMDGPUNumVGPRAttr(AMDGPUNumVGPRAttr *A); | |
bool VisitAMDGPUNumVGPRAttr(AMDGPUNumVGPRAttr *A) { | |
return true; | |
} | |
bool TraverseAMDGPUWavesPerEUAttr(AMDGPUWavesPerEUAttr *A); | |
bool VisitAMDGPUWavesPerEUAttr(AMDGPUWavesPerEUAttr *A) { | |
return true; | |
} | |
bool TraverseARMInterruptAttr(ARMInterruptAttr *A); | |
bool VisitARMInterruptAttr(ARMInterruptAttr *A) { | |
return true; | |
} | |
bool TraverseAVRInterruptAttr(AVRInterruptAttr *A); | |
bool VisitAVRInterruptAttr(AVRInterruptAttr *A) { | |
return true; | |
} | |
bool TraverseAVRSignalAttr(AVRSignalAttr *A); | |
bool VisitAVRSignalAttr(AVRSignalAttr *A) { | |
return true; | |
} | |
bool TraverseAbiTagAttr(AbiTagAttr *A); | |
bool VisitAbiTagAttr(AbiTagAttr *A) { | |
return true; | |
} | |
bool TraverseAcquireCapabilityAttr(AcquireCapabilityAttr *A); | |
bool VisitAcquireCapabilityAttr(AcquireCapabilityAttr *A) { | |
return true; | |
} | |
bool TraverseAcquireHandleAttr(AcquireHandleAttr *A); | |
bool VisitAcquireHandleAttr(AcquireHandleAttr *A) { | |
return true; | |
} | |
bool TraverseAcquiredAfterAttr(AcquiredAfterAttr *A); | |
bool VisitAcquiredAfterAttr(AcquiredAfterAttr *A) { | |
return true; | |
} | |
bool TraverseAcquiredBeforeAttr(AcquiredBeforeAttr *A); | |
bool VisitAcquiredBeforeAttr(AcquiredBeforeAttr *A) { | |
return true; | |
} | |
bool TraverseAddressSpaceAttr(AddressSpaceAttr *A); | |
bool VisitAddressSpaceAttr(AddressSpaceAttr *A) { | |
return true; | |
} | |
bool TraverseAliasAttr(AliasAttr *A); | |
bool VisitAliasAttr(AliasAttr *A) { | |
return true; | |
} | |
bool TraverseAlignMac68kAttr(AlignMac68kAttr *A); | |
bool VisitAlignMac68kAttr(AlignMac68kAttr *A) { | |
return true; | |
} | |
bool TraverseAlignNaturalAttr(AlignNaturalAttr *A); | |
bool VisitAlignNaturalAttr(AlignNaturalAttr *A) { | |
return true; | |
} | |
bool TraverseAlignValueAttr(AlignValueAttr *A); | |
bool VisitAlignValueAttr(AlignValueAttr *A) { | |
return true; | |
} | |
bool TraverseAlignedAttr(AlignedAttr *A); | |
bool VisitAlignedAttr(AlignedAttr *A) { | |
return true; | |
} | |
bool TraverseAllocAlignAttr(AllocAlignAttr *A); | |
bool VisitAllocAlignAttr(AllocAlignAttr *A) { | |
return true; | |
} | |
bool TraverseAllocSizeAttr(AllocSizeAttr *A); | |
bool VisitAllocSizeAttr(AllocSizeAttr *A) { | |
return true; | |
} | |
bool TraverseAlwaysDestroyAttr(AlwaysDestroyAttr *A); | |
bool VisitAlwaysDestroyAttr(AlwaysDestroyAttr *A) { | |
return true; | |
} | |
bool TraverseAlwaysInlineAttr(AlwaysInlineAttr *A); | |
bool VisitAlwaysInlineAttr(AlwaysInlineAttr *A) { | |
return true; | |
} | |
bool TraverseAnalyzerNoReturnAttr(AnalyzerNoReturnAttr *A); | |
bool VisitAnalyzerNoReturnAttr(AnalyzerNoReturnAttr *A) { | |
return true; | |
} | |
bool TraverseAnnotateAttr(AnnotateAttr *A); | |
bool VisitAnnotateAttr(AnnotateAttr *A) { | |
return true; | |
} | |
bool TraverseAnyX86InterruptAttr(AnyX86InterruptAttr *A); | |
bool VisitAnyX86InterruptAttr(AnyX86InterruptAttr *A) { | |
return true; | |
} | |
bool TraverseAnyX86NoCallerSavedRegistersAttr(AnyX86NoCallerSavedRegistersAttr *A); | |
bool VisitAnyX86NoCallerSavedRegistersAttr(AnyX86NoCallerSavedRegistersAttr *A) { | |
return true; | |
} | |
bool TraverseAnyX86NoCfCheckAttr(AnyX86NoCfCheckAttr *A); | |
bool VisitAnyX86NoCfCheckAttr(AnyX86NoCfCheckAttr *A) { | |
return true; | |
} | |
bool TraverseArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A); | |
bool VisitArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A) { | |
return true; | |
} | |
bool TraverseArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *A); | |
bool VisitArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *A) { | |
return true; | |
} | |
bool TraverseArmBuiltinAliasAttr(ArmBuiltinAliasAttr *A); | |
bool VisitArmBuiltinAliasAttr(ArmBuiltinAliasAttr *A) { | |
return true; | |
} | |
bool TraverseArmMveStrictPolymorphismAttr(ArmMveStrictPolymorphismAttr *A); | |
bool VisitArmMveStrictPolymorphismAttr(ArmMveStrictPolymorphismAttr *A) { | |
return true; | |
} | |
bool TraverseArtificialAttr(ArtificialAttr *A); | |
bool VisitArtificialAttr(ArtificialAttr *A) { | |
return true; | |
} | |
bool TraverseAsmLabelAttr(AsmLabelAttr *A); | |
bool VisitAsmLabelAttr(AsmLabelAttr *A) { | |
return true; | |
} | |
bool TraverseAssertCapabilityAttr(AssertCapabilityAttr *A); | |
bool VisitAssertCapabilityAttr(AssertCapabilityAttr *A) { | |
return true; | |
} | |
bool TraverseAssertExclusiveLockAttr(AssertExclusiveLockAttr *A); | |
bool VisitAssertExclusiveLockAttr(AssertExclusiveLockAttr *A) { | |
return true; | |
} | |
bool TraverseAssertSharedLockAttr(AssertSharedLockAttr *A); | |
bool VisitAssertSharedLockAttr(AssertSharedLockAttr *A) { | |
return true; | |
} | |
bool TraverseAssumeAlignedAttr(AssumeAlignedAttr *A); | |
bool VisitAssumeAlignedAttr(AssumeAlignedAttr *A) { | |
return true; | |
} | |
bool TraverseAssumptionAttr(AssumptionAttr *A); | |
bool VisitAssumptionAttr(AssumptionAttr *A) { | |
return true; | |
} | |
bool TraverseAvailabilityAttr(AvailabilityAttr *A); | |
bool VisitAvailabilityAttr(AvailabilityAttr *A) { | |
return true; | |
} | |
bool TraverseBPFPreserveAccessIndexAttr(BPFPreserveAccessIndexAttr *A); | |
bool VisitBPFPreserveAccessIndexAttr(BPFPreserveAccessIndexAttr *A) { | |
return true; | |
} | |
bool TraverseBlocksAttr(BlocksAttr *A); | |
bool VisitBlocksAttr(BlocksAttr *A) { | |
return true; | |
} | |
bool TraverseBuiltinAttr(BuiltinAttr *A); | |
bool VisitBuiltinAttr(BuiltinAttr *A) { | |
return true; | |
} | |
bool TraverseBuiltinAliasAttr(BuiltinAliasAttr *A); | |
bool VisitBuiltinAliasAttr(BuiltinAliasAttr *A) { | |
return true; | |
} | |
bool TraverseC11NoReturnAttr(C11NoReturnAttr *A); | |
bool VisitC11NoReturnAttr(C11NoReturnAttr *A) { | |
return true; | |
} | |
bool TraverseCDeclAttr(CDeclAttr *A); | |
bool VisitCDeclAttr(CDeclAttr *A) { | |
return true; | |
} | |
bool TraverseCFAuditedTransferAttr(CFAuditedTransferAttr *A); | |
bool VisitCFAuditedTransferAttr(CFAuditedTransferAttr *A) { | |
return true; | |
} | |
bool TraverseCFConsumedAttr(CFConsumedAttr *A); | |
bool VisitCFConsumedAttr(CFConsumedAttr *A) { | |
return true; | |
} | |
bool TraverseCFGuardAttr(CFGuardAttr *A); | |
bool VisitCFGuardAttr(CFGuardAttr *A) { | |
return true; | |
} | |
bool TraverseCFICanonicalJumpTableAttr(CFICanonicalJumpTableAttr *A); | |
bool VisitCFICanonicalJumpTableAttr(CFICanonicalJumpTableAttr *A) { | |
return true; | |
} | |
bool TraverseCFReturnsNotRetainedAttr(CFReturnsNotRetainedAttr *A); | |
bool VisitCFReturnsNotRetainedAttr(CFReturnsNotRetainedAttr *A) { | |
return true; | |
} | |
bool TraverseCFReturnsRetainedAttr(CFReturnsRetainedAttr *A); | |
bool VisitCFReturnsRetainedAttr(CFReturnsRetainedAttr *A) { | |
return true; | |
} | |
bool TraverseCFUnknownTransferAttr(CFUnknownTransferAttr *A); | |
bool VisitCFUnknownTransferAttr(CFUnknownTransferAttr *A) { | |
return true; | |
} | |
bool TraverseCPUDispatchAttr(CPUDispatchAttr *A); | |
bool VisitCPUDispatchAttr(CPUDispatchAttr *A) { | |
return true; | |
} | |
bool TraverseCPUSpecificAttr(CPUSpecificAttr *A); | |
bool VisitCPUSpecificAttr(CPUSpecificAttr *A) { | |
return true; | |
} | |
bool TraverseCUDAConstantAttr(CUDAConstantAttr *A); | |
bool VisitCUDAConstantAttr(CUDAConstantAttr *A) { | |
return true; | |
} | |
bool TraverseCUDADeviceAttr(CUDADeviceAttr *A); | |
bool VisitCUDADeviceAttr(CUDADeviceAttr *A) { | |
return true; | |
} | |
bool TraverseCUDADeviceBuiltinSurfaceTypeAttr(CUDADeviceBuiltinSurfaceTypeAttr *A); | |
bool VisitCUDADeviceBuiltinSurfaceTypeAttr(CUDADeviceBuiltinSurfaceTypeAttr *A) { | |
return true; | |
} | |
bool TraverseCUDADeviceBuiltinTextureTypeAttr(CUDADeviceBuiltinTextureTypeAttr *A); | |
bool VisitCUDADeviceBuiltinTextureTypeAttr(CUDADeviceBuiltinTextureTypeAttr *A) { | |
return true; | |
} | |
bool TraverseCUDAGlobalAttr(CUDAGlobalAttr *A); | |
bool VisitCUDAGlobalAttr(CUDAGlobalAttr *A) { | |
return true; | |
} | |
bool TraverseCUDAHostAttr(CUDAHostAttr *A); | |
bool VisitCUDAHostAttr(CUDAHostAttr *A) { | |
return true; | |
} | |
bool TraverseCUDAInvalidTargetAttr(CUDAInvalidTargetAttr *A); | |
bool VisitCUDAInvalidTargetAttr(CUDAInvalidTargetAttr *A) { | |
return true; | |
} | |
bool TraverseCUDALaunchBoundsAttr(CUDALaunchBoundsAttr *A); | |
bool VisitCUDALaunchBoundsAttr(CUDALaunchBoundsAttr *A) { | |
return true; | |
} | |
bool TraverseCUDASharedAttr(CUDASharedAttr *A); | |
bool VisitCUDASharedAttr(CUDASharedAttr *A) { | |
return true; | |
} | |
bool TraverseCXX11NoReturnAttr(CXX11NoReturnAttr *A); | |
bool VisitCXX11NoReturnAttr(CXX11NoReturnAttr *A) { | |
return true; | |
} | |
bool TraverseCallableWhenAttr(CallableWhenAttr *A); | |
bool VisitCallableWhenAttr(CallableWhenAttr *A) { | |
return true; | |
} | |
bool TraverseCallbackAttr(CallbackAttr *A); | |
bool VisitCallbackAttr(CallbackAttr *A) { | |
return true; | |
} | |
bool TraverseCalledOnceAttr(CalledOnceAttr *A); | |
bool VisitCalledOnceAttr(CalledOnceAttr *A) { | |
return true; | |
} | |
bool TraverseCapabilityAttr(CapabilityAttr *A); | |
bool VisitCapabilityAttr(CapabilityAttr *A) { | |
return true; | |
} | |
bool TraverseCapturedRecordAttr(CapturedRecordAttr *A); | |
bool VisitCapturedRecordAttr(CapturedRecordAttr *A) { | |
return true; | |
} | |
bool TraverseCarriesDependencyAttr(CarriesDependencyAttr *A); | |
bool VisitCarriesDependencyAttr(CarriesDependencyAttr *A) { | |
return true; | |
} | |
bool TraverseCleanupAttr(CleanupAttr *A); | |
bool VisitCleanupAttr(CleanupAttr *A) { | |
return true; | |
} | |
bool TraverseCmseNSCallAttr(CmseNSCallAttr *A); | |
bool VisitCmseNSCallAttr(CmseNSCallAttr *A) { | |
return true; | |
} | |
bool TraverseCmseNSEntryAttr(CmseNSEntryAttr *A); | |
bool VisitCmseNSEntryAttr(CmseNSEntryAttr *A) { | |
return true; | |
} | |
bool TraverseCodeSegAttr(CodeSegAttr *A); | |
bool VisitCodeSegAttr(CodeSegAttr *A) { | |
return true; | |
} | |
bool TraverseColdAttr(ColdAttr *A); | |
bool VisitColdAttr(ColdAttr *A) { | |
return true; | |
} | |
bool TraverseCommonAttr(CommonAttr *A); | |
bool VisitCommonAttr(CommonAttr *A) { | |
return true; | |
} | |
bool TraverseConstAttr(ConstAttr *A); | |
bool VisitConstAttr(ConstAttr *A) { | |
return true; | |
} | |
bool TraverseConstInitAttr(ConstInitAttr *A); | |
bool VisitConstInitAttr(ConstInitAttr *A) { | |
return true; | |
} | |
bool TraverseConstructorAttr(ConstructorAttr *A); | |
bool VisitConstructorAttr(ConstructorAttr *A) { | |
return true; | |
} | |
bool TraverseConsumableAttr(ConsumableAttr *A); | |
bool VisitConsumableAttr(ConsumableAttr *A) { | |
return true; | |
} | |
bool TraverseConsumableAutoCastAttr(ConsumableAutoCastAttr *A); | |
bool VisitConsumableAutoCastAttr(ConsumableAutoCastAttr *A) { | |
return true; | |
} | |
bool TraverseConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A); | |
bool VisitConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A) { | |
return true; | |
} | |
bool TraverseConvergentAttr(ConvergentAttr *A); | |
bool VisitConvergentAttr(ConvergentAttr *A) { | |
return true; | |
} | |
bool TraverseDLLExportAttr(DLLExportAttr *A); | |
bool VisitDLLExportAttr(DLLExportAttr *A) { | |
return true; | |
} | |
bool TraverseDLLExportStaticLocalAttr(DLLExportStaticLocalAttr *A); | |
bool VisitDLLExportStaticLocalAttr(DLLExportStaticLocalAttr *A) { | |
return true; | |
} | |
bool TraverseDLLImportAttr(DLLImportAttr *A); | |
bool VisitDLLImportAttr(DLLImportAttr *A) { | |
return true; | |
} | |
bool TraverseDLLImportStaticLocalAttr(DLLImportStaticLocalAttr *A); | |
bool VisitDLLImportStaticLocalAttr(DLLImportStaticLocalAttr *A) { | |
return true; | |
} | |
bool TraverseDeprecatedAttr(DeprecatedAttr *A); | |
bool VisitDeprecatedAttr(DeprecatedAttr *A) { | |
return true; | |
} | |
bool TraverseDestructorAttr(DestructorAttr *A); | |
bool VisitDestructorAttr(DestructorAttr *A) { | |
return true; | |
} | |
bool TraverseDiagnoseIfAttr(DiagnoseIfAttr *A); | |
bool VisitDiagnoseIfAttr(DiagnoseIfAttr *A) { | |
return true; | |
} | |
bool TraverseDisableTailCallsAttr(DisableTailCallsAttr *A); | |
bool VisitDisableTailCallsAttr(DisableTailCallsAttr *A) { | |
return true; | |
} | |
bool TraverseEmptyBasesAttr(EmptyBasesAttr *A); | |
bool VisitEmptyBasesAttr(EmptyBasesAttr *A) { | |
return true; | |
} | |
bool TraverseEnableIfAttr(EnableIfAttr *A); | |
bool VisitEnableIfAttr(EnableIfAttr *A) { | |
return true; | |
} | |
bool TraverseEnforceTCBAttr(EnforceTCBAttr *A); | |
bool VisitEnforceTCBAttr(EnforceTCBAttr *A) { | |
return true; | |
} | |
bool TraverseEnforceTCBLeafAttr(EnforceTCBLeafAttr *A); | |
bool VisitEnforceTCBLeafAttr(EnforceTCBLeafAttr *A) { | |
return true; | |
} | |
bool TraverseEnumExtensibilityAttr(EnumExtensibilityAttr *A); | |
bool VisitEnumExtensibilityAttr(EnumExtensibilityAttr *A) { | |
return true; | |
} | |
bool TraverseExcludeFromExplicitInstantiationAttr(ExcludeFromExplicitInstantiationAttr *A); | |
bool VisitExcludeFromExplicitInstantiationAttr(ExcludeFromExplicitInstantiationAttr *A) { | |
return true; | |
} | |
bool TraverseExclusiveTrylockFunctionAttr(ExclusiveTrylockFunctionAttr *A); | |
bool VisitExclusiveTrylockFunctionAttr(ExclusiveTrylockFunctionAttr *A) { | |
return true; | |
} | |
bool TraverseExternalSourceSymbolAttr(ExternalSourceSymbolAttr *A); | |
bool VisitExternalSourceSymbolAttr(ExternalSourceSymbolAttr *A) { | |
return true; | |
} | |
bool TraverseFallThroughAttr(FallThroughAttr *A); | |
bool VisitFallThroughAttr(FallThroughAttr *A) { | |
return true; | |
} | |
bool TraverseFastCallAttr(FastCallAttr *A); | |
bool VisitFastCallAttr(FastCallAttr *A) { | |
return true; | |
} | |
bool TraverseFinalAttr(FinalAttr *A); | |
bool VisitFinalAttr(FinalAttr *A) { | |
return true; | |
} | |
bool TraverseFlagEnumAttr(FlagEnumAttr *A); | |
bool VisitFlagEnumAttr(FlagEnumAttr *A) { | |
return true; | |
} | |
bool TraverseFlattenAttr(FlattenAttr *A); | |
bool VisitFlattenAttr(FlattenAttr *A) { | |
return true; | |
} | |
bool TraverseFormatAttr(FormatAttr *A); | |
bool VisitFormatAttr(FormatAttr *A) { | |
return true; | |
} | |
bool TraverseFormatArgAttr(FormatArgAttr *A); | |
bool VisitFormatArgAttr(FormatArgAttr *A) { | |
return true; | |
} | |
bool TraverseGNUInlineAttr(GNUInlineAttr *A); | |
bool VisitGNUInlineAttr(GNUInlineAttr *A) { | |
return true; | |
} | |
bool TraverseGuardedByAttr(GuardedByAttr *A); | |
bool VisitGuardedByAttr(GuardedByAttr *A) { | |
return true; | |
} | |
bool TraverseGuardedVarAttr(GuardedVarAttr *A); | |
bool VisitGuardedVarAttr(GuardedVarAttr *A) { | |
return true; | |
} | |
bool TraverseHIPManagedAttr(HIPManagedAttr *A); | |
bool VisitHIPManagedAttr(HIPManagedAttr *A) { | |
return true; | |
} | |
bool TraverseHotAttr(HotAttr *A); | |
bool VisitHotAttr(HotAttr *A) { | |
return true; | |
} | |
bool TraverseIBActionAttr(IBActionAttr *A); | |
bool VisitIBActionAttr(IBActionAttr *A) { | |
return true; | |
} | |
bool TraverseIBOutletAttr(IBOutletAttr *A); | |
bool VisitIBOutletAttr(IBOutletAttr *A) { | |
return true; | |
} | |
bool TraverseIBOutletCollectionAttr(IBOutletCollectionAttr *A); | |
bool VisitIBOutletCollectionAttr(IBOutletCollectionAttr *A) { | |
return true; | |
} | |
bool TraverseIFuncAttr(IFuncAttr *A); | |
bool VisitIFuncAttr(IFuncAttr *A) { | |
return true; | |
} | |
bool TraverseInitPriorityAttr(InitPriorityAttr *A); | |
bool VisitInitPriorityAttr(InitPriorityAttr *A) { | |
return true; | |
} | |
bool TraverseInitSegAttr(InitSegAttr *A); | |
bool VisitInitSegAttr(InitSegAttr *A) { | |
return true; | |
} | |
bool TraverseIntelOclBiccAttr(IntelOclBiccAttr *A); | |
bool VisitIntelOclBiccAttr(IntelOclBiccAttr *A) { | |
return true; | |
} | |
bool TraverseInternalLinkageAttr(InternalLinkageAttr *A); | |
bool VisitInternalLinkageAttr(InternalLinkageAttr *A) { | |
return true; | |
} | |
bool TraverseLTOVisibilityPublicAttr(LTOVisibilityPublicAttr *A); | |
bool VisitLTOVisibilityPublicAttr(LTOVisibilityPublicAttr *A) { | |
return true; | |
} | |
bool TraverseLayoutVersionAttr(LayoutVersionAttr *A); | |
bool VisitLayoutVersionAttr(LayoutVersionAttr *A) { | |
return true; | |
} | |
bool TraverseLeafAttr(LeafAttr *A); | |
bool VisitLeafAttr(LeafAttr *A) { | |
return true; | |
} | |
bool TraverseLifetimeBoundAttr(LifetimeBoundAttr *A); | |
bool VisitLifetimeBoundAttr(LifetimeBoundAttr *A) { | |
return true; | |
} | |
bool TraverseLikelyAttr(LikelyAttr *A); | |
bool VisitLikelyAttr(LikelyAttr *A) { | |
return true; | |
} | |
bool TraverseLoaderUninitializedAttr(LoaderUninitializedAttr *A); | |
bool VisitLoaderUninitializedAttr(LoaderUninitializedAttr *A) { | |
return true; | |
} | |
bool TraverseLockReturnedAttr(LockReturnedAttr *A); | |
bool VisitLockReturnedAttr(LockReturnedAttr *A) { | |
return true; | |
} | |
bool TraverseLocksExcludedAttr(LocksExcludedAttr *A); | |
bool VisitLocksExcludedAttr(LocksExcludedAttr *A) { | |
return true; | |
} | |
bool TraverseLoopHintAttr(LoopHintAttr *A); | |
bool VisitLoopHintAttr(LoopHintAttr *A) { | |
return true; | |
} | |
bool TraverseM68kInterruptAttr(M68kInterruptAttr *A); | |
bool VisitM68kInterruptAttr(M68kInterruptAttr *A) { | |
return true; | |
} | |
bool TraverseMIGServerRoutineAttr(MIGServerRoutineAttr *A); | |
bool VisitMIGServerRoutineAttr(MIGServerRoutineAttr *A) { | |
return true; | |
} | |
bool TraverseMSABIAttr(MSABIAttr *A); | |
bool VisitMSABIAttr(MSABIAttr *A) { | |
return true; | |
} | |
bool TraverseMSAllocatorAttr(MSAllocatorAttr *A); | |
bool VisitMSAllocatorAttr(MSAllocatorAttr *A) { | |
return true; | |
} | |
bool TraverseMSInheritanceAttr(MSInheritanceAttr *A); | |
bool VisitMSInheritanceAttr(MSInheritanceAttr *A) { | |
return true; | |
} | |
bool TraverseMSNoVTableAttr(MSNoVTableAttr *A); | |
bool VisitMSNoVTableAttr(MSNoVTableAttr *A) { | |
return true; | |
} | |
bool TraverseMSP430InterruptAttr(MSP430InterruptAttr *A); | |
bool VisitMSP430InterruptAttr(MSP430InterruptAttr *A) { | |
return true; | |
} | |
bool TraverseMSStructAttr(MSStructAttr *A); | |
bool VisitMSStructAttr(MSStructAttr *A) { | |
return true; | |
} | |
bool TraverseMSVtorDispAttr(MSVtorDispAttr *A); | |
bool VisitMSVtorDispAttr(MSVtorDispAttr *A) { | |
return true; | |
} | |
bool TraverseMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A); | |
bool VisitMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A) { | |
return true; | |
} | |
bool TraverseMayAliasAttr(MayAliasAttr *A); | |
bool VisitMayAliasAttr(MayAliasAttr *A) { | |
return true; | |
} | |
bool TraverseMicroMipsAttr(MicroMipsAttr *A); | |
bool VisitMicroMipsAttr(MicroMipsAttr *A) { | |
return true; | |
} | |
bool TraverseMinSizeAttr(MinSizeAttr *A); | |
bool VisitMinSizeAttr(MinSizeAttr *A) { | |
return true; | |
} | |
bool TraverseMinVectorWidthAttr(MinVectorWidthAttr *A); | |
bool VisitMinVectorWidthAttr(MinVectorWidthAttr *A) { | |
return true; | |
} | |
bool TraverseMips16Attr(Mips16Attr *A); | |
bool VisitMips16Attr(Mips16Attr *A) { | |
return true; | |
} | |
bool TraverseMipsInterruptAttr(MipsInterruptAttr *A); | |
bool VisitMipsInterruptAttr(MipsInterruptAttr *A) { | |
return true; | |
} | |
bool TraverseMipsLongCallAttr(MipsLongCallAttr *A); | |
bool VisitMipsLongCallAttr(MipsLongCallAttr *A) { | |
return true; | |
} | |
bool TraverseMipsShortCallAttr(MipsShortCallAttr *A); | |
bool VisitMipsShortCallAttr(MipsShortCallAttr *A) { | |
return true; | |
} | |
bool TraverseModeAttr(ModeAttr *A); | |
bool VisitModeAttr(ModeAttr *A) { | |
return true; | |
} | |
bool TraverseMustTailAttr(MustTailAttr *A); | |
bool VisitMustTailAttr(MustTailAttr *A) { | |
return true; | |
} | |
bool TraverseNSConsumedAttr(NSConsumedAttr *A); | |
bool VisitNSConsumedAttr(NSConsumedAttr *A) { | |
return true; | |
} | |
bool TraverseNSConsumesSelfAttr(NSConsumesSelfAttr *A); | |
bool VisitNSConsumesSelfAttr(NSConsumesSelfAttr *A) { | |
return true; | |
} | |
bool TraverseNSErrorDomainAttr(NSErrorDomainAttr *A); | |
bool VisitNSErrorDomainAttr(NSErrorDomainAttr *A) { | |
return true; | |
} | |
bool TraverseNSReturnsAutoreleasedAttr(NSReturnsAutoreleasedAttr *A); | |
bool VisitNSReturnsAutoreleasedAttr(NSReturnsAutoreleasedAttr *A) { | |
return true; | |
} | |
bool TraverseNSReturnsNotRetainedAttr(NSReturnsNotRetainedAttr *A); | |
bool VisitNSReturnsNotRetainedAttr(NSReturnsNotRetainedAttr *A) { | |
return true; | |
} | |
bool TraverseNSReturnsRetainedAttr(NSReturnsRetainedAttr *A); | |
bool VisitNSReturnsRetainedAttr(NSReturnsRetainedAttr *A) { | |
return true; | |
} | |
bool TraverseNakedAttr(NakedAttr *A); | |
bool VisitNakedAttr(NakedAttr *A) { | |
return true; | |
} | |
bool TraverseNoAliasAttr(NoAliasAttr *A); | |
bool VisitNoAliasAttr(NoAliasAttr *A) { | |
return true; | |
} | |
bool TraverseNoBuiltinAttr(NoBuiltinAttr *A); | |
bool VisitNoBuiltinAttr(NoBuiltinAttr *A) { | |
return true; | |
} | |
bool TraverseNoCommonAttr(NoCommonAttr *A); | |
bool VisitNoCommonAttr(NoCommonAttr *A) { | |
return true; | |
} | |
bool TraverseNoDebugAttr(NoDebugAttr *A); | |
bool VisitNoDebugAttr(NoDebugAttr *A) { | |
return true; | |
} | |
bool TraverseNoDerefAttr(NoDerefAttr *A); | |
bool VisitNoDerefAttr(NoDerefAttr *A) { | |
return true; | |
} | |
bool TraverseNoDestroyAttr(NoDestroyAttr *A); | |
bool VisitNoDestroyAttr(NoDestroyAttr *A) { | |
return true; | |
} | |
bool TraverseNoDuplicateAttr(NoDuplicateAttr *A); | |
bool VisitNoDuplicateAttr(NoDuplicateAttr *A) { | |
return true; | |
} | |
bool TraverseNoEscapeAttr(NoEscapeAttr *A); | |
bool VisitNoEscapeAttr(NoEscapeAttr *A) { | |
return true; | |
} | |
bool TraverseNoInlineAttr(NoInlineAttr *A); | |
bool VisitNoInlineAttr(NoInlineAttr *A) { | |
return true; | |
} | |
bool TraverseNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A); | |
bool VisitNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A) { | |
return true; | |
} | |
bool TraverseNoMergeAttr(NoMergeAttr *A); | |
bool VisitNoMergeAttr(NoMergeAttr *A) { | |
return true; | |
} | |
bool TraverseNoMicroMipsAttr(NoMicroMipsAttr *A); | |
bool VisitNoMicroMipsAttr(NoMicroMipsAttr *A) { | |
return true; | |
} | |
bool TraverseNoMips16Attr(NoMips16Attr *A); | |
bool VisitNoMips16Attr(NoMips16Attr *A) { | |
return true; | |
} | |
bool TraverseNoProfileFunctionAttr(NoProfileFunctionAttr *A); | |
bool VisitNoProfileFunctionAttr(NoProfileFunctionAttr *A) { | |
return true; | |
} | |
bool TraverseNoReturnAttr(NoReturnAttr *A); | |
bool VisitNoReturnAttr(NoReturnAttr *A) { | |
return true; | |
} | |
bool TraverseNoSanitizeAttr(NoSanitizeAttr *A); | |
bool VisitNoSanitizeAttr(NoSanitizeAttr *A) { | |
return true; | |
} | |
bool TraverseNoSpeculativeLoadHardeningAttr(NoSpeculativeLoadHardeningAttr *A); | |
bool VisitNoSpeculativeLoadHardeningAttr(NoSpeculativeLoadHardeningAttr *A) { | |
return true; | |
} | |
bool TraverseNoSplitStackAttr(NoSplitStackAttr *A); | |
bool VisitNoSplitStackAttr(NoSplitStackAttr *A) { | |
return true; | |
} | |
bool TraverseNoStackProtectorAttr(NoStackProtectorAttr *A); | |
bool VisitNoStackProtectorAttr(NoStackProtectorAttr *A) { | |
return true; | |
} | |
bool TraverseNoThreadSafetyAnalysisAttr(NoThreadSafetyAnalysisAttr *A); | |
bool VisitNoThreadSafetyAnalysisAttr(NoThreadSafetyAnalysisAttr *A) { | |
return true; | |
} | |
bool TraverseNoThrowAttr(NoThrowAttr *A); | |
bool VisitNoThrowAttr(NoThrowAttr *A) { | |
return true; | |
} | |
bool TraverseNoUniqueAddressAttr(NoUniqueAddressAttr *A); | |
bool VisitNoUniqueAddressAttr(NoUniqueAddressAttr *A) { | |
return true; | |
} | |
bool TraverseNonNullAttr(NonNullAttr *A); | |
bool VisitNonNullAttr(NonNullAttr *A) { | |
return true; | |
} | |
bool TraverseNotTailCalledAttr(NotTailCalledAttr *A); | |
bool VisitNotTailCalledAttr(NotTailCalledAttr *A) { | |
return true; | |
} | |
bool TraverseOMPAllocateDeclAttr(OMPAllocateDeclAttr *A); | |
bool VisitOMPAllocateDeclAttr(OMPAllocateDeclAttr *A) { | |
return true; | |
} | |
bool TraverseOMPCaptureKindAttr(OMPCaptureKindAttr *A); | |
bool VisitOMPCaptureKindAttr(OMPCaptureKindAttr *A) { | |
return true; | |
} | |
bool TraverseOMPCaptureNoInitAttr(OMPCaptureNoInitAttr *A); | |
bool VisitOMPCaptureNoInitAttr(OMPCaptureNoInitAttr *A) { | |
return true; | |
} | |
bool TraverseOMPDeclareSimdDeclAttr(OMPDeclareSimdDeclAttr *A); | |
bool VisitOMPDeclareSimdDeclAttr(OMPDeclareSimdDeclAttr *A) { | |
return true; | |
} | |
bool TraverseOMPDeclareTargetDeclAttr(OMPDeclareTargetDeclAttr *A); | |
bool VisitOMPDeclareTargetDeclAttr(OMPDeclareTargetDeclAttr *A) { | |
return true; | |
} | |
bool TraverseOMPDeclareVariantAttr(OMPDeclareVariantAttr *A); | |
bool VisitOMPDeclareVariantAttr(OMPDeclareVariantAttr *A) { | |
return true; | |
} | |
bool TraverseOMPReferencedVarAttr(OMPReferencedVarAttr *A); | |
bool VisitOMPReferencedVarAttr(OMPReferencedVarAttr *A) { | |
return true; | |
} | |
bool TraverseOMPThreadPrivateDeclAttr(OMPThreadPrivateDeclAttr *A); | |
bool VisitOMPThreadPrivateDeclAttr(OMPThreadPrivateDeclAttr *A) { | |
return true; | |
} | |
bool TraverseOSConsumedAttr(OSConsumedAttr *A); | |
bool VisitOSConsumedAttr(OSConsumedAttr *A) { | |
return true; | |
} | |
bool TraverseOSConsumesThisAttr(OSConsumesThisAttr *A); | |
bool VisitOSConsumesThisAttr(OSConsumesThisAttr *A) { | |
return true; | |
} | |
bool TraverseOSReturnsNotRetainedAttr(OSReturnsNotRetainedAttr *A); | |
bool VisitOSReturnsNotRetainedAttr(OSReturnsNotRetainedAttr *A) { | |
return true; | |
} | |
bool TraverseOSReturnsRetainedAttr(OSReturnsRetainedAttr *A); | |
bool VisitOSReturnsRetainedAttr(OSReturnsRetainedAttr *A) { | |
return true; | |
} | |
bool TraverseOSReturnsRetainedOnNonZeroAttr(OSReturnsRetainedOnNonZeroAttr *A); | |
bool VisitOSReturnsRetainedOnNonZeroAttr(OSReturnsRetainedOnNonZeroAttr *A) { | |
return true; | |
} | |
bool TraverseOSReturnsRetainedOnZeroAttr(OSReturnsRetainedOnZeroAttr *A); | |
bool VisitOSReturnsRetainedOnZeroAttr(OSReturnsRetainedOnZeroAttr *A) { | |
return true; | |
} | |
bool TraverseObjCBoxableAttr(ObjCBoxableAttr *A); | |
bool VisitObjCBoxableAttr(ObjCBoxableAttr *A) { | |
return true; | |
} | |
bool TraverseObjCBridgeAttr(ObjCBridgeAttr *A); | |
bool VisitObjCBridgeAttr(ObjCBridgeAttr *A) { | |
return true; | |
} | |
bool TraverseObjCBridgeMutableAttr(ObjCBridgeMutableAttr *A); | |
bool VisitObjCBridgeMutableAttr(ObjCBridgeMutableAttr *A) { | |
return true; | |
} | |
bool TraverseObjCBridgeRelatedAttr(ObjCBridgeRelatedAttr *A); | |
bool VisitObjCBridgeRelatedAttr(ObjCBridgeRelatedAttr *A) { | |
return true; | |
} | |
bool TraverseObjCClassStubAttr(ObjCClassStubAttr *A); | |
bool VisitObjCClassStubAttr(ObjCClassStubAttr *A) { | |
return true; | |
} | |
bool TraverseObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A); | |
bool VisitObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A) { | |
return true; | |
} | |
bool TraverseObjCDirectAttr(ObjCDirectAttr *A); | |
bool VisitObjCDirectAttr(ObjCDirectAttr *A) { | |
return true; | |
} | |
bool TraverseObjCDirectMembersAttr(ObjCDirectMembersAttr *A); | |
bool VisitObjCDirectMembersAttr(ObjCDirectMembersAttr *A) { | |
return true; | |
} | |
bool TraverseObjCExceptionAttr(ObjCExceptionAttr *A); | |
bool VisitObjCExceptionAttr(ObjCExceptionAttr *A) { | |
return true; | |
} | |
bool TraverseObjCExplicitProtocolImplAttr(ObjCExplicitProtocolImplAttr *A); | |
bool VisitObjCExplicitProtocolImplAttr(ObjCExplicitProtocolImplAttr *A) { | |
return true; | |
} | |
bool TraverseObjCExternallyRetainedAttr(ObjCExternallyRetainedAttr *A); | |
bool VisitObjCExternallyRetainedAttr(ObjCExternallyRetainedAttr *A) { | |
return true; | |
} | |
bool TraverseObjCGCAttr(ObjCGCAttr *A); | |
bool VisitObjCGCAttr(ObjCGCAttr *A) { | |
return true; | |
} | |
bool TraverseObjCIndependentClassAttr(ObjCIndependentClassAttr *A); | |
bool VisitObjCIndependentClassAttr(ObjCIndependentClassAttr *A) { | |
return true; | |
} | |
bool TraverseObjCInertUnsafeUnretainedAttr(ObjCInertUnsafeUnretainedAttr *A); | |
bool VisitObjCInertUnsafeUnretainedAttr(ObjCInertUnsafeUnretainedAttr *A) { | |
return true; | |
} | |
bool TraverseObjCKindOfAttr(ObjCKindOfAttr *A); | |
bool VisitObjCKindOfAttr(ObjCKindOfAttr *A) { | |
return true; | |
} | |
bool TraverseObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A); | |
bool VisitObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A) { | |
return true; | |
} | |
bool TraverseObjCNSObjectAttr(ObjCNSObjectAttr *A); | |
bool VisitObjCNSObjectAttr(ObjCNSObjectAttr *A) { | |
return true; | |
} | |
bool TraverseObjCNonLazyClassAttr(ObjCNonLazyClassAttr *A); | |
bool VisitObjCNonLazyClassAttr(ObjCNonLazyClassAttr *A) { | |
return true; | |
} | |
bool TraverseObjCNonRuntimeProtocolAttr(ObjCNonRuntimeProtocolAttr *A); | |
bool VisitObjCNonRuntimeProtocolAttr(ObjCNonRuntimeProtocolAttr *A) { | |
return true; | |
} | |
bool TraverseObjCOwnershipAttr(ObjCOwnershipAttr *A); | |
bool VisitObjCOwnershipAttr(ObjCOwnershipAttr *A) { | |
return true; | |
} | |
bool TraverseObjCPreciseLifetimeAttr(ObjCPreciseLifetimeAttr *A); | |
bool VisitObjCPreciseLifetimeAttr(ObjCPreciseLifetimeAttr *A) { | |
return true; | |
} | |
bool TraverseObjCRequiresPropertyDefsAttr(ObjCRequiresPropertyDefsAttr *A); | |
bool VisitObjCRequiresPropertyDefsAttr(ObjCRequiresPropertyDefsAttr *A) { | |
return true; | |
} | |
bool TraverseObjCRequiresSuperAttr(ObjCRequiresSuperAttr *A); | |
bool VisitObjCRequiresSuperAttr(ObjCRequiresSuperAttr *A) { | |
return true; | |
} | |
bool TraverseObjCReturnsInnerPointerAttr(ObjCReturnsInnerPointerAttr *A); | |
bool VisitObjCReturnsInnerPointerAttr(ObjCReturnsInnerPointerAttr *A) { | |
return true; | |
} | |
bool TraverseObjCRootClassAttr(ObjCRootClassAttr *A); | |
bool VisitObjCRootClassAttr(ObjCRootClassAttr *A) { | |
return true; | |
} | |
bool TraverseObjCRuntimeNameAttr(ObjCRuntimeNameAttr *A); | |
bool VisitObjCRuntimeNameAttr(ObjCRuntimeNameAttr *A) { | |
return true; | |
} | |
bool TraverseObjCRuntimeVisibleAttr(ObjCRuntimeVisibleAttr *A); | |
bool VisitObjCRuntimeVisibleAttr(ObjCRuntimeVisibleAttr *A) { | |
return true; | |
} | |
bool TraverseObjCSubclassingRestrictedAttr(ObjCSubclassingRestrictedAttr *A); | |
bool VisitObjCSubclassingRestrictedAttr(ObjCSubclassingRestrictedAttr *A) { | |
return true; | |
} | |
bool TraverseOpenCLAccessAttr(OpenCLAccessAttr *A); | |
bool VisitOpenCLAccessAttr(OpenCLAccessAttr *A) { | |
return true; | |
} | |
bool TraverseOpenCLConstantAddressSpaceAttr(OpenCLConstantAddressSpaceAttr *A); | |
bool VisitOpenCLConstantAddressSpaceAttr(OpenCLConstantAddressSpaceAttr *A) { | |
return true; | |
} | |
bool TraverseOpenCLGenericAddressSpaceAttr(OpenCLGenericAddressSpaceAttr *A); | |
bool VisitOpenCLGenericAddressSpaceAttr(OpenCLGenericAddressSpaceAttr *A) { | |
return true; | |
} | |
bool TraverseOpenCLGlobalAddressSpaceAttr(OpenCLGlobalAddressSpaceAttr *A); | |
bool VisitOpenCLGlobalAddressSpaceAttr(OpenCLGlobalAddressSpaceAttr *A) { | |
return true; | |
} | |
bool TraverseOpenCLGlobalDeviceAddressSpaceAttr(OpenCLGlobalDeviceAddressSpaceAttr *A); | |
bool VisitOpenCLGlobalDeviceAddressSpaceAttr(OpenCLGlobalDeviceAddressSpaceAttr *A) { | |
return true; | |
} | |
bool TraverseOpenCLGlobalHostAddressSpaceAttr(OpenCLGlobalHostAddressSpaceAttr *A); | |
bool VisitOpenCLGlobalHostAddressSpaceAttr(OpenCLGlobalHostAddressSpaceAttr *A) { | |
return true; | |
} | |
bool TraverseOpenCLIntelReqdSubGroupSizeAttr(OpenCLIntelReqdSubGroupSizeAttr *A); | |
bool VisitOpenCLIntelReqdSubGroupSizeAttr(OpenCLIntelReqdSubGroupSizeAttr *A) { | |
return true; | |
} | |
bool TraverseOpenCLKernelAttr(OpenCLKernelAttr *A); | |
bool VisitOpenCLKernelAttr(OpenCLKernelAttr *A) { | |
return true; | |
} | |
bool TraverseOpenCLLocalAddressSpaceAttr(OpenCLLocalAddressSpaceAttr *A); | |
bool VisitOpenCLLocalAddressSpaceAttr(OpenCLLocalAddressSpaceAttr *A) { | |
return true; | |
} | |
bool TraverseOpenCLPrivateAddressSpaceAttr(OpenCLPrivateAddressSpaceAttr *A); | |
bool VisitOpenCLPrivateAddressSpaceAttr(OpenCLPrivateAddressSpaceAttr *A) { | |
return true; | |
} | |
bool TraverseOpenCLUnrollHintAttr(OpenCLUnrollHintAttr *A); | |
bool VisitOpenCLUnrollHintAttr(OpenCLUnrollHintAttr *A) { | |
return true; | |
} | |
bool TraverseOptimizeNoneAttr(OptimizeNoneAttr *A); | |
bool VisitOptimizeNoneAttr(OptimizeNoneAttr *A) { | |
return true; | |
} | |
bool TraverseOverloadableAttr(OverloadableAttr *A); | |
bool VisitOverloadableAttr(OverloadableAttr *A) { | |
return true; | |
} | |
bool TraverseOverrideAttr(OverrideAttr *A); | |
bool VisitOverrideAttr(OverrideAttr *A) { | |
return true; | |
} | |
bool TraverseOwnerAttr(OwnerAttr *A); | |
bool VisitOwnerAttr(OwnerAttr *A) { | |
return true; | |
} | |
bool TraverseOwnershipAttr(OwnershipAttr *A); | |
bool VisitOwnershipAttr(OwnershipAttr *A) { | |
return true; | |
} | |
bool TraversePackedAttr(PackedAttr *A); | |
bool VisitPackedAttr(PackedAttr *A) { | |
return true; | |
} | |
bool TraverseParamTypestateAttr(ParamTypestateAttr *A); | |
bool VisitParamTypestateAttr(ParamTypestateAttr *A) { | |
return true; | |
} | |
bool TraversePascalAttr(PascalAttr *A); | |
bool VisitPascalAttr(PascalAttr *A) { | |
return true; | |
} | |
bool TraversePassObjectSizeAttr(PassObjectSizeAttr *A); | |
bool VisitPassObjectSizeAttr(PassObjectSizeAttr *A) { | |
return true; | |
} | |
bool TraversePatchableFunctionEntryAttr(PatchableFunctionEntryAttr *A); | |
bool VisitPatchableFunctionEntryAttr(PatchableFunctionEntryAttr *A) { | |
return true; | |
} | |
bool TraversePcsAttr(PcsAttr *A); | |
bool VisitPcsAttr(PcsAttr *A) { | |
return true; | |
} | |
bool TraversePointerAttr(PointerAttr *A); | |
bool VisitPointerAttr(PointerAttr *A) { | |
return true; | |
} | |
bool TraversePragmaClangBSSSectionAttr(PragmaClangBSSSectionAttr *A); | |
bool VisitPragmaClangBSSSectionAttr(PragmaClangBSSSectionAttr *A) { | |
return true; | |
} | |
bool TraversePragmaClangDataSectionAttr(PragmaClangDataSectionAttr *A); | |
bool VisitPragmaClangDataSectionAttr(PragmaClangDataSectionAttr *A) { | |
return true; | |
} | |
bool TraversePragmaClangRelroSectionAttr(PragmaClangRelroSectionAttr *A); | |
bool VisitPragmaClangRelroSectionAttr(PragmaClangRelroSectionAttr *A) { | |
return true; | |
} | |
bool TraversePragmaClangRodataSectionAttr(PragmaClangRodataSectionAttr *A); | |
bool VisitPragmaClangRodataSectionAttr(PragmaClangRodataSectionAttr *A) { | |
return true; | |
} | |
bool TraversePragmaClangTextSectionAttr(PragmaClangTextSectionAttr *A); | |
bool VisitPragmaClangTextSectionAttr(PragmaClangTextSectionAttr *A) { | |
return true; | |
} | |
bool TraversePreferredNameAttr(PreferredNameAttr *A); | |
bool VisitPreferredNameAttr(PreferredNameAttr *A) { | |
return true; | |
} | |
bool TraversePreserveAllAttr(PreserveAllAttr *A); | |
bool VisitPreserveAllAttr(PreserveAllAttr *A) { | |
return true; | |
} | |
bool TraversePreserveMostAttr(PreserveMostAttr *A); | |
bool VisitPreserveMostAttr(PreserveMostAttr *A) { | |
return true; | |
} | |
bool TraversePtGuardedByAttr(PtGuardedByAttr *A); | |
bool VisitPtGuardedByAttr(PtGuardedByAttr *A) { | |
return true; | |
} | |
bool TraversePtGuardedVarAttr(PtGuardedVarAttr *A); | |
bool VisitPtGuardedVarAttr(PtGuardedVarAttr *A) { | |
return true; | |
} | |
bool TraversePtr32Attr(Ptr32Attr *A); | |
bool VisitPtr32Attr(Ptr32Attr *A) { | |
return true; | |
} | |
bool TraversePtr64Attr(Ptr64Attr *A); | |
bool VisitPtr64Attr(Ptr64Attr *A) { | |
return true; | |
} | |
bool TraversePureAttr(PureAttr *A); | |
bool VisitPureAttr(PureAttr *A) { | |
return true; | |
} | |
bool TraverseRISCVInterruptAttr(RISCVInterruptAttr *A); | |
bool VisitRISCVInterruptAttr(RISCVInterruptAttr *A) { | |
return true; | |
} | |
bool TraverseRegCallAttr(RegCallAttr *A); | |
bool VisitRegCallAttr(RegCallAttr *A) { | |
return true; | |
} | |
bool TraverseReinitializesAttr(ReinitializesAttr *A); | |
bool VisitReinitializesAttr(ReinitializesAttr *A) { | |
return true; | |
} | |
bool TraverseReleaseCapabilityAttr(ReleaseCapabilityAttr *A); | |
bool VisitReleaseCapabilityAttr(ReleaseCapabilityAttr *A) { | |
return true; | |
} | |
bool TraverseReleaseHandleAttr(ReleaseHandleAttr *A); | |
bool VisitReleaseHandleAttr(ReleaseHandleAttr *A) { | |
return true; | |
} | |
bool TraverseRenderScriptKernelAttr(RenderScriptKernelAttr *A); | |
bool VisitRenderScriptKernelAttr(RenderScriptKernelAttr *A) { | |
return true; | |
} | |
bool TraverseReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A); | |
bool VisitReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A) { | |
return true; | |
} | |
bool TraverseRequiresCapabilityAttr(RequiresCapabilityAttr *A); | |
bool VisitRequiresCapabilityAttr(RequiresCapabilityAttr *A) { | |
return true; | |
} | |
bool TraverseRestrictAttr(RestrictAttr *A); | |
bool VisitRestrictAttr(RestrictAttr *A) { | |
return true; | |
} | |
bool TraverseRetainAttr(RetainAttr *A); | |
bool VisitRetainAttr(RetainAttr *A) { | |
return true; | |
} | |
bool TraverseReturnTypestateAttr(ReturnTypestateAttr *A); | |
bool VisitReturnTypestateAttr(ReturnTypestateAttr *A) { | |
return true; | |
} | |
bool TraverseReturnsNonNullAttr(ReturnsNonNullAttr *A); | |
bool VisitReturnsNonNullAttr(ReturnsNonNullAttr *A) { | |
return true; | |
} | |
bool TraverseReturnsTwiceAttr(ReturnsTwiceAttr *A); | |
bool VisitReturnsTwiceAttr(ReturnsTwiceAttr *A) { | |
return true; | |
} | |
bool TraverseSPtrAttr(SPtrAttr *A); | |
bool VisitSPtrAttr(SPtrAttr *A) { | |
return true; | |
} | |
bool TraverseSYCLKernelAttr(SYCLKernelAttr *A); | |
bool VisitSYCLKernelAttr(SYCLKernelAttr *A) { | |
return true; | |
} | |
bool TraverseScopedLockableAttr(ScopedLockableAttr *A); | |
bool VisitScopedLockableAttr(ScopedLockableAttr *A) { | |
return true; | |
} | |
bool TraverseSectionAttr(SectionAttr *A); | |
bool VisitSectionAttr(SectionAttr *A) { | |
return true; | |
} | |
bool TraverseSelectAnyAttr(SelectAnyAttr *A); | |
bool VisitSelectAnyAttr(SelectAnyAttr *A) { | |
return true; | |
} | |
bool TraverseSentinelAttr(SentinelAttr *A); | |
bool VisitSentinelAttr(SentinelAttr *A) { | |
return true; | |
} | |
bool TraverseSetTypestateAttr(SetTypestateAttr *A); | |
bool VisitSetTypestateAttr(SetTypestateAttr *A) { | |
return true; | |
} | |
bool TraverseSharedTrylockFunctionAttr(SharedTrylockFunctionAttr *A); | |
bool VisitSharedTrylockFunctionAttr(SharedTrylockFunctionAttr *A) { | |
return true; | |
} | |
bool TraverseSpeculativeLoadHardeningAttr(SpeculativeLoadHardeningAttr *A); | |
bool VisitSpeculativeLoadHardeningAttr(SpeculativeLoadHardeningAttr *A) { | |
return true; | |
} | |
bool TraverseStandaloneDebugAttr(StandaloneDebugAttr *A); | |
bool VisitStandaloneDebugAttr(StandaloneDebugAttr *A) { | |
return true; | |
} | |
bool TraverseStdCallAttr(StdCallAttr *A); | |
bool VisitStdCallAttr(StdCallAttr *A) { | |
return true; | |
} | |
bool TraverseStrictFPAttr(StrictFPAttr *A); | |
bool VisitStrictFPAttr(StrictFPAttr *A) { | |
return true; | |
} | |
bool TraverseSuppressAttr(SuppressAttr *A); | |
bool VisitSuppressAttr(SuppressAttr *A) { | |
return true; | |
} | |
bool TraverseSwiftAsyncAttr(SwiftAsyncAttr *A); | |
bool VisitSwiftAsyncAttr(SwiftAsyncAttr *A) { | |
return true; | |
} | |
bool TraverseSwiftAsyncCallAttr(SwiftAsyncCallAttr *A); | |
bool VisitSwiftAsyncCallAttr(SwiftAsyncCallAttr *A) { | |
return true; | |
} | |
bool TraverseSwiftAsyncContextAttr(SwiftAsyncContextAttr *A); | |
bool VisitSwiftAsyncContextAttr(SwiftAsyncContextAttr *A) { | |
return true; | |
} | |
bool TraverseSwiftAsyncErrorAttr(SwiftAsyncErrorAttr *A); | |
bool VisitSwiftAsyncErrorAttr(SwiftAsyncErrorAttr *A) { | |
return true; | |
} | |
bool TraverseSwiftAsyncNameAttr(SwiftAsyncNameAttr *A); | |
bool VisitSwiftAsyncNameAttr(SwiftAsyncNameAttr *A) { | |
return true; | |
} | |
bool TraverseSwiftAttrAttr(SwiftAttrAttr *A); | |
bool VisitSwiftAttrAttr(SwiftAttrAttr *A) { | |
return true; | |
} | |
bool TraverseSwiftBridgeAttr(SwiftBridgeAttr *A); | |
bool VisitSwiftBridgeAttr(SwiftBridgeAttr *A) { | |
return true; | |
} | |
bool TraverseSwiftBridgedTypedefAttr(SwiftBridgedTypedefAttr *A); | |
bool VisitSwiftBridgedTypedefAttr(SwiftBridgedTypedefAttr *A) { | |
return true; | |
} | |
bool TraverseSwiftCallAttr(SwiftCallAttr *A); | |
bool VisitSwiftCallAttr(SwiftCallAttr *A) { | |
return true; | |
} | |
bool TraverseSwiftContextAttr(SwiftContextAttr *A); | |
bool VisitSwiftContextAttr(SwiftContextAttr *A) { | |
return true; | |
} | |
bool TraverseSwiftErrorAttr(SwiftErrorAttr *A); | |
bool VisitSwiftErrorAttr(SwiftErrorAttr *A) { | |
return true; | |
} | |
bool TraverseSwiftErrorResultAttr(SwiftErrorResultAttr *A); | |
bool VisitSwiftErrorResultAttr(SwiftErrorResultAttr *A) { | |
return true; | |
} | |
bool TraverseSwiftIndirectResultAttr(SwiftIndirectResultAttr *A); | |
bool VisitSwiftIndirectResultAttr(SwiftIndirectResultAttr *A) { | |
return true; | |
} | |
bool TraverseSwiftNameAttr(SwiftNameAttr *A); | |
bool VisitSwiftNameAttr(SwiftNameAttr *A) { | |
return true; | |
} | |
bool TraverseSwiftNewTypeAttr(SwiftNewTypeAttr *A); | |
bool VisitSwiftNewTypeAttr(SwiftNewTypeAttr *A) { | |
return true; | |
} | |
bool TraverseSwiftObjCMembersAttr(SwiftObjCMembersAttr *A); | |
bool VisitSwiftObjCMembersAttr(SwiftObjCMembersAttr *A) { | |
return true; | |
} | |
bool TraverseSwiftPrivateAttr(SwiftPrivateAttr *A); | |
bool VisitSwiftPrivateAttr(SwiftPrivateAttr *A) { | |
return true; | |
} | |
bool TraverseSysVABIAttr(SysVABIAttr *A); | |
bool VisitSysVABIAttr(SysVABIAttr *A) { | |
return true; | |
} | |
bool TraverseTLSModelAttr(TLSModelAttr *A); | |
bool VisitTLSModelAttr(TLSModelAttr *A) { | |
return true; | |
} | |
bool TraverseTargetAttr(TargetAttr *A); | |
bool VisitTargetAttr(TargetAttr *A) { | |
return true; | |
} | |
bool TraverseTestTypestateAttr(TestTypestateAttr *A); | |
bool VisitTestTypestateAttr(TestTypestateAttr *A) { | |
return true; | |
} | |
bool TraverseThisCallAttr(ThisCallAttr *A); | |
bool VisitThisCallAttr(ThisCallAttr *A) { | |
return true; | |
} | |
bool TraverseThreadAttr(ThreadAttr *A); | |
bool VisitThreadAttr(ThreadAttr *A) { | |
return true; | |
} | |
bool TraverseTransparentUnionAttr(TransparentUnionAttr *A); | |
bool VisitTransparentUnionAttr(TransparentUnionAttr *A) { | |
return true; | |
} | |
bool TraverseTrivialABIAttr(TrivialABIAttr *A); | |
bool VisitTrivialABIAttr(TrivialABIAttr *A) { | |
return true; | |
} | |
bool TraverseTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A); | |
bool VisitTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A) { | |
return true; | |
} | |
bool TraverseTypeNonNullAttr(TypeNonNullAttr *A); | |
bool VisitTypeNonNullAttr(TypeNonNullAttr *A) { | |
return true; | |
} | |
bool TraverseTypeNullUnspecifiedAttr(TypeNullUnspecifiedAttr *A); | |
bool VisitTypeNullUnspecifiedAttr(TypeNullUnspecifiedAttr *A) { | |
return true; | |
} | |
bool TraverseTypeNullableAttr(TypeNullableAttr *A); | |
bool VisitTypeNullableAttr(TypeNullableAttr *A) { | |
return true; | |
} | |
bool TraverseTypeNullableResultAttr(TypeNullableResultAttr *A); | |
bool VisitTypeNullableResultAttr(TypeNullableResultAttr *A) { | |
return true; | |
} | |
bool TraverseTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A); | |
bool VisitTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A) { | |
return true; | |
} | |
bool TraverseTypeVisibilityAttr(TypeVisibilityAttr *A); | |
bool VisitTypeVisibilityAttr(TypeVisibilityAttr *A) { | |
return true; | |
} | |
bool TraverseUPtrAttr(UPtrAttr *A); | |
bool VisitUPtrAttr(UPtrAttr *A) { | |
return true; | |
} | |
bool TraverseUnavailableAttr(UnavailableAttr *A); | |
bool VisitUnavailableAttr(UnavailableAttr *A) { | |
return true; | |
} | |
bool TraverseUninitializedAttr(UninitializedAttr *A); | |
bool VisitUninitializedAttr(UninitializedAttr *A) { | |
return true; | |
} | |
bool TraverseUnlikelyAttr(UnlikelyAttr *A); | |
bool VisitUnlikelyAttr(UnlikelyAttr *A) { | |
return true; | |
} | |
bool TraverseUnusedAttr(UnusedAttr *A); | |
bool VisitUnusedAttr(UnusedAttr *A) { | |
return true; | |
} | |
bool TraverseUseHandleAttr(UseHandleAttr *A); | |
bool VisitUseHandleAttr(UseHandleAttr *A) { | |
return true; | |
} | |
bool TraverseUsedAttr(UsedAttr *A); | |
bool VisitUsedAttr(UsedAttr *A) { | |
return true; | |
} | |
bool TraverseUsingIfExistsAttr(UsingIfExistsAttr *A); | |
bool VisitUsingIfExistsAttr(UsingIfExistsAttr *A) { | |
return true; | |
} | |
bool TraverseUuidAttr(UuidAttr *A); | |
bool VisitUuidAttr(UuidAttr *A) { | |
return true; | |
} | |
bool TraverseVecReturnAttr(VecReturnAttr *A); | |
bool VisitVecReturnAttr(VecReturnAttr *A) { | |
return true; | |
} | |
bool TraverseVecTypeHintAttr(VecTypeHintAttr *A); | |
bool VisitVecTypeHintAttr(VecTypeHintAttr *A) { | |
return true; | |
} | |
bool TraverseVectorCallAttr(VectorCallAttr *A); | |
bool VisitVectorCallAttr(VectorCallAttr *A) { | |
return true; | |
} | |
bool TraverseVisibilityAttr(VisibilityAttr *A); | |
bool VisitVisibilityAttr(VisibilityAttr *A) { | |
return true; | |
} | |
bool TraverseWarnUnusedAttr(WarnUnusedAttr *A); | |
bool VisitWarnUnusedAttr(WarnUnusedAttr *A) { | |
return true; | |
} | |
bool TraverseWarnUnusedResultAttr(WarnUnusedResultAttr *A); | |
bool VisitWarnUnusedResultAttr(WarnUnusedResultAttr *A) { | |
return true; | |
} | |
bool TraverseWeakAttr(WeakAttr *A); | |
bool VisitWeakAttr(WeakAttr *A) { | |
return true; | |
} | |
bool TraverseWeakImportAttr(WeakImportAttr *A); | |
bool VisitWeakImportAttr(WeakImportAttr *A) { | |
return true; | |
} | |
bool TraverseWeakRefAttr(WeakRefAttr *A); | |
bool VisitWeakRefAttr(WeakRefAttr *A) { | |
return true; | |
} | |
bool TraverseWebAssemblyExportNameAttr(WebAssemblyExportNameAttr *A); | |
bool VisitWebAssemblyExportNameAttr(WebAssemblyExportNameAttr *A) { | |
return true; | |
} | |
bool TraverseWebAssemblyImportModuleAttr(WebAssemblyImportModuleAttr *A); | |
bool VisitWebAssemblyImportModuleAttr(WebAssemblyImportModuleAttr *A) { | |
return true; | |
} | |
bool TraverseWebAssemblyImportNameAttr(WebAssemblyImportNameAttr *A); | |
bool VisitWebAssemblyImportNameAttr(WebAssemblyImportNameAttr *A) { | |
return true; | |
} | |
bool TraverseWorkGroupSizeHintAttr(WorkGroupSizeHintAttr *A); | |
bool VisitWorkGroupSizeHintAttr(WorkGroupSizeHintAttr *A) { | |
return true; | |
} | |
bool TraverseX86ForceAlignArgPointerAttr(X86ForceAlignArgPointerAttr *A); | |
bool VisitX86ForceAlignArgPointerAttr(X86ForceAlignArgPointerAttr *A) { | |
return true; | |
} | |
bool TraverseXRayInstrumentAttr(XRayInstrumentAttr *A); | |
bool VisitXRayInstrumentAttr(XRayInstrumentAttr *A) { | |
return true; | |
} | |
bool TraverseXRayLogArgsAttr(XRayLogArgsAttr *A); | |
bool VisitXRayLogArgsAttr(XRayLogArgsAttr *A) { | |
return true; | |
} | |
Stmt::child_range getStmtChildren(Stmt *S) { return S->children(); } | |
private: | |
public: | |
bool TraverseGCCAsmStmt(GCCAsmStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseMSAsmStmt(MSAsmStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseBreakStmt(BreakStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXCatchStmt(CXXCatchStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXForRangeStmt(CXXForRangeStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXTryStmt(CXXTryStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCapturedStmt(CapturedStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCompoundStmt(CompoundStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseContinueStmt(ContinueStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCoreturnStmt(CoreturnStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCoroutineBodyStmt(CoroutineBodyStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseDeclStmt(DeclStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseDoStmt(DoStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseForStmt(ForStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseGotoStmt(GotoStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseIfStmt(IfStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseIndirectGotoStmt(IndirectGotoStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseMSDependentExistsStmt(MSDependentExistsStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseNullStmt(NullStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPCanonicalLoop(OMPCanonicalLoop *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPAtomicDirective(OMPAtomicDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPBarrierDirective(OMPBarrierDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPCancelDirective(OMPCancelDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPCancellationPointDirective(OMPCancellationPointDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPCriticalDirective(OMPCriticalDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPDepobjDirective(OMPDepobjDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPDispatchDirective(OMPDispatchDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPFlushDirective(OMPFlushDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPInteropDirective(OMPInteropDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPDistributeDirective(OMPDistributeDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPDistributeParallelForDirective(OMPDistributeParallelForDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPDistributeParallelForSimdDirective(OMPDistributeParallelForSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPDistributeSimdDirective(OMPDistributeSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPForDirective(OMPForDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPForSimdDirective(OMPForSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPMasterTaskLoopDirective(OMPMasterTaskLoopDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPMasterTaskLoopSimdDirective(OMPMasterTaskLoopSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPParallelForDirective(OMPParallelForDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPParallelForSimdDirective(OMPParallelForSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPParallelMasterTaskLoopDirective(OMPParallelMasterTaskLoopDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPParallelMasterTaskLoopSimdDirective(OMPParallelMasterTaskLoopSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPSimdDirective(OMPSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPTargetParallelForSimdDirective(OMPTargetParallelForSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPTargetSimdDirective(OMPTargetSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPTargetTeamsDistributeDirective(OMPTargetTeamsDistributeDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPTargetTeamsDistributeParallelForDirective(OMPTargetTeamsDistributeParallelForDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPTargetTeamsDistributeParallelForSimdDirective(OMPTargetTeamsDistributeParallelForSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPTargetTeamsDistributeSimdDirective(OMPTargetTeamsDistributeSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPTaskLoopDirective(OMPTaskLoopDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPTeamsDistributeDirective(OMPTeamsDistributeDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPTeamsDistributeParallelForDirective(OMPTeamsDistributeParallelForDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPTeamsDistributeParallelForSimdDirective(OMPTeamsDistributeParallelForSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPTeamsDistributeSimdDirective(OMPTeamsDistributeSimdDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPTileDirective(OMPTileDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPUnrollDirective(OMPUnrollDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPMaskedDirective(OMPMaskedDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPMasterDirective(OMPMasterDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPOrderedDirective(OMPOrderedDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPParallelDirective(OMPParallelDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPParallelMasterDirective(OMPParallelMasterDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPParallelSectionsDirective(OMPParallelSectionsDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPScanDirective(OMPScanDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPSectionDirective(OMPSectionDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPSectionsDirective(OMPSectionsDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPSingleDirective(OMPSingleDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPTargetDataDirective(OMPTargetDataDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPTargetDirective(OMPTargetDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPTargetEnterDataDirective(OMPTargetEnterDataDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPTargetExitDataDirective(OMPTargetExitDataDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPTargetParallelDirective(OMPTargetParallelDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPTargetParallelForDirective(OMPTargetParallelForDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPTargetTeamsDirective(OMPTargetTeamsDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPTargetUpdateDirective(OMPTargetUpdateDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPTaskDirective(OMPTaskDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPTaskgroupDirective(OMPTaskgroupDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPTaskwaitDirective(OMPTaskwaitDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPTaskyieldDirective(OMPTaskyieldDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPTeamsDirective(OMPTeamsDirective *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseObjCAtCatchStmt(ObjCAtCatchStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseObjCAtFinallyStmt(ObjCAtFinallyStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseObjCAtThrowStmt(ObjCAtThrowStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseObjCAtTryStmt(ObjCAtTryStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseObjCForCollectionStmt(ObjCForCollectionStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseReturnStmt(ReturnStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseSEHExceptStmt(SEHExceptStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseSEHFinallyStmt(SEHFinallyStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseSEHLeaveStmt(SEHLeaveStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseSEHTryStmt(SEHTryStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCaseStmt(CaseStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseDefaultStmt(DefaultStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseSwitchStmt(SwitchStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseAttributedStmt(AttributedStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseBinaryConditionalOperator(BinaryConditionalOperator *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseConditionalOperator(ConditionalOperator *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseAddrLabelExpr(AddrLabelExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseArrayInitIndexExpr(ArrayInitIndexExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseArrayInitLoopExpr(ArrayInitLoopExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseArraySubscriptExpr(ArraySubscriptExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseArrayTypeTraitExpr(ArrayTypeTraitExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseAsTypeExpr(AsTypeExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseAtomicExpr(AtomicExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseBinaryOperator(BinaryOperator *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCompoundAssignOperator(CompoundAssignOperator *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseBlockExpr(BlockExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXBindTemporaryExpr(CXXBindTemporaryExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXBoolLiteralExpr(CXXBoolLiteralExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXConstructExpr(CXXConstructExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXDefaultArgExpr(CXXDefaultArgExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXDefaultInitExpr(CXXDefaultInitExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXDeleteExpr(CXXDeleteExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXFoldExpr(CXXFoldExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXNewExpr(CXXNewExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXNoexceptExpr(CXXNoexceptExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXRewrittenBinaryOperator(CXXRewrittenBinaryOperator *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXScalarValueInitExpr(CXXScalarValueInitExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXStdInitializerListExpr(CXXStdInitializerListExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXThisExpr(CXXThisExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXThrowExpr(CXXThrowExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXTypeidExpr(CXXTypeidExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXUuidofExpr(CXXUuidofExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCallExpr(CallExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCUDAKernelCallExpr(CUDAKernelCallExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXMemberCallExpr(CXXMemberCallExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXOperatorCallExpr(CXXOperatorCallExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseUserDefinedLiteral(UserDefinedLiteral *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseBuiltinBitCastExpr(BuiltinBitCastExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCStyleCastExpr(CStyleCastExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXFunctionalCastExpr(CXXFunctionalCastExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXConstCastExpr(CXXConstCastExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXDynamicCastExpr(CXXDynamicCastExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXReinterpretCastExpr(CXXReinterpretCastExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCXXStaticCastExpr(CXXStaticCastExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseObjCBridgedCastExpr(ObjCBridgedCastExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseImplicitCastExpr(ImplicitCastExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCharacterLiteral(CharacterLiteral *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseChooseExpr(ChooseExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCompoundLiteralExpr(CompoundLiteralExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseConceptSpecializationExpr(ConceptSpecializationExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseConvertVectorExpr(ConvertVectorExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCoawaitExpr(CoawaitExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseCoyieldExpr(CoyieldExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseDeclRefExpr(DeclRefExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseDependentCoawaitExpr(DependentCoawaitExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseDesignatedInitExpr(DesignatedInitExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseExpressionTraitExpr(ExpressionTraitExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseExtVectorElementExpr(ExtVectorElementExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseFixedPointLiteral(FixedPointLiteral *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseFloatingLiteral(FloatingLiteral *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseConstantExpr(ConstantExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseExprWithCleanups(ExprWithCleanups *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseFunctionParmPackExpr(FunctionParmPackExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseGNUNullExpr(GNUNullExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseGenericSelectionExpr(GenericSelectionExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseImaginaryLiteral(ImaginaryLiteral *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseImplicitValueInitExpr(ImplicitValueInitExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseInitListExpr(InitListExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseIntegerLiteral(IntegerLiteral *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseLambdaExpr(LambdaExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseMSPropertyRefExpr(MSPropertyRefExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseMSPropertySubscriptExpr(MSPropertySubscriptExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseMaterializeTemporaryExpr(MaterializeTemporaryExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseMatrixSubscriptExpr(MatrixSubscriptExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseMemberExpr(MemberExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseNoInitExpr(NoInitExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPArraySectionExpr(OMPArraySectionExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPArrayShapingExpr(OMPArrayShapingExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOMPIteratorExpr(OMPIteratorExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseObjCArrayLiteral(ObjCArrayLiteral *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseObjCBoolLiteralExpr(ObjCBoolLiteralExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseObjCBoxedExpr(ObjCBoxedExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseObjCDictionaryLiteral(ObjCDictionaryLiteral *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseObjCEncodeExpr(ObjCEncodeExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseObjCIsaExpr(ObjCIsaExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseObjCIvarRefExpr(ObjCIvarRefExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseObjCMessageExpr(ObjCMessageExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseObjCPropertyRefExpr(ObjCPropertyRefExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseObjCProtocolExpr(ObjCProtocolExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseObjCSelectorExpr(ObjCSelectorExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseObjCStringLiteral(ObjCStringLiteral *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseObjCSubscriptRefExpr(ObjCSubscriptRefExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOffsetOfExpr(OffsetOfExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseOpaqueValueExpr(OpaqueValueExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseUnresolvedLookupExpr(UnresolvedLookupExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseUnresolvedMemberExpr(UnresolvedMemberExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraversePackExpansionExpr(PackExpansionExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseParenExpr(ParenExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseParenListExpr(ParenListExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraversePredefinedExpr(PredefinedExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraversePseudoObjectExpr(PseudoObjectExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseRecoveryExpr(RecoveryExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseRequiresExpr(RequiresExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseShuffleVectorExpr(ShuffleVectorExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseSizeOfPackExpr(SizeOfPackExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseSourceLocExpr(SourceLocExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseStmtExpr(StmtExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseStringLiteral(StringLiteral *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseSubstNonTypeTemplateParmPackExpr(SubstNonTypeTemplateParmPackExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseTypeTraitExpr(TypeTraitExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseTypoExpr(TypoExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseUnaryOperator(UnaryOperator *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseVAArgExpr(VAArgExpr *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseLabelStmt(LabelStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool TraverseWhileStmt(WhileStmt *S, DataRecursionQueue *Queue = std::__1::__get_nullptr_t()); | |
bool WalkUpFromStmt(Stmt *S) { return getDerived().VisitStmt(S); } | |
bool VisitStmt(Stmt *S) { return true; } | |
bool WalkUpFromAsmStmt(AsmStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitAsmStmt(S)) return false; } while (false); return true; } bool VisitAsmStmt(AsmStmt *S) { return true; } | |
bool WalkUpFromGCCAsmStmt(GCCAsmStmt *S) { do { if (!getDerived().WalkUpFromAsmStmt(S)) return false; } while (false); do { if (!getDerived().VisitGCCAsmStmt(S)) return false; } while (false); return true; } bool VisitGCCAsmStmt(GCCAsmStmt *S) { return true; } | |
bool WalkUpFromMSAsmStmt(MSAsmStmt *S) { do { if (!getDerived().WalkUpFromAsmStmt(S)) return false; } while (false); do { if (!getDerived().VisitMSAsmStmt(S)) return false; } while (false); return true; } bool VisitMSAsmStmt(MSAsmStmt *S) { return true; } | |
bool WalkUpFromBreakStmt(BreakStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitBreakStmt(S)) return false; } while (false); return true; } bool VisitBreakStmt(BreakStmt *S) { return true; } | |
bool WalkUpFromCXXCatchStmt(CXXCatchStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitCXXCatchStmt(S)) return false; } while (false); return true; } bool VisitCXXCatchStmt(CXXCatchStmt *S) { return true; } | |
bool WalkUpFromCXXForRangeStmt(CXXForRangeStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitCXXForRangeStmt(S)) return false; } while (false); return true; } bool VisitCXXForRangeStmt(CXXForRangeStmt *S) { return true; } | |
bool WalkUpFromCXXTryStmt(CXXTryStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitCXXTryStmt(S)) return false; } while (false); return true; } bool VisitCXXTryStmt(CXXTryStmt *S) { return true; } | |
bool WalkUpFromCapturedStmt(CapturedStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitCapturedStmt(S)) return false; } while (false); return true; } bool VisitCapturedStmt(CapturedStmt *S) { return true; } | |
bool WalkUpFromCompoundStmt(CompoundStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitCompoundStmt(S)) return false; } while (false); return true; } bool VisitCompoundStmt(CompoundStmt *S) { return true; } | |
bool WalkUpFromContinueStmt(ContinueStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitContinueStmt(S)) return false; } while (false); return true; } bool VisitContinueStmt(ContinueStmt *S) { return true; } | |
bool WalkUpFromCoreturnStmt(CoreturnStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitCoreturnStmt(S)) return false; } while (false); return true; } bool VisitCoreturnStmt(CoreturnStmt *S) { return true; } | |
bool WalkUpFromCoroutineBodyStmt(CoroutineBodyStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitCoroutineBodyStmt(S)) return false; } while (false); return true; } bool VisitCoroutineBodyStmt(CoroutineBodyStmt *S) { return true; } | |
bool WalkUpFromDeclStmt(DeclStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitDeclStmt(S)) return false; } while (false); return true; } bool VisitDeclStmt(DeclStmt *S) { return true; } | |
bool WalkUpFromDoStmt(DoStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitDoStmt(S)) return false; } while (false); return true; } bool VisitDoStmt(DoStmt *S) { return true; } | |
bool WalkUpFromForStmt(ForStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitForStmt(S)) return false; } while (false); return true; } bool VisitForStmt(ForStmt *S) { return true; } | |
bool WalkUpFromGotoStmt(GotoStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitGotoStmt(S)) return false; } while (false); return true; } bool VisitGotoStmt(GotoStmt *S) { return true; } | |
bool WalkUpFromIfStmt(IfStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitIfStmt(S)) return false; } while (false); return true; } bool VisitIfStmt(IfStmt *S) { return true; } | |
bool WalkUpFromIndirectGotoStmt(IndirectGotoStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitIndirectGotoStmt(S)) return false; } while (false); return true; } bool VisitIndirectGotoStmt(IndirectGotoStmt *S) { return true; } | |
bool WalkUpFromMSDependentExistsStmt(MSDependentExistsStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitMSDependentExistsStmt(S)) return false; } while (false); return true; } bool VisitMSDependentExistsStmt(MSDependentExistsStmt *S) { return true; } | |
bool WalkUpFromNullStmt(NullStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitNullStmt(S)) return false; } while (false); return true; } bool VisitNullStmt(NullStmt *S) { return true; } | |
bool WalkUpFromOMPCanonicalLoop(OMPCanonicalLoop *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitOMPCanonicalLoop(S)) return false; } while (false); return true; } bool VisitOMPCanonicalLoop(OMPCanonicalLoop *S) { return true; } | |
bool WalkUpFromOMPExecutableDirective(OMPExecutableDirective *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitOMPExecutableDirective(S)) return false; } while (false); return true; } bool VisitOMPExecutableDirective(OMPExecutableDirective *S) { return true; } | |
bool WalkUpFromOMPAtomicDirective(OMPAtomicDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPAtomicDirective(S)) return false; } while (false); return true; } bool VisitOMPAtomicDirective(OMPAtomicDirective *S) { return true; } | |
bool WalkUpFromOMPBarrierDirective(OMPBarrierDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPBarrierDirective(S)) return false; } while (false); return true; } bool VisitOMPBarrierDirective(OMPBarrierDirective *S) { return true; } | |
bool WalkUpFromOMPCancelDirective(OMPCancelDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPCancelDirective(S)) return false; } while (false); return true; } bool VisitOMPCancelDirective(OMPCancelDirective *S) { return true; } | |
bool WalkUpFromOMPCancellationPointDirective(OMPCancellationPointDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPCancellationPointDirective(S)) return false; } while (false); return true; } bool VisitOMPCancellationPointDirective(OMPCancellationPointDirective *S) { return true; } | |
bool WalkUpFromOMPCriticalDirective(OMPCriticalDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPCriticalDirective(S)) return false; } while (false); return true; } bool VisitOMPCriticalDirective(OMPCriticalDirective *S) { return true; } | |
bool WalkUpFromOMPDepobjDirective(OMPDepobjDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPDepobjDirective(S)) return false; } while (false); return true; } bool VisitOMPDepobjDirective(OMPDepobjDirective *S) { return true; } | |
bool WalkUpFromOMPDispatchDirective(OMPDispatchDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPDispatchDirective(S)) return false; } while (false); return true; } bool VisitOMPDispatchDirective(OMPDispatchDirective *S) { return true; } | |
bool WalkUpFromOMPFlushDirective(OMPFlushDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPFlushDirective(S)) return false; } while (false); return true; } bool VisitOMPFlushDirective(OMPFlushDirective *S) { return true; } | |
bool WalkUpFromOMPInteropDirective(OMPInteropDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPInteropDirective(S)) return false; } while (false); return true; } bool VisitOMPInteropDirective(OMPInteropDirective *S) { return true; } | |
bool WalkUpFromOMPLoopBasedDirective(OMPLoopBasedDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPLoopBasedDirective(S)) return false; } while (false); return true; } bool VisitOMPLoopBasedDirective(OMPLoopBasedDirective *S) { return true; } | |
bool WalkUpFromOMPLoopDirective(OMPLoopDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopBasedDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPLoopDirective(S)) return false; } while (false); return true; } bool VisitOMPLoopDirective(OMPLoopDirective *S) { return true; } | |
bool WalkUpFromOMPDistributeDirective(OMPDistributeDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPDistributeDirective(S)) return false; } while (false); return true; } bool VisitOMPDistributeDirective(OMPDistributeDirective *S) { return true; } | |
bool WalkUpFromOMPDistributeParallelForDirective(OMPDistributeParallelForDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPDistributeParallelForDirective(S)) return false; } while (false); return true; } bool VisitOMPDistributeParallelForDirective(OMPDistributeParallelForDirective *S) { return true; } | |
bool WalkUpFromOMPDistributeParallelForSimdDirective(OMPDistributeParallelForSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPDistributeParallelForSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPDistributeParallelForSimdDirective(OMPDistributeParallelForSimdDirective *S) { return true; } | |
bool WalkUpFromOMPDistributeSimdDirective(OMPDistributeSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPDistributeSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPDistributeSimdDirective(OMPDistributeSimdDirective *S) { return true; } | |
bool WalkUpFromOMPForDirective(OMPForDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPForDirective(S)) return false; } while (false); return true; } bool VisitOMPForDirective(OMPForDirective *S) { return true; } | |
bool WalkUpFromOMPForSimdDirective(OMPForSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPForSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPForSimdDirective(OMPForSimdDirective *S) { return true; } | |
bool WalkUpFromOMPMasterTaskLoopDirective(OMPMasterTaskLoopDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPMasterTaskLoopDirective(S)) return false; } while (false); return true; } bool VisitOMPMasterTaskLoopDirective(OMPMasterTaskLoopDirective *S) { return true; } | |
bool WalkUpFromOMPMasterTaskLoopSimdDirective(OMPMasterTaskLoopSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPMasterTaskLoopSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPMasterTaskLoopSimdDirective(OMPMasterTaskLoopSimdDirective *S) { return true; } | |
bool WalkUpFromOMPParallelForDirective(OMPParallelForDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPParallelForDirective(S)) return false; } while (false); return true; } bool VisitOMPParallelForDirective(OMPParallelForDirective *S) { return true; } | |
bool WalkUpFromOMPParallelForSimdDirective(OMPParallelForSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPParallelForSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPParallelForSimdDirective(OMPParallelForSimdDirective *S) { return true; } | |
bool WalkUpFromOMPParallelMasterTaskLoopDirective(OMPParallelMasterTaskLoopDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPParallelMasterTaskLoopDirective(S)) return false; } while (false); return true; } bool VisitOMPParallelMasterTaskLoopDirective(OMPParallelMasterTaskLoopDirective *S) { return true; } | |
bool WalkUpFromOMPParallelMasterTaskLoopSimdDirective(OMPParallelMasterTaskLoopSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPParallelMasterTaskLoopSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPParallelMasterTaskLoopSimdDirective(OMPParallelMasterTaskLoopSimdDirective *S) { return true; } | |
bool WalkUpFromOMPSimdDirective(OMPSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPSimdDirective(OMPSimdDirective *S) { return true; } | |
bool WalkUpFromOMPTargetParallelForSimdDirective(OMPTargetParallelForSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetParallelForSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetParallelForSimdDirective(OMPTargetParallelForSimdDirective *S) { return true; } | |
bool WalkUpFromOMPTargetSimdDirective(OMPTargetSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetSimdDirective(OMPTargetSimdDirective *S) { return true; } | |
bool WalkUpFromOMPTargetTeamsDistributeDirective(OMPTargetTeamsDistributeDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetTeamsDistributeDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetTeamsDistributeDirective(OMPTargetTeamsDistributeDirective *S) { return true; } | |
bool WalkUpFromOMPTargetTeamsDistributeParallelForDirective(OMPTargetTeamsDistributeParallelForDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetTeamsDistributeParallelForDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetTeamsDistributeParallelForDirective(OMPTargetTeamsDistributeParallelForDirective *S) { return true; } | |
bool WalkUpFromOMPTargetTeamsDistributeParallelForSimdDirective(OMPTargetTeamsDistributeParallelForSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetTeamsDistributeParallelForSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetTeamsDistributeParallelForSimdDirective(OMPTargetTeamsDistributeParallelForSimdDirective *S) { return true; } | |
bool WalkUpFromOMPTargetTeamsDistributeSimdDirective(OMPTargetTeamsDistributeSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetTeamsDistributeSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetTeamsDistributeSimdDirective(OMPTargetTeamsDistributeSimdDirective *S) { return true; } | |
bool WalkUpFromOMPTaskLoopDirective(OMPTaskLoopDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTaskLoopDirective(S)) return false; } while (false); return true; } bool VisitOMPTaskLoopDirective(OMPTaskLoopDirective *S) { return true; } | |
bool WalkUpFromOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTaskLoopSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *S) { return true; } | |
bool WalkUpFromOMPTeamsDistributeDirective(OMPTeamsDistributeDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTeamsDistributeDirective(S)) return false; } while (false); return true; } bool VisitOMPTeamsDistributeDirective(OMPTeamsDistributeDirective *S) { return true; } | |
bool WalkUpFromOMPTeamsDistributeParallelForDirective(OMPTeamsDistributeParallelForDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTeamsDistributeParallelForDirective(S)) return false; } while (false); return true; } bool VisitOMPTeamsDistributeParallelForDirective(OMPTeamsDistributeParallelForDirective *S) { return true; } | |
bool WalkUpFromOMPTeamsDistributeParallelForSimdDirective(OMPTeamsDistributeParallelForSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTeamsDistributeParallelForSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPTeamsDistributeParallelForSimdDirective(OMPTeamsDistributeParallelForSimdDirective *S) { return true; } | |
bool WalkUpFromOMPTeamsDistributeSimdDirective(OMPTeamsDistributeSimdDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTeamsDistributeSimdDirective(S)) return false; } while (false); return true; } bool VisitOMPTeamsDistributeSimdDirective(OMPTeamsDistributeSimdDirective *S) { return true; } | |
bool WalkUpFromOMPTileDirective(OMPTileDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopBasedDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTileDirective(S)) return false; } while (false); return true; } bool VisitOMPTileDirective(OMPTileDirective *S) { return true; } | |
bool WalkUpFromOMPUnrollDirective(OMPUnrollDirective *S) { do { if (!getDerived().WalkUpFromOMPLoopBasedDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPUnrollDirective(S)) return false; } while (false); return true; } bool VisitOMPUnrollDirective(OMPUnrollDirective *S) { return true; } | |
bool WalkUpFromOMPMaskedDirective(OMPMaskedDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPMaskedDirective(S)) return false; } while (false); return true; } bool VisitOMPMaskedDirective(OMPMaskedDirective *S) { return true; } | |
bool WalkUpFromOMPMasterDirective(OMPMasterDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPMasterDirective(S)) return false; } while (false); return true; } bool VisitOMPMasterDirective(OMPMasterDirective *S) { return true; } | |
bool WalkUpFromOMPOrderedDirective(OMPOrderedDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPOrderedDirective(S)) return false; } while (false); return true; } bool VisitOMPOrderedDirective(OMPOrderedDirective *S) { return true; } | |
bool WalkUpFromOMPParallelDirective(OMPParallelDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPParallelDirective(S)) return false; } while (false); return true; } bool VisitOMPParallelDirective(OMPParallelDirective *S) { return true; } | |
bool WalkUpFromOMPParallelMasterDirective(OMPParallelMasterDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPParallelMasterDirective(S)) return false; } while (false); return true; } bool VisitOMPParallelMasterDirective(OMPParallelMasterDirective *S) { return true; } | |
bool WalkUpFromOMPParallelSectionsDirective(OMPParallelSectionsDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPParallelSectionsDirective(S)) return false; } while (false); return true; } bool VisitOMPParallelSectionsDirective(OMPParallelSectionsDirective *S) { return true; } | |
bool WalkUpFromOMPScanDirective(OMPScanDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPScanDirective(S)) return false; } while (false); return true; } bool VisitOMPScanDirective(OMPScanDirective *S) { return true; } | |
bool WalkUpFromOMPSectionDirective(OMPSectionDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPSectionDirective(S)) return false; } while (false); return true; } bool VisitOMPSectionDirective(OMPSectionDirective *S) { return true; } | |
bool WalkUpFromOMPSectionsDirective(OMPSectionsDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPSectionsDirective(S)) return false; } while (false); return true; } bool VisitOMPSectionsDirective(OMPSectionsDirective *S) { return true; } | |
bool WalkUpFromOMPSingleDirective(OMPSingleDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPSingleDirective(S)) return false; } while (false); return true; } bool VisitOMPSingleDirective(OMPSingleDirective *S) { return true; } | |
bool WalkUpFromOMPTargetDataDirective(OMPTargetDataDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetDataDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetDataDirective(OMPTargetDataDirective *S) { return true; } | |
bool WalkUpFromOMPTargetDirective(OMPTargetDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetDirective(OMPTargetDirective *S) { return true; } | |
bool WalkUpFromOMPTargetEnterDataDirective(OMPTargetEnterDataDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetEnterDataDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetEnterDataDirective(OMPTargetEnterDataDirective *S) { return true; } | |
bool WalkUpFromOMPTargetExitDataDirective(OMPTargetExitDataDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetExitDataDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetExitDataDirective(OMPTargetExitDataDirective *S) { return true; } | |
bool WalkUpFromOMPTargetParallelDirective(OMPTargetParallelDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetParallelDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetParallelDirective(OMPTargetParallelDirective *S) { return true; } | |
bool WalkUpFromOMPTargetParallelForDirective(OMPTargetParallelForDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetParallelForDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetParallelForDirective(OMPTargetParallelForDirective *S) { return true; } | |
bool WalkUpFromOMPTargetTeamsDirective(OMPTargetTeamsDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetTeamsDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *S) { return true; } | |
bool WalkUpFromOMPTargetUpdateDirective(OMPTargetUpdateDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTargetUpdateDirective(S)) return false; } while (false); return true; } bool VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *S) { return true; } | |
bool WalkUpFromOMPTaskDirective(OMPTaskDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTaskDirective(S)) return false; } while (false); return true; } bool VisitOMPTaskDirective(OMPTaskDirective *S) { return true; } | |
bool WalkUpFromOMPTaskgroupDirective(OMPTaskgroupDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTaskgroupDirective(S)) return false; } while (false); return true; } bool VisitOMPTaskgroupDirective(OMPTaskgroupDirective *S) { return true; } | |
bool WalkUpFromOMPTaskwaitDirective(OMPTaskwaitDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTaskwaitDirective(S)) return false; } while (false); return true; } bool VisitOMPTaskwaitDirective(OMPTaskwaitDirective *S) { return true; } | |
bool WalkUpFromOMPTaskyieldDirective(OMPTaskyieldDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTaskyieldDirective(S)) return false; } while (false); return true; } bool VisitOMPTaskyieldDirective(OMPTaskyieldDirective *S) { return true; } | |
bool WalkUpFromOMPTeamsDirective(OMPTeamsDirective *S) { do { if (!getDerived().WalkUpFromOMPExecutableDirective(S)) return false; } while (false); do { if (!getDerived().VisitOMPTeamsDirective(S)) return false; } while (false); return true; } bool VisitOMPTeamsDirective(OMPTeamsDirective *S) { return true; } | |
bool WalkUpFromObjCAtCatchStmt(ObjCAtCatchStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitObjCAtCatchStmt(S)) return false; } while (false); return true; } bool VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) { return true; } | |
bool WalkUpFromObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitObjCAtFinallyStmt(S)) return false; } while (false); return true; } bool VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { return true; } | |
bool WalkUpFromObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitObjCAtSynchronizedStmt(S)) return false; } while (false); return true; } bool VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) { return true; } | |
bool WalkUpFromObjCAtThrowStmt(ObjCAtThrowStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitObjCAtThrowStmt(S)) return false; } while (false); return true; } bool VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) { return true; } | |
bool WalkUpFromObjCAtTryStmt(ObjCAtTryStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitObjCAtTryStmt(S)) return false; } while (false); return true; } bool VisitObjCAtTryStmt(ObjCAtTryStmt *S) { return true; } | |
bool WalkUpFromObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitObjCAutoreleasePoolStmt(S)) return false; } while (false); return true; } bool VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) { return true; } | |
bool WalkUpFromObjCForCollectionStmt(ObjCForCollectionStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitObjCForCollectionStmt(S)) return false; } while (false); return true; } bool VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { return true; } | |
bool WalkUpFromReturnStmt(ReturnStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitReturnStmt(S)) return false; } while (false); return true; } bool VisitReturnStmt(ReturnStmt *S) { return true; } | |
bool WalkUpFromSEHExceptStmt(SEHExceptStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitSEHExceptStmt(S)) return false; } while (false); return true; } bool VisitSEHExceptStmt(SEHExceptStmt *S) { return true; } | |
bool WalkUpFromSEHFinallyStmt(SEHFinallyStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitSEHFinallyStmt(S)) return false; } while (false); return true; } bool VisitSEHFinallyStmt(SEHFinallyStmt *S) { return true; } | |
bool WalkUpFromSEHLeaveStmt(SEHLeaveStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitSEHLeaveStmt(S)) return false; } while (false); return true; } bool VisitSEHLeaveStmt(SEHLeaveStmt *S) { return true; } | |
bool WalkUpFromSEHTryStmt(SEHTryStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitSEHTryStmt(S)) return false; } while (false); return true; } bool VisitSEHTryStmt(SEHTryStmt *S) { return true; } | |
bool WalkUpFromSwitchCase(SwitchCase *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitSwitchCase(S)) return false; } while (false); return true; } bool VisitSwitchCase(SwitchCase *S) { return true; } | |
bool WalkUpFromCaseStmt(CaseStmt *S) { do { if (!getDerived().WalkUpFromSwitchCase(S)) return false; } while (false); do { if (!getDerived().VisitCaseStmt(S)) return false; } while (false); return true; } bool VisitCaseStmt(CaseStmt *S) { return true; } | |
bool WalkUpFromDefaultStmt(DefaultStmt *S) { do { if (!getDerived().WalkUpFromSwitchCase(S)) return false; } while (false); do { if (!getDerived().VisitDefaultStmt(S)) return false; } while (false); return true; } bool VisitDefaultStmt(DefaultStmt *S) { return true; } | |
bool WalkUpFromSwitchStmt(SwitchStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitSwitchStmt(S)) return false; } while (false); return true; } bool VisitSwitchStmt(SwitchStmt *S) { return true; } | |
bool WalkUpFromValueStmt(ValueStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitValueStmt(S)) return false; } while (false); return true; } bool VisitValueStmt(ValueStmt *S) { return true; } | |
bool WalkUpFromAttributedStmt(AttributedStmt *S) { do { if (!getDerived().WalkUpFromValueStmt(S)) return false; } while (false); do { if (!getDerived().VisitAttributedStmt(S)) return false; } while (false); return true; } bool VisitAttributedStmt(AttributedStmt *S) { return true; } | |
bool WalkUpFromExpr(Expr *S) { do { if (!getDerived().WalkUpFromValueStmt(S)) return false; } while (false); do { if (!getDerived().VisitExpr(S)) return false; } while (false); return true; } bool VisitExpr(Expr *S) { return true; } | |
bool WalkUpFromAbstractConditionalOperator(AbstractConditionalOperator *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitAbstractConditionalOperator(S)) return false; } while (false); return true; } bool VisitAbstractConditionalOperator(AbstractConditionalOperator *S) { return true; } | |
bool WalkUpFromBinaryConditionalOperator(BinaryConditionalOperator *S) { do { if (!getDerived().WalkUpFromAbstractConditionalOperator(S)) return false; } while (false); do { if (!getDerived().VisitBinaryConditionalOperator(S)) return false; } while (false); return true; } bool VisitBinaryConditionalOperator(BinaryConditionalOperator *S) { return true; } | |
bool WalkUpFromConditionalOperator(ConditionalOperator *S) { do { if (!getDerived().WalkUpFromAbstractConditionalOperator(S)) return false; } while (false); do { if (!getDerived().VisitConditionalOperator(S)) return false; } while (false); return true; } bool VisitConditionalOperator(ConditionalOperator *S) { return true; } | |
bool WalkUpFromAddrLabelExpr(AddrLabelExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitAddrLabelExpr(S)) return false; } while (false); return true; } bool VisitAddrLabelExpr(AddrLabelExpr *S) { return true; } | |
bool WalkUpFromArrayInitIndexExpr(ArrayInitIndexExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitArrayInitIndexExpr(S)) return false; } while (false); return true; } bool VisitArrayInitIndexExpr(ArrayInitIndexExpr *S) { return true; } | |
bool WalkUpFromArrayInitLoopExpr(ArrayInitLoopExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitArrayInitLoopExpr(S)) return false; } while (false); return true; } bool VisitArrayInitLoopExpr(ArrayInitLoopExpr *S) { return true; } | |
bool WalkUpFromArraySubscriptExpr(ArraySubscriptExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitArraySubscriptExpr(S)) return false; } while (false); return true; } bool VisitArraySubscriptExpr(ArraySubscriptExpr *S) { return true; } | |
bool WalkUpFromArrayTypeTraitExpr(ArrayTypeTraitExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitArrayTypeTraitExpr(S)) return false; } while (false); return true; } bool VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *S) { return true; } | |
bool WalkUpFromAsTypeExpr(AsTypeExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitAsTypeExpr(S)) return false; } while (false); return true; } bool VisitAsTypeExpr(AsTypeExpr *S) { return true; } | |
bool WalkUpFromAtomicExpr(AtomicExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitAtomicExpr(S)) return false; } while (false); return true; } bool VisitAtomicExpr(AtomicExpr *S) { return true; } | |
bool WalkUpFromBinaryOperator(BinaryOperator *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitBinaryOperator(S)) return false; } while (false); return true; } bool VisitBinaryOperator(BinaryOperator *S) { return true; } | |
bool WalkUpFromCompoundAssignOperator(CompoundAssignOperator *S) { do { if (!getDerived().WalkUpFromBinaryOperator(S)) return false; } while (false); do { if (!getDerived().VisitCompoundAssignOperator(S)) return false; } while (false); return true; } bool VisitCompoundAssignOperator(CompoundAssignOperator *S) { return true; } | |
bool WalkUpFromBlockExpr(BlockExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitBlockExpr(S)) return false; } while (false); return true; } bool VisitBlockExpr(BlockExpr *S) { return true; } | |
bool WalkUpFromCXXBindTemporaryExpr(CXXBindTemporaryExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXBindTemporaryExpr(S)) return false; } while (false); return true; } bool VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *S) { return true; } | |
bool WalkUpFromCXXBoolLiteralExpr(CXXBoolLiteralExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXBoolLiteralExpr(S)) return false; } while (false); return true; } bool VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *S) { return true; } | |
bool WalkUpFromCXXConstructExpr(CXXConstructExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXConstructExpr(S)) return false; } while (false); return true; } bool VisitCXXConstructExpr(CXXConstructExpr *S) { return true; } | |
bool WalkUpFromCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *S) { do { if (!getDerived().WalkUpFromCXXConstructExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXTemporaryObjectExpr(S)) return false; } while (false); return true; } bool VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *S) { return true; } | |
bool WalkUpFromCXXDefaultArgExpr(CXXDefaultArgExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXDefaultArgExpr(S)) return false; } while (false); return true; } bool VisitCXXDefaultArgExpr(CXXDefaultArgExpr *S) { return true; } | |
bool WalkUpFromCXXDefaultInitExpr(CXXDefaultInitExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXDefaultInitExpr(S)) return false; } while (false); return true; } bool VisitCXXDefaultInitExpr(CXXDefaultInitExpr *S) { return true; } | |
bool WalkUpFromCXXDeleteExpr(CXXDeleteExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXDeleteExpr(S)) return false; } while (false); return true; } bool VisitCXXDeleteExpr(CXXDeleteExpr *S) { return true; } | |
bool WalkUpFromCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXDependentScopeMemberExpr(S)) return false; } while (false); return true; } bool VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *S) { return true; } | |
bool WalkUpFromCXXFoldExpr(CXXFoldExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXFoldExpr(S)) return false; } while (false); return true; } bool VisitCXXFoldExpr(CXXFoldExpr *S) { return true; } | |
bool WalkUpFromCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXInheritedCtorInitExpr(S)) return false; } while (false); return true; } bool VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *S) { return true; } | |
bool WalkUpFromCXXNewExpr(CXXNewExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXNewExpr(S)) return false; } while (false); return true; } bool VisitCXXNewExpr(CXXNewExpr *S) { return true; } | |
bool WalkUpFromCXXNoexceptExpr(CXXNoexceptExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXNoexceptExpr(S)) return false; } while (false); return true; } bool VisitCXXNoexceptExpr(CXXNoexceptExpr *S) { return true; } | |
bool WalkUpFromCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXNullPtrLiteralExpr(S)) return false; } while (false); return true; } bool VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *S) { return true; } | |
bool WalkUpFromCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXPseudoDestructorExpr(S)) return false; } while (false); return true; } bool VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *S) { return true; } | |
bool WalkUpFromCXXRewrittenBinaryOperator(CXXRewrittenBinaryOperator *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXRewrittenBinaryOperator(S)) return false; } while (false); return true; } bool VisitCXXRewrittenBinaryOperator(CXXRewrittenBinaryOperator *S) { return true; } | |
bool WalkUpFromCXXScalarValueInitExpr(CXXScalarValueInitExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXScalarValueInitExpr(S)) return false; } while (false); return true; } bool VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *S) { return true; } | |
bool WalkUpFromCXXStdInitializerListExpr(CXXStdInitializerListExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXStdInitializerListExpr(S)) return false; } while (false); return true; } bool VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *S) { return true; } | |
bool WalkUpFromCXXThisExpr(CXXThisExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXThisExpr(S)) return false; } while (false); return true; } bool VisitCXXThisExpr(CXXThisExpr *S) { return true; } | |
bool WalkUpFromCXXThrowExpr(CXXThrowExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXThrowExpr(S)) return false; } while (false); return true; } bool VisitCXXThrowExpr(CXXThrowExpr *S) { return true; } | |
bool WalkUpFromCXXTypeidExpr(CXXTypeidExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXTypeidExpr(S)) return false; } while (false); return true; } bool VisitCXXTypeidExpr(CXXTypeidExpr *S) { return true; } | |
bool WalkUpFromCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXUnresolvedConstructExpr(S)) return false; } while (false); return true; } bool VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *S) { return true; } | |
bool WalkUpFromCXXUuidofExpr(CXXUuidofExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXUuidofExpr(S)) return false; } while (false); return true; } bool VisitCXXUuidofExpr(CXXUuidofExpr *S) { return true; } | |
bool WalkUpFromCallExpr(CallExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCallExpr(S)) return false; } while (false); return true; } bool VisitCallExpr(CallExpr *S) { return true; } | |
bool WalkUpFromCUDAKernelCallExpr(CUDAKernelCallExpr *S) { do { if (!getDerived().WalkUpFromCallExpr(S)) return false; } while (false); do { if (!getDerived().VisitCUDAKernelCallExpr(S)) return false; } while (false); return true; } bool VisitCUDAKernelCallExpr(CUDAKernelCallExpr *S) { return true; } | |
bool WalkUpFromCXXMemberCallExpr(CXXMemberCallExpr *S) { do { if (!getDerived().WalkUpFromCallExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXMemberCallExpr(S)) return false; } while (false); return true; } bool VisitCXXMemberCallExpr(CXXMemberCallExpr *S) { return true; } | |
bool WalkUpFromCXXOperatorCallExpr(CXXOperatorCallExpr *S) { do { if (!getDerived().WalkUpFromCallExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXOperatorCallExpr(S)) return false; } while (false); return true; } bool VisitCXXOperatorCallExpr(CXXOperatorCallExpr *S) { return true; } | |
bool WalkUpFromUserDefinedLiteral(UserDefinedLiteral *S) { do { if (!getDerived().WalkUpFromCallExpr(S)) return false; } while (false); do { if (!getDerived().VisitUserDefinedLiteral(S)) return false; } while (false); return true; } bool VisitUserDefinedLiteral(UserDefinedLiteral *S) { return true; } | |
bool WalkUpFromCastExpr(CastExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCastExpr(S)) return false; } while (false); return true; } bool VisitCastExpr(CastExpr *S) { return true; } | |
bool WalkUpFromExplicitCastExpr(ExplicitCastExpr *S) { do { if (!getDerived().WalkUpFromCastExpr(S)) return false; } while (false); do { if (!getDerived().VisitExplicitCastExpr(S)) return false; } while (false); return true; } bool VisitExplicitCastExpr(ExplicitCastExpr *S) { return true; } | |
bool WalkUpFromBuiltinBitCastExpr(BuiltinBitCastExpr *S) { do { if (!getDerived().WalkUpFromExplicitCastExpr(S)) return false; } while (false); do { if (!getDerived().VisitBuiltinBitCastExpr(S)) return false; } while (false); return true; } bool VisitBuiltinBitCastExpr(BuiltinBitCastExpr *S) { return true; } | |
bool WalkUpFromCStyleCastExpr(CStyleCastExpr *S) { do { if (!getDerived().WalkUpFromExplicitCastExpr(S)) return false; } while (false); do { if (!getDerived().VisitCStyleCastExpr(S)) return false; } while (false); return true; } bool VisitCStyleCastExpr(CStyleCastExpr *S) { return true; } | |
bool WalkUpFromCXXFunctionalCastExpr(CXXFunctionalCastExpr *S) { do { if (!getDerived().WalkUpFromExplicitCastExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXFunctionalCastExpr(S)) return false; } while (false); return true; } bool VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *S) { return true; } | |
bool WalkUpFromCXXNamedCastExpr(CXXNamedCastExpr *S) { do { if (!getDerived().WalkUpFromExplicitCastExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXNamedCastExpr(S)) return false; } while (false); return true; } bool VisitCXXNamedCastExpr(CXXNamedCastExpr *S) { return true; } | |
bool WalkUpFromCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *S) { do { if (!getDerived().WalkUpFromCXXNamedCastExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXAddrspaceCastExpr(S)) return false; } while (false); return true; } bool VisitCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *S) { return true; } | |
bool WalkUpFromCXXConstCastExpr(CXXConstCastExpr *S) { do { if (!getDerived().WalkUpFromCXXNamedCastExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXConstCastExpr(S)) return false; } while (false); return true; } bool VisitCXXConstCastExpr(CXXConstCastExpr *S) { return true; } | |
bool WalkUpFromCXXDynamicCastExpr(CXXDynamicCastExpr *S) { do { if (!getDerived().WalkUpFromCXXNamedCastExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXDynamicCastExpr(S)) return false; } while (false); return true; } bool VisitCXXDynamicCastExpr(CXXDynamicCastExpr *S) { return true; } | |
bool WalkUpFromCXXReinterpretCastExpr(CXXReinterpretCastExpr *S) { do { if (!getDerived().WalkUpFromCXXNamedCastExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXReinterpretCastExpr(S)) return false; } while (false); return true; } bool VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *S) { return true; } | |
bool WalkUpFromCXXStaticCastExpr(CXXStaticCastExpr *S) { do { if (!getDerived().WalkUpFromCXXNamedCastExpr(S)) return false; } while (false); do { if (!getDerived().VisitCXXStaticCastExpr(S)) return false; } while (false); return true; } bool VisitCXXStaticCastExpr(CXXStaticCastExpr *S) { return true; } | |
bool WalkUpFromObjCBridgedCastExpr(ObjCBridgedCastExpr *S) { do { if (!getDerived().WalkUpFromExplicitCastExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCBridgedCastExpr(S)) return false; } while (false); return true; } bool VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *S) { return true; } | |
bool WalkUpFromImplicitCastExpr(ImplicitCastExpr *S) { do { if (!getDerived().WalkUpFromCastExpr(S)) return false; } while (false); do { if (!getDerived().VisitImplicitCastExpr(S)) return false; } while (false); return true; } bool VisitImplicitCastExpr(ImplicitCastExpr *S) { return true; } | |
bool WalkUpFromCharacterLiteral(CharacterLiteral *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCharacterLiteral(S)) return false; } while (false); return true; } bool VisitCharacterLiteral(CharacterLiteral *S) { return true; } | |
bool WalkUpFromChooseExpr(ChooseExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitChooseExpr(S)) return false; } while (false); return true; } bool VisitChooseExpr(ChooseExpr *S) { return true; } | |
bool WalkUpFromCompoundLiteralExpr(CompoundLiteralExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCompoundLiteralExpr(S)) return false; } while (false); return true; } bool VisitCompoundLiteralExpr(CompoundLiteralExpr *S) { return true; } | |
bool WalkUpFromConceptSpecializationExpr(ConceptSpecializationExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitConceptSpecializationExpr(S)) return false; } while (false); return true; } bool VisitConceptSpecializationExpr(ConceptSpecializationExpr *S) { return true; } | |
bool WalkUpFromConvertVectorExpr(ConvertVectorExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitConvertVectorExpr(S)) return false; } while (false); return true; } bool VisitConvertVectorExpr(ConvertVectorExpr *S) { return true; } | |
bool WalkUpFromCoroutineSuspendExpr(CoroutineSuspendExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitCoroutineSuspendExpr(S)) return false; } while (false); return true; } bool VisitCoroutineSuspendExpr(CoroutineSuspendExpr *S) { return true; } | |
bool WalkUpFromCoawaitExpr(CoawaitExpr *S) { do { if (!getDerived().WalkUpFromCoroutineSuspendExpr(S)) return false; } while (false); do { if (!getDerived().VisitCoawaitExpr(S)) return false; } while (false); return true; } bool VisitCoawaitExpr(CoawaitExpr *S) { return true; } | |
bool WalkUpFromCoyieldExpr(CoyieldExpr *S) { do { if (!getDerived().WalkUpFromCoroutineSuspendExpr(S)) return false; } while (false); do { if (!getDerived().VisitCoyieldExpr(S)) return false; } while (false); return true; } bool VisitCoyieldExpr(CoyieldExpr *S) { return true; } | |
bool WalkUpFromDeclRefExpr(DeclRefExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitDeclRefExpr(S)) return false; } while (false); return true; } bool VisitDeclRefExpr(DeclRefExpr *S) { return true; } | |
bool WalkUpFromDependentCoawaitExpr(DependentCoawaitExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitDependentCoawaitExpr(S)) return false; } while (false); return true; } bool VisitDependentCoawaitExpr(DependentCoawaitExpr *S) { return true; } | |
bool WalkUpFromDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitDependentScopeDeclRefExpr(S)) return false; } while (false); return true; } bool VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *S) { return true; } | |
bool WalkUpFromDesignatedInitExpr(DesignatedInitExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitDesignatedInitExpr(S)) return false; } while (false); return true; } bool VisitDesignatedInitExpr(DesignatedInitExpr *S) { return true; } | |
bool WalkUpFromDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitDesignatedInitUpdateExpr(S)) return false; } while (false); return true; } bool VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *S) { return true; } | |
bool WalkUpFromExpressionTraitExpr(ExpressionTraitExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitExpressionTraitExpr(S)) return false; } while (false); return true; } bool VisitExpressionTraitExpr(ExpressionTraitExpr *S) { return true; } | |
bool WalkUpFromExtVectorElementExpr(ExtVectorElementExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitExtVectorElementExpr(S)) return false; } while (false); return true; } bool VisitExtVectorElementExpr(ExtVectorElementExpr *S) { return true; } | |
bool WalkUpFromFixedPointLiteral(FixedPointLiteral *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitFixedPointLiteral(S)) return false; } while (false); return true; } bool VisitFixedPointLiteral(FixedPointLiteral *S) { return true; } | |
bool WalkUpFromFloatingLiteral(FloatingLiteral *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitFloatingLiteral(S)) return false; } while (false); return true; } bool VisitFloatingLiteral(FloatingLiteral *S) { return true; } | |
bool WalkUpFromFullExpr(FullExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitFullExpr(S)) return false; } while (false); return true; } bool VisitFullExpr(FullExpr *S) { return true; } | |
bool WalkUpFromConstantExpr(ConstantExpr *S) { do { if (!getDerived().WalkUpFromFullExpr(S)) return false; } while (false); do { if (!getDerived().VisitConstantExpr(S)) return false; } while (false); return true; } bool VisitConstantExpr(ConstantExpr *S) { return true; } | |
bool WalkUpFromExprWithCleanups(ExprWithCleanups *S) { do { if (!getDerived().WalkUpFromFullExpr(S)) return false; } while (false); do { if (!getDerived().VisitExprWithCleanups(S)) return false; } while (false); return true; } bool VisitExprWithCleanups(ExprWithCleanups *S) { return true; } | |
bool WalkUpFromFunctionParmPackExpr(FunctionParmPackExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitFunctionParmPackExpr(S)) return false; } while (false); return true; } bool VisitFunctionParmPackExpr(FunctionParmPackExpr *S) { return true; } | |
bool WalkUpFromGNUNullExpr(GNUNullExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitGNUNullExpr(S)) return false; } while (false); return true; } bool VisitGNUNullExpr(GNUNullExpr *S) { return true; } | |
bool WalkUpFromGenericSelectionExpr(GenericSelectionExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitGenericSelectionExpr(S)) return false; } while (false); return true; } bool VisitGenericSelectionExpr(GenericSelectionExpr *S) { return true; } | |
bool WalkUpFromImaginaryLiteral(ImaginaryLiteral *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitImaginaryLiteral(S)) return false; } while (false); return true; } bool VisitImaginaryLiteral(ImaginaryLiteral *S) { return true; } | |
bool WalkUpFromImplicitValueInitExpr(ImplicitValueInitExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitImplicitValueInitExpr(S)) return false; } while (false); return true; } bool VisitImplicitValueInitExpr(ImplicitValueInitExpr *S) { return true; } | |
bool WalkUpFromInitListExpr(InitListExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitInitListExpr(S)) return false; } while (false); return true; } bool VisitInitListExpr(InitListExpr *S) { return true; } | |
bool WalkUpFromIntegerLiteral(IntegerLiteral *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitIntegerLiteral(S)) return false; } while (false); return true; } bool VisitIntegerLiteral(IntegerLiteral *S) { return true; } | |
bool WalkUpFromLambdaExpr(LambdaExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitLambdaExpr(S)) return false; } while (false); return true; } bool VisitLambdaExpr(LambdaExpr *S) { return true; } | |
bool WalkUpFromMSPropertyRefExpr(MSPropertyRefExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitMSPropertyRefExpr(S)) return false; } while (false); return true; } bool VisitMSPropertyRefExpr(MSPropertyRefExpr *S) { return true; } | |
bool WalkUpFromMSPropertySubscriptExpr(MSPropertySubscriptExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitMSPropertySubscriptExpr(S)) return false; } while (false); return true; } bool VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *S) { return true; } | |
bool WalkUpFromMaterializeTemporaryExpr(MaterializeTemporaryExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitMaterializeTemporaryExpr(S)) return false; } while (false); return true; } bool VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *S) { return true; } | |
bool WalkUpFromMatrixSubscriptExpr(MatrixSubscriptExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitMatrixSubscriptExpr(S)) return false; } while (false); return true; } bool VisitMatrixSubscriptExpr(MatrixSubscriptExpr *S) { return true; } | |
bool WalkUpFromMemberExpr(MemberExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitMemberExpr(S)) return false; } while (false); return true; } bool VisitMemberExpr(MemberExpr *S) { return true; } | |
bool WalkUpFromNoInitExpr(NoInitExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitNoInitExpr(S)) return false; } while (false); return true; } bool VisitNoInitExpr(NoInitExpr *S) { return true; } | |
bool WalkUpFromOMPArraySectionExpr(OMPArraySectionExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitOMPArraySectionExpr(S)) return false; } while (false); return true; } bool VisitOMPArraySectionExpr(OMPArraySectionExpr *S) { return true; } | |
bool WalkUpFromOMPArrayShapingExpr(OMPArrayShapingExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitOMPArrayShapingExpr(S)) return false; } while (false); return true; } bool VisitOMPArrayShapingExpr(OMPArrayShapingExpr *S) { return true; } | |
bool WalkUpFromOMPIteratorExpr(OMPIteratorExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitOMPIteratorExpr(S)) return false; } while (false); return true; } bool VisitOMPIteratorExpr(OMPIteratorExpr *S) { return true; } | |
bool WalkUpFromObjCArrayLiteral(ObjCArrayLiteral *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCArrayLiteral(S)) return false; } while (false); return true; } bool VisitObjCArrayLiteral(ObjCArrayLiteral *S) { return true; } | |
bool WalkUpFromObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCAvailabilityCheckExpr(S)) return false; } while (false); return true; } bool VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *S) { return true; } | |
bool WalkUpFromObjCBoolLiteralExpr(ObjCBoolLiteralExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCBoolLiteralExpr(S)) return false; } while (false); return true; } bool VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *S) { return true; } | |
bool WalkUpFromObjCBoxedExpr(ObjCBoxedExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCBoxedExpr(S)) return false; } while (false); return true; } bool VisitObjCBoxedExpr(ObjCBoxedExpr *S) { return true; } | |
bool WalkUpFromObjCDictionaryLiteral(ObjCDictionaryLiteral *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCDictionaryLiteral(S)) return false; } while (false); return true; } bool VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *S) { return true; } | |
bool WalkUpFromObjCEncodeExpr(ObjCEncodeExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCEncodeExpr(S)) return false; } while (false); return true; } bool VisitObjCEncodeExpr(ObjCEncodeExpr *S) { return true; } | |
bool WalkUpFromObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCIndirectCopyRestoreExpr(S)) return false; } while (false); return true; } bool VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *S) { return true; } | |
bool WalkUpFromObjCIsaExpr(ObjCIsaExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCIsaExpr(S)) return false; } while (false); return true; } bool VisitObjCIsaExpr(ObjCIsaExpr *S) { return true; } | |
bool WalkUpFromObjCIvarRefExpr(ObjCIvarRefExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCIvarRefExpr(S)) return false; } while (false); return true; } bool VisitObjCIvarRefExpr(ObjCIvarRefExpr *S) { return true; } | |
bool WalkUpFromObjCMessageExpr(ObjCMessageExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCMessageExpr(S)) return false; } while (false); return true; } bool VisitObjCMessageExpr(ObjCMessageExpr *S) { return true; } | |
bool WalkUpFromObjCPropertyRefExpr(ObjCPropertyRefExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCPropertyRefExpr(S)) return false; } while (false); return true; } bool VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *S) { return true; } | |
bool WalkUpFromObjCProtocolExpr(ObjCProtocolExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCProtocolExpr(S)) return false; } while (false); return true; } bool VisitObjCProtocolExpr(ObjCProtocolExpr *S) { return true; } | |
bool WalkUpFromObjCSelectorExpr(ObjCSelectorExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCSelectorExpr(S)) return false; } while (false); return true; } bool VisitObjCSelectorExpr(ObjCSelectorExpr *S) { return true; } | |
bool WalkUpFromObjCStringLiteral(ObjCStringLiteral *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCStringLiteral(S)) return false; } while (false); return true; } bool VisitObjCStringLiteral(ObjCStringLiteral *S) { return true; } | |
bool WalkUpFromObjCSubscriptRefExpr(ObjCSubscriptRefExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitObjCSubscriptRefExpr(S)) return false; } while (false); return true; } bool VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *S) { return true; } | |
bool WalkUpFromOffsetOfExpr(OffsetOfExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitOffsetOfExpr(S)) return false; } while (false); return true; } bool VisitOffsetOfExpr(OffsetOfExpr *S) { return true; } | |
bool WalkUpFromOpaqueValueExpr(OpaqueValueExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitOpaqueValueExpr(S)) return false; } while (false); return true; } bool VisitOpaqueValueExpr(OpaqueValueExpr *S) { return true; } | |
bool WalkUpFromOverloadExpr(OverloadExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitOverloadExpr(S)) return false; } while (false); return true; } bool VisitOverloadExpr(OverloadExpr *S) { return true; } | |
bool WalkUpFromUnresolvedLookupExpr(UnresolvedLookupExpr *S) { do { if (!getDerived().WalkUpFromOverloadExpr(S)) return false; } while (false); do { if (!getDerived().VisitUnresolvedLookupExpr(S)) return false; } while (false); return true; } bool VisitUnresolvedLookupExpr(UnresolvedLookupExpr *S) { return true; } | |
bool WalkUpFromUnresolvedMemberExpr(UnresolvedMemberExpr *S) { do { if (!getDerived().WalkUpFromOverloadExpr(S)) return false; } while (false); do { if (!getDerived().VisitUnresolvedMemberExpr(S)) return false; } while (false); return true; } bool VisitUnresolvedMemberExpr(UnresolvedMemberExpr *S) { return true; } | |
bool WalkUpFromPackExpansionExpr(PackExpansionExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitPackExpansionExpr(S)) return false; } while (false); return true; } bool VisitPackExpansionExpr(PackExpansionExpr *S) { return true; } | |
bool WalkUpFromParenExpr(ParenExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitParenExpr(S)) return false; } while (false); return true; } bool VisitParenExpr(ParenExpr *S) { return true; } | |
bool WalkUpFromParenListExpr(ParenListExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitParenListExpr(S)) return false; } while (false); return true; } bool VisitParenListExpr(ParenListExpr *S) { return true; } | |
bool WalkUpFromPredefinedExpr(PredefinedExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitPredefinedExpr(S)) return false; } while (false); return true; } bool VisitPredefinedExpr(PredefinedExpr *S) { return true; } | |
bool WalkUpFromPseudoObjectExpr(PseudoObjectExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitPseudoObjectExpr(S)) return false; } while (false); return true; } bool VisitPseudoObjectExpr(PseudoObjectExpr *S) { return true; } | |
bool WalkUpFromRecoveryExpr(RecoveryExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitRecoveryExpr(S)) return false; } while (false); return true; } bool VisitRecoveryExpr(RecoveryExpr *S) { return true; } | |
bool WalkUpFromRequiresExpr(RequiresExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitRequiresExpr(S)) return false; } while (false); return true; } bool VisitRequiresExpr(RequiresExpr *S) { return true; } | |
bool WalkUpFromSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitSYCLUniqueStableNameExpr(S)) return false; } while (false); return true; } bool VisitSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *S) { return true; } | |
bool WalkUpFromShuffleVectorExpr(ShuffleVectorExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitShuffleVectorExpr(S)) return false; } while (false); return true; } bool VisitShuffleVectorExpr(ShuffleVectorExpr *S) { return true; } | |
bool WalkUpFromSizeOfPackExpr(SizeOfPackExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitSizeOfPackExpr(S)) return false; } while (false); return true; } bool VisitSizeOfPackExpr(SizeOfPackExpr *S) { return true; } | |
bool WalkUpFromSourceLocExpr(SourceLocExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitSourceLocExpr(S)) return false; } while (false); return true; } bool VisitSourceLocExpr(SourceLocExpr *S) { return true; } | |
bool WalkUpFromStmtExpr(StmtExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitStmtExpr(S)) return false; } while (false); return true; } bool VisitStmtExpr(StmtExpr *S) { return true; } | |
bool WalkUpFromStringLiteral(StringLiteral *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitStringLiteral(S)) return false; } while (false); return true; } bool VisitStringLiteral(StringLiteral *S) { return true; } | |
bool WalkUpFromSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitSubstNonTypeTemplateParmExpr(S)) return false; } while (false); return true; } bool VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *S) { return true; } | |
bool WalkUpFromSubstNonTypeTemplateParmPackExpr(SubstNonTypeTemplateParmPackExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitSubstNonTypeTemplateParmPackExpr(S)) return false; } while (false); return true; } bool VisitSubstNonTypeTemplateParmPackExpr(SubstNonTypeTemplateParmPackExpr *S) { return true; } | |
bool WalkUpFromTypeTraitExpr(TypeTraitExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitTypeTraitExpr(S)) return false; } while (false); return true; } bool VisitTypeTraitExpr(TypeTraitExpr *S) { return true; } | |
bool WalkUpFromTypoExpr(TypoExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitTypoExpr(S)) return false; } while (false); return true; } bool VisitTypoExpr(TypoExpr *S) { return true; } | |
bool WalkUpFromUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitUnaryExprOrTypeTraitExpr(S)) return false; } while (false); return true; } bool VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *S) { return true; } | |
bool WalkUpFromUnaryOperator(UnaryOperator *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitUnaryOperator(S)) return false; } while (false); return true; } bool VisitUnaryOperator(UnaryOperator *S) { return true; } | |
bool WalkUpFromVAArgExpr(VAArgExpr *S) { do { if (!getDerived().WalkUpFromExpr(S)) return false; } while (false); do { if (!getDerived().VisitVAArgExpr(S)) return false; } while (false); return true; } bool VisitVAArgExpr(VAArgExpr *S) { return true; } | |
bool WalkUpFromLabelStmt(LabelStmt *S) { do { if (!getDerived().WalkUpFromValueStmt(S)) return false; } while (false); do { if (!getDerived().VisitLabelStmt(S)) return false; } while (false); return true; } bool VisitLabelStmt(LabelStmt *S) { return true; } | |
bool WalkUpFromWhileStmt(WhileStmt *S) { do { if (!getDerived().WalkUpFromStmt(S)) return false; } while (false); do { if (!getDerived().VisitWhileStmt(S)) return false; } while (false); return true; } bool VisitWhileStmt(WhileStmt *S) { return true; } | |
bool TraverseAdjustedType(AdjustedType *T); | |
bool TraverseDecayedType(DecayedType *T); | |
bool TraverseConstantArrayType(ConstantArrayType *T); | |
bool TraverseDependentSizedArrayType(DependentSizedArrayType *T); | |
bool TraverseIncompleteArrayType(IncompleteArrayType *T); | |
bool TraverseVariableArrayType(VariableArrayType *T); | |
bool TraverseAtomicType(AtomicType *T); | |
bool TraverseAttributedType(AttributedType *T); | |
bool TraverseBlockPointerType(BlockPointerType *T); | |
bool TraverseBuiltinType(BuiltinType *T); | |
bool TraverseComplexType(ComplexType *T); | |
bool TraverseDecltypeType(DecltypeType *T); | |
bool TraverseAutoType(AutoType *T); | |
bool TraverseDeducedTemplateSpecializationType(DeducedTemplateSpecializationType *T); | |
bool TraverseDependentAddressSpaceType(DependentAddressSpaceType *T); | |
bool TraverseDependentExtIntType(DependentExtIntType *T); | |
bool TraverseDependentNameType(DependentNameType *T); | |
bool TraverseDependentSizedExtVectorType(DependentSizedExtVectorType *T); | |
bool TraverseDependentTemplateSpecializationType(DependentTemplateSpecializationType *T); | |
bool TraverseDependentVectorType(DependentVectorType *T); | |
bool TraverseElaboratedType(ElaboratedType *T); | |
bool TraverseExtIntType(ExtIntType *T); | |
bool TraverseFunctionNoProtoType(FunctionNoProtoType *T); | |
bool TraverseFunctionProtoType(FunctionProtoType *T); | |
bool TraverseInjectedClassNameType(InjectedClassNameType *T); | |
bool TraverseMacroQualifiedType(MacroQualifiedType *T); | |
bool TraverseConstantMatrixType(ConstantMatrixType *T); | |
bool TraverseDependentSizedMatrixType(DependentSizedMatrixType *T); | |
bool TraverseMemberPointerType(MemberPointerType *T); | |
bool TraverseObjCObjectPointerType(ObjCObjectPointerType *T); | |
bool TraverseObjCObjectType(ObjCObjectType *T); | |
bool TraverseObjCInterfaceType(ObjCInterfaceType *T); | |
bool TraverseObjCTypeParamType(ObjCTypeParamType *T); | |
bool TraversePackExpansionType(PackExpansionType *T); | |
bool TraverseParenType(ParenType *T); | |
bool TraversePipeType(PipeType *T); | |
bool TraversePointerType(PointerType *T); | |
bool TraverseLValueReferenceType(LValueReferenceType *T); | |
bool TraverseRValueReferenceType(RValueReferenceType *T); | |
bool TraverseSubstTemplateTypeParmPackType(SubstTemplateTypeParmPackType *T); | |
bool TraverseSubstTemplateTypeParmType(SubstTemplateTypeParmType *T); | |
bool TraverseEnumType(EnumType *T); | |
bool TraverseRecordType(RecordType *T); | |
bool TraverseTemplateSpecializationType(TemplateSpecializationType *T); | |
bool TraverseTemplateTypeParmType(TemplateTypeParmType *T); | |
bool TraverseTypeOfExprType(TypeOfExprType *T); | |
bool TraverseTypeOfType(TypeOfType *T); | |
bool TraverseTypedefType(TypedefType *T); | |
bool TraverseUnaryTransformType(UnaryTransformType *T); | |
bool TraverseUnresolvedUsingType(UnresolvedUsingType *T); | |
bool TraverseVectorType(VectorType *T); | |
bool TraverseExtVectorType(ExtVectorType *T); | |
bool WalkUpFromType(Type *T) { return getDerived().VisitType(T); } | |
bool VisitType(Type *T) { return true; } | |
bool WalkUpFromAdjustedType(AdjustedType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitAdjustedType(T)) return false; } while (false); return true; } bool VisitAdjustedType(AdjustedType *T) { return true; } | |
bool WalkUpFromDecayedType(DecayedType *T) { do { if (!getDerived().WalkUpFromAdjustedType(T)) return false; } while (false); do { if (!getDerived().VisitDecayedType(T)) return false; } while (false); return true; } bool VisitDecayedType(DecayedType *T) { return true; } | |
bool WalkUpFromArrayType(ArrayType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitArrayType(T)) return false; } while (false); return true; } bool VisitArrayType(ArrayType *T) { return true; } | |
bool WalkUpFromConstantArrayType(ConstantArrayType *T) { do { if (!getDerived().WalkUpFromArrayType(T)) return false; } while (false); do { if (!getDerived().VisitConstantArrayType(T)) return false; } while (false); return true; } bool VisitConstantArrayType(ConstantArrayType *T) { return true; } | |
bool WalkUpFromDependentSizedArrayType(DependentSizedArrayType *T) { do { if (!getDerived().WalkUpFromArrayType(T)) return false; } while (false); do { if (!getDerived().VisitDependentSizedArrayType(T)) return false; } while (false); return true; } bool VisitDependentSizedArrayType(DependentSizedArrayType *T) { return true; } | |
bool WalkUpFromIncompleteArrayType(IncompleteArrayType *T) { do { if (!getDerived().WalkUpFromArrayType(T)) return false; } while (false); do { if (!getDerived().VisitIncompleteArrayType(T)) return false; } while (false); return true; } bool VisitIncompleteArrayType(IncompleteArrayType *T) { return true; } | |
bool WalkUpFromVariableArrayType(VariableArrayType *T) { do { if (!getDerived().WalkUpFromArrayType(T)) return false; } while (false); do { if (!getDerived().VisitVariableArrayType(T)) return false; } while (false); return true; } bool VisitVariableArrayType(VariableArrayType *T) { return true; } | |
bool WalkUpFromAtomicType(AtomicType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitAtomicType(T)) return false; } while (false); return true; } bool VisitAtomicType(AtomicType *T) { return true; } | |
bool WalkUpFromAttributedType(AttributedType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitAttributedType(T)) return false; } while (false); return true; } bool VisitAttributedType(AttributedType *T) { return true; } | |
bool WalkUpFromBlockPointerType(BlockPointerType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitBlockPointerType(T)) return false; } while (false); return true; } bool VisitBlockPointerType(BlockPointerType *T) { return true; } | |
bool WalkUpFromBuiltinType(BuiltinType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitBuiltinType(T)) return false; } while (false); return true; } bool VisitBuiltinType(BuiltinType *T) { return true; } | |
bool WalkUpFromComplexType(ComplexType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitComplexType(T)) return false; } while (false); return true; } bool VisitComplexType(ComplexType *T) { return true; } | |
bool WalkUpFromDecltypeType(DecltypeType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitDecltypeType(T)) return false; } while (false); return true; } bool VisitDecltypeType(DecltypeType *T) { return true; } | |
bool WalkUpFromDeducedType(DeducedType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitDeducedType(T)) return false; } while (false); return true; } bool VisitDeducedType(DeducedType *T) { return true; } | |
bool WalkUpFromAutoType(AutoType *T) { do { if (!getDerived().WalkUpFromDeducedType(T)) return false; } while (false); do { if (!getDerived().VisitAutoType(T)) return false; } while (false); return true; } bool VisitAutoType(AutoType *T) { return true; } | |
bool WalkUpFromDeducedTemplateSpecializationType(DeducedTemplateSpecializationType *T) { do { if (!getDerived().WalkUpFromDeducedType(T)) return false; } while (false); do { if (!getDerived().VisitDeducedTemplateSpecializationType(T)) return false; } while (false); return true; } bool VisitDeducedTemplateSpecializationType(DeducedTemplateSpecializationType *T) { return true; } | |
bool WalkUpFromDependentAddressSpaceType(DependentAddressSpaceType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitDependentAddressSpaceType(T)) return false; } while (false); return true; } bool VisitDependentAddressSpaceType(DependentAddressSpaceType *T) { return true; } | |
bool WalkUpFromDependentExtIntType(DependentExtIntType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitDependentExtIntType(T)) return false; } while (false); return true; } bool VisitDependentExtIntType(DependentExtIntType *T) { return true; } | |
bool WalkUpFromDependentNameType(DependentNameType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitDependentNameType(T)) return false; } while (false); return true; } bool VisitDependentNameType(DependentNameType *T) { return true; } | |
bool WalkUpFromDependentSizedExtVectorType(DependentSizedExtVectorType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitDependentSizedExtVectorType(T)) return false; } while (false); return true; } bool VisitDependentSizedExtVectorType(DependentSizedExtVectorType *T) { return true; } | |
bool WalkUpFromDependentTemplateSpecializationType(DependentTemplateSpecializationType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitDependentTemplateSpecializationType(T)) return false; } while (false); return true; } bool VisitDependentTemplateSpecializationType(DependentTemplateSpecializationType *T) { return true; } | |
bool WalkUpFromDependentVectorType(DependentVectorType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitDependentVectorType(T)) return false; } while (false); return true; } bool VisitDependentVectorType(DependentVectorType *T) { return true; } | |
bool WalkUpFromElaboratedType(ElaboratedType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitElaboratedType(T)) return false; } while (false); return true; } bool VisitElaboratedType(ElaboratedType *T) { return true; } | |
bool WalkUpFromExtIntType(ExtIntType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitExtIntType(T)) return false; } while (false); return true; } bool VisitExtIntType(ExtIntType *T) { return true; } | |
bool WalkUpFromFunctionType(FunctionType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitFunctionType(T)) return false; } while (false); return true; } bool VisitFunctionType(FunctionType *T) { return true; } | |
bool WalkUpFromFunctionNoProtoType(FunctionNoProtoType *T) { do { if (!getDerived().WalkUpFromFunctionType(T)) return false; } while (false); do { if (!getDerived().VisitFunctionNoProtoType(T)) return false; } while (false); return true; } bool VisitFunctionNoProtoType(FunctionNoProtoType *T) { return true; } | |
bool WalkUpFromFunctionProtoType(FunctionProtoType *T) { do { if (!getDerived().WalkUpFromFunctionType(T)) return false; } while (false); do { if (!getDerived().VisitFunctionProtoType(T)) return false; } while (false); return true; } bool VisitFunctionProtoType(FunctionProtoType *T) { return true; } | |
bool WalkUpFromInjectedClassNameType(InjectedClassNameType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitInjectedClassNameType(T)) return false; } while (false); return true; } bool VisitInjectedClassNameType(InjectedClassNameType *T) { return true; } | |
bool WalkUpFromMacroQualifiedType(MacroQualifiedType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitMacroQualifiedType(T)) return false; } while (false); return true; } bool VisitMacroQualifiedType(MacroQualifiedType *T) { return true; } | |
bool WalkUpFromMatrixType(MatrixType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitMatrixType(T)) return false; } while (false); return true; } bool VisitMatrixType(MatrixType *T) { return true; } | |
bool WalkUpFromConstantMatrixType(ConstantMatrixType *T) { do { if (!getDerived().WalkUpFromMatrixType(T)) return false; } while (false); do { if (!getDerived().VisitConstantMatrixType(T)) return false; } while (false); return true; } bool VisitConstantMatrixType(ConstantMatrixType *T) { return true; } | |
bool WalkUpFromDependentSizedMatrixType(DependentSizedMatrixType *T) { do { if (!getDerived().WalkUpFromMatrixType(T)) return false; } while (false); do { if (!getDerived().VisitDependentSizedMatrixType(T)) return false; } while (false); return true; } bool VisitDependentSizedMatrixType(DependentSizedMatrixType *T) { return true; } | |
bool WalkUpFromMemberPointerType(MemberPointerType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitMemberPointerType(T)) return false; } while (false); return true; } bool VisitMemberPointerType(MemberPointerType *T) { return true; } | |
bool WalkUpFromObjCObjectPointerType(ObjCObjectPointerType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitObjCObjectPointerType(T)) return false; } while (false); return true; } bool VisitObjCObjectPointerType(ObjCObjectPointerType *T) { return true; } | |
bool WalkUpFromObjCObjectType(ObjCObjectType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitObjCObjectType(T)) return false; } while (false); return true; } bool VisitObjCObjectType(ObjCObjectType *T) { return true; } | |
bool WalkUpFromObjCInterfaceType(ObjCInterfaceType *T) { do { if (!getDerived().WalkUpFromObjCObjectType(T)) return false; } while (false); do { if (!getDerived().VisitObjCInterfaceType(T)) return false; } while (false); return true; } bool VisitObjCInterfaceType(ObjCInterfaceType *T) { return true; } | |
bool WalkUpFromObjCTypeParamType(ObjCTypeParamType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitObjCTypeParamType(T)) return false; } while (false); return true; } bool VisitObjCTypeParamType(ObjCTypeParamType *T) { return true; } | |
bool WalkUpFromPackExpansionType(PackExpansionType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitPackExpansionType(T)) return false; } while (false); return true; } bool VisitPackExpansionType(PackExpansionType *T) { return true; } | |
bool WalkUpFromParenType(ParenType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitParenType(T)) return false; } while (false); return true; } bool VisitParenType(ParenType *T) { return true; } | |
bool WalkUpFromPipeType(PipeType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitPipeType(T)) return false; } while (false); return true; } bool VisitPipeType(PipeType *T) { return true; } | |
bool WalkUpFromPointerType(PointerType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitPointerType(T)) return false; } while (false); return true; } bool VisitPointerType(PointerType *T) { return true; } | |
bool WalkUpFromReferenceType(ReferenceType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitReferenceType(T)) return false; } while (false); return true; } bool VisitReferenceType(ReferenceType *T) { return true; } | |
bool WalkUpFromLValueReferenceType(LValueReferenceType *T) { do { if (!getDerived().WalkUpFromReferenceType(T)) return false; } while (false); do { if (!getDerived().VisitLValueReferenceType(T)) return false; } while (false); return true; } bool VisitLValueReferenceType(LValueReferenceType *T) { return true; } | |
bool WalkUpFromRValueReferenceType(RValueReferenceType *T) { do { if (!getDerived().WalkUpFromReferenceType(T)) return false; } while (false); do { if (!getDerived().VisitRValueReferenceType(T)) return false; } while (false); return true; } bool VisitRValueReferenceType(RValueReferenceType *T) { return true; } | |
bool WalkUpFromSubstTemplateTypeParmPackType(SubstTemplateTypeParmPackType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitSubstTemplateTypeParmPackType(T)) return false; } while (false); return true; } bool VisitSubstTemplateTypeParmPackType(SubstTemplateTypeParmPackType *T) { return true; } | |
bool WalkUpFromSubstTemplateTypeParmType(SubstTemplateTypeParmType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitSubstTemplateTypeParmType(T)) return false; } while (false); return true; } bool VisitSubstTemplateTypeParmType(SubstTemplateTypeParmType *T) { return true; } | |
bool WalkUpFromTagType(TagType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitTagType(T)) return false; } while (false); return true; } bool VisitTagType(TagType *T) { return true; } | |
bool WalkUpFromEnumType(EnumType *T) { do { if (!getDerived().WalkUpFromTagType(T)) return false; } while (false); do { if (!getDerived().VisitEnumType(T)) return false; } while (false); return true; } bool VisitEnumType(EnumType *T) { return true; } | |
bool WalkUpFromRecordType(RecordType *T) { do { if (!getDerived().WalkUpFromTagType(T)) return false; } while (false); do { if (!getDerived().VisitRecordType(T)) return false; } while (false); return true; } bool VisitRecordType(RecordType *T) { return true; } | |
bool WalkUpFromTemplateSpecializationType(TemplateSpecializationType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitTemplateSpecializationType(T)) return false; } while (false); return true; } bool VisitTemplateSpecializationType(TemplateSpecializationType *T) { return true; } | |
bool WalkUpFromTemplateTypeParmType(TemplateTypeParmType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitTemplateTypeParmType(T)) return false; } while (false); return true; } bool VisitTemplateTypeParmType(TemplateTypeParmType *T) { return true; } | |
bool WalkUpFromTypeOfExprType(TypeOfExprType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitTypeOfExprType(T)) return false; } while (false); return true; } bool VisitTypeOfExprType(TypeOfExprType *T) { return true; } | |
bool WalkUpFromTypeOfType(TypeOfType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitTypeOfType(T)) return false; } while (false); return true; } bool VisitTypeOfType(TypeOfType *T) { return true; } | |
bool WalkUpFromTypedefType(TypedefType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitTypedefType(T)) return false; } while (false); return true; } bool VisitTypedefType(TypedefType *T) { return true; } | |
bool WalkUpFromUnaryTransformType(UnaryTransformType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitUnaryTransformType(T)) return false; } while (false); return true; } bool VisitUnaryTransformType(UnaryTransformType *T) { return true; } | |
bool WalkUpFromUnresolvedUsingType(UnresolvedUsingType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitUnresolvedUsingType(T)) return false; } while (false); return true; } bool VisitUnresolvedUsingType(UnresolvedUsingType *T) { return true; } | |
bool WalkUpFromVectorType(VectorType *T) { do { if (!getDerived().WalkUpFromType(T)) return false; } while (false); do { if (!getDerived().VisitVectorType(T)) return false; } while (false); return true; } bool VisitVectorType(VectorType *T) { return true; } | |
bool WalkUpFromExtVectorType(ExtVectorType *T) { do { if (!getDerived().WalkUpFromVectorType(T)) return false; } while (false); do { if (!getDerived().VisitExtVectorType(T)) return false; } while (false); return true; } bool VisitExtVectorType(ExtVectorType *T) { return true; } | |
bool TraverseQualifiedTypeLoc(QualifiedTypeLoc TL); | |
bool TraverseAdjustedTypeLoc(AdjustedTypeLoc TL); | |
bool TraverseDecayedTypeLoc(DecayedTypeLoc TL); | |
bool TraverseConstantArrayTypeLoc(ConstantArrayTypeLoc TL); | |
bool TraverseDependentSizedArrayTypeLoc(DependentSizedArrayTypeLoc TL); | |
bool TraverseIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL); | |
bool TraverseVariableArrayTypeLoc(VariableArrayTypeLoc TL); | |
bool TraverseAtomicTypeLoc(AtomicTypeLoc TL); | |
bool TraverseAttributedTypeLoc(AttributedTypeLoc TL); | |
bool TraverseBlockPointerTypeLoc(BlockPointerTypeLoc TL); | |
bool TraverseBuiltinTypeLoc(BuiltinTypeLoc TL); | |
bool TraverseComplexTypeLoc(ComplexTypeLoc TL); | |
bool TraverseDecltypeTypeLoc(DecltypeTypeLoc TL); | |
bool TraverseAutoTypeLoc(AutoTypeLoc TL); | |
bool TraverseDeducedTemplateSpecializationTypeLoc(DeducedTemplateSpecializationTypeLoc TL); | |
bool TraverseDependentAddressSpaceTypeLoc(DependentAddressSpaceTypeLoc TL); | |
bool TraverseDependentExtIntTypeLoc(DependentExtIntTypeLoc TL); | |
bool TraverseDependentNameTypeLoc(DependentNameTypeLoc TL); | |
bool TraverseDependentSizedExtVectorTypeLoc(DependentSizedExtVectorTypeLoc TL); | |
bool TraverseDependentTemplateSpecializationTypeLoc(DependentTemplateSpecializationTypeLoc TL); | |
bool TraverseDependentVectorTypeLoc(DependentVectorTypeLoc TL); | |
bool TraverseElaboratedTypeLoc(ElaboratedTypeLoc TL); | |
bool TraverseExtIntTypeLoc(ExtIntTypeLoc TL); | |
bool TraverseFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL); | |
bool TraverseFunctionProtoTypeLoc(FunctionProtoTypeLoc TL); | |
bool TraverseInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL); | |
bool TraverseMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL); | |
bool TraverseConstantMatrixTypeLoc(ConstantMatrixTypeLoc TL); | |
bool TraverseDependentSizedMatrixTypeLoc(DependentSizedMatrixTypeLoc TL); | |
bool TraverseMemberPointerTypeLoc(MemberPointerTypeLoc TL); | |
bool TraverseObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL); | |
bool TraverseObjCObjectTypeLoc(ObjCObjectTypeLoc TL); | |
bool TraverseObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL); | |
bool TraverseObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL); | |
bool TraversePackExpansionTypeLoc(PackExpansionTypeLoc TL); | |
bool TraverseParenTypeLoc(ParenTypeLoc TL); | |
bool TraversePipeTypeLoc(PipeTypeLoc TL); | |
bool TraversePointerTypeLoc(PointerTypeLoc TL); | |
bool TraverseLValueReferenceTypeLoc(LValueReferenceTypeLoc TL); | |
bool TraverseRValueReferenceTypeLoc(RValueReferenceTypeLoc TL); | |
bool TraverseSubstTemplateTypeParmPackTypeLoc(SubstTemplateTypeParmPackTypeLoc TL); | |
bool TraverseSubstTemplateTypeParmTypeLoc(SubstTemplateTypeParmTypeLoc TL); | |
bool TraverseEnumTypeLoc(EnumTypeLoc TL); | |
bool TraverseRecordTypeLoc(RecordTypeLoc TL); | |
bool TraverseTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL); | |
bool TraverseTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL); | |
bool TraverseTypeOfExprTypeLoc(TypeOfExprTypeLoc TL); | |
bool TraverseTypeOfTypeLoc(TypeOfTypeLoc TL); | |
bool TraverseTypedefTypeLoc(TypedefTypeLoc TL); | |
bool TraverseUnaryTransformTypeLoc(UnaryTransformTypeLoc TL); | |
bool TraverseUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL); | |
bool TraverseVectorTypeLoc(VectorTypeLoc TL); | |
bool TraverseExtVectorTypeLoc(ExtVectorTypeLoc TL); | |
bool WalkUpFromTypeLoc(TypeLoc TL) { return getDerived().VisitTypeLoc(TL); } | |
bool VisitTypeLoc(TypeLoc TL) { return true; } | |
bool WalkUpFromQualifiedTypeLoc(QualifiedTypeLoc TL) { | |
return getDerived().VisitUnqualTypeLoc(TL.getUnqualifiedLoc()); | |
} | |
bool VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { return true; } | |
bool WalkUpFromUnqualTypeLoc(UnqualTypeLoc TL) { | |
return getDerived().VisitUnqualTypeLoc(TL.getUnqualifiedLoc()); | |
} | |
bool VisitUnqualTypeLoc(UnqualTypeLoc TL) { return true; } | |
bool WalkUpFromAdjustedTypeLoc(AdjustedTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitAdjustedTypeLoc(TL)) return false; } while (false); return true; } bool VisitAdjustedTypeLoc(AdjustedTypeLoc TL) { return true; } | |
bool WalkUpFromDecayedTypeLoc(DecayedTypeLoc TL) { do { if (!getDerived().WalkUpFromAdjustedTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitDecayedTypeLoc(TL)) return false; } while (false); return true; } bool VisitDecayedTypeLoc(DecayedTypeLoc TL) { return true; } | |
bool WalkUpFromArrayTypeLoc(ArrayTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitArrayTypeLoc(TL)) return false; } while (false); return true; } bool VisitArrayTypeLoc(ArrayTypeLoc TL) { return true; } | |
bool WalkUpFromConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { do { if (!getDerived().WalkUpFromArrayTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitConstantArrayTypeLoc(TL)) return false; } while (false); return true; } bool VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { return true; } | |
bool WalkUpFromDependentSizedArrayTypeLoc(DependentSizedArrayTypeLoc TL) { do { if (!getDerived().WalkUpFromArrayTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitDependentSizedArrayTypeLoc(TL)) return false; } while (false); return true; } bool VisitDependentSizedArrayTypeLoc(DependentSizedArrayTypeLoc TL) { return true; } | |
bool WalkUpFromIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { do { if (!getDerived().WalkUpFromArrayTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitIncompleteArrayTypeLoc(TL)) return false; } while (false); return true; } bool VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { return true; } | |
bool WalkUpFromVariableArrayTypeLoc(VariableArrayTypeLoc TL) { do { if (!getDerived().WalkUpFromArrayTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitVariableArrayTypeLoc(TL)) return false; } while (false); return true; } bool VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { return true; } | |
bool WalkUpFromAtomicTypeLoc(AtomicTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitAtomicTypeLoc(TL)) return false; } while (false); return true; } bool VisitAtomicTypeLoc(AtomicTypeLoc TL) { return true; } | |
bool WalkUpFromAttributedTypeLoc(AttributedTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitAttributedTypeLoc(TL)) return false; } while (false); return true; } bool VisitAttributedTypeLoc(AttributedTypeLoc TL) { return true; } | |
bool WalkUpFromBlockPointerTypeLoc(BlockPointerTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitBlockPointerTypeLoc(TL)) return false; } while (false); return true; } bool VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { return true; } | |
bool WalkUpFromBuiltinTypeLoc(BuiltinTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitBuiltinTypeLoc(TL)) return false; } while (false); return true; } bool VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { return true; } | |
bool WalkUpFromComplexTypeLoc(ComplexTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitComplexTypeLoc(TL)) return false; } while (false); return true; } bool VisitComplexTypeLoc(ComplexTypeLoc TL) { return true; } | |
bool WalkUpFromDecltypeTypeLoc(DecltypeTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitDecltypeTypeLoc(TL)) return false; } while (false); return true; } bool VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { return true; } | |
bool WalkUpFromDeducedTypeLoc(DeducedTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitDeducedTypeLoc(TL)) return false; } while (false); return true; } bool VisitDeducedTypeLoc(DeducedTypeLoc TL) { return true; } | |
bool WalkUpFromAutoTypeLoc(AutoTypeLoc TL) { do { if (!getDerived().WalkUpFromDeducedTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitAutoTypeLoc(TL)) return false; } while (false); return true; } bool VisitAutoTypeLoc(AutoTypeLoc TL) { return true; } | |
bool WalkUpFromDeducedTemplateSpecializationTypeLoc(DeducedTemplateSpecializationTypeLoc TL) { do { if (!getDerived().WalkUpFromDeducedTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitDeducedTemplateSpecializationTypeLoc(TL)) return false; } while (false); return true; } bool VisitDeducedTemplateSpecializationTypeLoc(DeducedTemplateSpecializationTypeLoc TL) { return true; } | |
bool WalkUpFromDependentAddressSpaceTypeLoc(DependentAddressSpaceTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitDependentAddressSpaceTypeLoc(TL)) return false; } while (false); return true; } bool VisitDependentAddressSpaceTypeLoc(DependentAddressSpaceTypeLoc TL) { return true; } | |
bool WalkUpFromDependentExtIntTypeLoc(DependentExtIntTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitDependentExtIntTypeLoc(TL)) return false; } while (false); return true; } bool VisitDependentExtIntTypeLoc(DependentExtIntTypeLoc TL) { return true; } | |
bool WalkUpFromDependentNameTypeLoc(DependentNameTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitDependentNameTypeLoc(TL)) return false; } while (false); return true; } bool VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { return true; } | |
bool WalkUpFromDependentSizedExtVectorTypeLoc(DependentSizedExtVectorTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitDependentSizedExtVectorTypeLoc(TL)) return false; } while (false); return true; } bool VisitDependentSizedExtVectorTypeLoc(DependentSizedExtVectorTypeLoc TL) { return true; } | |
bool WalkUpFromDependentTemplateSpecializationTypeLoc(DependentTemplateSpecializationTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitDependentTemplateSpecializationTypeLoc(TL)) return false; } while (false); return true; } bool VisitDependentTemplateSpecializationTypeLoc(DependentTemplateSpecializationTypeLoc TL) { return true; } | |
bool WalkUpFromDependentVectorTypeLoc(DependentVectorTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitDependentVectorTypeLoc(TL)) return false; } while (false); return true; } bool VisitDependentVectorTypeLoc(DependentVectorTypeLoc TL) { return true; } | |
bool WalkUpFromElaboratedTypeLoc(ElaboratedTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitElaboratedTypeLoc(TL)) return false; } while (false); return true; } bool VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { return true; } | |
bool WalkUpFromExtIntTypeLoc(ExtIntTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitExtIntTypeLoc(TL)) return false; } while (false); return true; } bool VisitExtIntTypeLoc(ExtIntTypeLoc TL) { return true; } | |
bool WalkUpFromFunctionTypeLoc(FunctionTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitFunctionTypeLoc(TL)) return false; } while (false); return true; } bool VisitFunctionTypeLoc(FunctionTypeLoc TL) { return true; } | |
bool WalkUpFromFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { do { if (!getDerived().WalkUpFromFunctionTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitFunctionNoProtoTypeLoc(TL)) return false; } while (false); return true; } bool VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { return true; } | |
bool WalkUpFromFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { do { if (!getDerived().WalkUpFromFunctionTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitFunctionProtoTypeLoc(TL)) return false; } while (false); return true; } bool VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { return true; } | |
bool WalkUpFromInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitInjectedClassNameTypeLoc(TL)) return false; } while (false); return true; } bool VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { return true; } | |
bool WalkUpFromMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitMacroQualifiedTypeLoc(TL)) return false; } while (false); return true; } bool VisitMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL) { return true; } | |
bool WalkUpFromMatrixTypeLoc(MatrixTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitMatrixTypeLoc(TL)) return false; } while (false); return true; } bool VisitMatrixTypeLoc(MatrixTypeLoc TL) { return true; } | |
bool WalkUpFromConstantMatrixTypeLoc(ConstantMatrixTypeLoc TL) { do { if (!getDerived().WalkUpFromMatrixTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitConstantMatrixTypeLoc(TL)) return false; } while (false); return true; } bool VisitConstantMatrixTypeLoc(ConstantMatrixTypeLoc TL) { return true; } | |
bool WalkUpFromDependentSizedMatrixTypeLoc(DependentSizedMatrixTypeLoc TL) { do { if (!getDerived().WalkUpFromMatrixTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitDependentSizedMatrixTypeLoc(TL)) return false; } while (false); return true; } bool VisitDependentSizedMatrixTypeLoc(DependentSizedMatrixTypeLoc TL) { return true; } | |
bool WalkUpFromMemberPointerTypeLoc(MemberPointerTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitMemberPointerTypeLoc(TL)) return false; } while (false); return true; } bool VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { return true; } | |
bool WalkUpFromObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitObjCObjectPointerTypeLoc(TL)) return false; } while (false); return true; } bool VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { return true; } | |
bool WalkUpFromObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitObjCObjectTypeLoc(TL)) return false; } while (false); return true; } bool VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { return true; } | |
bool WalkUpFromObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { do { if (!getDerived().WalkUpFromObjCObjectTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitObjCInterfaceTypeLoc(TL)) return false; } while (false); return true; } bool VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { return true; } | |
bool WalkUpFromObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitObjCTypeParamTypeLoc(TL)) return false; } while (false); return true; } bool VisitObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) { return true; } | |
bool WalkUpFromPackExpansionTypeLoc(PackExpansionTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitPackExpansionTypeLoc(TL)) return false; } while (false); return true; } bool VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { return true; } | |
bool WalkUpFromParenTypeLoc(ParenTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitParenTypeLoc(TL)) return false; } while (false); return true; } bool VisitParenTypeLoc(ParenTypeLoc TL) { return true; } | |
bool WalkUpFromPipeTypeLoc(PipeTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitPipeTypeLoc(TL)) return false; } while (false); return true; } bool VisitPipeTypeLoc(PipeTypeLoc TL) { return true; } | |
bool WalkUpFromPointerTypeLoc(PointerTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitPointerTypeLoc(TL)) return false; } while (false); return true; } bool VisitPointerTypeLoc(PointerTypeLoc TL) { return true; } | |
bool WalkUpFromReferenceTypeLoc(ReferenceTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitReferenceTypeLoc(TL)) return false; } while (false); return true; } bool VisitReferenceTypeLoc(ReferenceTypeLoc TL) { return true; } | |
bool WalkUpFromLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { do { if (!getDerived().WalkUpFromReferenceTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitLValueReferenceTypeLoc(TL)) return false; } while (false); return true; } bool VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { return true; } | |
bool WalkUpFromRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { do { if (!getDerived().WalkUpFromReferenceTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitRValueReferenceTypeLoc(TL)) return false; } while (false); return true; } bool VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { return true; } | |
bool WalkUpFromSubstTemplateTypeParmPackTypeLoc(SubstTemplateTypeParmPackTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitSubstTemplateTypeParmPackTypeLoc(TL)) return false; } while (false); return true; } bool VisitSubstTemplateTypeParmPackTypeLoc(SubstTemplateTypeParmPackTypeLoc TL) { return true; } | |
bool WalkUpFromSubstTemplateTypeParmTypeLoc(SubstTemplateTypeParmTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitSubstTemplateTypeParmTypeLoc(TL)) return false; } while (false); return true; } bool VisitSubstTemplateTypeParmTypeLoc(SubstTemplateTypeParmTypeLoc TL) { return true; } | |
bool WalkUpFromTagTypeLoc(TagTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitTagTypeLoc(TL)) return false; } while (false); return true; } bool VisitTagTypeLoc(TagTypeLoc TL) { return true; } | |
bool WalkUpFromEnumTypeLoc(EnumTypeLoc TL) { do { if (!getDerived().WalkUpFromTagTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitEnumTypeLoc(TL)) return false; } while (false); return true; } bool VisitEnumTypeLoc(EnumTypeLoc TL) { return true; } | |
bool WalkUpFromRecordTypeLoc(RecordTypeLoc TL) { do { if (!getDerived().WalkUpFromTagTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitRecordTypeLoc(TL)) return false; } while (false); return true; } bool VisitRecordTypeLoc(RecordTypeLoc TL) { return true; } | |
bool WalkUpFromTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitTemplateSpecializationTypeLoc(TL)) return false; } while (false); return true; } bool VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL) { return true; } | |
bool WalkUpFromTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitTemplateTypeParmTypeLoc(TL)) return false; } while (false); return true; } bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { return true; } | |
bool WalkUpFromTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitTypeOfExprTypeLoc(TL)) return false; } while (false); return true; } bool VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { return true; } | |
bool WalkUpFromTypeOfTypeLoc(TypeOfTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitTypeOfTypeLoc(TL)) return false; } while (false); return true; } bool VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { return true; } | |
bool WalkUpFromTypedefTypeLoc(TypedefTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitTypedefTypeLoc(TL)) return false; } while (false); return true; } bool VisitTypedefTypeLoc(TypedefTypeLoc TL) { return true; } | |
bool WalkUpFromUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitUnaryTransformTypeLoc(TL)) return false; } while (false); return true; } bool VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { return true; } | |
bool WalkUpFromUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitUnresolvedUsingTypeLoc(TL)) return false; } while (false); return true; } bool VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { return true; } | |
bool WalkUpFromVectorTypeLoc(VectorTypeLoc TL) { do { if (!getDerived().WalkUpFromTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitVectorTypeLoc(TL)) return false; } while (false); return true; } bool VisitVectorTypeLoc(VectorTypeLoc TL) { return true; } | |
bool WalkUpFromExtVectorTypeLoc(ExtVectorTypeLoc TL) { do { if (!getDerived().WalkUpFromVectorTypeLoc(TL)) return false; } while (false); do { if (!getDerived().VisitExtVectorTypeLoc(TL)) return false; } while (false); return true; } bool VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { return true; } | |
bool TraverseAccessSpecDecl(AccessSpecDecl *D); | |
bool TraverseBlockDecl(BlockDecl *D); | |
bool TraverseCapturedDecl(CapturedDecl *D); | |
bool TraverseClassScopeFunctionSpecializationDecl(ClassScopeFunctionSpecializationDecl *D); | |
bool TraverseEmptyDecl(EmptyDecl *D); | |
bool TraverseExportDecl(ExportDecl *D); | |
bool TraverseExternCContextDecl(ExternCContextDecl *D); | |
bool TraverseFileScopeAsmDecl(FileScopeAsmDecl *D); | |
bool TraverseFriendDecl(FriendDecl *D); | |
bool TraverseFriendTemplateDecl(FriendTemplateDecl *D); | |
bool TraverseImportDecl(ImportDecl *D); | |
bool TraverseLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D); | |
bool TraverseLinkageSpecDecl(LinkageSpecDecl *D); | |
bool TraverseUsingDecl(UsingDecl *D); | |
bool TraverseUsingEnumDecl(UsingEnumDecl *D); | |
bool TraverseLabelDecl(LabelDecl *D); | |
bool TraverseNamespaceDecl(NamespaceDecl *D); | |
bool TraverseNamespaceAliasDecl(NamespaceAliasDecl *D); | |
bool TraverseObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D); | |
bool TraverseObjCCategoryDecl(ObjCCategoryDecl *D); | |
bool TraverseObjCCategoryImplDecl(ObjCCategoryImplDecl *D); | |
bool TraverseObjCImplementationDecl(ObjCImplementationDecl *D); | |
bool TraverseObjCInterfaceDecl(ObjCInterfaceDecl *D); | |
bool TraverseObjCProtocolDecl(ObjCProtocolDecl *D); | |
bool TraverseObjCMethodDecl(ObjCMethodDecl *D); | |
bool TraverseObjCPropertyDecl(ObjCPropertyDecl *D); | |
bool TraverseBuiltinTemplateDecl(BuiltinTemplateDecl *D); | |
bool TraverseConceptDecl(ConceptDecl *D); | |
bool TraverseClassTemplateDecl(ClassTemplateDecl *D); | |
bool TraverseFunctionTemplateDecl(FunctionTemplateDecl *D); | |
bool TraverseTypeAliasTemplateDecl(TypeAliasTemplateDecl *D); | |
bool TraverseVarTemplateDecl(VarTemplateDecl *D); | |
bool TraverseTemplateTemplateParmDecl(TemplateTemplateParmDecl *D); | |
bool TraverseEnumDecl(EnumDecl *D); | |
bool TraverseRecordDecl(RecordDecl *D); | |
bool TraverseCXXRecordDecl(CXXRecordDecl *D); | |
bool TraverseClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl *D); | |
bool TraverseClassTemplatePartialSpecializationDecl(ClassTemplatePartialSpecializationDecl *D); | |
bool TraverseTemplateTypeParmDecl(TemplateTypeParmDecl *D); | |
bool TraverseObjCTypeParamDecl(ObjCTypeParamDecl *D); | |
bool TraverseTypeAliasDecl(TypeAliasDecl *D); | |
bool TraverseTypedefDecl(TypedefDecl *D); | |
bool TraverseUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D); | |
bool TraverseUnresolvedUsingIfExistsDecl(UnresolvedUsingIfExistsDecl *D); | |
bool TraverseUsingDirectiveDecl(UsingDirectiveDecl *D); | |
bool TraverseUsingPackDecl(UsingPackDecl *D); | |
bool TraverseUsingShadowDecl(UsingShadowDecl *D); | |
bool TraverseConstructorUsingShadowDecl(ConstructorUsingShadowDecl *D); | |
bool TraverseBindingDecl(BindingDecl *D); | |
bool TraverseFieldDecl(FieldDecl *D); | |
bool TraverseObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D); | |
bool TraverseObjCIvarDecl(ObjCIvarDecl *D); | |
bool TraverseFunctionDecl(FunctionDecl *D); | |
bool TraverseCXXDeductionGuideDecl(CXXDeductionGuideDecl *D); | |
bool TraverseCXXMethodDecl(CXXMethodDecl *D); | |
bool TraverseCXXConstructorDecl(CXXConstructorDecl *D); | |
bool TraverseCXXConversionDecl(CXXConversionDecl *D); | |
bool TraverseCXXDestructorDecl(CXXDestructorDecl *D); | |
bool TraverseMSPropertyDecl(MSPropertyDecl *D); | |
bool TraverseNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D); | |
bool TraverseVarDecl(VarDecl *D); | |
bool TraverseDecompositionDecl(DecompositionDecl *D); | |
bool TraverseImplicitParamDecl(ImplicitParamDecl *D); | |
bool TraverseOMPCapturedExprDecl(OMPCapturedExprDecl *D); | |
bool TraverseParmVarDecl(ParmVarDecl *D); | |
bool TraverseVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D); | |
bool TraverseVarTemplatePartialSpecializationDecl(VarTemplatePartialSpecializationDecl *D); | |
bool TraverseEnumConstantDecl(EnumConstantDecl *D); | |
bool TraverseIndirectFieldDecl(IndirectFieldDecl *D); | |
bool TraverseMSGuidDecl(MSGuidDecl *D); | |
bool TraverseOMPDeclareMapperDecl(OMPDeclareMapperDecl *D); | |
bool TraverseOMPDeclareReductionDecl(OMPDeclareReductionDecl *D); | |
bool TraverseTemplateParamObjectDecl(TemplateParamObjectDecl *D); | |
bool TraverseUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D); | |
bool TraverseOMPAllocateDecl(OMPAllocateDecl *D); | |
bool TraverseOMPRequiresDecl(OMPRequiresDecl *D); | |
bool TraverseOMPThreadPrivateDecl(OMPThreadPrivateDecl *D); | |
bool TraverseObjCPropertyImplDecl(ObjCPropertyImplDecl *D); | |
bool TraversePragmaCommentDecl(PragmaCommentDecl *D); | |
bool TraversePragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D); | |
bool TraverseRequiresExprBodyDecl(RequiresExprBodyDecl *D); | |
bool TraverseStaticAssertDecl(StaticAssertDecl *D); | |
bool TraverseTranslationUnitDecl(TranslationUnitDecl *D); | |
bool WalkUpFromDecl(Decl *D) { return getDerived().VisitDecl(D); } | |
bool VisitDecl(Decl *D) { return true; } | |
bool WalkUpFromAccessSpecDecl(AccessSpecDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitAccessSpecDecl(D)) return false; } while (false); return true; } bool VisitAccessSpecDecl(AccessSpecDecl *D) { return true; } | |
bool WalkUpFromBlockDecl(BlockDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitBlockDecl(D)) return false; } while (false); return true; } bool VisitBlockDecl(BlockDecl *D) { return true; } | |
bool WalkUpFromCapturedDecl(CapturedDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitCapturedDecl(D)) return false; } while (false); return true; } bool VisitCapturedDecl(CapturedDecl *D) { return true; } | |
bool WalkUpFromClassScopeFunctionSpecializationDecl(ClassScopeFunctionSpecializationDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitClassScopeFunctionSpecializationDecl(D)) return false; } while (false); return true; } bool VisitClassScopeFunctionSpecializationDecl(ClassScopeFunctionSpecializationDecl *D) { return true; } | |
bool WalkUpFromEmptyDecl(EmptyDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitEmptyDecl(D)) return false; } while (false); return true; } bool VisitEmptyDecl(EmptyDecl *D) { return true; } | |
bool WalkUpFromExportDecl(ExportDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitExportDecl(D)) return false; } while (false); return true; } bool VisitExportDecl(ExportDecl *D) { return true; } | |
bool WalkUpFromExternCContextDecl(ExternCContextDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitExternCContextDecl(D)) return false; } while (false); return true; } bool VisitExternCContextDecl(ExternCContextDecl *D) { return true; } | |
bool WalkUpFromFileScopeAsmDecl(FileScopeAsmDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitFileScopeAsmDecl(D)) return false; } while (false); return true; } bool VisitFileScopeAsmDecl(FileScopeAsmDecl *D) { return true; } | |
bool WalkUpFromFriendDecl(FriendDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitFriendDecl(D)) return false; } while (false); return true; } bool VisitFriendDecl(FriendDecl *D) { return true; } | |
bool WalkUpFromFriendTemplateDecl(FriendTemplateDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitFriendTemplateDecl(D)) return false; } while (false); return true; } bool VisitFriendTemplateDecl(FriendTemplateDecl *D) { return true; } | |
bool WalkUpFromImportDecl(ImportDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitImportDecl(D)) return false; } while (false); return true; } bool VisitImportDecl(ImportDecl *D) { return true; } | |
bool WalkUpFromLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitLifetimeExtendedTemporaryDecl(D)) return false; } while (false); return true; } bool VisitLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D) { return true; } | |
bool WalkUpFromLinkageSpecDecl(LinkageSpecDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitLinkageSpecDecl(D)) return false; } while (false); return true; } bool VisitLinkageSpecDecl(LinkageSpecDecl *D) { return true; } | |
bool WalkUpFromNamedDecl(NamedDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitNamedDecl(D)) return false; } while (false); return true; } bool VisitNamedDecl(NamedDecl *D) { return true; } | |
bool WalkUpFromBaseUsingDecl(BaseUsingDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitBaseUsingDecl(D)) return false; } while (false); return true; } bool VisitBaseUsingDecl(BaseUsingDecl *D) { return true; } | |
bool WalkUpFromUsingDecl(UsingDecl *D) { do { if (!getDerived().WalkUpFromBaseUsingDecl(D)) return false; } while (false); do { if (!getDerived().VisitUsingDecl(D)) return false; } while (false); return true; } bool VisitUsingDecl(UsingDecl *D) { return true; } | |
bool WalkUpFromUsingEnumDecl(UsingEnumDecl *D) { do { if (!getDerived().WalkUpFromBaseUsingDecl(D)) return false; } while (false); do { if (!getDerived().VisitUsingEnumDecl(D)) return false; } while (false); return true; } bool VisitUsingEnumDecl(UsingEnumDecl *D) { return true; } | |
bool WalkUpFromLabelDecl(LabelDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitLabelDecl(D)) return false; } while (false); return true; } bool VisitLabelDecl(LabelDecl *D) { return true; } | |
bool WalkUpFromNamespaceDecl(NamespaceDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitNamespaceDecl(D)) return false; } while (false); return true; } bool VisitNamespaceDecl(NamespaceDecl *D) { return true; } | |
bool WalkUpFromNamespaceAliasDecl(NamespaceAliasDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitNamespaceAliasDecl(D)) return false; } while (false); return true; } bool VisitNamespaceAliasDecl(NamespaceAliasDecl *D) { return true; } | |
bool WalkUpFromObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCCompatibleAliasDecl(D)) return false; } while (false); return true; } bool VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D) { return true; } | |
bool WalkUpFromObjCContainerDecl(ObjCContainerDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCContainerDecl(D)) return false; } while (false); return true; } bool VisitObjCContainerDecl(ObjCContainerDecl *D) { return true; } | |
bool WalkUpFromObjCCategoryDecl(ObjCCategoryDecl *D) { do { if (!getDerived().WalkUpFromObjCContainerDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCCategoryDecl(D)) return false; } while (false); return true; } bool VisitObjCCategoryDecl(ObjCCategoryDecl *D) { return true; } | |
bool WalkUpFromObjCImplDecl(ObjCImplDecl *D) { do { if (!getDerived().WalkUpFromObjCContainerDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCImplDecl(D)) return false; } while (false); return true; } bool VisitObjCImplDecl(ObjCImplDecl *D) { return true; } | |
bool WalkUpFromObjCCategoryImplDecl(ObjCCategoryImplDecl *D) { do { if (!getDerived().WalkUpFromObjCImplDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCCategoryImplDecl(D)) return false; } while (false); return true; } bool VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) { return true; } | |
bool WalkUpFromObjCImplementationDecl(ObjCImplementationDecl *D) { do { if (!getDerived().WalkUpFromObjCImplDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCImplementationDecl(D)) return false; } while (false); return true; } bool VisitObjCImplementationDecl(ObjCImplementationDecl *D) { return true; } | |
bool WalkUpFromObjCInterfaceDecl(ObjCInterfaceDecl *D) { do { if (!getDerived().WalkUpFromObjCContainerDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCInterfaceDecl(D)) return false; } while (false); return true; } bool VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) { return true; } | |
bool WalkUpFromObjCProtocolDecl(ObjCProtocolDecl *D) { do { if (!getDerived().WalkUpFromObjCContainerDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCProtocolDecl(D)) return false; } while (false); return true; } bool VisitObjCProtocolDecl(ObjCProtocolDecl *D) { return true; } | |
bool WalkUpFromObjCMethodDecl(ObjCMethodDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCMethodDecl(D)) return false; } while (false); return true; } bool VisitObjCMethodDecl(ObjCMethodDecl *D) { return true; } | |
bool WalkUpFromObjCPropertyDecl(ObjCPropertyDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCPropertyDecl(D)) return false; } while (false); return true; } bool VisitObjCPropertyDecl(ObjCPropertyDecl *D) { return true; } | |
bool WalkUpFromTemplateDecl(TemplateDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitTemplateDecl(D)) return false; } while (false); return true; } bool VisitTemplateDecl(TemplateDecl *D) { return true; } | |
bool WalkUpFromBuiltinTemplateDecl(BuiltinTemplateDecl *D) { do { if (!getDerived().WalkUpFromTemplateDecl(D)) return false; } while (false); do { if (!getDerived().VisitBuiltinTemplateDecl(D)) return false; } while (false); return true; } bool VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D) { return true; } | |
bool WalkUpFromConceptDecl(ConceptDecl *D) { do { if (!getDerived().WalkUpFromTemplateDecl(D)) return false; } while (false); do { if (!getDerived().VisitConceptDecl(D)) return false; } while (false); return true; } bool VisitConceptDecl(ConceptDecl *D) { return true; } | |
bool WalkUpFromRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) { do { if (!getDerived().WalkUpFromTemplateDecl(D)) return false; } while (false); do { if (!getDerived().VisitRedeclarableTemplateDecl(D)) return false; } while (false); return true; } bool VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) { return true; } | |
bool WalkUpFromClassTemplateDecl(ClassTemplateDecl *D) { do { if (!getDerived().WalkUpFromRedeclarableTemplateDecl(D)) return false; } while (false); do { if (!getDerived().VisitClassTemplateDecl(D)) return false; } while (false); return true; } bool VisitClassTemplateDecl(ClassTemplateDecl *D) { return true; } | |
bool WalkUpFromFunctionTemplateDecl(FunctionTemplateDecl *D) { do { if (!getDerived().WalkUpFromRedeclarableTemplateDecl(D)) return false; } while (false); do { if (!getDerived().VisitFunctionTemplateDecl(D)) return false; } while (false); return true; } bool VisitFunctionTemplateDecl(FunctionTemplateDecl *D) { return true; } | |
bool WalkUpFromTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) { do { if (!getDerived().WalkUpFromRedeclarableTemplateDecl(D)) return false; } while (false); do { if (!getDerived().VisitTypeAliasTemplateDecl(D)) return false; } while (false); return true; } bool VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) { return true; } | |
bool WalkUpFromVarTemplateDecl(VarTemplateDecl *D) { do { if (!getDerived().WalkUpFromRedeclarableTemplateDecl(D)) return false; } while (false); do { if (!getDerived().VisitVarTemplateDecl(D)) return false; } while (false); return true; } bool VisitVarTemplateDecl(VarTemplateDecl *D) { return true; } | |
bool WalkUpFromTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) { do { if (!getDerived().WalkUpFromTemplateDecl(D)) return false; } while (false); do { if (!getDerived().VisitTemplateTemplateParmDecl(D)) return false; } while (false); return true; } bool VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) { return true; } | |
bool WalkUpFromTypeDecl(TypeDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitTypeDecl(D)) return false; } while (false); return true; } bool VisitTypeDecl(TypeDecl *D) { return true; } | |
bool WalkUpFromTagDecl(TagDecl *D) { do { if (!getDerived().WalkUpFromTypeDecl(D)) return false; } while (false); do { if (!getDerived().VisitTagDecl(D)) return false; } while (false); return true; } bool VisitTagDecl(TagDecl *D) { return true; } | |
bool WalkUpFromEnumDecl(EnumDecl *D) { do { if (!getDerived().WalkUpFromTagDecl(D)) return false; } while (false); do { if (!getDerived().VisitEnumDecl(D)) return false; } while (false); return true; } bool VisitEnumDecl(EnumDecl *D) { return true; } | |
bool WalkUpFromRecordDecl(RecordDecl *D) { do { if (!getDerived().WalkUpFromTagDecl(D)) return false; } while (false); do { if (!getDerived().VisitRecordDecl(D)) return false; } while (false); return true; } bool VisitRecordDecl(RecordDecl *D) { return true; } | |
bool WalkUpFromCXXRecordDecl(CXXRecordDecl *D) { do { if (!getDerived().WalkUpFromRecordDecl(D)) return false; } while (false); do { if (!getDerived().VisitCXXRecordDecl(D)) return false; } while (false); return true; } bool VisitCXXRecordDecl(CXXRecordDecl *D) { return true; } | |
bool WalkUpFromClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl *D) { do { if (!getDerived().WalkUpFromCXXRecordDecl(D)) return false; } while (false); do { if (!getDerived().VisitClassTemplateSpecializationDecl(D)) return false; } while (false); return true; } bool VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl *D) { return true; } | |
bool WalkUpFromClassTemplatePartialSpecializationDecl(ClassTemplatePartialSpecializationDecl *D) { do { if (!getDerived().WalkUpFromClassTemplateSpecializationDecl(D)) return false; } while (false); do { if (!getDerived().VisitClassTemplatePartialSpecializationDecl(D)) return false; } while (false); return true; } bool VisitClassTemplatePartialSpecializationDecl(ClassTemplatePartialSpecializationDecl *D) { return true; } | |
bool WalkUpFromTemplateTypeParmDecl(TemplateTypeParmDecl *D) { do { if (!getDerived().WalkUpFromTypeDecl(D)) return false; } while (false); do { if (!getDerived().VisitTemplateTypeParmDecl(D)) return false; } while (false); return true; } bool VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) { return true; } | |
bool WalkUpFromTypedefNameDecl(TypedefNameDecl *D) { do { if (!getDerived().WalkUpFromTypeDecl(D)) return false; } while (false); do { if (!getDerived().VisitTypedefNameDecl(D)) return false; } while (false); return true; } bool VisitTypedefNameDecl(TypedefNameDecl *D) { return true; } | |
bool WalkUpFromObjCTypeParamDecl(ObjCTypeParamDecl *D) { do { if (!getDerived().WalkUpFromTypedefNameDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCTypeParamDecl(D)) return false; } while (false); return true; } bool VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) { return true; } | |
bool WalkUpFromTypeAliasDecl(TypeAliasDecl *D) { do { if (!getDerived().WalkUpFromTypedefNameDecl(D)) return false; } while (false); do { if (!getDerived().VisitTypeAliasDecl(D)) return false; } while (false); return true; } bool VisitTypeAliasDecl(TypeAliasDecl *D) { return true; } | |
bool WalkUpFromTypedefDecl(TypedefDecl *D) { do { if (!getDerived().WalkUpFromTypedefNameDecl(D)) return false; } while (false); do { if (!getDerived().VisitTypedefDecl(D)) return false; } while (false); return true; } bool VisitTypedefDecl(TypedefDecl *D) { return true; } | |
bool WalkUpFromUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D) { do { if (!getDerived().WalkUpFromTypeDecl(D)) return false; } while (false); do { if (!getDerived().VisitUnresolvedUsingTypenameDecl(D)) return false; } while (false); return true; } bool VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D) { return true; } | |
bool WalkUpFromUnresolvedUsingIfExistsDecl(UnresolvedUsingIfExistsDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitUnresolvedUsingIfExistsDecl(D)) return false; } while (false); return true; } bool VisitUnresolvedUsingIfExistsDecl(UnresolvedUsingIfExistsDecl *D) { return true; } | |
bool WalkUpFromUsingDirectiveDecl(UsingDirectiveDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitUsingDirectiveDecl(D)) return false; } while (false); return true; } bool VisitUsingDirectiveDecl(UsingDirectiveDecl *D) { return true; } | |
bool WalkUpFromUsingPackDecl(UsingPackDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitUsingPackDecl(D)) return false; } while (false); return true; } bool VisitUsingPackDecl(UsingPackDecl *D) { return true; } | |
bool WalkUpFromUsingShadowDecl(UsingShadowDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitUsingShadowDecl(D)) return false; } while (false); return true; } bool VisitUsingShadowDecl(UsingShadowDecl *D) { return true; } | |
bool WalkUpFromConstructorUsingShadowDecl(ConstructorUsingShadowDecl *D) { do { if (!getDerived().WalkUpFromUsingShadowDecl(D)) return false; } while (false); do { if (!getDerived().VisitConstructorUsingShadowDecl(D)) return false; } while (false); return true; } bool VisitConstructorUsingShadowDecl(ConstructorUsingShadowDecl *D) { return true; } | |
bool WalkUpFromValueDecl(ValueDecl *D) { do { if (!getDerived().WalkUpFromNamedDecl(D)) return false; } while (false); do { if (!getDerived().VisitValueDecl(D)) return false; } while (false); return true; } bool VisitValueDecl(ValueDecl *D) { return true; } | |
bool WalkUpFromBindingDecl(BindingDecl *D) { do { if (!getDerived().WalkUpFromValueDecl(D)) return false; } while (false); do { if (!getDerived().VisitBindingDecl(D)) return false; } while (false); return true; } bool VisitBindingDecl(BindingDecl *D) { return true; } | |
bool WalkUpFromDeclaratorDecl(DeclaratorDecl *D) { do { if (!getDerived().WalkUpFromValueDecl(D)) return false; } while (false); do { if (!getDerived().VisitDeclaratorDecl(D)) return false; } while (false); return true; } bool VisitDeclaratorDecl(DeclaratorDecl *D) { return true; } | |
bool WalkUpFromFieldDecl(FieldDecl *D) { do { if (!getDerived().WalkUpFromDeclaratorDecl(D)) return false; } while (false); do { if (!getDerived().VisitFieldDecl(D)) return false; } while (false); return true; } bool VisitFieldDecl(FieldDecl *D) { return true; } | |
bool WalkUpFromObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) { do { if (!getDerived().WalkUpFromFieldDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCAtDefsFieldDecl(D)) return false; } while (false); return true; } bool VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) { return true; } | |
bool WalkUpFromObjCIvarDecl(ObjCIvarDecl *D) { do { if (!getDerived().WalkUpFromFieldDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCIvarDecl(D)) return false; } while (false); return true; } bool VisitObjCIvarDecl(ObjCIvarDecl *D) { return true; } | |
bool WalkUpFromFunctionDecl(FunctionDecl *D) { do { if (!getDerived().WalkUpFromDeclaratorDecl(D)) return false; } while (false); do { if (!getDerived().VisitFunctionDecl(D)) return false; } while (false); return true; } bool VisitFunctionDecl(FunctionDecl *D) { return true; } | |
bool WalkUpFromCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) { do { if (!getDerived().WalkUpFromFunctionDecl(D)) return false; } while (false); do { if (!getDerived().VisitCXXDeductionGuideDecl(D)) return false; } while (false); return true; } bool VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) { return true; } | |
bool WalkUpFromCXXMethodDecl(CXXMethodDecl *D) { do { if (!getDerived().WalkUpFromFunctionDecl(D)) return false; } while (false); do { if (!getDerived().VisitCXXMethodDecl(D)) return false; } while (false); return true; } bool VisitCXXMethodDecl(CXXMethodDecl *D) { return true; } | |
bool WalkUpFromCXXConstructorDecl(CXXConstructorDecl *D) { do { if (!getDerived().WalkUpFromCXXMethodDecl(D)) return false; } while (false); do { if (!getDerived().VisitCXXConstructorDecl(D)) return false; } while (false); return true; } bool VisitCXXConstructorDecl(CXXConstructorDecl *D) { return true; } | |
bool WalkUpFromCXXConversionDecl(CXXConversionDecl *D) { do { if (!getDerived().WalkUpFromCXXMethodDecl(D)) return false; } while (false); do { if (!getDerived().VisitCXXConversionDecl(D)) return false; } while (false); return true; } bool VisitCXXConversionDecl(CXXConversionDecl *D) { return true; } | |
bool WalkUpFromCXXDestructorDecl(CXXDestructorDecl *D) { do { if (!getDerived().WalkUpFromCXXMethodDecl(D)) return false; } while (false); do { if (!getDerived().VisitCXXDestructorDecl(D)) return false; } while (false); return true; } bool VisitCXXDestructorDecl(CXXDestructorDecl *D) { return true; } | |
bool WalkUpFromMSPropertyDecl(MSPropertyDecl *D) { do { if (!getDerived().WalkUpFromDeclaratorDecl(D)) return false; } while (false); do { if (!getDerived().VisitMSPropertyDecl(D)) return false; } while (false); return true; } bool VisitMSPropertyDecl(MSPropertyDecl *D) { return true; } | |
bool WalkUpFromNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) { do { if (!getDerived().WalkUpFromDeclaratorDecl(D)) return false; } while (false); do { if (!getDerived().VisitNonTypeTemplateParmDecl(D)) return false; } while (false); return true; } bool VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) { return true; } | |
bool WalkUpFromVarDecl(VarDecl *D) { do { if (!getDerived().WalkUpFromDeclaratorDecl(D)) return false; } while (false); do { if (!getDerived().VisitVarDecl(D)) return false; } while (false); return true; } bool VisitVarDecl(VarDecl *D) { return true; } | |
bool WalkUpFromDecompositionDecl(DecompositionDecl *D) { do { if (!getDerived().WalkUpFromVarDecl(D)) return false; } while (false); do { if (!getDerived().VisitDecompositionDecl(D)) return false; } while (false); return true; } bool VisitDecompositionDecl(DecompositionDecl *D) { return true; } | |
bool WalkUpFromImplicitParamDecl(ImplicitParamDecl *D) { do { if (!getDerived().WalkUpFromVarDecl(D)) return false; } while (false); do { if (!getDerived().VisitImplicitParamDecl(D)) return false; } while (false); return true; } bool VisitImplicitParamDecl(ImplicitParamDecl *D) { return true; } | |
bool WalkUpFromOMPCapturedExprDecl(OMPCapturedExprDecl *D) { do { if (!getDerived().WalkUpFromVarDecl(D)) return false; } while (false); do { if (!getDerived().VisitOMPCapturedExprDecl(D)) return false; } while (false); return true; } bool VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D) { return true; } | |
bool WalkUpFromParmVarDecl(ParmVarDecl *D) { do { if (!getDerived().WalkUpFromVarDecl(D)) return false; } while (false); do { if (!getDerived().VisitParmVarDecl(D)) return false; } while (false); return true; } bool VisitParmVarDecl(ParmVarDecl *D) { return true; } | |
bool WalkUpFromVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D) { do { if (!getDerived().WalkUpFromVarDecl(D)) return false; } while (false); do { if (!getDerived().VisitVarTemplateSpecializationDecl(D)) return false; } while (false); return true; } bool VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D) { return true; } | |
bool WalkUpFromVarTemplatePartialSpecializationDecl(VarTemplatePartialSpecializationDecl *D) { do { if (!getDerived().WalkUpFromVarTemplateSpecializationDecl(D)) return false; } while (false); do { if (!getDerived().VisitVarTemplatePartialSpecializationDecl(D)) return false; } while (false); return true; } bool VisitVarTemplatePartialSpecializationDecl(VarTemplatePartialSpecializationDecl *D) { return true; } | |
bool WalkUpFromEnumConstantDecl(EnumConstantDecl *D) { do { if (!getDerived().WalkUpFromValueDecl(D)) return false; } while (false); do { if (!getDerived().VisitEnumConstantDecl(D)) return false; } while (false); return true; } bool VisitEnumConstantDecl(EnumConstantDecl *D) { return true; } | |
bool WalkUpFromIndirectFieldDecl(IndirectFieldDecl *D) { do { if (!getDerived().WalkUpFromValueDecl(D)) return false; } while (false); do { if (!getDerived().VisitIndirectFieldDecl(D)) return false; } while (false); return true; } bool VisitIndirectFieldDecl(IndirectFieldDecl *D) { return true; } | |
bool WalkUpFromMSGuidDecl(MSGuidDecl *D) { do { if (!getDerived().WalkUpFromValueDecl(D)) return false; } while (false); do { if (!getDerived().VisitMSGuidDecl(D)) return false; } while (false); return true; } bool VisitMSGuidDecl(MSGuidDecl *D) { return true; } | |
bool WalkUpFromOMPDeclareMapperDecl(OMPDeclareMapperDecl *D) { do { if (!getDerived().WalkUpFromValueDecl(D)) return false; } while (false); do { if (!getDerived().VisitOMPDeclareMapperDecl(D)) return false; } while (false); return true; } bool VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D) { return true; } | |
bool WalkUpFromOMPDeclareReductionDecl(OMPDeclareReductionDecl *D) { do { if (!getDerived().WalkUpFromValueDecl(D)) return false; } while (false); do { if (!getDerived().VisitOMPDeclareReductionDecl(D)) return false; } while (false); return true; } bool VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D) { return true; } | |
bool WalkUpFromTemplateParamObjectDecl(TemplateParamObjectDecl *D) { do { if (!getDerived().WalkUpFromValueDecl(D)) return false; } while (false); do { if (!getDerived().VisitTemplateParamObjectDecl(D)) return false; } while (false); return true; } bool VisitTemplateParamObjectDecl(TemplateParamObjectDecl *D) { return true; } | |
bool WalkUpFromUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) { do { if (!getDerived().WalkUpFromValueDecl(D)) return false; } while (false); do { if (!getDerived().VisitUnresolvedUsingValueDecl(D)) return false; } while (false); return true; } bool VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) { return true; } | |
bool WalkUpFromOMPAllocateDecl(OMPAllocateDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitOMPAllocateDecl(D)) return false; } while (false); return true; } bool VisitOMPAllocateDecl(OMPAllocateDecl *D) { return true; } | |
bool WalkUpFromOMPRequiresDecl(OMPRequiresDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitOMPRequiresDecl(D)) return false; } while (false); return true; } bool VisitOMPRequiresDecl(OMPRequiresDecl *D) { return true; } | |
bool WalkUpFromOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitOMPThreadPrivateDecl(D)) return false; } while (false); return true; } bool VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) { return true; } | |
bool WalkUpFromObjCPropertyImplDecl(ObjCPropertyImplDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitObjCPropertyImplDecl(D)) return false; } while (false); return true; } bool VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) { return true; } | |
bool WalkUpFromPragmaCommentDecl(PragmaCommentDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitPragmaCommentDecl(D)) return false; } while (false); return true; } bool VisitPragmaCommentDecl(PragmaCommentDecl *D) { return true; } | |
bool WalkUpFromPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitPragmaDetectMismatchDecl(D)) return false; } while (false); return true; } bool VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D) { return true; } | |
bool WalkUpFromRequiresExprBodyDecl(RequiresExprBodyDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitRequiresExprBodyDecl(D)) return false; } while (false); return true; } bool VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D) { return true; } | |
bool WalkUpFromStaticAssertDecl(StaticAssertDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitStaticAssertDecl(D)) return false; } while (false); return true; } bool VisitStaticAssertDecl(StaticAssertDecl *D) { return true; } | |
bool WalkUpFromTranslationUnitDecl(TranslationUnitDecl *D) { do { if (!getDerived().WalkUpFromDecl(D)) return false; } while (false); do { if (!getDerived().VisitTranslationUnitDecl(D)) return false; } while (false); return true; } bool VisitTranslationUnitDecl(TranslationUnitDecl *D) { return true; } | |
bool canIgnoreChildDeclWhileTraversingDeclContext(const Decl *Child); | |
bool TraverseTemplateInstantiations(ClassTemplateDecl *D); | |
bool TraverseTemplateInstantiations(VarTemplateDecl *D); | |
bool TraverseTemplateInstantiations(FunctionTemplateDecl *D); | |
bool dataTraverseNode(Stmt *S, DataRecursionQueue *Queue); | |
private: | |
bool TraverseTemplateParameterListHelper(TemplateParameterList *TPL); | |
template <typename T> | |
bool TraverseDeclTemplateParameterLists(T *D); | |
bool TraverseTemplateTypeParamDeclConstraints(const TemplateTypeParmDecl *D); | |
bool TraverseTemplateArgumentLocsHelper(const TemplateArgumentLoc *TAL, | |
unsigned Count); | |
bool TraverseArrayTypeLocHelper(ArrayTypeLoc TL); | |
bool TraverseRecordHelper(RecordDecl *D); | |
bool TraverseCXXRecordHelper(CXXRecordDecl *D); | |
bool TraverseDeclaratorHelper(DeclaratorDecl *D); | |
bool TraverseDeclContextHelper(DeclContext *DC); | |
bool TraverseFunctionHelper(FunctionDecl *D); | |
bool TraverseVarHelper(VarDecl *D); | |
bool TraverseOMPExecutableDirective(OMPExecutableDirective *S); | |
bool TraverseOMPLoopDirective(OMPLoopDirective *S); | |
bool TraverseOMPClause(OMPClause *C); | |
bool VisitOMPAcqRelClause(OMPAcqRelClause *C); | |
bool VisitOMPAcquireClause(OMPAcquireClause *C); | |
bool VisitOMPAffinityClause(OMPAffinityClause *C); | |
bool VisitOMPAlignedClause(OMPAlignedClause *C); | |
bool VisitOMPAllocateClause(OMPAllocateClause *C); | |
bool VisitOMPAllocatorClause(OMPAllocatorClause *C); | |
bool VisitOMPAtomicDefaultMemOrderClause(OMPAtomicDefaultMemOrderClause *C); | |
bool VisitOMPCaptureClause(OMPCaptureClause *C); | |
bool VisitOMPCollapseClause(OMPCollapseClause *C); | |
bool VisitOMPCopyprivateClause(OMPCopyprivateClause *C); | |
bool VisitOMPCopyinClause(OMPCopyinClause *C); | |
bool VisitOMPDefaultClause(OMPDefaultClause *C); | |
bool VisitOMPDefaultmapClause(OMPDefaultmapClause *C); | |
bool VisitOMPDependClause(OMPDependClause *C); | |
bool VisitOMPDepobjClause(OMPDepobjClause *C); | |
bool VisitOMPDestroyClause(OMPDestroyClause *C); | |
bool VisitOMPDetachClause(OMPDetachClause *C); | |
bool VisitOMPDeviceClause(OMPDeviceClause *C); | |
bool VisitOMPDistScheduleClause(OMPDistScheduleClause *C); | |
bool VisitOMPDynamicAllocatorsClause(OMPDynamicAllocatorsClause *C); | |
bool VisitOMPExclusiveClause(OMPExclusiveClause *C); | |
bool VisitOMPFilterClause(OMPFilterClause *C); | |
bool VisitOMPFinalClause(OMPFinalClause *C); | |
bool VisitOMPFirstprivateClause(OMPFirstprivateClause *C); | |
bool VisitOMPFlushClause(OMPFlushClause *C); | |
bool VisitOMPFromClause(OMPFromClause *C); | |
bool VisitOMPFullClause(OMPFullClause *C); | |
bool VisitOMPGrainsizeClause(OMPGrainsizeClause *C); | |
bool VisitOMPHintClause(OMPHintClause *C); | |
bool VisitOMPIfClause(OMPIfClause *C); | |
bool VisitOMPInReductionClause(OMPInReductionClause *C); | |
bool VisitOMPInclusiveClause(OMPInclusiveClause *C); | |
bool VisitOMPInitClause(OMPInitClause *C); | |
bool VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause *C); | |
bool VisitOMPLastprivateClause(OMPLastprivateClause *C); | |
bool VisitOMPLinearClause(OMPLinearClause *C); | |
bool VisitOMPMapClause(OMPMapClause *C); | |
bool VisitOMPMergeableClause(OMPMergeableClause *C); | |
bool VisitOMPNogroupClause(OMPNogroupClause *C); | |
bool VisitOMPNowaitClause(OMPNowaitClause *C); | |
bool VisitOMPNocontextClause(OMPNocontextClause *C); | |
bool VisitOMPNontemporalClause(OMPNontemporalClause *C); | |
bool VisitOMPNovariantsClause(OMPNovariantsClause *C); | |
bool VisitOMPNumTasksClause(OMPNumTasksClause *C); | |
bool VisitOMPNumTeamsClause(OMPNumTeamsClause *C); | |
bool VisitOMPNumThreadsClause(OMPNumThreadsClause *C); | |
bool VisitOMPOrderClause(OMPOrderClause *C); | |
bool VisitOMPOrderedClause(OMPOrderedClause *C); | |
bool VisitOMPPartialClause(OMPPartialClause *C); | |
bool VisitOMPPriorityClause(OMPPriorityClause *C); | |
bool VisitOMPPrivateClause(OMPPrivateClause *C); | |
bool VisitOMPProcBindClause(OMPProcBindClause *C); | |
bool VisitOMPReadClause(OMPReadClause *C); | |
bool VisitOMPReductionClause(OMPReductionClause *C); | |
bool VisitOMPRelaxedClause(OMPRelaxedClause *C); | |
bool VisitOMPReleaseClause(OMPReleaseClause *C); | |
bool VisitOMPReverseOffloadClause(OMPReverseOffloadClause *C); | |
bool VisitOMPSafelenClause(OMPSafelenClause *C); | |
bool VisitOMPScheduleClause(OMPScheduleClause *C); | |
bool VisitOMPSeqCstClause(OMPSeqCstClause *C); | |
bool VisitOMPSharedClause(OMPSharedClause *C); | |
bool VisitOMPSIMDClause(OMPSIMDClause *C); | |
bool VisitOMPSimdlenClause(OMPSimdlenClause *C); | |
bool VisitOMPSizesClause(OMPSizesClause *C); | |
bool VisitOMPTaskReductionClause(OMPTaskReductionClause *C); | |
bool VisitOMPThreadLimitClause(OMPThreadLimitClause *C); | |
bool VisitOMPThreadsClause(OMPThreadsClause *C); | |
bool VisitOMPToClause(OMPToClause *C); | |
bool VisitOMPUnifiedAddressClause(OMPUnifiedAddressClause *C); | |
bool VisitOMPUnifiedSharedMemoryClause(OMPUnifiedSharedMemoryClause *C); | |
bool VisitOMPUntiedClause(OMPUntiedClause *C); | |
bool VisitOMPUpdateClause(OMPUpdateClause *C); | |
bool VisitOMPUseClause(OMPUseClause *C); | |
bool VisitOMPUseDeviceAddrClause(OMPUseDeviceAddrClause *C); | |
bool VisitOMPUseDevicePtrClause(OMPUseDevicePtrClause *C); | |
bool VisitOMPUsesAllocatorsClause(OMPUsesAllocatorsClause *C); | |
bool VisitOMPWriteClause(OMPWriteClause *C); | |
template <typename T> bool VisitOMPClauseList(T *Node); | |
bool VisitOMPClauseWithPreInit(OMPClauseWithPreInit *Node); | |
bool VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *Node); | |
bool PostVisitStmt(Stmt *S); | |
}; | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::dataTraverseNode(Stmt *S, | |
DataRecursionQueue *Queue) { | |
switch (S->getStmtClass()) { | |
case Stmt::NoStmtClass: | |
break; | |
case Stmt::GCCAsmStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseGCCAsmStmt), decltype(&Derived::TraverseGCCAsmStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseGCCAsmStmt), decltype(&Derived::TraverseGCCAsmStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseGCCAsmStmt(static_cast<GCCAsmStmt *>(S), Queue) : getDerived().TraverseGCCAsmStmt(static_cast<GCCAsmStmt *>(S))); | |
case Stmt::MSAsmStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMSAsmStmt), decltype(&Derived::TraverseMSAsmStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMSAsmStmt), decltype(&Derived::TraverseMSAsmStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseMSAsmStmt(static_cast<MSAsmStmt *>(S), Queue) : getDerived().TraverseMSAsmStmt(static_cast<MSAsmStmt *>(S))); | |
case Stmt::BreakStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseBreakStmt), decltype(&Derived::TraverseBreakStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseBreakStmt), decltype(&Derived::TraverseBreakStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseBreakStmt(static_cast<BreakStmt *>(S), Queue) : getDerived().TraverseBreakStmt(static_cast<BreakStmt *>(S))); | |
case Stmt::CXXCatchStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXCatchStmt), decltype(&Derived::TraverseCXXCatchStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXCatchStmt), decltype(&Derived::TraverseCXXCatchStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXCatchStmt(static_cast<CXXCatchStmt *>(S), Queue) : getDerived().TraverseCXXCatchStmt(static_cast<CXXCatchStmt *>(S))); | |
case Stmt::CXXForRangeStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXForRangeStmt), decltype(&Derived::TraverseCXXForRangeStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXForRangeStmt), decltype(&Derived::TraverseCXXForRangeStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXForRangeStmt(static_cast<CXXForRangeStmt *>(S), Queue) : getDerived().TraverseCXXForRangeStmt(static_cast<CXXForRangeStmt *>(S))); | |
case Stmt::CXXTryStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXTryStmt), decltype(&Derived::TraverseCXXTryStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXTryStmt), decltype(&Derived::TraverseCXXTryStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXTryStmt(static_cast<CXXTryStmt *>(S), Queue) : getDerived().TraverseCXXTryStmt(static_cast<CXXTryStmt *>(S))); | |
case Stmt::CapturedStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCapturedStmt), decltype(&Derived::TraverseCapturedStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCapturedStmt), decltype(&Derived::TraverseCapturedStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCapturedStmt(static_cast<CapturedStmt *>(S), Queue) : getDerived().TraverseCapturedStmt(static_cast<CapturedStmt *>(S))); | |
case Stmt::CompoundStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCompoundStmt), decltype(&Derived::TraverseCompoundStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCompoundStmt), decltype(&Derived::TraverseCompoundStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCompoundStmt(static_cast<CompoundStmt *>(S), Queue) : getDerived().TraverseCompoundStmt(static_cast<CompoundStmt *>(S))); | |
case Stmt::ContinueStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseContinueStmt), decltype(&Derived::TraverseContinueStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseContinueStmt), decltype(&Derived::TraverseContinueStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseContinueStmt(static_cast<ContinueStmt *>(S), Queue) : getDerived().TraverseContinueStmt(static_cast<ContinueStmt *>(S))); | |
case Stmt::CoreturnStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCoreturnStmt), decltype(&Derived::TraverseCoreturnStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCoreturnStmt), decltype(&Derived::TraverseCoreturnStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCoreturnStmt(static_cast<CoreturnStmt *>(S), Queue) : getDerived().TraverseCoreturnStmt(static_cast<CoreturnStmt *>(S))); | |
case Stmt::CoroutineBodyStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCoroutineBodyStmt), decltype(&Derived::TraverseCoroutineBodyStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCoroutineBodyStmt), decltype(&Derived::TraverseCoroutineBodyStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCoroutineBodyStmt(static_cast<CoroutineBodyStmt *>(S), Queue) : getDerived().TraverseCoroutineBodyStmt(static_cast<CoroutineBodyStmt *>(S))); | |
case Stmt::DeclStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDeclStmt), decltype(&Derived::TraverseDeclStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDeclStmt), decltype(&Derived::TraverseDeclStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseDeclStmt(static_cast<DeclStmt *>(S), Queue) : getDerived().TraverseDeclStmt(static_cast<DeclStmt *>(S))); | |
case Stmt::DoStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDoStmt), decltype(&Derived::TraverseDoStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDoStmt), decltype(&Derived::TraverseDoStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseDoStmt(static_cast<DoStmt *>(S), Queue) : getDerived().TraverseDoStmt(static_cast<DoStmt *>(S))); | |
case Stmt::ForStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseForStmt), decltype(&Derived::TraverseForStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseForStmt), decltype(&Derived::TraverseForStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseForStmt(static_cast<ForStmt *>(S), Queue) : getDerived().TraverseForStmt(static_cast<ForStmt *>(S))); | |
case Stmt::GotoStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseGotoStmt), decltype(&Derived::TraverseGotoStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseGotoStmt), decltype(&Derived::TraverseGotoStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseGotoStmt(static_cast<GotoStmt *>(S), Queue) : getDerived().TraverseGotoStmt(static_cast<GotoStmt *>(S))); | |
case Stmt::IfStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseIfStmt), decltype(&Derived::TraverseIfStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseIfStmt), decltype(&Derived::TraverseIfStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseIfStmt(static_cast<IfStmt *>(S), Queue) : getDerived().TraverseIfStmt(static_cast<IfStmt *>(S))); | |
case Stmt::IndirectGotoStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseIndirectGotoStmt), decltype(&Derived::TraverseIndirectGotoStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseIndirectGotoStmt), decltype(&Derived::TraverseIndirectGotoStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseIndirectGotoStmt(static_cast<IndirectGotoStmt *>(S), Queue) : getDerived().TraverseIndirectGotoStmt(static_cast<IndirectGotoStmt *>(S))); | |
case Stmt::MSDependentExistsStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMSDependentExistsStmt), decltype(&Derived::TraverseMSDependentExistsStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMSDependentExistsStmt), decltype(&Derived::TraverseMSDependentExistsStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseMSDependentExistsStmt(static_cast<MSDependentExistsStmt *>(S), Queue) : getDerived().TraverseMSDependentExistsStmt(static_cast<MSDependentExistsStmt *>(S))); | |
case Stmt::NullStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseNullStmt), decltype(&Derived::TraverseNullStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseNullStmt), decltype(&Derived::TraverseNullStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseNullStmt(static_cast<NullStmt *>(S), Queue) : getDerived().TraverseNullStmt(static_cast<NullStmt *>(S))); | |
case Stmt::OMPCanonicalLoopClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPCanonicalLoop), decltype(&Derived::TraverseOMPCanonicalLoop)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPCanonicalLoop), decltype(&Derived::TraverseOMPCanonicalLoop)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPCanonicalLoop(static_cast<OMPCanonicalLoop *>(S), Queue) : getDerived().TraverseOMPCanonicalLoop(static_cast<OMPCanonicalLoop *>(S))); | |
case Stmt::OMPAtomicDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPAtomicDirective), decltype(&Derived::TraverseOMPAtomicDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPAtomicDirective), decltype(&Derived::TraverseOMPAtomicDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPAtomicDirective(static_cast<OMPAtomicDirective *>(S), Queue) : getDerived().TraverseOMPAtomicDirective(static_cast<OMPAtomicDirective *>(S))); | |
case Stmt::OMPBarrierDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPBarrierDirective), decltype(&Derived::TraverseOMPBarrierDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPBarrierDirective), decltype(&Derived::TraverseOMPBarrierDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPBarrierDirective(static_cast<OMPBarrierDirective *>(S), Queue) : getDerived().TraverseOMPBarrierDirective(static_cast<OMPBarrierDirective *>(S))); | |
case Stmt::OMPCancelDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPCancelDirective), decltype(&Derived::TraverseOMPCancelDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPCancelDirective), decltype(&Derived::TraverseOMPCancelDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPCancelDirective(static_cast<OMPCancelDirective *>(S), Queue) : getDerived().TraverseOMPCancelDirective(static_cast<OMPCancelDirective *>(S))); | |
case Stmt::OMPCancellationPointDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPCancellationPointDirective), decltype(&Derived::TraverseOMPCancellationPointDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPCancellationPointDirective), decltype(&Derived::TraverseOMPCancellationPointDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPCancellationPointDirective(static_cast<OMPCancellationPointDirective *>(S), Queue) : getDerived().TraverseOMPCancellationPointDirective(static_cast<OMPCancellationPointDirective *>(S))); | |
case Stmt::OMPCriticalDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPCriticalDirective), decltype(&Derived::TraverseOMPCriticalDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPCriticalDirective), decltype(&Derived::TraverseOMPCriticalDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPCriticalDirective(static_cast<OMPCriticalDirective *>(S), Queue) : getDerived().TraverseOMPCriticalDirective(static_cast<OMPCriticalDirective *>(S))); | |
case Stmt::OMPDepobjDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPDepobjDirective), decltype(&Derived::TraverseOMPDepobjDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPDepobjDirective), decltype(&Derived::TraverseOMPDepobjDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPDepobjDirective(static_cast<OMPDepobjDirective *>(S), Queue) : getDerived().TraverseOMPDepobjDirective(static_cast<OMPDepobjDirective *>(S))); | |
case Stmt::OMPDispatchDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPDispatchDirective), decltype(&Derived::TraverseOMPDispatchDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPDispatchDirective), decltype(&Derived::TraverseOMPDispatchDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPDispatchDirective(static_cast<OMPDispatchDirective *>(S), Queue) : getDerived().TraverseOMPDispatchDirective(static_cast<OMPDispatchDirective *>(S))); | |
case Stmt::OMPFlushDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPFlushDirective), decltype(&Derived::TraverseOMPFlushDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPFlushDirective), decltype(&Derived::TraverseOMPFlushDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPFlushDirective(static_cast<OMPFlushDirective *>(S), Queue) : getDerived().TraverseOMPFlushDirective(static_cast<OMPFlushDirective *>(S))); | |
case Stmt::OMPInteropDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPInteropDirective), decltype(&Derived::TraverseOMPInteropDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPInteropDirective), decltype(&Derived::TraverseOMPInteropDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPInteropDirective(static_cast<OMPInteropDirective *>(S), Queue) : getDerived().TraverseOMPInteropDirective(static_cast<OMPInteropDirective *>(S))); | |
case Stmt::OMPDistributeDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPDistributeDirective), decltype(&Derived::TraverseOMPDistributeDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPDistributeDirective), decltype(&Derived::TraverseOMPDistributeDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPDistributeDirective(static_cast<OMPDistributeDirective *>(S), Queue) : getDerived().TraverseOMPDistributeDirective(static_cast<OMPDistributeDirective *>(S))); | |
case Stmt::OMPDistributeParallelForDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPDistributeParallelForDirective), decltype(&Derived::TraverseOMPDistributeParallelForDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPDistributeParallelForDirective), decltype(&Derived::TraverseOMPDistributeParallelForDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPDistributeParallelForDirective(static_cast<OMPDistributeParallelForDirective *>(S), Queue) : getDerived().TraverseOMPDistributeParallelForDirective(static_cast<OMPDistributeParallelForDirective *>(S))); | |
case Stmt::OMPDistributeParallelForSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPDistributeParallelForSimdDirective), decltype(&Derived::TraverseOMPDistributeParallelForSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPDistributeParallelForSimdDirective), decltype(&Derived::TraverseOMPDistributeParallelForSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPDistributeParallelForSimdDirective(static_cast<OMPDistributeParallelForSimdDirective *>(S), Queue) : getDerived().TraverseOMPDistributeParallelForSimdDirective(static_cast<OMPDistributeParallelForSimdDirective *>(S))); | |
case Stmt::OMPDistributeSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPDistributeSimdDirective), decltype(&Derived::TraverseOMPDistributeSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPDistributeSimdDirective), decltype(&Derived::TraverseOMPDistributeSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPDistributeSimdDirective(static_cast<OMPDistributeSimdDirective *>(S), Queue) : getDerived().TraverseOMPDistributeSimdDirective(static_cast<OMPDistributeSimdDirective *>(S))); | |
case Stmt::OMPForDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPForDirective), decltype(&Derived::TraverseOMPForDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPForDirective), decltype(&Derived::TraverseOMPForDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPForDirective(static_cast<OMPForDirective *>(S), Queue) : getDerived().TraverseOMPForDirective(static_cast<OMPForDirective *>(S))); | |
case Stmt::OMPForSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPForSimdDirective), decltype(&Derived::TraverseOMPForSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPForSimdDirective), decltype(&Derived::TraverseOMPForSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPForSimdDirective(static_cast<OMPForSimdDirective *>(S), Queue) : getDerived().TraverseOMPForSimdDirective(static_cast<OMPForSimdDirective *>(S))); | |
case Stmt::OMPMasterTaskLoopDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPMasterTaskLoopDirective), decltype(&Derived::TraverseOMPMasterTaskLoopDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPMasterTaskLoopDirective), decltype(&Derived::TraverseOMPMasterTaskLoopDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPMasterTaskLoopDirective(static_cast<OMPMasterTaskLoopDirective *>(S), Queue) : getDerived().TraverseOMPMasterTaskLoopDirective(static_cast<OMPMasterTaskLoopDirective *>(S))); | |
case Stmt::OMPMasterTaskLoopSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPMasterTaskLoopSimdDirective), decltype(&Derived::TraverseOMPMasterTaskLoopSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPMasterTaskLoopSimdDirective), decltype(&Derived::TraverseOMPMasterTaskLoopSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPMasterTaskLoopSimdDirective(static_cast<OMPMasterTaskLoopSimdDirective *>(S), Queue) : getDerived().TraverseOMPMasterTaskLoopSimdDirective(static_cast<OMPMasterTaskLoopSimdDirective *>(S))); | |
case Stmt::OMPParallelForDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelForDirective), decltype(&Derived::TraverseOMPParallelForDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelForDirective), decltype(&Derived::TraverseOMPParallelForDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPParallelForDirective(static_cast<OMPParallelForDirective *>(S), Queue) : getDerived().TraverseOMPParallelForDirective(static_cast<OMPParallelForDirective *>(S))); | |
case Stmt::OMPParallelForSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelForSimdDirective), decltype(&Derived::TraverseOMPParallelForSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelForSimdDirective), decltype(&Derived::TraverseOMPParallelForSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPParallelForSimdDirective(static_cast<OMPParallelForSimdDirective *>(S), Queue) : getDerived().TraverseOMPParallelForSimdDirective(static_cast<OMPParallelForSimdDirective *>(S))); | |
case Stmt::OMPParallelMasterTaskLoopDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelMasterTaskLoopDirective), decltype(&Derived::TraverseOMPParallelMasterTaskLoopDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelMasterTaskLoopDirective), decltype(&Derived::TraverseOMPParallelMasterTaskLoopDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPParallelMasterTaskLoopDirective(static_cast<OMPParallelMasterTaskLoopDirective *>(S), Queue) : getDerived().TraverseOMPParallelMasterTaskLoopDirective(static_cast<OMPParallelMasterTaskLoopDirective *>(S))); | |
case Stmt::OMPParallelMasterTaskLoopSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelMasterTaskLoopSimdDirective), decltype(&Derived::TraverseOMPParallelMasterTaskLoopSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelMasterTaskLoopSimdDirective), decltype(&Derived::TraverseOMPParallelMasterTaskLoopSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPParallelMasterTaskLoopSimdDirective(static_cast<OMPParallelMasterTaskLoopSimdDirective *>(S), Queue) : getDerived().TraverseOMPParallelMasterTaskLoopSimdDirective(static_cast<OMPParallelMasterTaskLoopSimdDirective *>(S))); | |
case Stmt::OMPSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPSimdDirective), decltype(&Derived::TraverseOMPSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPSimdDirective), decltype(&Derived::TraverseOMPSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPSimdDirective(static_cast<OMPSimdDirective *>(S), Queue) : getDerived().TraverseOMPSimdDirective(static_cast<OMPSimdDirective *>(S))); | |
case Stmt::OMPTargetParallelForSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetParallelForSimdDirective), decltype(&Derived::TraverseOMPTargetParallelForSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetParallelForSimdDirective), decltype(&Derived::TraverseOMPTargetParallelForSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetParallelForSimdDirective(static_cast<OMPTargetParallelForSimdDirective *>(S), Queue) : getDerived().TraverseOMPTargetParallelForSimdDirective(static_cast<OMPTargetParallelForSimdDirective *>(S))); | |
case Stmt::OMPTargetSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetSimdDirective), decltype(&Derived::TraverseOMPTargetSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetSimdDirective), decltype(&Derived::TraverseOMPTargetSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetSimdDirective(static_cast<OMPTargetSimdDirective *>(S), Queue) : getDerived().TraverseOMPTargetSimdDirective(static_cast<OMPTargetSimdDirective *>(S))); | |
case Stmt::OMPTargetTeamsDistributeDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetTeamsDistributeDirective), decltype(&Derived::TraverseOMPTargetTeamsDistributeDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetTeamsDistributeDirective), decltype(&Derived::TraverseOMPTargetTeamsDistributeDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetTeamsDistributeDirective(static_cast<OMPTargetTeamsDistributeDirective *>(S), Queue) : getDerived().TraverseOMPTargetTeamsDistributeDirective(static_cast<OMPTargetTeamsDistributeDirective *>(S))); | |
case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetTeamsDistributeParallelForDirective), decltype(&Derived::TraverseOMPTargetTeamsDistributeParallelForDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetTeamsDistributeParallelForDirective), decltype(&Derived::TraverseOMPTargetTeamsDistributeParallelForDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetTeamsDistributeParallelForDirective(static_cast<OMPTargetTeamsDistributeParallelForDirective *>(S), Queue) : getDerived().TraverseOMPTargetTeamsDistributeParallelForDirective(static_cast<OMPTargetTeamsDistributeParallelForDirective *>(S))); | |
case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetTeamsDistributeParallelForSimdDirective), decltype(&Derived::TraverseOMPTargetTeamsDistributeParallelForSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetTeamsDistributeParallelForSimdDirective), decltype(&Derived::TraverseOMPTargetTeamsDistributeParallelForSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetTeamsDistributeParallelForSimdDirective(static_cast<OMPTargetTeamsDistributeParallelForSimdDirective *>(S), Queue) : getDerived().TraverseOMPTargetTeamsDistributeParallelForSimdDirective(static_cast<OMPTargetTeamsDistributeParallelForSimdDirective *>(S))); | |
case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetTeamsDistributeSimdDirective), decltype(&Derived::TraverseOMPTargetTeamsDistributeSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetTeamsDistributeSimdDirective), decltype(&Derived::TraverseOMPTargetTeamsDistributeSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetTeamsDistributeSimdDirective(static_cast<OMPTargetTeamsDistributeSimdDirective *>(S), Queue) : getDerived().TraverseOMPTargetTeamsDistributeSimdDirective(static_cast<OMPTargetTeamsDistributeSimdDirective *>(S))); | |
case Stmt::OMPTaskLoopDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTaskLoopDirective), decltype(&Derived::TraverseOMPTaskLoopDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTaskLoopDirective), decltype(&Derived::TraverseOMPTaskLoopDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTaskLoopDirective(static_cast<OMPTaskLoopDirective *>(S), Queue) : getDerived().TraverseOMPTaskLoopDirective(static_cast<OMPTaskLoopDirective *>(S))); | |
case Stmt::OMPTaskLoopSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTaskLoopSimdDirective), decltype(&Derived::TraverseOMPTaskLoopSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTaskLoopSimdDirective), decltype(&Derived::TraverseOMPTaskLoopSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTaskLoopSimdDirective(static_cast<OMPTaskLoopSimdDirective *>(S), Queue) : getDerived().TraverseOMPTaskLoopSimdDirective(static_cast<OMPTaskLoopSimdDirective *>(S))); | |
case Stmt::OMPTeamsDistributeDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTeamsDistributeDirective), decltype(&Derived::TraverseOMPTeamsDistributeDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTeamsDistributeDirective), decltype(&Derived::TraverseOMPTeamsDistributeDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTeamsDistributeDirective(static_cast<OMPTeamsDistributeDirective *>(S), Queue) : getDerived().TraverseOMPTeamsDistributeDirective(static_cast<OMPTeamsDistributeDirective *>(S))); | |
case Stmt::OMPTeamsDistributeParallelForDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTeamsDistributeParallelForDirective), decltype(&Derived::TraverseOMPTeamsDistributeParallelForDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTeamsDistributeParallelForDirective), decltype(&Derived::TraverseOMPTeamsDistributeParallelForDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTeamsDistributeParallelForDirective(static_cast<OMPTeamsDistributeParallelForDirective *>(S), Queue) : getDerived().TraverseOMPTeamsDistributeParallelForDirective(static_cast<OMPTeamsDistributeParallelForDirective *>(S))); | |
case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTeamsDistributeParallelForSimdDirective), decltype(&Derived::TraverseOMPTeamsDistributeParallelForSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTeamsDistributeParallelForSimdDirective), decltype(&Derived::TraverseOMPTeamsDistributeParallelForSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTeamsDistributeParallelForSimdDirective(static_cast<OMPTeamsDistributeParallelForSimdDirective *>(S), Queue) : getDerived().TraverseOMPTeamsDistributeParallelForSimdDirective(static_cast<OMPTeamsDistributeParallelForSimdDirective *>(S))); | |
case Stmt::OMPTeamsDistributeSimdDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTeamsDistributeSimdDirective), decltype(&Derived::TraverseOMPTeamsDistributeSimdDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTeamsDistributeSimdDirective), decltype(&Derived::TraverseOMPTeamsDistributeSimdDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTeamsDistributeSimdDirective(static_cast<OMPTeamsDistributeSimdDirective *>(S), Queue) : getDerived().TraverseOMPTeamsDistributeSimdDirective(static_cast<OMPTeamsDistributeSimdDirective *>(S))); | |
case Stmt::OMPTileDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTileDirective), decltype(&Derived::TraverseOMPTileDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTileDirective), decltype(&Derived::TraverseOMPTileDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTileDirective(static_cast<OMPTileDirective *>(S), Queue) : getDerived().TraverseOMPTileDirective(static_cast<OMPTileDirective *>(S))); | |
case Stmt::OMPUnrollDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPUnrollDirective), decltype(&Derived::TraverseOMPUnrollDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPUnrollDirective), decltype(&Derived::TraverseOMPUnrollDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPUnrollDirective(static_cast<OMPUnrollDirective *>(S), Queue) : getDerived().TraverseOMPUnrollDirective(static_cast<OMPUnrollDirective *>(S))); | |
case Stmt::OMPMaskedDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPMaskedDirective), decltype(&Derived::TraverseOMPMaskedDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPMaskedDirective), decltype(&Derived::TraverseOMPMaskedDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPMaskedDirective(static_cast<OMPMaskedDirective *>(S), Queue) : getDerived().TraverseOMPMaskedDirective(static_cast<OMPMaskedDirective *>(S))); | |
case Stmt::OMPMasterDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPMasterDirective), decltype(&Derived::TraverseOMPMasterDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPMasterDirective), decltype(&Derived::TraverseOMPMasterDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPMasterDirective(static_cast<OMPMasterDirective *>(S), Queue) : getDerived().TraverseOMPMasterDirective(static_cast<OMPMasterDirective *>(S))); | |
case Stmt::OMPOrderedDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPOrderedDirective), decltype(&Derived::TraverseOMPOrderedDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPOrderedDirective), decltype(&Derived::TraverseOMPOrderedDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPOrderedDirective(static_cast<OMPOrderedDirective *>(S), Queue) : getDerived().TraverseOMPOrderedDirective(static_cast<OMPOrderedDirective *>(S))); | |
case Stmt::OMPParallelDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelDirective), decltype(&Derived::TraverseOMPParallelDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelDirective), decltype(&Derived::TraverseOMPParallelDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPParallelDirective(static_cast<OMPParallelDirective *>(S), Queue) : getDerived().TraverseOMPParallelDirective(static_cast<OMPParallelDirective *>(S))); | |
case Stmt::OMPParallelMasterDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelMasterDirective), decltype(&Derived::TraverseOMPParallelMasterDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelMasterDirective), decltype(&Derived::TraverseOMPParallelMasterDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPParallelMasterDirective(static_cast<OMPParallelMasterDirective *>(S), Queue) : getDerived().TraverseOMPParallelMasterDirective(static_cast<OMPParallelMasterDirective *>(S))); | |
case Stmt::OMPParallelSectionsDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelSectionsDirective), decltype(&Derived::TraverseOMPParallelSectionsDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPParallelSectionsDirective), decltype(&Derived::TraverseOMPParallelSectionsDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPParallelSectionsDirective(static_cast<OMPParallelSectionsDirective *>(S), Queue) : getDerived().TraverseOMPParallelSectionsDirective(static_cast<OMPParallelSectionsDirective *>(S))); | |
case Stmt::OMPScanDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPScanDirective), decltype(&Derived::TraverseOMPScanDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPScanDirective), decltype(&Derived::TraverseOMPScanDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPScanDirective(static_cast<OMPScanDirective *>(S), Queue) : getDerived().TraverseOMPScanDirective(static_cast<OMPScanDirective *>(S))); | |
case Stmt::OMPSectionDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPSectionDirective), decltype(&Derived::TraverseOMPSectionDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPSectionDirective), decltype(&Derived::TraverseOMPSectionDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPSectionDirective(static_cast<OMPSectionDirective *>(S), Queue) : getDerived().TraverseOMPSectionDirective(static_cast<OMPSectionDirective *>(S))); | |
case Stmt::OMPSectionsDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPSectionsDirective), decltype(&Derived::TraverseOMPSectionsDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPSectionsDirective), decltype(&Derived::TraverseOMPSectionsDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPSectionsDirective(static_cast<OMPSectionsDirective *>(S), Queue) : getDerived().TraverseOMPSectionsDirective(static_cast<OMPSectionsDirective *>(S))); | |
case Stmt::OMPSingleDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPSingleDirective), decltype(&Derived::TraverseOMPSingleDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPSingleDirective), decltype(&Derived::TraverseOMPSingleDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPSingleDirective(static_cast<OMPSingleDirective *>(S), Queue) : getDerived().TraverseOMPSingleDirective(static_cast<OMPSingleDirective *>(S))); | |
case Stmt::OMPTargetDataDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetDataDirective), decltype(&Derived::TraverseOMPTargetDataDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetDataDirective), decltype(&Derived::TraverseOMPTargetDataDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetDataDirective(static_cast<OMPTargetDataDirective *>(S), Queue) : getDerived().TraverseOMPTargetDataDirective(static_cast<OMPTargetDataDirective *>(S))); | |
case Stmt::OMPTargetDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetDirective), decltype(&Derived::TraverseOMPTargetDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetDirective), decltype(&Derived::TraverseOMPTargetDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetDirective(static_cast<OMPTargetDirective *>(S), Queue) : getDerived().TraverseOMPTargetDirective(static_cast<OMPTargetDirective *>(S))); | |
case Stmt::OMPTargetEnterDataDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetEnterDataDirective), decltype(&Derived::TraverseOMPTargetEnterDataDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetEnterDataDirective), decltype(&Derived::TraverseOMPTargetEnterDataDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetEnterDataDirective(static_cast<OMPTargetEnterDataDirective *>(S), Queue) : getDerived().TraverseOMPTargetEnterDataDirective(static_cast<OMPTargetEnterDataDirective *>(S))); | |
case Stmt::OMPTargetExitDataDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetExitDataDirective), decltype(&Derived::TraverseOMPTargetExitDataDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetExitDataDirective), decltype(&Derived::TraverseOMPTargetExitDataDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetExitDataDirective(static_cast<OMPTargetExitDataDirective *>(S), Queue) : getDerived().TraverseOMPTargetExitDataDirective(static_cast<OMPTargetExitDataDirective *>(S))); | |
case Stmt::OMPTargetParallelDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetParallelDirective), decltype(&Derived::TraverseOMPTargetParallelDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetParallelDirective), decltype(&Derived::TraverseOMPTargetParallelDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetParallelDirective(static_cast<OMPTargetParallelDirective *>(S), Queue) : getDerived().TraverseOMPTargetParallelDirective(static_cast<OMPTargetParallelDirective *>(S))); | |
case Stmt::OMPTargetParallelForDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetParallelForDirective), decltype(&Derived::TraverseOMPTargetParallelForDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetParallelForDirective), decltype(&Derived::TraverseOMPTargetParallelForDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetParallelForDirective(static_cast<OMPTargetParallelForDirective *>(S), Queue) : getDerived().TraverseOMPTargetParallelForDirective(static_cast<OMPTargetParallelForDirective *>(S))); | |
case Stmt::OMPTargetTeamsDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetTeamsDirective), decltype(&Derived::TraverseOMPTargetTeamsDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetTeamsDirective), decltype(&Derived::TraverseOMPTargetTeamsDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetTeamsDirective(static_cast<OMPTargetTeamsDirective *>(S), Queue) : getDerived().TraverseOMPTargetTeamsDirective(static_cast<OMPTargetTeamsDirective *>(S))); | |
case Stmt::OMPTargetUpdateDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetUpdateDirective), decltype(&Derived::TraverseOMPTargetUpdateDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTargetUpdateDirective), decltype(&Derived::TraverseOMPTargetUpdateDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTargetUpdateDirective(static_cast<OMPTargetUpdateDirective *>(S), Queue) : getDerived().TraverseOMPTargetUpdateDirective(static_cast<OMPTargetUpdateDirective *>(S))); | |
case Stmt::OMPTaskDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTaskDirective), decltype(&Derived::TraverseOMPTaskDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTaskDirective), decltype(&Derived::TraverseOMPTaskDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTaskDirective(static_cast<OMPTaskDirective *>(S), Queue) : getDerived().TraverseOMPTaskDirective(static_cast<OMPTaskDirective *>(S))); | |
case Stmt::OMPTaskgroupDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTaskgroupDirective), decltype(&Derived::TraverseOMPTaskgroupDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTaskgroupDirective), decltype(&Derived::TraverseOMPTaskgroupDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTaskgroupDirective(static_cast<OMPTaskgroupDirective *>(S), Queue) : getDerived().TraverseOMPTaskgroupDirective(static_cast<OMPTaskgroupDirective *>(S))); | |
case Stmt::OMPTaskwaitDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTaskwaitDirective), decltype(&Derived::TraverseOMPTaskwaitDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTaskwaitDirective), decltype(&Derived::TraverseOMPTaskwaitDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTaskwaitDirective(static_cast<OMPTaskwaitDirective *>(S), Queue) : getDerived().TraverseOMPTaskwaitDirective(static_cast<OMPTaskwaitDirective *>(S))); | |
case Stmt::OMPTaskyieldDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTaskyieldDirective), decltype(&Derived::TraverseOMPTaskyieldDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTaskyieldDirective), decltype(&Derived::TraverseOMPTaskyieldDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTaskyieldDirective(static_cast<OMPTaskyieldDirective *>(S), Queue) : getDerived().TraverseOMPTaskyieldDirective(static_cast<OMPTaskyieldDirective *>(S))); | |
case Stmt::OMPTeamsDirectiveClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTeamsDirective), decltype(&Derived::TraverseOMPTeamsDirective)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPTeamsDirective), decltype(&Derived::TraverseOMPTeamsDirective)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPTeamsDirective(static_cast<OMPTeamsDirective *>(S), Queue) : getDerived().TraverseOMPTeamsDirective(static_cast<OMPTeamsDirective *>(S))); | |
case Stmt::ObjCAtCatchStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAtCatchStmt), decltype(&Derived::TraverseObjCAtCatchStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAtCatchStmt), decltype(&Derived::TraverseObjCAtCatchStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCAtCatchStmt(static_cast<ObjCAtCatchStmt *>(S), Queue) : getDerived().TraverseObjCAtCatchStmt(static_cast<ObjCAtCatchStmt *>(S))); | |
case Stmt::ObjCAtFinallyStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAtFinallyStmt), decltype(&Derived::TraverseObjCAtFinallyStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAtFinallyStmt), decltype(&Derived::TraverseObjCAtFinallyStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCAtFinallyStmt(static_cast<ObjCAtFinallyStmt *>(S), Queue) : getDerived().TraverseObjCAtFinallyStmt(static_cast<ObjCAtFinallyStmt *>(S))); | |
case Stmt::ObjCAtSynchronizedStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAtSynchronizedStmt), decltype(&Derived::TraverseObjCAtSynchronizedStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAtSynchronizedStmt), decltype(&Derived::TraverseObjCAtSynchronizedStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCAtSynchronizedStmt(static_cast<ObjCAtSynchronizedStmt *>(S), Queue) : getDerived().TraverseObjCAtSynchronizedStmt(static_cast<ObjCAtSynchronizedStmt *>(S))); | |
case Stmt::ObjCAtThrowStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAtThrowStmt), decltype(&Derived::TraverseObjCAtThrowStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAtThrowStmt), decltype(&Derived::TraverseObjCAtThrowStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCAtThrowStmt(static_cast<ObjCAtThrowStmt *>(S), Queue) : getDerived().TraverseObjCAtThrowStmt(static_cast<ObjCAtThrowStmt *>(S))); | |
case Stmt::ObjCAtTryStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAtTryStmt), decltype(&Derived::TraverseObjCAtTryStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAtTryStmt), decltype(&Derived::TraverseObjCAtTryStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCAtTryStmt(static_cast<ObjCAtTryStmt *>(S), Queue) : getDerived().TraverseObjCAtTryStmt(static_cast<ObjCAtTryStmt *>(S))); | |
case Stmt::ObjCAutoreleasePoolStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAutoreleasePoolStmt), decltype(&Derived::TraverseObjCAutoreleasePoolStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAutoreleasePoolStmt), decltype(&Derived::TraverseObjCAutoreleasePoolStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCAutoreleasePoolStmt(static_cast<ObjCAutoreleasePoolStmt *>(S), Queue) : getDerived().TraverseObjCAutoreleasePoolStmt(static_cast<ObjCAutoreleasePoolStmt *>(S))); | |
case Stmt::ObjCForCollectionStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCForCollectionStmt), decltype(&Derived::TraverseObjCForCollectionStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCForCollectionStmt), decltype(&Derived::TraverseObjCForCollectionStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCForCollectionStmt(static_cast<ObjCForCollectionStmt *>(S), Queue) : getDerived().TraverseObjCForCollectionStmt(static_cast<ObjCForCollectionStmt *>(S))); | |
case Stmt::ReturnStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseReturnStmt), decltype(&Derived::TraverseReturnStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseReturnStmt), decltype(&Derived::TraverseReturnStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseReturnStmt(static_cast<ReturnStmt *>(S), Queue) : getDerived().TraverseReturnStmt(static_cast<ReturnStmt *>(S))); | |
case Stmt::SEHExceptStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSEHExceptStmt), decltype(&Derived::TraverseSEHExceptStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSEHExceptStmt), decltype(&Derived::TraverseSEHExceptStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseSEHExceptStmt(static_cast<SEHExceptStmt *>(S), Queue) : getDerived().TraverseSEHExceptStmt(static_cast<SEHExceptStmt *>(S))); | |
case Stmt::SEHFinallyStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSEHFinallyStmt), decltype(&Derived::TraverseSEHFinallyStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSEHFinallyStmt), decltype(&Derived::TraverseSEHFinallyStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseSEHFinallyStmt(static_cast<SEHFinallyStmt *>(S), Queue) : getDerived().TraverseSEHFinallyStmt(static_cast<SEHFinallyStmt *>(S))); | |
case Stmt::SEHLeaveStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSEHLeaveStmt), decltype(&Derived::TraverseSEHLeaveStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSEHLeaveStmt), decltype(&Derived::TraverseSEHLeaveStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseSEHLeaveStmt(static_cast<SEHLeaveStmt *>(S), Queue) : getDerived().TraverseSEHLeaveStmt(static_cast<SEHLeaveStmt *>(S))); | |
case Stmt::SEHTryStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSEHTryStmt), decltype(&Derived::TraverseSEHTryStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSEHTryStmt), decltype(&Derived::TraverseSEHTryStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseSEHTryStmt(static_cast<SEHTryStmt *>(S), Queue) : getDerived().TraverseSEHTryStmt(static_cast<SEHTryStmt *>(S))); | |
case Stmt::CaseStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCaseStmt), decltype(&Derived::TraverseCaseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCaseStmt), decltype(&Derived::TraverseCaseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCaseStmt(static_cast<CaseStmt *>(S), Queue) : getDerived().TraverseCaseStmt(static_cast<CaseStmt *>(S))); | |
case Stmt::DefaultStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDefaultStmt), decltype(&Derived::TraverseDefaultStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDefaultStmt), decltype(&Derived::TraverseDefaultStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseDefaultStmt(static_cast<DefaultStmt *>(S), Queue) : getDerived().TraverseDefaultStmt(static_cast<DefaultStmt *>(S))); | |
case Stmt::SwitchStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSwitchStmt), decltype(&Derived::TraverseSwitchStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSwitchStmt), decltype(&Derived::TraverseSwitchStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseSwitchStmt(static_cast<SwitchStmt *>(S), Queue) : getDerived().TraverseSwitchStmt(static_cast<SwitchStmt *>(S))); | |
case Stmt::AttributedStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseAttributedStmt), decltype(&Derived::TraverseAttributedStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseAttributedStmt), decltype(&Derived::TraverseAttributedStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseAttributedStmt(static_cast<AttributedStmt *>(S), Queue) : getDerived().TraverseAttributedStmt(static_cast<AttributedStmt *>(S))); | |
case Stmt::BinaryConditionalOperatorClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseBinaryConditionalOperator), decltype(&Derived::TraverseBinaryConditionalOperator)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseBinaryConditionalOperator), decltype(&Derived::TraverseBinaryConditionalOperator)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseBinaryConditionalOperator(static_cast<BinaryConditionalOperator *>(S), Queue) : getDerived().TraverseBinaryConditionalOperator(static_cast<BinaryConditionalOperator *>(S))); | |
case Stmt::ConditionalOperatorClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseConditionalOperator), decltype(&Derived::TraverseConditionalOperator)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseConditionalOperator), decltype(&Derived::TraverseConditionalOperator)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseConditionalOperator(static_cast<ConditionalOperator *>(S), Queue) : getDerived().TraverseConditionalOperator(static_cast<ConditionalOperator *>(S))); | |
case Stmt::AddrLabelExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseAddrLabelExpr), decltype(&Derived::TraverseAddrLabelExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseAddrLabelExpr), decltype(&Derived::TraverseAddrLabelExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseAddrLabelExpr(static_cast<AddrLabelExpr *>(S), Queue) : getDerived().TraverseAddrLabelExpr(static_cast<AddrLabelExpr *>(S))); | |
case Stmt::ArrayInitIndexExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseArrayInitIndexExpr), decltype(&Derived::TraverseArrayInitIndexExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseArrayInitIndexExpr), decltype(&Derived::TraverseArrayInitIndexExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseArrayInitIndexExpr(static_cast<ArrayInitIndexExpr *>(S), Queue) : getDerived().TraverseArrayInitIndexExpr(static_cast<ArrayInitIndexExpr *>(S))); | |
case Stmt::ArrayInitLoopExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseArrayInitLoopExpr), decltype(&Derived::TraverseArrayInitLoopExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseArrayInitLoopExpr), decltype(&Derived::TraverseArrayInitLoopExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseArrayInitLoopExpr(static_cast<ArrayInitLoopExpr *>(S), Queue) : getDerived().TraverseArrayInitLoopExpr(static_cast<ArrayInitLoopExpr *>(S))); | |
case Stmt::ArraySubscriptExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseArraySubscriptExpr), decltype(&Derived::TraverseArraySubscriptExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseArraySubscriptExpr), decltype(&Derived::TraverseArraySubscriptExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseArraySubscriptExpr(static_cast<ArraySubscriptExpr *>(S), Queue) : getDerived().TraverseArraySubscriptExpr(static_cast<ArraySubscriptExpr *>(S))); | |
case Stmt::ArrayTypeTraitExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseArrayTypeTraitExpr), decltype(&Derived::TraverseArrayTypeTraitExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseArrayTypeTraitExpr), decltype(&Derived::TraverseArrayTypeTraitExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseArrayTypeTraitExpr(static_cast<ArrayTypeTraitExpr *>(S), Queue) : getDerived().TraverseArrayTypeTraitExpr(static_cast<ArrayTypeTraitExpr *>(S))); | |
case Stmt::AsTypeExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseAsTypeExpr), decltype(&Derived::TraverseAsTypeExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseAsTypeExpr), decltype(&Derived::TraverseAsTypeExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseAsTypeExpr(static_cast<AsTypeExpr *>(S), Queue) : getDerived().TraverseAsTypeExpr(static_cast<AsTypeExpr *>(S))); | |
case Stmt::AtomicExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseAtomicExpr), decltype(&Derived::TraverseAtomicExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseAtomicExpr), decltype(&Derived::TraverseAtomicExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseAtomicExpr(static_cast<AtomicExpr *>(S), Queue) : getDerived().TraverseAtomicExpr(static_cast<AtomicExpr *>(S))); | |
case Stmt::BinaryOperatorClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseBinaryOperator), decltype(&Derived::TraverseBinaryOperator)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseBinaryOperator), decltype(&Derived::TraverseBinaryOperator)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseBinaryOperator(static_cast<BinaryOperator *>(S), Queue) : getDerived().TraverseBinaryOperator(static_cast<BinaryOperator *>(S))); | |
case Stmt::CompoundAssignOperatorClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCompoundAssignOperator), decltype(&Derived::TraverseCompoundAssignOperator)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCompoundAssignOperator), decltype(&Derived::TraverseCompoundAssignOperator)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCompoundAssignOperator(static_cast<CompoundAssignOperator *>(S), Queue) : getDerived().TraverseCompoundAssignOperator(static_cast<CompoundAssignOperator *>(S))); | |
case Stmt::BlockExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseBlockExpr), decltype(&Derived::TraverseBlockExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseBlockExpr), decltype(&Derived::TraverseBlockExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseBlockExpr(static_cast<BlockExpr *>(S), Queue) : getDerived().TraverseBlockExpr(static_cast<BlockExpr *>(S))); | |
case Stmt::CXXBindTemporaryExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXBindTemporaryExpr), decltype(&Derived::TraverseCXXBindTemporaryExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXBindTemporaryExpr), decltype(&Derived::TraverseCXXBindTemporaryExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXBindTemporaryExpr(static_cast<CXXBindTemporaryExpr *>(S), Queue) : getDerived().TraverseCXXBindTemporaryExpr(static_cast<CXXBindTemporaryExpr *>(S))); | |
case Stmt::CXXBoolLiteralExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXBoolLiteralExpr), decltype(&Derived::TraverseCXXBoolLiteralExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXBoolLiteralExpr), decltype(&Derived::TraverseCXXBoolLiteralExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXBoolLiteralExpr(static_cast<CXXBoolLiteralExpr *>(S), Queue) : getDerived().TraverseCXXBoolLiteralExpr(static_cast<CXXBoolLiteralExpr *>(S))); | |
case Stmt::CXXConstructExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXConstructExpr), decltype(&Derived::TraverseCXXConstructExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXConstructExpr), decltype(&Derived::TraverseCXXConstructExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXConstructExpr(static_cast<CXXConstructExpr *>(S), Queue) : getDerived().TraverseCXXConstructExpr(static_cast<CXXConstructExpr *>(S))); | |
case Stmt::CXXTemporaryObjectExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXTemporaryObjectExpr), decltype(&Derived::TraverseCXXTemporaryObjectExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXTemporaryObjectExpr), decltype(&Derived::TraverseCXXTemporaryObjectExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXTemporaryObjectExpr(static_cast<CXXTemporaryObjectExpr *>(S), Queue) : getDerived().TraverseCXXTemporaryObjectExpr(static_cast<CXXTemporaryObjectExpr *>(S))); | |
case Stmt::CXXDefaultArgExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXDefaultArgExpr), decltype(&Derived::TraverseCXXDefaultArgExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXDefaultArgExpr), decltype(&Derived::TraverseCXXDefaultArgExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXDefaultArgExpr(static_cast<CXXDefaultArgExpr *>(S), Queue) : getDerived().TraverseCXXDefaultArgExpr(static_cast<CXXDefaultArgExpr *>(S))); | |
case Stmt::CXXDefaultInitExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXDefaultInitExpr), decltype(&Derived::TraverseCXXDefaultInitExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXDefaultInitExpr), decltype(&Derived::TraverseCXXDefaultInitExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXDefaultInitExpr(static_cast<CXXDefaultInitExpr *>(S), Queue) : getDerived().TraverseCXXDefaultInitExpr(static_cast<CXXDefaultInitExpr *>(S))); | |
case Stmt::CXXDeleteExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXDeleteExpr), decltype(&Derived::TraverseCXXDeleteExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXDeleteExpr), decltype(&Derived::TraverseCXXDeleteExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXDeleteExpr(static_cast<CXXDeleteExpr *>(S), Queue) : getDerived().TraverseCXXDeleteExpr(static_cast<CXXDeleteExpr *>(S))); | |
case Stmt::CXXDependentScopeMemberExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXDependentScopeMemberExpr), decltype(&Derived::TraverseCXXDependentScopeMemberExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXDependentScopeMemberExpr), decltype(&Derived::TraverseCXXDependentScopeMemberExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXDependentScopeMemberExpr(static_cast<CXXDependentScopeMemberExpr *>(S), Queue) : getDerived().TraverseCXXDependentScopeMemberExpr(static_cast<CXXDependentScopeMemberExpr *>(S))); | |
case Stmt::CXXFoldExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXFoldExpr), decltype(&Derived::TraverseCXXFoldExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXFoldExpr), decltype(&Derived::TraverseCXXFoldExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXFoldExpr(static_cast<CXXFoldExpr *>(S), Queue) : getDerived().TraverseCXXFoldExpr(static_cast<CXXFoldExpr *>(S))); | |
case Stmt::CXXInheritedCtorInitExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXInheritedCtorInitExpr), decltype(&Derived::TraverseCXXInheritedCtorInitExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXInheritedCtorInitExpr), decltype(&Derived::TraverseCXXInheritedCtorInitExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXInheritedCtorInitExpr(static_cast<CXXInheritedCtorInitExpr *>(S), Queue) : getDerived().TraverseCXXInheritedCtorInitExpr(static_cast<CXXInheritedCtorInitExpr *>(S))); | |
case Stmt::CXXNewExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXNewExpr), decltype(&Derived::TraverseCXXNewExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXNewExpr), decltype(&Derived::TraverseCXXNewExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXNewExpr(static_cast<CXXNewExpr *>(S), Queue) : getDerived().TraverseCXXNewExpr(static_cast<CXXNewExpr *>(S))); | |
case Stmt::CXXNoexceptExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXNoexceptExpr), decltype(&Derived::TraverseCXXNoexceptExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXNoexceptExpr), decltype(&Derived::TraverseCXXNoexceptExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXNoexceptExpr(static_cast<CXXNoexceptExpr *>(S), Queue) : getDerived().TraverseCXXNoexceptExpr(static_cast<CXXNoexceptExpr *>(S))); | |
case Stmt::CXXNullPtrLiteralExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXNullPtrLiteralExpr), decltype(&Derived::TraverseCXXNullPtrLiteralExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXNullPtrLiteralExpr), decltype(&Derived::TraverseCXXNullPtrLiteralExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXNullPtrLiteralExpr(static_cast<CXXNullPtrLiteralExpr *>(S), Queue) : getDerived().TraverseCXXNullPtrLiteralExpr(static_cast<CXXNullPtrLiteralExpr *>(S))); | |
case Stmt::CXXPseudoDestructorExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXPseudoDestructorExpr), decltype(&Derived::TraverseCXXPseudoDestructorExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXPseudoDestructorExpr), decltype(&Derived::TraverseCXXPseudoDestructorExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXPseudoDestructorExpr(static_cast<CXXPseudoDestructorExpr *>(S), Queue) : getDerived().TraverseCXXPseudoDestructorExpr(static_cast<CXXPseudoDestructorExpr *>(S))); | |
case Stmt::CXXRewrittenBinaryOperatorClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXRewrittenBinaryOperator), decltype(&Derived::TraverseCXXRewrittenBinaryOperator)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXRewrittenBinaryOperator), decltype(&Derived::TraverseCXXRewrittenBinaryOperator)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXRewrittenBinaryOperator(static_cast<CXXRewrittenBinaryOperator *>(S), Queue) : getDerived().TraverseCXXRewrittenBinaryOperator(static_cast<CXXRewrittenBinaryOperator *>(S))); | |
case Stmt::CXXScalarValueInitExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXScalarValueInitExpr), decltype(&Derived::TraverseCXXScalarValueInitExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXScalarValueInitExpr), decltype(&Derived::TraverseCXXScalarValueInitExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXScalarValueInitExpr(static_cast<CXXScalarValueInitExpr *>(S), Queue) : getDerived().TraverseCXXScalarValueInitExpr(static_cast<CXXScalarValueInitExpr *>(S))); | |
case Stmt::CXXStdInitializerListExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXStdInitializerListExpr), decltype(&Derived::TraverseCXXStdInitializerListExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXStdInitializerListExpr), decltype(&Derived::TraverseCXXStdInitializerListExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXStdInitializerListExpr(static_cast<CXXStdInitializerListExpr *>(S), Queue) : getDerived().TraverseCXXStdInitializerListExpr(static_cast<CXXStdInitializerListExpr *>(S))); | |
case Stmt::CXXThisExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXThisExpr), decltype(&Derived::TraverseCXXThisExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXThisExpr), decltype(&Derived::TraverseCXXThisExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXThisExpr(static_cast<CXXThisExpr *>(S), Queue) : getDerived().TraverseCXXThisExpr(static_cast<CXXThisExpr *>(S))); | |
case Stmt::CXXThrowExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXThrowExpr), decltype(&Derived::TraverseCXXThrowExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXThrowExpr), decltype(&Derived::TraverseCXXThrowExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXThrowExpr(static_cast<CXXThrowExpr *>(S), Queue) : getDerived().TraverseCXXThrowExpr(static_cast<CXXThrowExpr *>(S))); | |
case Stmt::CXXTypeidExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXTypeidExpr), decltype(&Derived::TraverseCXXTypeidExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXTypeidExpr), decltype(&Derived::TraverseCXXTypeidExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXTypeidExpr(static_cast<CXXTypeidExpr *>(S), Queue) : getDerived().TraverseCXXTypeidExpr(static_cast<CXXTypeidExpr *>(S))); | |
case Stmt::CXXUnresolvedConstructExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXUnresolvedConstructExpr), decltype(&Derived::TraverseCXXUnresolvedConstructExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXUnresolvedConstructExpr), decltype(&Derived::TraverseCXXUnresolvedConstructExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXUnresolvedConstructExpr(static_cast<CXXUnresolvedConstructExpr *>(S), Queue) : getDerived().TraverseCXXUnresolvedConstructExpr(static_cast<CXXUnresolvedConstructExpr *>(S))); | |
case Stmt::CXXUuidofExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXUuidofExpr), decltype(&Derived::TraverseCXXUuidofExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXUuidofExpr), decltype(&Derived::TraverseCXXUuidofExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXUuidofExpr(static_cast<CXXUuidofExpr *>(S), Queue) : getDerived().TraverseCXXUuidofExpr(static_cast<CXXUuidofExpr *>(S))); | |
case Stmt::CallExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCallExpr), decltype(&Derived::TraverseCallExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCallExpr), decltype(&Derived::TraverseCallExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCallExpr(static_cast<CallExpr *>(S), Queue) : getDerived().TraverseCallExpr(static_cast<CallExpr *>(S))); | |
case Stmt::CUDAKernelCallExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCUDAKernelCallExpr), decltype(&Derived::TraverseCUDAKernelCallExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCUDAKernelCallExpr), decltype(&Derived::TraverseCUDAKernelCallExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCUDAKernelCallExpr(static_cast<CUDAKernelCallExpr *>(S), Queue) : getDerived().TraverseCUDAKernelCallExpr(static_cast<CUDAKernelCallExpr *>(S))); | |
case Stmt::CXXMemberCallExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXMemberCallExpr), decltype(&Derived::TraverseCXXMemberCallExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXMemberCallExpr), decltype(&Derived::TraverseCXXMemberCallExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXMemberCallExpr(static_cast<CXXMemberCallExpr *>(S), Queue) : getDerived().TraverseCXXMemberCallExpr(static_cast<CXXMemberCallExpr *>(S))); | |
case Stmt::CXXOperatorCallExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXOperatorCallExpr), decltype(&Derived::TraverseCXXOperatorCallExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXOperatorCallExpr), decltype(&Derived::TraverseCXXOperatorCallExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXOperatorCallExpr(static_cast<CXXOperatorCallExpr *>(S), Queue) : getDerived().TraverseCXXOperatorCallExpr(static_cast<CXXOperatorCallExpr *>(S))); | |
case Stmt::UserDefinedLiteralClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseUserDefinedLiteral), decltype(&Derived::TraverseUserDefinedLiteral)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseUserDefinedLiteral), decltype(&Derived::TraverseUserDefinedLiteral)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseUserDefinedLiteral(static_cast<UserDefinedLiteral *>(S), Queue) : getDerived().TraverseUserDefinedLiteral(static_cast<UserDefinedLiteral *>(S))); | |
case Stmt::BuiltinBitCastExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseBuiltinBitCastExpr), decltype(&Derived::TraverseBuiltinBitCastExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseBuiltinBitCastExpr), decltype(&Derived::TraverseBuiltinBitCastExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseBuiltinBitCastExpr(static_cast<BuiltinBitCastExpr *>(S), Queue) : getDerived().TraverseBuiltinBitCastExpr(static_cast<BuiltinBitCastExpr *>(S))); | |
case Stmt::CStyleCastExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCStyleCastExpr), decltype(&Derived::TraverseCStyleCastExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCStyleCastExpr), decltype(&Derived::TraverseCStyleCastExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCStyleCastExpr(static_cast<CStyleCastExpr *>(S), Queue) : getDerived().TraverseCStyleCastExpr(static_cast<CStyleCastExpr *>(S))); | |
case Stmt::CXXFunctionalCastExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXFunctionalCastExpr), decltype(&Derived::TraverseCXXFunctionalCastExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXFunctionalCastExpr), decltype(&Derived::TraverseCXXFunctionalCastExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXFunctionalCastExpr(static_cast<CXXFunctionalCastExpr *>(S), Queue) : getDerived().TraverseCXXFunctionalCastExpr(static_cast<CXXFunctionalCastExpr *>(S))); | |
case Stmt::CXXAddrspaceCastExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXAddrspaceCastExpr), decltype(&Derived::TraverseCXXAddrspaceCastExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXAddrspaceCastExpr), decltype(&Derived::TraverseCXXAddrspaceCastExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXAddrspaceCastExpr(static_cast<CXXAddrspaceCastExpr *>(S), Queue) : getDerived().TraverseCXXAddrspaceCastExpr(static_cast<CXXAddrspaceCastExpr *>(S))); | |
case Stmt::CXXConstCastExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXConstCastExpr), decltype(&Derived::TraverseCXXConstCastExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXConstCastExpr), decltype(&Derived::TraverseCXXConstCastExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXConstCastExpr(static_cast<CXXConstCastExpr *>(S), Queue) : getDerived().TraverseCXXConstCastExpr(static_cast<CXXConstCastExpr *>(S))); | |
case Stmt::CXXDynamicCastExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXDynamicCastExpr), decltype(&Derived::TraverseCXXDynamicCastExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXDynamicCastExpr), decltype(&Derived::TraverseCXXDynamicCastExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXDynamicCastExpr(static_cast<CXXDynamicCastExpr *>(S), Queue) : getDerived().TraverseCXXDynamicCastExpr(static_cast<CXXDynamicCastExpr *>(S))); | |
case Stmt::CXXReinterpretCastExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXReinterpretCastExpr), decltype(&Derived::TraverseCXXReinterpretCastExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXReinterpretCastExpr), decltype(&Derived::TraverseCXXReinterpretCastExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXReinterpretCastExpr(static_cast<CXXReinterpretCastExpr *>(S), Queue) : getDerived().TraverseCXXReinterpretCastExpr(static_cast<CXXReinterpretCastExpr *>(S))); | |
case Stmt::CXXStaticCastExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXStaticCastExpr), decltype(&Derived::TraverseCXXStaticCastExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCXXStaticCastExpr), decltype(&Derived::TraverseCXXStaticCastExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCXXStaticCastExpr(static_cast<CXXStaticCastExpr *>(S), Queue) : getDerived().TraverseCXXStaticCastExpr(static_cast<CXXStaticCastExpr *>(S))); | |
case Stmt::ObjCBridgedCastExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCBridgedCastExpr), decltype(&Derived::TraverseObjCBridgedCastExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCBridgedCastExpr), decltype(&Derived::TraverseObjCBridgedCastExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCBridgedCastExpr(static_cast<ObjCBridgedCastExpr *>(S), Queue) : getDerived().TraverseObjCBridgedCastExpr(static_cast<ObjCBridgedCastExpr *>(S))); | |
case Stmt::ImplicitCastExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseImplicitCastExpr), decltype(&Derived::TraverseImplicitCastExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseImplicitCastExpr), decltype(&Derived::TraverseImplicitCastExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseImplicitCastExpr(static_cast<ImplicitCastExpr *>(S), Queue) : getDerived().TraverseImplicitCastExpr(static_cast<ImplicitCastExpr *>(S))); | |
case Stmt::CharacterLiteralClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCharacterLiteral), decltype(&Derived::TraverseCharacterLiteral)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCharacterLiteral), decltype(&Derived::TraverseCharacterLiteral)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCharacterLiteral(static_cast<CharacterLiteral *>(S), Queue) : getDerived().TraverseCharacterLiteral(static_cast<CharacterLiteral *>(S))); | |
case Stmt::ChooseExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseChooseExpr), decltype(&Derived::TraverseChooseExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseChooseExpr), decltype(&Derived::TraverseChooseExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseChooseExpr(static_cast<ChooseExpr *>(S), Queue) : getDerived().TraverseChooseExpr(static_cast<ChooseExpr *>(S))); | |
case Stmt::CompoundLiteralExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCompoundLiteralExpr), decltype(&Derived::TraverseCompoundLiteralExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCompoundLiteralExpr), decltype(&Derived::TraverseCompoundLiteralExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCompoundLiteralExpr(static_cast<CompoundLiteralExpr *>(S), Queue) : getDerived().TraverseCompoundLiteralExpr(static_cast<CompoundLiteralExpr *>(S))); | |
case Stmt::ConceptSpecializationExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseConceptSpecializationExpr), decltype(&Derived::TraverseConceptSpecializationExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseConceptSpecializationExpr), decltype(&Derived::TraverseConceptSpecializationExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseConceptSpecializationExpr(static_cast<ConceptSpecializationExpr *>(S), Queue) : getDerived().TraverseConceptSpecializationExpr(static_cast<ConceptSpecializationExpr *>(S))); | |
case Stmt::ConvertVectorExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseConvertVectorExpr), decltype(&Derived::TraverseConvertVectorExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseConvertVectorExpr), decltype(&Derived::TraverseConvertVectorExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseConvertVectorExpr(static_cast<ConvertVectorExpr *>(S), Queue) : getDerived().TraverseConvertVectorExpr(static_cast<ConvertVectorExpr *>(S))); | |
case Stmt::CoawaitExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCoawaitExpr), decltype(&Derived::TraverseCoawaitExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCoawaitExpr), decltype(&Derived::TraverseCoawaitExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCoawaitExpr(static_cast<CoawaitExpr *>(S), Queue) : getDerived().TraverseCoawaitExpr(static_cast<CoawaitExpr *>(S))); | |
case Stmt::CoyieldExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCoyieldExpr), decltype(&Derived::TraverseCoyieldExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseCoyieldExpr), decltype(&Derived::TraverseCoyieldExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseCoyieldExpr(static_cast<CoyieldExpr *>(S), Queue) : getDerived().TraverseCoyieldExpr(static_cast<CoyieldExpr *>(S))); | |
case Stmt::DeclRefExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDeclRefExpr), decltype(&Derived::TraverseDeclRefExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDeclRefExpr), decltype(&Derived::TraverseDeclRefExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseDeclRefExpr(static_cast<DeclRefExpr *>(S), Queue) : getDerived().TraverseDeclRefExpr(static_cast<DeclRefExpr *>(S))); | |
case Stmt::DependentCoawaitExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDependentCoawaitExpr), decltype(&Derived::TraverseDependentCoawaitExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDependentCoawaitExpr), decltype(&Derived::TraverseDependentCoawaitExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseDependentCoawaitExpr(static_cast<DependentCoawaitExpr *>(S), Queue) : getDerived().TraverseDependentCoawaitExpr(static_cast<DependentCoawaitExpr *>(S))); | |
case Stmt::DependentScopeDeclRefExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDependentScopeDeclRefExpr), decltype(&Derived::TraverseDependentScopeDeclRefExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDependentScopeDeclRefExpr), decltype(&Derived::TraverseDependentScopeDeclRefExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseDependentScopeDeclRefExpr(static_cast<DependentScopeDeclRefExpr *>(S), Queue) : getDerived().TraverseDependentScopeDeclRefExpr(static_cast<DependentScopeDeclRefExpr *>(S))); | |
case Stmt::DesignatedInitExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDesignatedInitExpr), decltype(&Derived::TraverseDesignatedInitExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDesignatedInitExpr), decltype(&Derived::TraverseDesignatedInitExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseDesignatedInitExpr(static_cast<DesignatedInitExpr *>(S), Queue) : getDerived().TraverseDesignatedInitExpr(static_cast<DesignatedInitExpr *>(S))); | |
case Stmt::DesignatedInitUpdateExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDesignatedInitUpdateExpr), decltype(&Derived::TraverseDesignatedInitUpdateExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseDesignatedInitUpdateExpr), decltype(&Derived::TraverseDesignatedInitUpdateExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseDesignatedInitUpdateExpr(static_cast<DesignatedInitUpdateExpr *>(S), Queue) : getDerived().TraverseDesignatedInitUpdateExpr(static_cast<DesignatedInitUpdateExpr *>(S))); | |
case Stmt::ExpressionTraitExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseExpressionTraitExpr), decltype(&Derived::TraverseExpressionTraitExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseExpressionTraitExpr), decltype(&Derived::TraverseExpressionTraitExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseExpressionTraitExpr(static_cast<ExpressionTraitExpr *>(S), Queue) : getDerived().TraverseExpressionTraitExpr(static_cast<ExpressionTraitExpr *>(S))); | |
case Stmt::ExtVectorElementExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseExtVectorElementExpr), decltype(&Derived::TraverseExtVectorElementExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseExtVectorElementExpr), decltype(&Derived::TraverseExtVectorElementExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseExtVectorElementExpr(static_cast<ExtVectorElementExpr *>(S), Queue) : getDerived().TraverseExtVectorElementExpr(static_cast<ExtVectorElementExpr *>(S))); | |
case Stmt::FixedPointLiteralClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseFixedPointLiteral), decltype(&Derived::TraverseFixedPointLiteral)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseFixedPointLiteral), decltype(&Derived::TraverseFixedPointLiteral)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseFixedPointLiteral(static_cast<FixedPointLiteral *>(S), Queue) : getDerived().TraverseFixedPointLiteral(static_cast<FixedPointLiteral *>(S))); | |
case Stmt::FloatingLiteralClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseFloatingLiteral), decltype(&Derived::TraverseFloatingLiteral)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseFloatingLiteral), decltype(&Derived::TraverseFloatingLiteral)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseFloatingLiteral(static_cast<FloatingLiteral *>(S), Queue) : getDerived().TraverseFloatingLiteral(static_cast<FloatingLiteral *>(S))); | |
case Stmt::ConstantExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseConstantExpr), decltype(&Derived::TraverseConstantExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseConstantExpr), decltype(&Derived::TraverseConstantExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseConstantExpr(static_cast<ConstantExpr *>(S), Queue) : getDerived().TraverseConstantExpr(static_cast<ConstantExpr *>(S))); | |
case Stmt::ExprWithCleanupsClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseExprWithCleanups), decltype(&Derived::TraverseExprWithCleanups)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseExprWithCleanups), decltype(&Derived::TraverseExprWithCleanups)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseExprWithCleanups(static_cast<ExprWithCleanups *>(S), Queue) : getDerived().TraverseExprWithCleanups(static_cast<ExprWithCleanups *>(S))); | |
case Stmt::FunctionParmPackExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseFunctionParmPackExpr), decltype(&Derived::TraverseFunctionParmPackExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseFunctionParmPackExpr), decltype(&Derived::TraverseFunctionParmPackExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseFunctionParmPackExpr(static_cast<FunctionParmPackExpr *>(S), Queue) : getDerived().TraverseFunctionParmPackExpr(static_cast<FunctionParmPackExpr *>(S))); | |
case Stmt::GNUNullExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseGNUNullExpr), decltype(&Derived::TraverseGNUNullExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseGNUNullExpr), decltype(&Derived::TraverseGNUNullExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseGNUNullExpr(static_cast<GNUNullExpr *>(S), Queue) : getDerived().TraverseGNUNullExpr(static_cast<GNUNullExpr *>(S))); | |
case Stmt::GenericSelectionExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseGenericSelectionExpr), decltype(&Derived::TraverseGenericSelectionExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseGenericSelectionExpr), decltype(&Derived::TraverseGenericSelectionExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseGenericSelectionExpr(static_cast<GenericSelectionExpr *>(S), Queue) : getDerived().TraverseGenericSelectionExpr(static_cast<GenericSelectionExpr *>(S))); | |
case Stmt::ImaginaryLiteralClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseImaginaryLiteral), decltype(&Derived::TraverseImaginaryLiteral)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseImaginaryLiteral), decltype(&Derived::TraverseImaginaryLiteral)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseImaginaryLiteral(static_cast<ImaginaryLiteral *>(S), Queue) : getDerived().TraverseImaginaryLiteral(static_cast<ImaginaryLiteral *>(S))); | |
case Stmt::ImplicitValueInitExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseImplicitValueInitExpr), decltype(&Derived::TraverseImplicitValueInitExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseImplicitValueInitExpr), decltype(&Derived::TraverseImplicitValueInitExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseImplicitValueInitExpr(static_cast<ImplicitValueInitExpr *>(S), Queue) : getDerived().TraverseImplicitValueInitExpr(static_cast<ImplicitValueInitExpr *>(S))); | |
case Stmt::InitListExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseInitListExpr), decltype(&Derived::TraverseInitListExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseInitListExpr), decltype(&Derived::TraverseInitListExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseInitListExpr(static_cast<InitListExpr *>(S), Queue) : getDerived().TraverseInitListExpr(static_cast<InitListExpr *>(S))); | |
case Stmt::IntegerLiteralClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseIntegerLiteral), decltype(&Derived::TraverseIntegerLiteral)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseIntegerLiteral), decltype(&Derived::TraverseIntegerLiteral)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseIntegerLiteral(static_cast<IntegerLiteral *>(S), Queue) : getDerived().TraverseIntegerLiteral(static_cast<IntegerLiteral *>(S))); | |
case Stmt::LambdaExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseLambdaExpr), decltype(&Derived::TraverseLambdaExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseLambdaExpr), decltype(&Derived::TraverseLambdaExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseLambdaExpr(static_cast<LambdaExpr *>(S), Queue) : getDerived().TraverseLambdaExpr(static_cast<LambdaExpr *>(S))); | |
case Stmt::MSPropertyRefExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMSPropertyRefExpr), decltype(&Derived::TraverseMSPropertyRefExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMSPropertyRefExpr), decltype(&Derived::TraverseMSPropertyRefExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseMSPropertyRefExpr(static_cast<MSPropertyRefExpr *>(S), Queue) : getDerived().TraverseMSPropertyRefExpr(static_cast<MSPropertyRefExpr *>(S))); | |
case Stmt::MSPropertySubscriptExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMSPropertySubscriptExpr), decltype(&Derived::TraverseMSPropertySubscriptExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMSPropertySubscriptExpr), decltype(&Derived::TraverseMSPropertySubscriptExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseMSPropertySubscriptExpr(static_cast<MSPropertySubscriptExpr *>(S), Queue) : getDerived().TraverseMSPropertySubscriptExpr(static_cast<MSPropertySubscriptExpr *>(S))); | |
case Stmt::MaterializeTemporaryExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMaterializeTemporaryExpr), decltype(&Derived::TraverseMaterializeTemporaryExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMaterializeTemporaryExpr), decltype(&Derived::TraverseMaterializeTemporaryExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseMaterializeTemporaryExpr(static_cast<MaterializeTemporaryExpr *>(S), Queue) : getDerived().TraverseMaterializeTemporaryExpr(static_cast<MaterializeTemporaryExpr *>(S))); | |
case Stmt::MatrixSubscriptExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMatrixSubscriptExpr), decltype(&Derived::TraverseMatrixSubscriptExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMatrixSubscriptExpr), decltype(&Derived::TraverseMatrixSubscriptExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseMatrixSubscriptExpr(static_cast<MatrixSubscriptExpr *>(S), Queue) : getDerived().TraverseMatrixSubscriptExpr(static_cast<MatrixSubscriptExpr *>(S))); | |
case Stmt::MemberExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMemberExpr), decltype(&Derived::TraverseMemberExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseMemberExpr), decltype(&Derived::TraverseMemberExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseMemberExpr(static_cast<MemberExpr *>(S), Queue) : getDerived().TraverseMemberExpr(static_cast<MemberExpr *>(S))); | |
case Stmt::NoInitExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseNoInitExpr), decltype(&Derived::TraverseNoInitExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseNoInitExpr), decltype(&Derived::TraverseNoInitExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseNoInitExpr(static_cast<NoInitExpr *>(S), Queue) : getDerived().TraverseNoInitExpr(static_cast<NoInitExpr *>(S))); | |
case Stmt::OMPArraySectionExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPArraySectionExpr), decltype(&Derived::TraverseOMPArraySectionExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPArraySectionExpr), decltype(&Derived::TraverseOMPArraySectionExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPArraySectionExpr(static_cast<OMPArraySectionExpr *>(S), Queue) : getDerived().TraverseOMPArraySectionExpr(static_cast<OMPArraySectionExpr *>(S))); | |
case Stmt::OMPArrayShapingExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPArrayShapingExpr), decltype(&Derived::TraverseOMPArrayShapingExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPArrayShapingExpr), decltype(&Derived::TraverseOMPArrayShapingExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPArrayShapingExpr(static_cast<OMPArrayShapingExpr *>(S), Queue) : getDerived().TraverseOMPArrayShapingExpr(static_cast<OMPArrayShapingExpr *>(S))); | |
case Stmt::OMPIteratorExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPIteratorExpr), decltype(&Derived::TraverseOMPIteratorExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOMPIteratorExpr), decltype(&Derived::TraverseOMPIteratorExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOMPIteratorExpr(static_cast<OMPIteratorExpr *>(S), Queue) : getDerived().TraverseOMPIteratorExpr(static_cast<OMPIteratorExpr *>(S))); | |
case Stmt::ObjCArrayLiteralClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCArrayLiteral), decltype(&Derived::TraverseObjCArrayLiteral)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCArrayLiteral), decltype(&Derived::TraverseObjCArrayLiteral)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCArrayLiteral(static_cast<ObjCArrayLiteral *>(S), Queue) : getDerived().TraverseObjCArrayLiteral(static_cast<ObjCArrayLiteral *>(S))); | |
case Stmt::ObjCAvailabilityCheckExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAvailabilityCheckExpr), decltype(&Derived::TraverseObjCAvailabilityCheckExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCAvailabilityCheckExpr), decltype(&Derived::TraverseObjCAvailabilityCheckExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCAvailabilityCheckExpr(static_cast<ObjCAvailabilityCheckExpr *>(S), Queue) : getDerived().TraverseObjCAvailabilityCheckExpr(static_cast<ObjCAvailabilityCheckExpr *>(S))); | |
case Stmt::ObjCBoolLiteralExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCBoolLiteralExpr), decltype(&Derived::TraverseObjCBoolLiteralExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCBoolLiteralExpr), decltype(&Derived::TraverseObjCBoolLiteralExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCBoolLiteralExpr(static_cast<ObjCBoolLiteralExpr *>(S), Queue) : getDerived().TraverseObjCBoolLiteralExpr(static_cast<ObjCBoolLiteralExpr *>(S))); | |
case Stmt::ObjCBoxedExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCBoxedExpr), decltype(&Derived::TraverseObjCBoxedExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCBoxedExpr), decltype(&Derived::TraverseObjCBoxedExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCBoxedExpr(static_cast<ObjCBoxedExpr *>(S), Queue) : getDerived().TraverseObjCBoxedExpr(static_cast<ObjCBoxedExpr *>(S))); | |
case Stmt::ObjCDictionaryLiteralClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCDictionaryLiteral), decltype(&Derived::TraverseObjCDictionaryLiteral)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCDictionaryLiteral), decltype(&Derived::TraverseObjCDictionaryLiteral)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCDictionaryLiteral(static_cast<ObjCDictionaryLiteral *>(S), Queue) : getDerived().TraverseObjCDictionaryLiteral(static_cast<ObjCDictionaryLiteral *>(S))); | |
case Stmt::ObjCEncodeExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCEncodeExpr), decltype(&Derived::TraverseObjCEncodeExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCEncodeExpr), decltype(&Derived::TraverseObjCEncodeExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCEncodeExpr(static_cast<ObjCEncodeExpr *>(S), Queue) : getDerived().TraverseObjCEncodeExpr(static_cast<ObjCEncodeExpr *>(S))); | |
case Stmt::ObjCIndirectCopyRestoreExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCIndirectCopyRestoreExpr), decltype(&Derived::TraverseObjCIndirectCopyRestoreExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCIndirectCopyRestoreExpr), decltype(&Derived::TraverseObjCIndirectCopyRestoreExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCIndirectCopyRestoreExpr(static_cast<ObjCIndirectCopyRestoreExpr *>(S), Queue) : getDerived().TraverseObjCIndirectCopyRestoreExpr(static_cast<ObjCIndirectCopyRestoreExpr *>(S))); | |
case Stmt::ObjCIsaExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCIsaExpr), decltype(&Derived::TraverseObjCIsaExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCIsaExpr), decltype(&Derived::TraverseObjCIsaExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCIsaExpr(static_cast<ObjCIsaExpr *>(S), Queue) : getDerived().TraverseObjCIsaExpr(static_cast<ObjCIsaExpr *>(S))); | |
case Stmt::ObjCIvarRefExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCIvarRefExpr), decltype(&Derived::TraverseObjCIvarRefExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCIvarRefExpr), decltype(&Derived::TraverseObjCIvarRefExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCIvarRefExpr(static_cast<ObjCIvarRefExpr *>(S), Queue) : getDerived().TraverseObjCIvarRefExpr(static_cast<ObjCIvarRefExpr *>(S))); | |
case Stmt::ObjCMessageExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCMessageExpr), decltype(&Derived::TraverseObjCMessageExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCMessageExpr), decltype(&Derived::TraverseObjCMessageExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCMessageExpr(static_cast<ObjCMessageExpr *>(S), Queue) : getDerived().TraverseObjCMessageExpr(static_cast<ObjCMessageExpr *>(S))); | |
case Stmt::ObjCPropertyRefExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCPropertyRefExpr), decltype(&Derived::TraverseObjCPropertyRefExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCPropertyRefExpr), decltype(&Derived::TraverseObjCPropertyRefExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCPropertyRefExpr(static_cast<ObjCPropertyRefExpr *>(S), Queue) : getDerived().TraverseObjCPropertyRefExpr(static_cast<ObjCPropertyRefExpr *>(S))); | |
case Stmt::ObjCProtocolExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCProtocolExpr), decltype(&Derived::TraverseObjCProtocolExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCProtocolExpr), decltype(&Derived::TraverseObjCProtocolExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCProtocolExpr(static_cast<ObjCProtocolExpr *>(S), Queue) : getDerived().TraverseObjCProtocolExpr(static_cast<ObjCProtocolExpr *>(S))); | |
case Stmt::ObjCSelectorExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCSelectorExpr), decltype(&Derived::TraverseObjCSelectorExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCSelectorExpr), decltype(&Derived::TraverseObjCSelectorExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCSelectorExpr(static_cast<ObjCSelectorExpr *>(S), Queue) : getDerived().TraverseObjCSelectorExpr(static_cast<ObjCSelectorExpr *>(S))); | |
case Stmt::ObjCStringLiteralClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCStringLiteral), decltype(&Derived::TraverseObjCStringLiteral)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCStringLiteral), decltype(&Derived::TraverseObjCStringLiteral)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCStringLiteral(static_cast<ObjCStringLiteral *>(S), Queue) : getDerived().TraverseObjCStringLiteral(static_cast<ObjCStringLiteral *>(S))); | |
case Stmt::ObjCSubscriptRefExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCSubscriptRefExpr), decltype(&Derived::TraverseObjCSubscriptRefExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseObjCSubscriptRefExpr), decltype(&Derived::TraverseObjCSubscriptRefExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseObjCSubscriptRefExpr(static_cast<ObjCSubscriptRefExpr *>(S), Queue) : getDerived().TraverseObjCSubscriptRefExpr(static_cast<ObjCSubscriptRefExpr *>(S))); | |
case Stmt::OffsetOfExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOffsetOfExpr), decltype(&Derived::TraverseOffsetOfExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOffsetOfExpr), decltype(&Derived::TraverseOffsetOfExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOffsetOfExpr(static_cast<OffsetOfExpr *>(S), Queue) : getDerived().TraverseOffsetOfExpr(static_cast<OffsetOfExpr *>(S))); | |
case Stmt::OpaqueValueExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOpaqueValueExpr), decltype(&Derived::TraverseOpaqueValueExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseOpaqueValueExpr), decltype(&Derived::TraverseOpaqueValueExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseOpaqueValueExpr(static_cast<OpaqueValueExpr *>(S), Queue) : getDerived().TraverseOpaqueValueExpr(static_cast<OpaqueValueExpr *>(S))); | |
case Stmt::UnresolvedLookupExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseUnresolvedLookupExpr), decltype(&Derived::TraverseUnresolvedLookupExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseUnresolvedLookupExpr), decltype(&Derived::TraverseUnresolvedLookupExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseUnresolvedLookupExpr(static_cast<UnresolvedLookupExpr *>(S), Queue) : getDerived().TraverseUnresolvedLookupExpr(static_cast<UnresolvedLookupExpr *>(S))); | |
case Stmt::UnresolvedMemberExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseUnresolvedMemberExpr), decltype(&Derived::TraverseUnresolvedMemberExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseUnresolvedMemberExpr), decltype(&Derived::TraverseUnresolvedMemberExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseUnresolvedMemberExpr(static_cast<UnresolvedMemberExpr *>(S), Queue) : getDerived().TraverseUnresolvedMemberExpr(static_cast<UnresolvedMemberExpr *>(S))); | |
case Stmt::PackExpansionExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraversePackExpansionExpr), decltype(&Derived::TraversePackExpansionExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraversePackExpansionExpr), decltype(&Derived::TraversePackExpansionExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraversePackExpansionExpr(static_cast<PackExpansionExpr *>(S), Queue) : getDerived().TraversePackExpansionExpr(static_cast<PackExpansionExpr *>(S))); | |
case Stmt::ParenExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseParenExpr), decltype(&Derived::TraverseParenExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseParenExpr), decltype(&Derived::TraverseParenExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseParenExpr(static_cast<ParenExpr *>(S), Queue) : getDerived().TraverseParenExpr(static_cast<ParenExpr *>(S))); | |
case Stmt::ParenListExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseParenListExpr), decltype(&Derived::TraverseParenListExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseParenListExpr), decltype(&Derived::TraverseParenListExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseParenListExpr(static_cast<ParenListExpr *>(S), Queue) : getDerived().TraverseParenListExpr(static_cast<ParenListExpr *>(S))); | |
case Stmt::PredefinedExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraversePredefinedExpr), decltype(&Derived::TraversePredefinedExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraversePredefinedExpr), decltype(&Derived::TraversePredefinedExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraversePredefinedExpr(static_cast<PredefinedExpr *>(S), Queue) : getDerived().TraversePredefinedExpr(static_cast<PredefinedExpr *>(S))); | |
case Stmt::PseudoObjectExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraversePseudoObjectExpr), decltype(&Derived::TraversePseudoObjectExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraversePseudoObjectExpr), decltype(&Derived::TraversePseudoObjectExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraversePseudoObjectExpr(static_cast<PseudoObjectExpr *>(S), Queue) : getDerived().TraversePseudoObjectExpr(static_cast<PseudoObjectExpr *>(S))); | |
case Stmt::RecoveryExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseRecoveryExpr), decltype(&Derived::TraverseRecoveryExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseRecoveryExpr), decltype(&Derived::TraverseRecoveryExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseRecoveryExpr(static_cast<RecoveryExpr *>(S), Queue) : getDerived().TraverseRecoveryExpr(static_cast<RecoveryExpr *>(S))); | |
case Stmt::RequiresExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseRequiresExpr), decltype(&Derived::TraverseRequiresExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseRequiresExpr), decltype(&Derived::TraverseRequiresExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseRequiresExpr(static_cast<RequiresExpr *>(S), Queue) : getDerived().TraverseRequiresExpr(static_cast<RequiresExpr *>(S))); | |
case Stmt::SYCLUniqueStableNameExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSYCLUniqueStableNameExpr), decltype(&Derived::TraverseSYCLUniqueStableNameExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSYCLUniqueStableNameExpr), decltype(&Derived::TraverseSYCLUniqueStableNameExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseSYCLUniqueStableNameExpr(static_cast<SYCLUniqueStableNameExpr *>(S), Queue) : getDerived().TraverseSYCLUniqueStableNameExpr(static_cast<SYCLUniqueStableNameExpr *>(S))); | |
case Stmt::ShuffleVectorExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseShuffleVectorExpr), decltype(&Derived::TraverseShuffleVectorExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseShuffleVectorExpr), decltype(&Derived::TraverseShuffleVectorExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseShuffleVectorExpr(static_cast<ShuffleVectorExpr *>(S), Queue) : getDerived().TraverseShuffleVectorExpr(static_cast<ShuffleVectorExpr *>(S))); | |
case Stmt::SizeOfPackExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSizeOfPackExpr), decltype(&Derived::TraverseSizeOfPackExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSizeOfPackExpr), decltype(&Derived::TraverseSizeOfPackExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseSizeOfPackExpr(static_cast<SizeOfPackExpr *>(S), Queue) : getDerived().TraverseSizeOfPackExpr(static_cast<SizeOfPackExpr *>(S))); | |
case Stmt::SourceLocExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSourceLocExpr), decltype(&Derived::TraverseSourceLocExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSourceLocExpr), decltype(&Derived::TraverseSourceLocExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseSourceLocExpr(static_cast<SourceLocExpr *>(S), Queue) : getDerived().TraverseSourceLocExpr(static_cast<SourceLocExpr *>(S))); | |
case Stmt::StmtExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmtExpr), decltype(&Derived::TraverseStmtExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmtExpr), decltype(&Derived::TraverseStmtExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmtExpr(static_cast<StmtExpr *>(S), Queue) : getDerived().TraverseStmtExpr(static_cast<StmtExpr *>(S))); | |
case Stmt::StringLiteralClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStringLiteral), decltype(&Derived::TraverseStringLiteral)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStringLiteral), decltype(&Derived::TraverseStringLiteral)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStringLiteral(static_cast<StringLiteral *>(S), Queue) : getDerived().TraverseStringLiteral(static_cast<StringLiteral *>(S))); | |
case Stmt::SubstNonTypeTemplateParmExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSubstNonTypeTemplateParmExpr), decltype(&Derived::TraverseSubstNonTypeTemplateParmExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSubstNonTypeTemplateParmExpr), decltype(&Derived::TraverseSubstNonTypeTemplateParmExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseSubstNonTypeTemplateParmExpr(static_cast<SubstNonTypeTemplateParmExpr *>(S), Queue) : getDerived().TraverseSubstNonTypeTemplateParmExpr(static_cast<SubstNonTypeTemplateParmExpr *>(S))); | |
case Stmt::SubstNonTypeTemplateParmPackExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSubstNonTypeTemplateParmPackExpr), decltype(&Derived::TraverseSubstNonTypeTemplateParmPackExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseSubstNonTypeTemplateParmPackExpr), decltype(&Derived::TraverseSubstNonTypeTemplateParmPackExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseSubstNonTypeTemplateParmPackExpr(static_cast<SubstNonTypeTemplateParmPackExpr *>(S), Queue) : getDerived().TraverseSubstNonTypeTemplateParmPackExpr(static_cast<SubstNonTypeTemplateParmPackExpr *>(S))); | |
case Stmt::TypeTraitExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseTypeTraitExpr), decltype(&Derived::TraverseTypeTraitExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseTypeTraitExpr), decltype(&Derived::TraverseTypeTraitExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseTypeTraitExpr(static_cast<TypeTraitExpr *>(S), Queue) : getDerived().TraverseTypeTraitExpr(static_cast<TypeTraitExpr *>(S))); | |
case Stmt::TypoExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseTypoExpr), decltype(&Derived::TraverseTypoExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseTypoExpr), decltype(&Derived::TraverseTypoExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseTypoExpr(static_cast<TypoExpr *>(S), Queue) : getDerived().TraverseTypoExpr(static_cast<TypoExpr *>(S))); | |
case Stmt::UnaryExprOrTypeTraitExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseUnaryExprOrTypeTraitExpr), decltype(&Derived::TraverseUnaryExprOrTypeTraitExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseUnaryExprOrTypeTraitExpr), decltype(&Derived::TraverseUnaryExprOrTypeTraitExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseUnaryExprOrTypeTraitExpr(static_cast<UnaryExprOrTypeTraitExpr *>(S), Queue) : getDerived().TraverseUnaryExprOrTypeTraitExpr(static_cast<UnaryExprOrTypeTraitExpr *>(S))); | |
case Stmt::UnaryOperatorClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseUnaryOperator), decltype(&Derived::TraverseUnaryOperator)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseUnaryOperator), decltype(&Derived::TraverseUnaryOperator)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseUnaryOperator(static_cast<UnaryOperator *>(S), Queue) : getDerived().TraverseUnaryOperator(static_cast<UnaryOperator *>(S))); | |
case Stmt::VAArgExprClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseVAArgExpr), decltype(&Derived::TraverseVAArgExpr)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseVAArgExpr), decltype(&Derived::TraverseVAArgExpr)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseVAArgExpr(static_cast<VAArgExpr *>(S), Queue) : getDerived().TraverseVAArgExpr(static_cast<VAArgExpr *>(S))); | |
case Stmt::LabelStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseLabelStmt), decltype(&Derived::TraverseLabelStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseLabelStmt), decltype(&Derived::TraverseLabelStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseLabelStmt(static_cast<LabelStmt *>(S), Queue) : getDerived().TraverseLabelStmt(static_cast<LabelStmt *>(S))); | |
case Stmt::WhileStmtClass: return (::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseWhileStmt), decltype(&Derived::TraverseWhileStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseWhileStmt), decltype(&Derived::TraverseWhileStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseWhileStmt(static_cast<WhileStmt *>(S), Queue) : getDerived().TraverseWhileStmt(static_cast<WhileStmt *>(S))); | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::PostVisitStmt(Stmt *S) { | |
switch (S->getStmtClass()) { | |
case Stmt::NoStmtClass: | |
break; | |
case Stmt::GCCAsmStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseGCCAsmStmt, &Derived::TraverseGCCAsmStmt)) { do { if (!getDerived().WalkUpFromGCCAsmStmt(static_cast<GCCAsmStmt *>(S))) return false; } while (false); } break; | |
case Stmt::MSAsmStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseMSAsmStmt, &Derived::TraverseMSAsmStmt)) { do { if (!getDerived().WalkUpFromMSAsmStmt(static_cast<MSAsmStmt *>(S))) return false; } while (false); } break; | |
case Stmt::BreakStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseBreakStmt, &Derived::TraverseBreakStmt)) { do { if (!getDerived().WalkUpFromBreakStmt(static_cast<BreakStmt *>(S))) return false; } while (false); } break; | |
case Stmt::CXXCatchStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXCatchStmt, &Derived::TraverseCXXCatchStmt)) { do { if (!getDerived().WalkUpFromCXXCatchStmt(static_cast<CXXCatchStmt *>(S))) return false; } while (false); } break; | |
case Stmt::CXXForRangeStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXForRangeStmt, &Derived::TraverseCXXForRangeStmt)) { do { if (!getDerived().WalkUpFromCXXForRangeStmt(static_cast<CXXForRangeStmt *>(S))) return false; } while (false); } break; | |
case Stmt::CXXTryStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXTryStmt, &Derived::TraverseCXXTryStmt)) { do { if (!getDerived().WalkUpFromCXXTryStmt(static_cast<CXXTryStmt *>(S))) return false; } while (false); } break; | |
case Stmt::CapturedStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCapturedStmt, &Derived::TraverseCapturedStmt)) { do { if (!getDerived().WalkUpFromCapturedStmt(static_cast<CapturedStmt *>(S))) return false; } while (false); } break; | |
case Stmt::CompoundStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCompoundStmt, &Derived::TraverseCompoundStmt)) { do { if (!getDerived().WalkUpFromCompoundStmt(static_cast<CompoundStmt *>(S))) return false; } while (false); } break; | |
case Stmt::ContinueStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseContinueStmt, &Derived::TraverseContinueStmt)) { do { if (!getDerived().WalkUpFromContinueStmt(static_cast<ContinueStmt *>(S))) return false; } while (false); } break; | |
case Stmt::CoreturnStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCoreturnStmt, &Derived::TraverseCoreturnStmt)) { do { if (!getDerived().WalkUpFromCoreturnStmt(static_cast<CoreturnStmt *>(S))) return false; } while (false); } break; | |
case Stmt::CoroutineBodyStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCoroutineBodyStmt, &Derived::TraverseCoroutineBodyStmt)) { do { if (!getDerived().WalkUpFromCoroutineBodyStmt(static_cast<CoroutineBodyStmt *>(S))) return false; } while (false); } break; | |
case Stmt::DeclStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseDeclStmt, &Derived::TraverseDeclStmt)) { do { if (!getDerived().WalkUpFromDeclStmt(static_cast<DeclStmt *>(S))) return false; } while (false); } break; | |
case Stmt::DoStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseDoStmt, &Derived::TraverseDoStmt)) { do { if (!getDerived().WalkUpFromDoStmt(static_cast<DoStmt *>(S))) return false; } while (false); } break; | |
case Stmt::ForStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseForStmt, &Derived::TraverseForStmt)) { do { if (!getDerived().WalkUpFromForStmt(static_cast<ForStmt *>(S))) return false; } while (false); } break; | |
case Stmt::GotoStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseGotoStmt, &Derived::TraverseGotoStmt)) { do { if (!getDerived().WalkUpFromGotoStmt(static_cast<GotoStmt *>(S))) return false; } while (false); } break; | |
case Stmt::IfStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseIfStmt, &Derived::TraverseIfStmt)) { do { if (!getDerived().WalkUpFromIfStmt(static_cast<IfStmt *>(S))) return false; } while (false); } break; | |
case Stmt::IndirectGotoStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseIndirectGotoStmt, &Derived::TraverseIndirectGotoStmt)) { do { if (!getDerived().WalkUpFromIndirectGotoStmt(static_cast<IndirectGotoStmt *>(S))) return false; } while (false); } break; | |
case Stmt::MSDependentExistsStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseMSDependentExistsStmt, &Derived::TraverseMSDependentExistsStmt)) { do { if (!getDerived().WalkUpFromMSDependentExistsStmt(static_cast<MSDependentExistsStmt *>(S))) return false; } while (false); } break; | |
case Stmt::NullStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseNullStmt, &Derived::TraverseNullStmt)) { do { if (!getDerived().WalkUpFromNullStmt(static_cast<NullStmt *>(S))) return false; } while (false); } break; | |
case Stmt::OMPCanonicalLoopClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPCanonicalLoop, &Derived::TraverseOMPCanonicalLoop)) { do { if (!getDerived().WalkUpFromOMPCanonicalLoop(static_cast<OMPCanonicalLoop *>(S))) return false; } while (false); } break; | |
case Stmt::OMPAtomicDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPAtomicDirective, &Derived::TraverseOMPAtomicDirective)) { do { if (!getDerived().WalkUpFromOMPAtomicDirective(static_cast<OMPAtomicDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPBarrierDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPBarrierDirective, &Derived::TraverseOMPBarrierDirective)) { do { if (!getDerived().WalkUpFromOMPBarrierDirective(static_cast<OMPBarrierDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPCancelDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPCancelDirective, &Derived::TraverseOMPCancelDirective)) { do { if (!getDerived().WalkUpFromOMPCancelDirective(static_cast<OMPCancelDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPCancellationPointDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPCancellationPointDirective, &Derived::TraverseOMPCancellationPointDirective)) { do { if (!getDerived().WalkUpFromOMPCancellationPointDirective(static_cast<OMPCancellationPointDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPCriticalDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPCriticalDirective, &Derived::TraverseOMPCriticalDirective)) { do { if (!getDerived().WalkUpFromOMPCriticalDirective(static_cast<OMPCriticalDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPDepobjDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPDepobjDirective, &Derived::TraverseOMPDepobjDirective)) { do { if (!getDerived().WalkUpFromOMPDepobjDirective(static_cast<OMPDepobjDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPDispatchDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPDispatchDirective, &Derived::TraverseOMPDispatchDirective)) { do { if (!getDerived().WalkUpFromOMPDispatchDirective(static_cast<OMPDispatchDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPFlushDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPFlushDirective, &Derived::TraverseOMPFlushDirective)) { do { if (!getDerived().WalkUpFromOMPFlushDirective(static_cast<OMPFlushDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPInteropDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPInteropDirective, &Derived::TraverseOMPInteropDirective)) { do { if (!getDerived().WalkUpFromOMPInteropDirective(static_cast<OMPInteropDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPDistributeDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPDistributeDirective, &Derived::TraverseOMPDistributeDirective)) { do { if (!getDerived().WalkUpFromOMPDistributeDirective(static_cast<OMPDistributeDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPDistributeParallelForDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPDistributeParallelForDirective, &Derived::TraverseOMPDistributeParallelForDirective)) { do { if (!getDerived().WalkUpFromOMPDistributeParallelForDirective(static_cast<OMPDistributeParallelForDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPDistributeParallelForSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPDistributeParallelForSimdDirective, &Derived::TraverseOMPDistributeParallelForSimdDirective)) { do { if (!getDerived().WalkUpFromOMPDistributeParallelForSimdDirective(static_cast<OMPDistributeParallelForSimdDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPDistributeSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPDistributeSimdDirective, &Derived::TraverseOMPDistributeSimdDirective)) { do { if (!getDerived().WalkUpFromOMPDistributeSimdDirective(static_cast<OMPDistributeSimdDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPForDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPForDirective, &Derived::TraverseOMPForDirective)) { do { if (!getDerived().WalkUpFromOMPForDirective(static_cast<OMPForDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPForSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPForSimdDirective, &Derived::TraverseOMPForSimdDirective)) { do { if (!getDerived().WalkUpFromOMPForSimdDirective(static_cast<OMPForSimdDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPMasterTaskLoopDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPMasterTaskLoopDirective, &Derived::TraverseOMPMasterTaskLoopDirective)) { do { if (!getDerived().WalkUpFromOMPMasterTaskLoopDirective(static_cast<OMPMasterTaskLoopDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPMasterTaskLoopSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPMasterTaskLoopSimdDirective, &Derived::TraverseOMPMasterTaskLoopSimdDirective)) { do { if (!getDerived().WalkUpFromOMPMasterTaskLoopSimdDirective(static_cast<OMPMasterTaskLoopSimdDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPParallelForDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPParallelForDirective, &Derived::TraverseOMPParallelForDirective)) { do { if (!getDerived().WalkUpFromOMPParallelForDirective(static_cast<OMPParallelForDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPParallelForSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPParallelForSimdDirective, &Derived::TraverseOMPParallelForSimdDirective)) { do { if (!getDerived().WalkUpFromOMPParallelForSimdDirective(static_cast<OMPParallelForSimdDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPParallelMasterTaskLoopDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPParallelMasterTaskLoopDirective, &Derived::TraverseOMPParallelMasterTaskLoopDirective)) { do { if (!getDerived().WalkUpFromOMPParallelMasterTaskLoopDirective(static_cast<OMPParallelMasterTaskLoopDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPParallelMasterTaskLoopSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPParallelMasterTaskLoopSimdDirective, &Derived::TraverseOMPParallelMasterTaskLoopSimdDirective)) { do { if (!getDerived().WalkUpFromOMPParallelMasterTaskLoopSimdDirective(static_cast<OMPParallelMasterTaskLoopSimdDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPSimdDirective, &Derived::TraverseOMPSimdDirective)) { do { if (!getDerived().WalkUpFromOMPSimdDirective(static_cast<OMPSimdDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPTargetParallelForSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetParallelForSimdDirective, &Derived::TraverseOMPTargetParallelForSimdDirective)) { do { if (!getDerived().WalkUpFromOMPTargetParallelForSimdDirective(static_cast<OMPTargetParallelForSimdDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPTargetSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetSimdDirective, &Derived::TraverseOMPTargetSimdDirective)) { do { if (!getDerived().WalkUpFromOMPTargetSimdDirective(static_cast<OMPTargetSimdDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPTargetTeamsDistributeDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetTeamsDistributeDirective, &Derived::TraverseOMPTargetTeamsDistributeDirective)) { do { if (!getDerived().WalkUpFromOMPTargetTeamsDistributeDirective(static_cast<OMPTargetTeamsDistributeDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetTeamsDistributeParallelForDirective, &Derived::TraverseOMPTargetTeamsDistributeParallelForDirective)) { do { if (!getDerived().WalkUpFromOMPTargetTeamsDistributeParallelForDirective(static_cast<OMPTargetTeamsDistributeParallelForDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetTeamsDistributeParallelForSimdDirective, &Derived::TraverseOMPTargetTeamsDistributeParallelForSimdDirective)) { do { if (!getDerived().WalkUpFromOMPTargetTeamsDistributeParallelForSimdDirective(static_cast<OMPTargetTeamsDistributeParallelForSimdDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetTeamsDistributeSimdDirective, &Derived::TraverseOMPTargetTeamsDistributeSimdDirective)) { do { if (!getDerived().WalkUpFromOMPTargetTeamsDistributeSimdDirective(static_cast<OMPTargetTeamsDistributeSimdDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPTaskLoopDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTaskLoopDirective, &Derived::TraverseOMPTaskLoopDirective)) { do { if (!getDerived().WalkUpFromOMPTaskLoopDirective(static_cast<OMPTaskLoopDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPTaskLoopSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTaskLoopSimdDirective, &Derived::TraverseOMPTaskLoopSimdDirective)) { do { if (!getDerived().WalkUpFromOMPTaskLoopSimdDirective(static_cast<OMPTaskLoopSimdDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPTeamsDistributeDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTeamsDistributeDirective, &Derived::TraverseOMPTeamsDistributeDirective)) { do { if (!getDerived().WalkUpFromOMPTeamsDistributeDirective(static_cast<OMPTeamsDistributeDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPTeamsDistributeParallelForDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTeamsDistributeParallelForDirective, &Derived::TraverseOMPTeamsDistributeParallelForDirective)) { do { if (!getDerived().WalkUpFromOMPTeamsDistributeParallelForDirective(static_cast<OMPTeamsDistributeParallelForDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTeamsDistributeParallelForSimdDirective, &Derived::TraverseOMPTeamsDistributeParallelForSimdDirective)) { do { if (!getDerived().WalkUpFromOMPTeamsDistributeParallelForSimdDirective(static_cast<OMPTeamsDistributeParallelForSimdDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPTeamsDistributeSimdDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTeamsDistributeSimdDirective, &Derived::TraverseOMPTeamsDistributeSimdDirective)) { do { if (!getDerived().WalkUpFromOMPTeamsDistributeSimdDirective(static_cast<OMPTeamsDistributeSimdDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPTileDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTileDirective, &Derived::TraverseOMPTileDirective)) { do { if (!getDerived().WalkUpFromOMPTileDirective(static_cast<OMPTileDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPUnrollDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPUnrollDirective, &Derived::TraverseOMPUnrollDirective)) { do { if (!getDerived().WalkUpFromOMPUnrollDirective(static_cast<OMPUnrollDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPMaskedDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPMaskedDirective, &Derived::TraverseOMPMaskedDirective)) { do { if (!getDerived().WalkUpFromOMPMaskedDirective(static_cast<OMPMaskedDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPMasterDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPMasterDirective, &Derived::TraverseOMPMasterDirective)) { do { if (!getDerived().WalkUpFromOMPMasterDirective(static_cast<OMPMasterDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPOrderedDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPOrderedDirective, &Derived::TraverseOMPOrderedDirective)) { do { if (!getDerived().WalkUpFromOMPOrderedDirective(static_cast<OMPOrderedDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPParallelDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPParallelDirective, &Derived::TraverseOMPParallelDirective)) { do { if (!getDerived().WalkUpFromOMPParallelDirective(static_cast<OMPParallelDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPParallelMasterDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPParallelMasterDirective, &Derived::TraverseOMPParallelMasterDirective)) { do { if (!getDerived().WalkUpFromOMPParallelMasterDirective(static_cast<OMPParallelMasterDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPParallelSectionsDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPParallelSectionsDirective, &Derived::TraverseOMPParallelSectionsDirective)) { do { if (!getDerived().WalkUpFromOMPParallelSectionsDirective(static_cast<OMPParallelSectionsDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPScanDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPScanDirective, &Derived::TraverseOMPScanDirective)) { do { if (!getDerived().WalkUpFromOMPScanDirective(static_cast<OMPScanDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPSectionDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPSectionDirective, &Derived::TraverseOMPSectionDirective)) { do { if (!getDerived().WalkUpFromOMPSectionDirective(static_cast<OMPSectionDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPSectionsDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPSectionsDirective, &Derived::TraverseOMPSectionsDirective)) { do { if (!getDerived().WalkUpFromOMPSectionsDirective(static_cast<OMPSectionsDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPSingleDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPSingleDirective, &Derived::TraverseOMPSingleDirective)) { do { if (!getDerived().WalkUpFromOMPSingleDirective(static_cast<OMPSingleDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPTargetDataDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetDataDirective, &Derived::TraverseOMPTargetDataDirective)) { do { if (!getDerived().WalkUpFromOMPTargetDataDirective(static_cast<OMPTargetDataDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPTargetDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetDirective, &Derived::TraverseOMPTargetDirective)) { do { if (!getDerived().WalkUpFromOMPTargetDirective(static_cast<OMPTargetDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPTargetEnterDataDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetEnterDataDirective, &Derived::TraverseOMPTargetEnterDataDirective)) { do { if (!getDerived().WalkUpFromOMPTargetEnterDataDirective(static_cast<OMPTargetEnterDataDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPTargetExitDataDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetExitDataDirective, &Derived::TraverseOMPTargetExitDataDirective)) { do { if (!getDerived().WalkUpFromOMPTargetExitDataDirective(static_cast<OMPTargetExitDataDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPTargetParallelDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetParallelDirective, &Derived::TraverseOMPTargetParallelDirective)) { do { if (!getDerived().WalkUpFromOMPTargetParallelDirective(static_cast<OMPTargetParallelDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPTargetParallelForDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetParallelForDirective, &Derived::TraverseOMPTargetParallelForDirective)) { do { if (!getDerived().WalkUpFromOMPTargetParallelForDirective(static_cast<OMPTargetParallelForDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPTargetTeamsDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetTeamsDirective, &Derived::TraverseOMPTargetTeamsDirective)) { do { if (!getDerived().WalkUpFromOMPTargetTeamsDirective(static_cast<OMPTargetTeamsDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPTargetUpdateDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTargetUpdateDirective, &Derived::TraverseOMPTargetUpdateDirective)) { do { if (!getDerived().WalkUpFromOMPTargetUpdateDirective(static_cast<OMPTargetUpdateDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPTaskDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTaskDirective, &Derived::TraverseOMPTaskDirective)) { do { if (!getDerived().WalkUpFromOMPTaskDirective(static_cast<OMPTaskDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPTaskgroupDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTaskgroupDirective, &Derived::TraverseOMPTaskgroupDirective)) { do { if (!getDerived().WalkUpFromOMPTaskgroupDirective(static_cast<OMPTaskgroupDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPTaskwaitDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTaskwaitDirective, &Derived::TraverseOMPTaskwaitDirective)) { do { if (!getDerived().WalkUpFromOMPTaskwaitDirective(static_cast<OMPTaskwaitDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPTaskyieldDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTaskyieldDirective, &Derived::TraverseOMPTaskyieldDirective)) { do { if (!getDerived().WalkUpFromOMPTaskyieldDirective(static_cast<OMPTaskyieldDirective *>(S))) return false; } while (false); } break; | |
case Stmt::OMPTeamsDirectiveClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPTeamsDirective, &Derived::TraverseOMPTeamsDirective)) { do { if (!getDerived().WalkUpFromOMPTeamsDirective(static_cast<OMPTeamsDirective *>(S))) return false; } while (false); } break; | |
case Stmt::ObjCAtCatchStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCAtCatchStmt, &Derived::TraverseObjCAtCatchStmt)) { do { if (!getDerived().WalkUpFromObjCAtCatchStmt(static_cast<ObjCAtCatchStmt *>(S))) return false; } while (false); } break; | |
case Stmt::ObjCAtFinallyStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCAtFinallyStmt, &Derived::TraverseObjCAtFinallyStmt)) { do { if (!getDerived().WalkUpFromObjCAtFinallyStmt(static_cast<ObjCAtFinallyStmt *>(S))) return false; } while (false); } break; | |
case Stmt::ObjCAtSynchronizedStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCAtSynchronizedStmt, &Derived::TraverseObjCAtSynchronizedStmt)) { do { if (!getDerived().WalkUpFromObjCAtSynchronizedStmt(static_cast<ObjCAtSynchronizedStmt *>(S))) return false; } while (false); } break; | |
case Stmt::ObjCAtThrowStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCAtThrowStmt, &Derived::TraverseObjCAtThrowStmt)) { do { if (!getDerived().WalkUpFromObjCAtThrowStmt(static_cast<ObjCAtThrowStmt *>(S))) return false; } while (false); } break; | |
case Stmt::ObjCAtTryStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCAtTryStmt, &Derived::TraverseObjCAtTryStmt)) { do { if (!getDerived().WalkUpFromObjCAtTryStmt(static_cast<ObjCAtTryStmt *>(S))) return false; } while (false); } break; | |
case Stmt::ObjCAutoreleasePoolStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCAutoreleasePoolStmt, &Derived::TraverseObjCAutoreleasePoolStmt)) { do { if (!getDerived().WalkUpFromObjCAutoreleasePoolStmt(static_cast<ObjCAutoreleasePoolStmt *>(S))) return false; } while (false); } break; | |
case Stmt::ObjCForCollectionStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCForCollectionStmt, &Derived::TraverseObjCForCollectionStmt)) { do { if (!getDerived().WalkUpFromObjCForCollectionStmt(static_cast<ObjCForCollectionStmt *>(S))) return false; } while (false); } break; | |
case Stmt::ReturnStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseReturnStmt, &Derived::TraverseReturnStmt)) { do { if (!getDerived().WalkUpFromReturnStmt(static_cast<ReturnStmt *>(S))) return false; } while (false); } break; | |
case Stmt::SEHExceptStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseSEHExceptStmt, &Derived::TraverseSEHExceptStmt)) { do { if (!getDerived().WalkUpFromSEHExceptStmt(static_cast<SEHExceptStmt *>(S))) return false; } while (false); } break; | |
case Stmt::SEHFinallyStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseSEHFinallyStmt, &Derived::TraverseSEHFinallyStmt)) { do { if (!getDerived().WalkUpFromSEHFinallyStmt(static_cast<SEHFinallyStmt *>(S))) return false; } while (false); } break; | |
case Stmt::SEHLeaveStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseSEHLeaveStmt, &Derived::TraverseSEHLeaveStmt)) { do { if (!getDerived().WalkUpFromSEHLeaveStmt(static_cast<SEHLeaveStmt *>(S))) return false; } while (false); } break; | |
case Stmt::SEHTryStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseSEHTryStmt, &Derived::TraverseSEHTryStmt)) { do { if (!getDerived().WalkUpFromSEHTryStmt(static_cast<SEHTryStmt *>(S))) return false; } while (false); } break; | |
case Stmt::CaseStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCaseStmt, &Derived::TraverseCaseStmt)) { do { if (!getDerived().WalkUpFromCaseStmt(static_cast<CaseStmt *>(S))) return false; } while (false); } break; | |
case Stmt::DefaultStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseDefaultStmt, &Derived::TraverseDefaultStmt)) { do { if (!getDerived().WalkUpFromDefaultStmt(static_cast<DefaultStmt *>(S))) return false; } while (false); } break; | |
case Stmt::SwitchStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseSwitchStmt, &Derived::TraverseSwitchStmt)) { do { if (!getDerived().WalkUpFromSwitchStmt(static_cast<SwitchStmt *>(S))) return false; } while (false); } break; | |
case Stmt::AttributedStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseAttributedStmt, &Derived::TraverseAttributedStmt)) { do { if (!getDerived().WalkUpFromAttributedStmt(static_cast<AttributedStmt *>(S))) return false; } while (false); } break; | |
case Stmt::BinaryConditionalOperatorClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseBinaryConditionalOperator, &Derived::TraverseBinaryConditionalOperator)) { do { if (!getDerived().WalkUpFromBinaryConditionalOperator(static_cast<BinaryConditionalOperator *>(S))) return false; } while (false); } break; | |
case Stmt::ConditionalOperatorClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseConditionalOperator, &Derived::TraverseConditionalOperator)) { do { if (!getDerived().WalkUpFromConditionalOperator(static_cast<ConditionalOperator *>(S))) return false; } while (false); } break; | |
case Stmt::AddrLabelExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseAddrLabelExpr, &Derived::TraverseAddrLabelExpr)) { do { if (!getDerived().WalkUpFromAddrLabelExpr(static_cast<AddrLabelExpr *>(S))) return false; } while (false); } break; | |
case Stmt::ArrayInitIndexExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseArrayInitIndexExpr, &Derived::TraverseArrayInitIndexExpr)) { do { if (!getDerived().WalkUpFromArrayInitIndexExpr(static_cast<ArrayInitIndexExpr *>(S))) return false; } while (false); } break; | |
case Stmt::ArrayInitLoopExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseArrayInitLoopExpr, &Derived::TraverseArrayInitLoopExpr)) { do { if (!getDerived().WalkUpFromArrayInitLoopExpr(static_cast<ArrayInitLoopExpr *>(S))) return false; } while (false); } break; | |
case Stmt::ArraySubscriptExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseArraySubscriptExpr, &Derived::TraverseArraySubscriptExpr)) { do { if (!getDerived().WalkUpFromArraySubscriptExpr(static_cast<ArraySubscriptExpr *>(S))) return false; } while (false); } break; | |
case Stmt::ArrayTypeTraitExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseArrayTypeTraitExpr, &Derived::TraverseArrayTypeTraitExpr)) { do { if (!getDerived().WalkUpFromArrayTypeTraitExpr(static_cast<ArrayTypeTraitExpr *>(S))) return false; } while (false); } break; | |
case Stmt::AsTypeExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseAsTypeExpr, &Derived::TraverseAsTypeExpr)) { do { if (!getDerived().WalkUpFromAsTypeExpr(static_cast<AsTypeExpr *>(S))) return false; } while (false); } break; | |
case Stmt::AtomicExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseAtomicExpr, &Derived::TraverseAtomicExpr)) { do { if (!getDerived().WalkUpFromAtomicExpr(static_cast<AtomicExpr *>(S))) return false; } while (false); } break; | |
case Stmt::BinaryOperatorClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseBinaryOperator, &Derived::TraverseBinaryOperator)) { do { if (!getDerived().WalkUpFromBinaryOperator(static_cast<BinaryOperator *>(S))) return false; } while (false); } break; | |
case Stmt::CompoundAssignOperatorClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCompoundAssignOperator, &Derived::TraverseCompoundAssignOperator)) { do { if (!getDerived().WalkUpFromCompoundAssignOperator(static_cast<CompoundAssignOperator *>(S))) return false; } while (false); } break; | |
case Stmt::BlockExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseBlockExpr, &Derived::TraverseBlockExpr)) { do { if (!getDerived().WalkUpFromBlockExpr(static_cast<BlockExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXBindTemporaryExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXBindTemporaryExpr, &Derived::TraverseCXXBindTemporaryExpr)) { do { if (!getDerived().WalkUpFromCXXBindTemporaryExpr(static_cast<CXXBindTemporaryExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXBoolLiteralExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXBoolLiteralExpr, &Derived::TraverseCXXBoolLiteralExpr)) { do { if (!getDerived().WalkUpFromCXXBoolLiteralExpr(static_cast<CXXBoolLiteralExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXConstructExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXConstructExpr, &Derived::TraverseCXXConstructExpr)) { do { if (!getDerived().WalkUpFromCXXConstructExpr(static_cast<CXXConstructExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXTemporaryObjectExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXTemporaryObjectExpr, &Derived::TraverseCXXTemporaryObjectExpr)) { do { if (!getDerived().WalkUpFromCXXTemporaryObjectExpr(static_cast<CXXTemporaryObjectExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXDefaultArgExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXDefaultArgExpr, &Derived::TraverseCXXDefaultArgExpr)) { do { if (!getDerived().WalkUpFromCXXDefaultArgExpr(static_cast<CXXDefaultArgExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXDefaultInitExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXDefaultInitExpr, &Derived::TraverseCXXDefaultInitExpr)) { do { if (!getDerived().WalkUpFromCXXDefaultInitExpr(static_cast<CXXDefaultInitExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXDeleteExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXDeleteExpr, &Derived::TraverseCXXDeleteExpr)) { do { if (!getDerived().WalkUpFromCXXDeleteExpr(static_cast<CXXDeleteExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXDependentScopeMemberExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXDependentScopeMemberExpr, &Derived::TraverseCXXDependentScopeMemberExpr)) { do { if (!getDerived().WalkUpFromCXXDependentScopeMemberExpr(static_cast<CXXDependentScopeMemberExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXFoldExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXFoldExpr, &Derived::TraverseCXXFoldExpr)) { do { if (!getDerived().WalkUpFromCXXFoldExpr(static_cast<CXXFoldExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXInheritedCtorInitExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXInheritedCtorInitExpr, &Derived::TraverseCXXInheritedCtorInitExpr)) { do { if (!getDerived().WalkUpFromCXXInheritedCtorInitExpr(static_cast<CXXInheritedCtorInitExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXNewExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXNewExpr, &Derived::TraverseCXXNewExpr)) { do { if (!getDerived().WalkUpFromCXXNewExpr(static_cast<CXXNewExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXNoexceptExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXNoexceptExpr, &Derived::TraverseCXXNoexceptExpr)) { do { if (!getDerived().WalkUpFromCXXNoexceptExpr(static_cast<CXXNoexceptExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXNullPtrLiteralExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXNullPtrLiteralExpr, &Derived::TraverseCXXNullPtrLiteralExpr)) { do { if (!getDerived().WalkUpFromCXXNullPtrLiteralExpr(static_cast<CXXNullPtrLiteralExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXPseudoDestructorExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXPseudoDestructorExpr, &Derived::TraverseCXXPseudoDestructorExpr)) { do { if (!getDerived().WalkUpFromCXXPseudoDestructorExpr(static_cast<CXXPseudoDestructorExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXRewrittenBinaryOperatorClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXRewrittenBinaryOperator, &Derived::TraverseCXXRewrittenBinaryOperator)) { do { if (!getDerived().WalkUpFromCXXRewrittenBinaryOperator(static_cast<CXXRewrittenBinaryOperator *>(S))) return false; } while (false); } break; | |
case Stmt::CXXScalarValueInitExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXScalarValueInitExpr, &Derived::TraverseCXXScalarValueInitExpr)) { do { if (!getDerived().WalkUpFromCXXScalarValueInitExpr(static_cast<CXXScalarValueInitExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXStdInitializerListExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXStdInitializerListExpr, &Derived::TraverseCXXStdInitializerListExpr)) { do { if (!getDerived().WalkUpFromCXXStdInitializerListExpr(static_cast<CXXStdInitializerListExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXThisExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXThisExpr, &Derived::TraverseCXXThisExpr)) { do { if (!getDerived().WalkUpFromCXXThisExpr(static_cast<CXXThisExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXThrowExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXThrowExpr, &Derived::TraverseCXXThrowExpr)) { do { if (!getDerived().WalkUpFromCXXThrowExpr(static_cast<CXXThrowExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXTypeidExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXTypeidExpr, &Derived::TraverseCXXTypeidExpr)) { do { if (!getDerived().WalkUpFromCXXTypeidExpr(static_cast<CXXTypeidExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXUnresolvedConstructExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXUnresolvedConstructExpr, &Derived::TraverseCXXUnresolvedConstructExpr)) { do { if (!getDerived().WalkUpFromCXXUnresolvedConstructExpr(static_cast<CXXUnresolvedConstructExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXUuidofExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXUuidofExpr, &Derived::TraverseCXXUuidofExpr)) { do { if (!getDerived().WalkUpFromCXXUuidofExpr(static_cast<CXXUuidofExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CallExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCallExpr, &Derived::TraverseCallExpr)) { do { if (!getDerived().WalkUpFromCallExpr(static_cast<CallExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CUDAKernelCallExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCUDAKernelCallExpr, &Derived::TraverseCUDAKernelCallExpr)) { do { if (!getDerived().WalkUpFromCUDAKernelCallExpr(static_cast<CUDAKernelCallExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXMemberCallExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXMemberCallExpr, &Derived::TraverseCXXMemberCallExpr)) { do { if (!getDerived().WalkUpFromCXXMemberCallExpr(static_cast<CXXMemberCallExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXOperatorCallExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXOperatorCallExpr, &Derived::TraverseCXXOperatorCallExpr)) { do { if (!getDerived().WalkUpFromCXXOperatorCallExpr(static_cast<CXXOperatorCallExpr *>(S))) return false; } while (false); } break; | |
case Stmt::UserDefinedLiteralClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseUserDefinedLiteral, &Derived::TraverseUserDefinedLiteral)) { do { if (!getDerived().WalkUpFromUserDefinedLiteral(static_cast<UserDefinedLiteral *>(S))) return false; } while (false); } break; | |
case Stmt::BuiltinBitCastExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseBuiltinBitCastExpr, &Derived::TraverseBuiltinBitCastExpr)) { do { if (!getDerived().WalkUpFromBuiltinBitCastExpr(static_cast<BuiltinBitCastExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CStyleCastExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCStyleCastExpr, &Derived::TraverseCStyleCastExpr)) { do { if (!getDerived().WalkUpFromCStyleCastExpr(static_cast<CStyleCastExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXFunctionalCastExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXFunctionalCastExpr, &Derived::TraverseCXXFunctionalCastExpr)) { do { if (!getDerived().WalkUpFromCXXFunctionalCastExpr(static_cast<CXXFunctionalCastExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXAddrspaceCastExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXAddrspaceCastExpr, &Derived::TraverseCXXAddrspaceCastExpr)) { do { if (!getDerived().WalkUpFromCXXAddrspaceCastExpr(static_cast<CXXAddrspaceCastExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXConstCastExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXConstCastExpr, &Derived::TraverseCXXConstCastExpr)) { do { if (!getDerived().WalkUpFromCXXConstCastExpr(static_cast<CXXConstCastExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXDynamicCastExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXDynamicCastExpr, &Derived::TraverseCXXDynamicCastExpr)) { do { if (!getDerived().WalkUpFromCXXDynamicCastExpr(static_cast<CXXDynamicCastExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXReinterpretCastExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXReinterpretCastExpr, &Derived::TraverseCXXReinterpretCastExpr)) { do { if (!getDerived().WalkUpFromCXXReinterpretCastExpr(static_cast<CXXReinterpretCastExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CXXStaticCastExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCXXStaticCastExpr, &Derived::TraverseCXXStaticCastExpr)) { do { if (!getDerived().WalkUpFromCXXStaticCastExpr(static_cast<CXXStaticCastExpr *>(S))) return false; } while (false); } break; | |
case Stmt::ObjCBridgedCastExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCBridgedCastExpr, &Derived::TraverseObjCBridgedCastExpr)) { do { if (!getDerived().WalkUpFromObjCBridgedCastExpr(static_cast<ObjCBridgedCastExpr *>(S))) return false; } while (false); } break; | |
case Stmt::ImplicitCastExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseImplicitCastExpr, &Derived::TraverseImplicitCastExpr)) { do { if (!getDerived().WalkUpFromImplicitCastExpr(static_cast<ImplicitCastExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CharacterLiteralClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCharacterLiteral, &Derived::TraverseCharacterLiteral)) { do { if (!getDerived().WalkUpFromCharacterLiteral(static_cast<CharacterLiteral *>(S))) return false; } while (false); } break; | |
case Stmt::ChooseExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseChooseExpr, &Derived::TraverseChooseExpr)) { do { if (!getDerived().WalkUpFromChooseExpr(static_cast<ChooseExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CompoundLiteralExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCompoundLiteralExpr, &Derived::TraverseCompoundLiteralExpr)) { do { if (!getDerived().WalkUpFromCompoundLiteralExpr(static_cast<CompoundLiteralExpr *>(S))) return false; } while (false); } break; | |
case Stmt::ConceptSpecializationExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseConceptSpecializationExpr, &Derived::TraverseConceptSpecializationExpr)) { do { if (!getDerived().WalkUpFromConceptSpecializationExpr(static_cast<ConceptSpecializationExpr *>(S))) return false; } while (false); } break; | |
case Stmt::ConvertVectorExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseConvertVectorExpr, &Derived::TraverseConvertVectorExpr)) { do { if (!getDerived().WalkUpFromConvertVectorExpr(static_cast<ConvertVectorExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CoawaitExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCoawaitExpr, &Derived::TraverseCoawaitExpr)) { do { if (!getDerived().WalkUpFromCoawaitExpr(static_cast<CoawaitExpr *>(S))) return false; } while (false); } break; | |
case Stmt::CoyieldExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseCoyieldExpr, &Derived::TraverseCoyieldExpr)) { do { if (!getDerived().WalkUpFromCoyieldExpr(static_cast<CoyieldExpr *>(S))) return false; } while (false); } break; | |
case Stmt::DeclRefExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseDeclRefExpr, &Derived::TraverseDeclRefExpr)) { do { if (!getDerived().WalkUpFromDeclRefExpr(static_cast<DeclRefExpr *>(S))) return false; } while (false); } break; | |
case Stmt::DependentCoawaitExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseDependentCoawaitExpr, &Derived::TraverseDependentCoawaitExpr)) { do { if (!getDerived().WalkUpFromDependentCoawaitExpr(static_cast<DependentCoawaitExpr *>(S))) return false; } while (false); } break; | |
case Stmt::DependentScopeDeclRefExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseDependentScopeDeclRefExpr, &Derived::TraverseDependentScopeDeclRefExpr)) { do { if (!getDerived().WalkUpFromDependentScopeDeclRefExpr(static_cast<DependentScopeDeclRefExpr *>(S))) return false; } while (false); } break; | |
case Stmt::DesignatedInitExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseDesignatedInitExpr, &Derived::TraverseDesignatedInitExpr)) { do { if (!getDerived().WalkUpFromDesignatedInitExpr(static_cast<DesignatedInitExpr *>(S))) return false; } while (false); } break; | |
case Stmt::DesignatedInitUpdateExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseDesignatedInitUpdateExpr, &Derived::TraverseDesignatedInitUpdateExpr)) { do { if (!getDerived().WalkUpFromDesignatedInitUpdateExpr(static_cast<DesignatedInitUpdateExpr *>(S))) return false; } while (false); } break; | |
case Stmt::ExpressionTraitExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseExpressionTraitExpr, &Derived::TraverseExpressionTraitExpr)) { do { if (!getDerived().WalkUpFromExpressionTraitExpr(static_cast<ExpressionTraitExpr *>(S))) return false; } while (false); } break; | |
case Stmt::ExtVectorElementExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseExtVectorElementExpr, &Derived::TraverseExtVectorElementExpr)) { do { if (!getDerived().WalkUpFromExtVectorElementExpr(static_cast<ExtVectorElementExpr *>(S))) return false; } while (false); } break; | |
case Stmt::FixedPointLiteralClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseFixedPointLiteral, &Derived::TraverseFixedPointLiteral)) { do { if (!getDerived().WalkUpFromFixedPointLiteral(static_cast<FixedPointLiteral *>(S))) return false; } while (false); } break; | |
case Stmt::FloatingLiteralClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseFloatingLiteral, &Derived::TraverseFloatingLiteral)) { do { if (!getDerived().WalkUpFromFloatingLiteral(static_cast<FloatingLiteral *>(S))) return false; } while (false); } break; | |
case Stmt::ConstantExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseConstantExpr, &Derived::TraverseConstantExpr)) { do { if (!getDerived().WalkUpFromConstantExpr(static_cast<ConstantExpr *>(S))) return false; } while (false); } break; | |
case Stmt::ExprWithCleanupsClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseExprWithCleanups, &Derived::TraverseExprWithCleanups)) { do { if (!getDerived().WalkUpFromExprWithCleanups(static_cast<ExprWithCleanups *>(S))) return false; } while (false); } break; | |
case Stmt::FunctionParmPackExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseFunctionParmPackExpr, &Derived::TraverseFunctionParmPackExpr)) { do { if (!getDerived().WalkUpFromFunctionParmPackExpr(static_cast<FunctionParmPackExpr *>(S))) return false; } while (false); } break; | |
case Stmt::GNUNullExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseGNUNullExpr, &Derived::TraverseGNUNullExpr)) { do { if (!getDerived().WalkUpFromGNUNullExpr(static_cast<GNUNullExpr *>(S))) return false; } while (false); } break; | |
case Stmt::GenericSelectionExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseGenericSelectionExpr, &Derived::TraverseGenericSelectionExpr)) { do { if (!getDerived().WalkUpFromGenericSelectionExpr(static_cast<GenericSelectionExpr *>(S))) return false; } while (false); } break; | |
case Stmt::ImaginaryLiteralClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseImaginaryLiteral, &Derived::TraverseImaginaryLiteral)) { do { if (!getDerived().WalkUpFromImaginaryLiteral(static_cast<ImaginaryLiteral *>(S))) return false; } while (false); } break; | |
case Stmt::ImplicitValueInitExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseImplicitValueInitExpr, &Derived::TraverseImplicitValueInitExpr)) { do { if (!getDerived().WalkUpFromImplicitValueInitExpr(static_cast<ImplicitValueInitExpr *>(S))) return false; } while (false); } break; | |
case Stmt::InitListExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseInitListExpr, &Derived::TraverseInitListExpr)) { auto ILE = static_cast<InitListExpr *>(S); if (auto Syn = ILE->isSemanticForm() ? ILE->getSyntacticForm() : ILE) do { if (!getDerived().WalkUpFromInitListExpr(Syn)) return false; } while (false); if (auto Sem = ILE->isSemanticForm() ? ILE : ILE->getSemanticForm()) do { if (!getDerived().WalkUpFromInitListExpr(Sem)) return false; } while (false); } break; | |
case Stmt::IntegerLiteralClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseIntegerLiteral, &Derived::TraverseIntegerLiteral)) { do { if (!getDerived().WalkUpFromIntegerLiteral(static_cast<IntegerLiteral *>(S))) return false; } while (false); } break; | |
case Stmt::LambdaExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseLambdaExpr, &Derived::TraverseLambdaExpr)) { do { if (!getDerived().WalkUpFromLambdaExpr(static_cast<LambdaExpr *>(S))) return false; } while (false); } break; | |
case Stmt::MSPropertyRefExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseMSPropertyRefExpr, &Derived::TraverseMSPropertyRefExpr)) { do { if (!getDerived().WalkUpFromMSPropertyRefExpr(static_cast<MSPropertyRefExpr *>(S))) return false; } while (false); } break; | |
case Stmt::MSPropertySubscriptExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseMSPropertySubscriptExpr, &Derived::TraverseMSPropertySubscriptExpr)) { do { if (!getDerived().WalkUpFromMSPropertySubscriptExpr(static_cast<MSPropertySubscriptExpr *>(S))) return false; } while (false); } break; | |
case Stmt::MaterializeTemporaryExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseMaterializeTemporaryExpr, &Derived::TraverseMaterializeTemporaryExpr)) { do { if (!getDerived().WalkUpFromMaterializeTemporaryExpr(static_cast<MaterializeTemporaryExpr *>(S))) return false; } while (false); } break; | |
case Stmt::MatrixSubscriptExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseMatrixSubscriptExpr, &Derived::TraverseMatrixSubscriptExpr)) { do { if (!getDerived().WalkUpFromMatrixSubscriptExpr(static_cast<MatrixSubscriptExpr *>(S))) return false; } while (false); } break; | |
case Stmt::MemberExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseMemberExpr, &Derived::TraverseMemberExpr)) { do { if (!getDerived().WalkUpFromMemberExpr(static_cast<MemberExpr *>(S))) return false; } while (false); } break; | |
case Stmt::NoInitExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseNoInitExpr, &Derived::TraverseNoInitExpr)) { do { if (!getDerived().WalkUpFromNoInitExpr(static_cast<NoInitExpr *>(S))) return false; } while (false); } break; | |
case Stmt::OMPArraySectionExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPArraySectionExpr, &Derived::TraverseOMPArraySectionExpr)) { do { if (!getDerived().WalkUpFromOMPArraySectionExpr(static_cast<OMPArraySectionExpr *>(S))) return false; } while (false); } break; | |
case Stmt::OMPArrayShapingExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPArrayShapingExpr, &Derived::TraverseOMPArrayShapingExpr)) { do { if (!getDerived().WalkUpFromOMPArrayShapingExpr(static_cast<OMPArrayShapingExpr *>(S))) return false; } while (false); } break; | |
case Stmt::OMPIteratorExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOMPIteratorExpr, &Derived::TraverseOMPIteratorExpr)) { do { if (!getDerived().WalkUpFromOMPIteratorExpr(static_cast<OMPIteratorExpr *>(S))) return false; } while (false); } break; | |
case Stmt::ObjCArrayLiteralClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCArrayLiteral, &Derived::TraverseObjCArrayLiteral)) { do { if (!getDerived().WalkUpFromObjCArrayLiteral(static_cast<ObjCArrayLiteral *>(S))) return false; } while (false); } break; | |
case Stmt::ObjCAvailabilityCheckExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCAvailabilityCheckExpr, &Derived::TraverseObjCAvailabilityCheckExpr)) { do { if (!getDerived().WalkUpFromObjCAvailabilityCheckExpr(static_cast<ObjCAvailabilityCheckExpr *>(S))) return false; } while (false); } break; | |
case Stmt::ObjCBoolLiteralExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCBoolLiteralExpr, &Derived::TraverseObjCBoolLiteralExpr)) { do { if (!getDerived().WalkUpFromObjCBoolLiteralExpr(static_cast<ObjCBoolLiteralExpr *>(S))) return false; } while (false); } break; | |
case Stmt::ObjCBoxedExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCBoxedExpr, &Derived::TraverseObjCBoxedExpr)) { do { if (!getDerived().WalkUpFromObjCBoxedExpr(static_cast<ObjCBoxedExpr *>(S))) return false; } while (false); } break; | |
case Stmt::ObjCDictionaryLiteralClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCDictionaryLiteral, &Derived::TraverseObjCDictionaryLiteral)) { do { if (!getDerived().WalkUpFromObjCDictionaryLiteral(static_cast<ObjCDictionaryLiteral *>(S))) return false; } while (false); } break; | |
case Stmt::ObjCEncodeExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCEncodeExpr, &Derived::TraverseObjCEncodeExpr)) { do { if (!getDerived().WalkUpFromObjCEncodeExpr(static_cast<ObjCEncodeExpr *>(S))) return false; } while (false); } break; | |
case Stmt::ObjCIndirectCopyRestoreExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCIndirectCopyRestoreExpr, &Derived::TraverseObjCIndirectCopyRestoreExpr)) { do { if (!getDerived().WalkUpFromObjCIndirectCopyRestoreExpr(static_cast<ObjCIndirectCopyRestoreExpr *>(S))) return false; } while (false); } break; | |
case Stmt::ObjCIsaExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCIsaExpr, &Derived::TraverseObjCIsaExpr)) { do { if (!getDerived().WalkUpFromObjCIsaExpr(static_cast<ObjCIsaExpr *>(S))) return false; } while (false); } break; | |
case Stmt::ObjCIvarRefExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCIvarRefExpr, &Derived::TraverseObjCIvarRefExpr)) { do { if (!getDerived().WalkUpFromObjCIvarRefExpr(static_cast<ObjCIvarRefExpr *>(S))) return false; } while (false); } break; | |
case Stmt::ObjCMessageExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCMessageExpr, &Derived::TraverseObjCMessageExpr)) { do { if (!getDerived().WalkUpFromObjCMessageExpr(static_cast<ObjCMessageExpr *>(S))) return false; } while (false); } break; | |
case Stmt::ObjCPropertyRefExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCPropertyRefExpr, &Derived::TraverseObjCPropertyRefExpr)) { do { if (!getDerived().WalkUpFromObjCPropertyRefExpr(static_cast<ObjCPropertyRefExpr *>(S))) return false; } while (false); } break; | |
case Stmt::ObjCProtocolExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCProtocolExpr, &Derived::TraverseObjCProtocolExpr)) { do { if (!getDerived().WalkUpFromObjCProtocolExpr(static_cast<ObjCProtocolExpr *>(S))) return false; } while (false); } break; | |
case Stmt::ObjCSelectorExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCSelectorExpr, &Derived::TraverseObjCSelectorExpr)) { do { if (!getDerived().WalkUpFromObjCSelectorExpr(static_cast<ObjCSelectorExpr *>(S))) return false; } while (false); } break; | |
case Stmt::ObjCStringLiteralClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCStringLiteral, &Derived::TraverseObjCStringLiteral)) { do { if (!getDerived().WalkUpFromObjCStringLiteral(static_cast<ObjCStringLiteral *>(S))) return false; } while (false); } break; | |
case Stmt::ObjCSubscriptRefExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseObjCSubscriptRefExpr, &Derived::TraverseObjCSubscriptRefExpr)) { do { if (!getDerived().WalkUpFromObjCSubscriptRefExpr(static_cast<ObjCSubscriptRefExpr *>(S))) return false; } while (false); } break; | |
case Stmt::OffsetOfExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOffsetOfExpr, &Derived::TraverseOffsetOfExpr)) { do { if (!getDerived().WalkUpFromOffsetOfExpr(static_cast<OffsetOfExpr *>(S))) return false; } while (false); } break; | |
case Stmt::OpaqueValueExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseOpaqueValueExpr, &Derived::TraverseOpaqueValueExpr)) { do { if (!getDerived().WalkUpFromOpaqueValueExpr(static_cast<OpaqueValueExpr *>(S))) return false; } while (false); } break; | |
case Stmt::UnresolvedLookupExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseUnresolvedLookupExpr, &Derived::TraverseUnresolvedLookupExpr)) { do { if (!getDerived().WalkUpFromUnresolvedLookupExpr(static_cast<UnresolvedLookupExpr *>(S))) return false; } while (false); } break; | |
case Stmt::UnresolvedMemberExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseUnresolvedMemberExpr, &Derived::TraverseUnresolvedMemberExpr)) { do { if (!getDerived().WalkUpFromUnresolvedMemberExpr(static_cast<UnresolvedMemberExpr *>(S))) return false; } while (false); } break; | |
case Stmt::PackExpansionExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraversePackExpansionExpr, &Derived::TraversePackExpansionExpr)) { do { if (!getDerived().WalkUpFromPackExpansionExpr(static_cast<PackExpansionExpr *>(S))) return false; } while (false); } break; | |
case Stmt::ParenExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseParenExpr, &Derived::TraverseParenExpr)) { do { if (!getDerived().WalkUpFromParenExpr(static_cast<ParenExpr *>(S))) return false; } while (false); } break; | |
case Stmt::ParenListExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseParenListExpr, &Derived::TraverseParenListExpr)) { do { if (!getDerived().WalkUpFromParenListExpr(static_cast<ParenListExpr *>(S))) return false; } while (false); } break; | |
case Stmt::PredefinedExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraversePredefinedExpr, &Derived::TraversePredefinedExpr)) { do { if (!getDerived().WalkUpFromPredefinedExpr(static_cast<PredefinedExpr *>(S))) return false; } while (false); } break; | |
case Stmt::PseudoObjectExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraversePseudoObjectExpr, &Derived::TraversePseudoObjectExpr)) { do { if (!getDerived().WalkUpFromPseudoObjectExpr(static_cast<PseudoObjectExpr *>(S))) return false; } while (false); } break; | |
case Stmt::RecoveryExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseRecoveryExpr, &Derived::TraverseRecoveryExpr)) { do { if (!getDerived().WalkUpFromRecoveryExpr(static_cast<RecoveryExpr *>(S))) return false; } while (false); } break; | |
case Stmt::RequiresExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseRequiresExpr, &Derived::TraverseRequiresExpr)) { do { if (!getDerived().WalkUpFromRequiresExpr(static_cast<RequiresExpr *>(S))) return false; } while (false); } break; | |
case Stmt::SYCLUniqueStableNameExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseSYCLUniqueStableNameExpr, &Derived::TraverseSYCLUniqueStableNameExpr)) { do { if (!getDerived().WalkUpFromSYCLUniqueStableNameExpr(static_cast<SYCLUniqueStableNameExpr *>(S))) return false; } while (false); } break; | |
case Stmt::ShuffleVectorExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseShuffleVectorExpr, &Derived::TraverseShuffleVectorExpr)) { do { if (!getDerived().WalkUpFromShuffleVectorExpr(static_cast<ShuffleVectorExpr *>(S))) return false; } while (false); } break; | |
case Stmt::SizeOfPackExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseSizeOfPackExpr, &Derived::TraverseSizeOfPackExpr)) { do { if (!getDerived().WalkUpFromSizeOfPackExpr(static_cast<SizeOfPackExpr *>(S))) return false; } while (false); } break; | |
case Stmt::SourceLocExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseSourceLocExpr, &Derived::TraverseSourceLocExpr)) { do { if (!getDerived().WalkUpFromSourceLocExpr(static_cast<SourceLocExpr *>(S))) return false; } while (false); } break; | |
case Stmt::StmtExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseStmtExpr, &Derived::TraverseStmtExpr)) { do { if (!getDerived().WalkUpFromStmtExpr(static_cast<StmtExpr *>(S))) return false; } while (false); } break; | |
case Stmt::StringLiteralClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseStringLiteral, &Derived::TraverseStringLiteral)) { do { if (!getDerived().WalkUpFromStringLiteral(static_cast<StringLiteral *>(S))) return false; } while (false); } break; | |
case Stmt::SubstNonTypeTemplateParmExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseSubstNonTypeTemplateParmExpr, &Derived::TraverseSubstNonTypeTemplateParmExpr)) { do { if (!getDerived().WalkUpFromSubstNonTypeTemplateParmExpr(static_cast<SubstNonTypeTemplateParmExpr *>(S))) return false; } while (false); } break; | |
case Stmt::SubstNonTypeTemplateParmPackExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseSubstNonTypeTemplateParmPackExpr, &Derived::TraverseSubstNonTypeTemplateParmPackExpr)) { do { if (!getDerived().WalkUpFromSubstNonTypeTemplateParmPackExpr(static_cast<SubstNonTypeTemplateParmPackExpr *>(S))) return false; } while (false); } break; | |
case Stmt::TypeTraitExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseTypeTraitExpr, &Derived::TraverseTypeTraitExpr)) { do { if (!getDerived().WalkUpFromTypeTraitExpr(static_cast<TypeTraitExpr *>(S))) return false; } while (false); } break; | |
case Stmt::TypoExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseTypoExpr, &Derived::TraverseTypoExpr)) { do { if (!getDerived().WalkUpFromTypoExpr(static_cast<TypoExpr *>(S))) return false; } while (false); } break; | |
case Stmt::UnaryExprOrTypeTraitExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseUnaryExprOrTypeTraitExpr, &Derived::TraverseUnaryExprOrTypeTraitExpr)) { do { if (!getDerived().WalkUpFromUnaryExprOrTypeTraitExpr(static_cast<UnaryExprOrTypeTraitExpr *>(S))) return false; } while (false); } break; | |
case Stmt::UnaryOperatorClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseUnaryOperator, &Derived::TraverseUnaryOperator)) { do { if (!getDerived().WalkUpFromUnaryOperator(static_cast<UnaryOperator *>(S))) return false; } while (false); } break; | |
case Stmt::VAArgExprClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseVAArgExpr, &Derived::TraverseVAArgExpr)) { do { if (!getDerived().WalkUpFromVAArgExpr(static_cast<VAArgExpr *>(S))) return false; } while (false); } break; | |
case Stmt::LabelStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseLabelStmt, &Derived::TraverseLabelStmt)) { do { if (!getDerived().WalkUpFromLabelStmt(static_cast<LabelStmt *>(S))) return false; } while (false); } break; | |
case Stmt::WhileStmtClass: if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseWhileStmt, &Derived::TraverseWhileStmt)) { do { if (!getDerived().WalkUpFromWhileStmt(static_cast<WhileStmt *>(S))) return false; } while (false); } break; | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseStmt(Stmt *S, | |
DataRecursionQueue *Queue) { | |
if (!S) | |
return true; | |
if (Queue) { | |
Queue->push_back({S, false}); | |
return true; | |
} | |
SmallVector<llvm::PointerIntPair<Stmt *, 1, bool>, 8> LocalQueue; | |
LocalQueue.push_back({S, false}); | |
while (!LocalQueue.empty()) { | |
auto &CurrSAndVisited = LocalQueue.back(); | |
Stmt *CurrS = CurrSAndVisited.getPointer(); | |
bool Visited = CurrSAndVisited.getInt(); | |
if (Visited) { | |
LocalQueue.pop_back(); | |
do { if (!getDerived().dataTraverseStmtPost(CurrS)) return false; } while (false); | |
if (getDerived().shouldTraversePostOrder()) { | |
do { if (!getDerived().PostVisitStmt(CurrS)) return false; } while (false); | |
} | |
continue; | |
} | |
if (getDerived().dataTraverseStmtPre(CurrS)) { | |
CurrSAndVisited.setInt(true); | |
size_t N = LocalQueue.size(); | |
do { if (!getDerived().dataTraverseNode(CurrS, &LocalQueue)) return false; } while (false); | |
std::reverse(LocalQueue.begin() + N, LocalQueue.end()); | |
} else { | |
LocalQueue.pop_back(); | |
} | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseType(QualType T) { | |
if (T.isNull()) | |
return true; | |
switch (T->getTypeClass()) { | |
case Type::Adjusted: return getDerived().TraverseAdjustedType( static_cast<AdjustedType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::Decayed: return getDerived().TraverseDecayedType( static_cast<DecayedType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::ConstantArray: return getDerived().TraverseConstantArrayType( static_cast<ConstantArrayType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::DependentSizedArray: return getDerived().TraverseDependentSizedArrayType( static_cast<DependentSizedArrayType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::IncompleteArray: return getDerived().TraverseIncompleteArrayType( static_cast<IncompleteArrayType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::VariableArray: return getDerived().TraverseVariableArrayType( static_cast<VariableArrayType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::Atomic: return getDerived().TraverseAtomicType( static_cast<AtomicType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::Attributed: return getDerived().TraverseAttributedType( static_cast<AttributedType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::BlockPointer: return getDerived().TraverseBlockPointerType( static_cast<BlockPointerType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::Builtin: return getDerived().TraverseBuiltinType( static_cast<BuiltinType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::Complex: return getDerived().TraverseComplexType( static_cast<ComplexType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::Decltype: return getDerived().TraverseDecltypeType( static_cast<DecltypeType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::Auto: return getDerived().TraverseAutoType( static_cast<AutoType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::DeducedTemplateSpecialization: return getDerived().TraverseDeducedTemplateSpecializationType( static_cast<DeducedTemplateSpecializationType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::DependentAddressSpace: return getDerived().TraverseDependentAddressSpaceType( static_cast<DependentAddressSpaceType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::DependentExtInt: return getDerived().TraverseDependentExtIntType( static_cast<DependentExtIntType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::DependentName: return getDerived().TraverseDependentNameType( static_cast<DependentNameType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::DependentSizedExtVector: return getDerived().TraverseDependentSizedExtVectorType( static_cast<DependentSizedExtVectorType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::DependentTemplateSpecialization: return getDerived().TraverseDependentTemplateSpecializationType( static_cast<DependentTemplateSpecializationType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::DependentVector: return getDerived().TraverseDependentVectorType( static_cast<DependentVectorType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::Elaborated: return getDerived().TraverseElaboratedType( static_cast<ElaboratedType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::ExtInt: return getDerived().TraverseExtIntType( static_cast<ExtIntType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::FunctionNoProto: return getDerived().TraverseFunctionNoProtoType( static_cast<FunctionNoProtoType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::FunctionProto: return getDerived().TraverseFunctionProtoType( static_cast<FunctionProtoType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::InjectedClassName: return getDerived().TraverseInjectedClassNameType( static_cast<InjectedClassNameType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::MacroQualified: return getDerived().TraverseMacroQualifiedType( static_cast<MacroQualifiedType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::ConstantMatrix: return getDerived().TraverseConstantMatrixType( static_cast<ConstantMatrixType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::DependentSizedMatrix: return getDerived().TraverseDependentSizedMatrixType( static_cast<DependentSizedMatrixType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::MemberPointer: return getDerived().TraverseMemberPointerType( static_cast<MemberPointerType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::ObjCObjectPointer: return getDerived().TraverseObjCObjectPointerType( static_cast<ObjCObjectPointerType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::ObjCObject: return getDerived().TraverseObjCObjectType( static_cast<ObjCObjectType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::ObjCInterface: return getDerived().TraverseObjCInterfaceType( static_cast<ObjCInterfaceType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::ObjCTypeParam: return getDerived().TraverseObjCTypeParamType( static_cast<ObjCTypeParamType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::PackExpansion: return getDerived().TraversePackExpansionType( static_cast<PackExpansionType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::Paren: return getDerived().TraverseParenType( static_cast<ParenType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::Pipe: return getDerived().TraversePipeType( static_cast<PipeType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::Pointer: return getDerived().TraversePointerType( static_cast<PointerType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::LValueReference: return getDerived().TraverseLValueReferenceType( static_cast<LValueReferenceType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::RValueReference: return getDerived().TraverseRValueReferenceType( static_cast<RValueReferenceType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::SubstTemplateTypeParmPack: return getDerived().TraverseSubstTemplateTypeParmPackType( static_cast<SubstTemplateTypeParmPackType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::SubstTemplateTypeParm: return getDerived().TraverseSubstTemplateTypeParmType( static_cast<SubstTemplateTypeParmType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::Enum: return getDerived().TraverseEnumType( static_cast<EnumType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::Record: return getDerived().TraverseRecordType( static_cast<RecordType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::TemplateSpecialization: return getDerived().TraverseTemplateSpecializationType( static_cast<TemplateSpecializationType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::TemplateTypeParm: return getDerived().TraverseTemplateTypeParmType( static_cast<TemplateTypeParmType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::TypeOfExpr: return getDerived().TraverseTypeOfExprType( static_cast<TypeOfExprType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::TypeOf: return getDerived().TraverseTypeOfType( static_cast<TypeOfType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::Typedef: return getDerived().TraverseTypedefType( static_cast<TypedefType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::UnaryTransform: return getDerived().TraverseUnaryTransformType( static_cast<UnaryTransformType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::UnresolvedUsing: return getDerived().TraverseUnresolvedUsingType( static_cast<UnresolvedUsingType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::Vector: return getDerived().TraverseVectorType( static_cast<VectorType *>(const_cast<Type *>(T.getTypePtr()))); | |
case Type::ExtVector: return getDerived().TraverseExtVectorType( static_cast<ExtVectorType *>(const_cast<Type *>(T.getTypePtr()))); | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseTypeLoc(TypeLoc TL) { | |
if (TL.isNull()) | |
return true; | |
switch (TL.getTypeLocClass()) { | |
case TypeLoc::Qualified: return getDerived().TraverseQualifiedTypeLoc(TL.castAs<QualifiedTypeLoc>()); | |
case TypeLoc::Adjusted: return getDerived().TraverseAdjustedTypeLoc(TL.castAs<AdjustedTypeLoc>()); | |
case TypeLoc::Decayed: return getDerived().TraverseDecayedTypeLoc(TL.castAs<DecayedTypeLoc>()); | |
case TypeLoc::ConstantArray: return getDerived().TraverseConstantArrayTypeLoc(TL.castAs<ConstantArrayTypeLoc>()); | |
case TypeLoc::DependentSizedArray: return getDerived().TraverseDependentSizedArrayTypeLoc(TL.castAs<DependentSizedArrayTypeLoc>()); | |
case TypeLoc::IncompleteArray: return getDerived().TraverseIncompleteArrayTypeLoc(TL.castAs<IncompleteArrayTypeLoc>()); | |
case TypeLoc::VariableArray: return getDerived().TraverseVariableArrayTypeLoc(TL.castAs<VariableArrayTypeLoc>()); | |
case TypeLoc::Atomic: return getDerived().TraverseAtomicTypeLoc(TL.castAs<AtomicTypeLoc>()); | |
case TypeLoc::Attributed: return getDerived().TraverseAttributedTypeLoc(TL.castAs<AttributedTypeLoc>()); | |
case TypeLoc::BlockPointer: return getDerived().TraverseBlockPointerTypeLoc(TL.castAs<BlockPointerTypeLoc>()); | |
case TypeLoc::Builtin: return getDerived().TraverseBuiltinTypeLoc(TL.castAs<BuiltinTypeLoc>()); | |
case TypeLoc::Complex: return getDerived().TraverseComplexTypeLoc(TL.castAs<ComplexTypeLoc>()); | |
case TypeLoc::Decltype: return getDerived().TraverseDecltypeTypeLoc(TL.castAs<DecltypeTypeLoc>()); | |
case TypeLoc::Auto: return getDerived().TraverseAutoTypeLoc(TL.castAs<AutoTypeLoc>()); | |
case TypeLoc::DeducedTemplateSpecialization: return getDerived().TraverseDeducedTemplateSpecializationTypeLoc(TL.castAs<DeducedTemplateSpecializationTypeLoc>()); | |
case TypeLoc::DependentAddressSpace: return getDerived().TraverseDependentAddressSpaceTypeLoc(TL.castAs<DependentAddressSpaceTypeLoc>()); | |
case TypeLoc::DependentExtInt: return getDerived().TraverseDependentExtIntTypeLoc(TL.castAs<DependentExtIntTypeLoc>()); | |
case TypeLoc::DependentName: return getDerived().TraverseDependentNameTypeLoc(TL.castAs<DependentNameTypeLoc>()); | |
case TypeLoc::DependentSizedExtVector: return getDerived().TraverseDependentSizedExtVectorTypeLoc(TL.castAs<DependentSizedExtVectorTypeLoc>()); | |
case TypeLoc::DependentTemplateSpecialization: return getDerived().TraverseDependentTemplateSpecializationTypeLoc(TL.castAs<DependentTemplateSpecializationTypeLoc>()); | |
case TypeLoc::DependentVector: return getDerived().TraverseDependentVectorTypeLoc(TL.castAs<DependentVectorTypeLoc>()); | |
case TypeLoc::Elaborated: return getDerived().TraverseElaboratedTypeLoc(TL.castAs<ElaboratedTypeLoc>()); | |
case TypeLoc::ExtInt: return getDerived().TraverseExtIntTypeLoc(TL.castAs<ExtIntTypeLoc>()); | |
case TypeLoc::FunctionNoProto: return getDerived().TraverseFunctionNoProtoTypeLoc(TL.castAs<FunctionNoProtoTypeLoc>()); | |
case TypeLoc::FunctionProto: return getDerived().TraverseFunctionProtoTypeLoc(TL.castAs<FunctionProtoTypeLoc>()); | |
case TypeLoc::InjectedClassName: return getDerived().TraverseInjectedClassNameTypeLoc(TL.castAs<InjectedClassNameTypeLoc>()); | |
case TypeLoc::MacroQualified: return getDerived().TraverseMacroQualifiedTypeLoc(TL.castAs<MacroQualifiedTypeLoc>()); | |
case TypeLoc::ConstantMatrix: return getDerived().TraverseConstantMatrixTypeLoc(TL.castAs<ConstantMatrixTypeLoc>()); | |
case TypeLoc::DependentSizedMatrix: return getDerived().TraverseDependentSizedMatrixTypeLoc(TL.castAs<DependentSizedMatrixTypeLoc>()); | |
case TypeLoc::MemberPointer: return getDerived().TraverseMemberPointerTypeLoc(TL.castAs<MemberPointerTypeLoc>()); | |
case TypeLoc::ObjCObjectPointer: return getDerived().TraverseObjCObjectPointerTypeLoc(TL.castAs<ObjCObjectPointerTypeLoc>()); | |
case TypeLoc::ObjCObject: return getDerived().TraverseObjCObjectTypeLoc(TL.castAs<ObjCObjectTypeLoc>()); | |
case TypeLoc::ObjCInterface: return getDerived().TraverseObjCInterfaceTypeLoc(TL.castAs<ObjCInterfaceTypeLoc>()); | |
case TypeLoc::ObjCTypeParam: return getDerived().TraverseObjCTypeParamTypeLoc(TL.castAs<ObjCTypeParamTypeLoc>()); | |
case TypeLoc::PackExpansion: return getDerived().TraversePackExpansionTypeLoc(TL.castAs<PackExpansionTypeLoc>()); | |
case TypeLoc::Paren: return getDerived().TraverseParenTypeLoc(TL.castAs<ParenTypeLoc>()); | |
case TypeLoc::Pipe: return getDerived().TraversePipeTypeLoc(TL.castAs<PipeTypeLoc>()); | |
case TypeLoc::Pointer: return getDerived().TraversePointerTypeLoc(TL.castAs<PointerTypeLoc>()); | |
case TypeLoc::LValueReference: return getDerived().TraverseLValueReferenceTypeLoc(TL.castAs<LValueReferenceTypeLoc>()); | |
case TypeLoc::RValueReference: return getDerived().TraverseRValueReferenceTypeLoc(TL.castAs<RValueReferenceTypeLoc>()); | |
case TypeLoc::SubstTemplateTypeParmPack: return getDerived().TraverseSubstTemplateTypeParmPackTypeLoc(TL.castAs<SubstTemplateTypeParmPackTypeLoc>()); | |
case TypeLoc::SubstTemplateTypeParm: return getDerived().TraverseSubstTemplateTypeParmTypeLoc(TL.castAs<SubstTemplateTypeParmTypeLoc>()); | |
case TypeLoc::Enum: return getDerived().TraverseEnumTypeLoc(TL.castAs<EnumTypeLoc>()); | |
case TypeLoc::Record: return getDerived().TraverseRecordTypeLoc(TL.castAs<RecordTypeLoc>()); | |
case TypeLoc::TemplateSpecialization: return getDerived().TraverseTemplateSpecializationTypeLoc(TL.castAs<TemplateSpecializationTypeLoc>()); | |
case TypeLoc::TemplateTypeParm: return getDerived().TraverseTemplateTypeParmTypeLoc(TL.castAs<TemplateTypeParmTypeLoc>()); | |
case TypeLoc::TypeOfExpr: return getDerived().TraverseTypeOfExprTypeLoc(TL.castAs<TypeOfExprTypeLoc>()); | |
case TypeLoc::TypeOf: return getDerived().TraverseTypeOfTypeLoc(TL.castAs<TypeOfTypeLoc>()); | |
case TypeLoc::Typedef: return getDerived().TraverseTypedefTypeLoc(TL.castAs<TypedefTypeLoc>()); | |
case TypeLoc::UnaryTransform: return getDerived().TraverseUnaryTransformTypeLoc(TL.castAs<UnaryTransformTypeLoc>()); | |
case TypeLoc::UnresolvedUsing: return getDerived().TraverseUnresolvedUsingTypeLoc(TL.castAs<UnresolvedUsingTypeLoc>()); | |
case TypeLoc::Vector: return getDerived().TraverseVectorTypeLoc(TL.castAs<VectorTypeLoc>()); | |
case TypeLoc::ExtVector: return getDerived().TraverseExtVectorTypeLoc(TL.castAs<ExtVectorTypeLoc>()); | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAArch64VectorPcsAttr(AArch64VectorPcsAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAArch64VectorPcsAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAMDGPUFlatWorkGroupSizeAttr(AMDGPUFlatWorkGroupSizeAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAMDGPUFlatWorkGroupSizeAttr(A)) | |
return false; | |
if (!getDerived().TraverseStmt(A->getMin())) | |
return false; | |
if (!getDerived().TraverseStmt(A->getMax())) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAMDGPUNumSGPRAttr(AMDGPUNumSGPRAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAMDGPUNumSGPRAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAMDGPUNumVGPRAttr(AMDGPUNumVGPRAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAMDGPUNumVGPRAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAMDGPUWavesPerEUAttr(AMDGPUWavesPerEUAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAMDGPUWavesPerEUAttr(A)) | |
return false; | |
if (!getDerived().TraverseStmt(A->getMin())) | |
return false; | |
if (!getDerived().TraverseStmt(A->getMax())) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseARMInterruptAttr(ARMInterruptAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitARMInterruptAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAVRInterruptAttr(AVRInterruptAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAVRInterruptAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAVRSignalAttr(AVRSignalAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAVRSignalAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAbiTagAttr(AbiTagAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAbiTagAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAcquireCapabilityAttr(AcquireCapabilityAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAcquireCapabilityAttr(A)) | |
return false; | |
{ | |
Expr * *I = A->args_begin(); | |
Expr * *E = A->args_end(); | |
for (; I != E; ++I) { | |
if (!getDerived().TraverseStmt(*I)) | |
return false; | |
} | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAcquireHandleAttr(AcquireHandleAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAcquireHandleAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAcquiredAfterAttr(AcquiredAfterAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAcquiredAfterAttr(A)) | |
return false; | |
{ | |
Expr * *I = A->args_begin(); | |
Expr * *E = A->args_end(); | |
for (; I != E; ++I) { | |
if (!getDerived().TraverseStmt(*I)) | |
return false; | |
} | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAcquiredBeforeAttr(AcquiredBeforeAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAcquiredBeforeAttr(A)) | |
return false; | |
{ | |
Expr * *I = A->args_begin(); | |
Expr * *E = A->args_end(); | |
for (; I != E; ++I) { | |
if (!getDerived().TraverseStmt(*I)) | |
return false; | |
} | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAddressSpaceAttr(AddressSpaceAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAddressSpaceAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAliasAttr(AliasAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAliasAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAlignMac68kAttr(AlignMac68kAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAlignMac68kAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAlignNaturalAttr(AlignNaturalAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAlignNaturalAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAlignValueAttr(AlignValueAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAlignValueAttr(A)) | |
return false; | |
if (!getDerived().TraverseStmt(A->getAlignment())) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAlignedAttr(AlignedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAlignedAttr(A)) | |
return false; | |
if (A->isAlignmentExpr()) { | |
if (!getDerived().TraverseStmt(A->getAlignmentExpr())) | |
return false; | |
} else if (auto *TSI = A->getAlignmentType()) { | |
if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc())) | |
return false; | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAllocAlignAttr(AllocAlignAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAllocAlignAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAllocSizeAttr(AllocSizeAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAllocSizeAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAlwaysDestroyAttr(AlwaysDestroyAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAlwaysDestroyAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAlwaysInlineAttr(AlwaysInlineAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAlwaysInlineAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAnalyzerNoReturnAttr(AnalyzerNoReturnAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAnalyzerNoReturnAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAnnotateAttr(AnnotateAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAnnotateAttr(A)) | |
return false; | |
{ | |
Expr * *I = A->args_begin(); | |
Expr * *E = A->args_end(); | |
for (; I != E; ++I) { | |
if (!getDerived().TraverseStmt(*I)) | |
return false; | |
} | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAnyX86InterruptAttr(AnyX86InterruptAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAnyX86InterruptAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAnyX86NoCallerSavedRegistersAttr(AnyX86NoCallerSavedRegistersAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAnyX86NoCallerSavedRegistersAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAnyX86NoCfCheckAttr(AnyX86NoCfCheckAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAnyX86NoCfCheckAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitArcWeakrefUnavailableAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitArgumentWithTypeTagAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseArmBuiltinAliasAttr(ArmBuiltinAliasAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitArmBuiltinAliasAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseArmMveStrictPolymorphismAttr(ArmMveStrictPolymorphismAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitArmMveStrictPolymorphismAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseArtificialAttr(ArtificialAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitArtificialAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAsmLabelAttr(AsmLabelAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAsmLabelAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAssertCapabilityAttr(AssertCapabilityAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAssertCapabilityAttr(A)) | |
return false; | |
{ | |
Expr * *I = A->args_begin(); | |
Expr * *E = A->args_end(); | |
for (; I != E; ++I) { | |
if (!getDerived().TraverseStmt(*I)) | |
return false; | |
} | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAssertExclusiveLockAttr(AssertExclusiveLockAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAssertExclusiveLockAttr(A)) | |
return false; | |
{ | |
Expr * *I = A->args_begin(); | |
Expr * *E = A->args_end(); | |
for (; I != E; ++I) { | |
if (!getDerived().TraverseStmt(*I)) | |
return false; | |
} | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAssertSharedLockAttr(AssertSharedLockAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAssertSharedLockAttr(A)) | |
return false; | |
{ | |
Expr * *I = A->args_begin(); | |
Expr * *E = A->args_end(); | |
for (; I != E; ++I) { | |
if (!getDerived().TraverseStmt(*I)) | |
return false; | |
} | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAssumeAlignedAttr(AssumeAlignedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAssumeAlignedAttr(A)) | |
return false; | |
if (!getDerived().TraverseStmt(A->getAlignment())) | |
return false; | |
if (!getDerived().TraverseStmt(A->getOffset())) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAssumptionAttr(AssumptionAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAssumptionAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAvailabilityAttr(AvailabilityAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitAvailabilityAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseBPFPreserveAccessIndexAttr(BPFPreserveAccessIndexAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitBPFPreserveAccessIndexAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseBlocksAttr(BlocksAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitBlocksAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseBuiltinAttr(BuiltinAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitBuiltinAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseBuiltinAliasAttr(BuiltinAliasAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitBuiltinAliasAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseC11NoReturnAttr(C11NoReturnAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitC11NoReturnAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCDeclAttr(CDeclAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCDeclAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCFAuditedTransferAttr(CFAuditedTransferAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCFAuditedTransferAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCFConsumedAttr(CFConsumedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCFConsumedAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCFGuardAttr(CFGuardAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCFGuardAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCFICanonicalJumpTableAttr(CFICanonicalJumpTableAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCFICanonicalJumpTableAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCFReturnsNotRetainedAttr(CFReturnsNotRetainedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCFReturnsNotRetainedAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCFReturnsRetainedAttr(CFReturnsRetainedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCFReturnsRetainedAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCFUnknownTransferAttr(CFUnknownTransferAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCFUnknownTransferAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCPUDispatchAttr(CPUDispatchAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCPUDispatchAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCPUSpecificAttr(CPUSpecificAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCPUSpecificAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCUDAConstantAttr(CUDAConstantAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCUDAConstantAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCUDADeviceAttr(CUDADeviceAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCUDADeviceAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCUDADeviceBuiltinSurfaceTypeAttr(CUDADeviceBuiltinSurfaceTypeAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCUDADeviceBuiltinSurfaceTypeAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCUDADeviceBuiltinTextureTypeAttr(CUDADeviceBuiltinTextureTypeAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCUDADeviceBuiltinTextureTypeAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCUDAGlobalAttr(CUDAGlobalAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCUDAGlobalAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCUDAHostAttr(CUDAHostAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCUDAHostAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCUDAInvalidTargetAttr(CUDAInvalidTargetAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCUDAInvalidTargetAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCUDALaunchBoundsAttr(CUDALaunchBoundsAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCUDALaunchBoundsAttr(A)) | |
return false; | |
if (!getDerived().TraverseStmt(A->getMaxThreads())) | |
return false; | |
if (!getDerived().TraverseStmt(A->getMinBlocks())) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCUDASharedAttr(CUDASharedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCUDASharedAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCXX11NoReturnAttr(CXX11NoReturnAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCXX11NoReturnAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCallableWhenAttr(CallableWhenAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCallableWhenAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCallbackAttr(CallbackAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCallbackAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCalledOnceAttr(CalledOnceAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCalledOnceAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCapabilityAttr(CapabilityAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCapabilityAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCapturedRecordAttr(CapturedRecordAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCapturedRecordAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCarriesDependencyAttr(CarriesDependencyAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCarriesDependencyAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCleanupAttr(CleanupAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCleanupAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCmseNSCallAttr(CmseNSCallAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCmseNSCallAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCmseNSEntryAttr(CmseNSEntryAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCmseNSEntryAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCodeSegAttr(CodeSegAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCodeSegAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseColdAttr(ColdAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitColdAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCommonAttr(CommonAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitCommonAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseConstAttr(ConstAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitConstAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseConstInitAttr(ConstInitAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitConstInitAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseConstructorAttr(ConstructorAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitConstructorAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseConsumableAttr(ConsumableAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitConsumableAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseConsumableAutoCastAttr(ConsumableAutoCastAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitConsumableAutoCastAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitConsumableSetOnReadAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseConvergentAttr(ConvergentAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitConvergentAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseDLLExportAttr(DLLExportAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitDLLExportAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseDLLExportStaticLocalAttr(DLLExportStaticLocalAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitDLLExportStaticLocalAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseDLLImportAttr(DLLImportAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitDLLImportAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseDLLImportStaticLocalAttr(DLLImportStaticLocalAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitDLLImportStaticLocalAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseDeprecatedAttr(DeprecatedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitDeprecatedAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseDestructorAttr(DestructorAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitDestructorAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseDiagnoseIfAttr(DiagnoseIfAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitDiagnoseIfAttr(A)) | |
return false; | |
if (!getDerived().TraverseStmt(A->getCond())) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseDisableTailCallsAttr(DisableTailCallsAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitDisableTailCallsAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseEmptyBasesAttr(EmptyBasesAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitEmptyBasesAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseEnableIfAttr(EnableIfAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitEnableIfAttr(A)) | |
return false; | |
if (!getDerived().TraverseStmt(A->getCond())) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseEnforceTCBAttr(EnforceTCBAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitEnforceTCBAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseEnforceTCBLeafAttr(EnforceTCBLeafAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitEnforceTCBLeafAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseEnumExtensibilityAttr(EnumExtensibilityAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitEnumExtensibilityAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseExcludeFromExplicitInstantiationAttr(ExcludeFromExplicitInstantiationAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitExcludeFromExplicitInstantiationAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseExclusiveTrylockFunctionAttr(ExclusiveTrylockFunctionAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitExclusiveTrylockFunctionAttr(A)) | |
return false; | |
if (!getDerived().TraverseStmt(A->getSuccessValue())) | |
return false; | |
{ | |
Expr * *I = A->args_begin(); | |
Expr * *E = A->args_end(); | |
for (; I != E; ++I) { | |
if (!getDerived().TraverseStmt(*I)) | |
return false; | |
} | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseExternalSourceSymbolAttr(ExternalSourceSymbolAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitExternalSourceSymbolAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseFallThroughAttr(FallThroughAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitFallThroughAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseFastCallAttr(FastCallAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitFastCallAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseFinalAttr(FinalAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitFinalAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseFlagEnumAttr(FlagEnumAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitFlagEnumAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseFlattenAttr(FlattenAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitFlattenAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseFormatAttr(FormatAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitFormatAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseFormatArgAttr(FormatArgAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitFormatArgAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseGNUInlineAttr(GNUInlineAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitGNUInlineAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseGuardedByAttr(GuardedByAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitGuardedByAttr(A)) | |
return false; | |
if (!getDerived().TraverseStmt(A->getArg())) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseGuardedVarAttr(GuardedVarAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitGuardedVarAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseHIPManagedAttr(HIPManagedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitHIPManagedAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseHotAttr(HotAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitHotAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseIBActionAttr(IBActionAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitIBActionAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseIBOutletAttr(IBOutletAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitIBOutletAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseIBOutletCollectionAttr(IBOutletCollectionAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitIBOutletCollectionAttr(A)) | |
return false; | |
if (auto *TSI = A->getInterfaceLoc()) | |
if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc())) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseIFuncAttr(IFuncAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitIFuncAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseInitPriorityAttr(InitPriorityAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitInitPriorityAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseInitSegAttr(InitSegAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitInitSegAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseIntelOclBiccAttr(IntelOclBiccAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitIntelOclBiccAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseInternalLinkageAttr(InternalLinkageAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitInternalLinkageAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseLTOVisibilityPublicAttr(LTOVisibilityPublicAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitLTOVisibilityPublicAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseLayoutVersionAttr(LayoutVersionAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitLayoutVersionAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseLeafAttr(LeafAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitLeafAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseLifetimeBoundAttr(LifetimeBoundAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitLifetimeBoundAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseLikelyAttr(LikelyAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitLikelyAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseLoaderUninitializedAttr(LoaderUninitializedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitLoaderUninitializedAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseLockReturnedAttr(LockReturnedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitLockReturnedAttr(A)) | |
return false; | |
if (!getDerived().TraverseStmt(A->getArg())) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseLocksExcludedAttr(LocksExcludedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitLocksExcludedAttr(A)) | |
return false; | |
{ | |
Expr * *I = A->args_begin(); | |
Expr * *E = A->args_end(); | |
for (; I != E; ++I) { | |
if (!getDerived().TraverseStmt(*I)) | |
return false; | |
} | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseLoopHintAttr(LoopHintAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitLoopHintAttr(A)) | |
return false; | |
if (!getDerived().TraverseStmt(A->getValue())) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseM68kInterruptAttr(M68kInterruptAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitM68kInterruptAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseMIGServerRoutineAttr(MIGServerRoutineAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitMIGServerRoutineAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseMSABIAttr(MSABIAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitMSABIAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseMSAllocatorAttr(MSAllocatorAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitMSAllocatorAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseMSInheritanceAttr(MSInheritanceAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitMSInheritanceAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseMSNoVTableAttr(MSNoVTableAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitMSNoVTableAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseMSP430InterruptAttr(MSP430InterruptAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitMSP430InterruptAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseMSStructAttr(MSStructAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitMSStructAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseMSVtorDispAttr(MSVtorDispAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitMSVtorDispAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitMaxFieldAlignmentAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseMayAliasAttr(MayAliasAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitMayAliasAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseMicroMipsAttr(MicroMipsAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitMicroMipsAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseMinSizeAttr(MinSizeAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitMinSizeAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseMinVectorWidthAttr(MinVectorWidthAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitMinVectorWidthAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseMips16Attr(Mips16Attr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitMips16Attr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseMipsInterruptAttr(MipsInterruptAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitMipsInterruptAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseMipsLongCallAttr(MipsLongCallAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitMipsLongCallAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseMipsShortCallAttr(MipsShortCallAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitMipsShortCallAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseModeAttr(ModeAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitModeAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseMustTailAttr(MustTailAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitMustTailAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNSConsumedAttr(NSConsumedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNSConsumedAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNSConsumesSelfAttr(NSConsumesSelfAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNSConsumesSelfAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNSErrorDomainAttr(NSErrorDomainAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNSErrorDomainAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNSReturnsAutoreleasedAttr(NSReturnsAutoreleasedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNSReturnsAutoreleasedAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNSReturnsNotRetainedAttr(NSReturnsNotRetainedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNSReturnsNotRetainedAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNSReturnsRetainedAttr(NSReturnsRetainedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNSReturnsRetainedAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNakedAttr(NakedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNakedAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNoAliasAttr(NoAliasAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNoAliasAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNoBuiltinAttr(NoBuiltinAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNoBuiltinAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNoCommonAttr(NoCommonAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNoCommonAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNoDebugAttr(NoDebugAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNoDebugAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNoDerefAttr(NoDerefAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNoDerefAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNoDestroyAttr(NoDestroyAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNoDestroyAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNoDuplicateAttr(NoDuplicateAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNoDuplicateAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNoEscapeAttr(NoEscapeAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNoEscapeAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNoInlineAttr(NoInlineAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNoInlineAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNoInstrumentFunctionAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNoMergeAttr(NoMergeAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNoMergeAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNoMicroMipsAttr(NoMicroMipsAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNoMicroMipsAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNoMips16Attr(NoMips16Attr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNoMips16Attr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNoProfileFunctionAttr(NoProfileFunctionAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNoProfileFunctionAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNoReturnAttr(NoReturnAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNoReturnAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNoSanitizeAttr(NoSanitizeAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNoSanitizeAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNoSpeculativeLoadHardeningAttr(NoSpeculativeLoadHardeningAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNoSpeculativeLoadHardeningAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNoSplitStackAttr(NoSplitStackAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNoSplitStackAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNoStackProtectorAttr(NoStackProtectorAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNoStackProtectorAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNoThreadSafetyAnalysisAttr(NoThreadSafetyAnalysisAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNoThreadSafetyAnalysisAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNoThrowAttr(NoThrowAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNoThrowAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNoUniqueAddressAttr(NoUniqueAddressAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNoUniqueAddressAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNonNullAttr(NonNullAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNonNullAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNotTailCalledAttr(NotTailCalledAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitNotTailCalledAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOMPAllocateDeclAttr(OMPAllocateDeclAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOMPAllocateDeclAttr(A)) | |
return false; | |
if (!getDerived().TraverseStmt(A->getAllocator())) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOMPCaptureKindAttr(OMPCaptureKindAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOMPCaptureKindAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOMPCaptureNoInitAttr(OMPCaptureNoInitAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOMPCaptureNoInitAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOMPDeclareSimdDeclAttr(OMPDeclareSimdDeclAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOMPDeclareSimdDeclAttr(A)) | |
return false; | |
if (!getDerived().TraverseStmt(A->getSimdlen())) | |
return false; | |
{ | |
Expr * *I = A->uniforms_begin(); | |
Expr * *E = A->uniforms_end(); | |
for (; I != E; ++I) { | |
if (!getDerived().TraverseStmt(*I)) | |
return false; | |
} | |
} | |
{ | |
Expr * *I = A->aligneds_begin(); | |
Expr * *E = A->aligneds_end(); | |
for (; I != E; ++I) { | |
if (!getDerived().TraverseStmt(*I)) | |
return false; | |
} | |
} | |
{ | |
Expr * *I = A->alignments_begin(); | |
Expr * *E = A->alignments_end(); | |
for (; I != E; ++I) { | |
if (!getDerived().TraverseStmt(*I)) | |
return false; | |
} | |
} | |
{ | |
Expr * *I = A->linears_begin(); | |
Expr * *E = A->linears_end(); | |
for (; I != E; ++I) { | |
if (!getDerived().TraverseStmt(*I)) | |
return false; | |
} | |
} | |
{ | |
Expr * *I = A->steps_begin(); | |
Expr * *E = A->steps_end(); | |
for (; I != E; ++I) { | |
if (!getDerived().TraverseStmt(*I)) | |
return false; | |
} | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOMPDeclareTargetDeclAttr(OMPDeclareTargetDeclAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOMPDeclareTargetDeclAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOMPDeclareVariantAttr(OMPDeclareVariantAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOMPDeclareVariantAttr(A)) | |
return false; | |
if (!getDerived().TraverseStmt(A->getVariantFuncRef())) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOMPReferencedVarAttr(OMPReferencedVarAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOMPReferencedVarAttr(A)) | |
return false; | |
if (!getDerived().TraverseStmt(A->getRef())) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOMPThreadPrivateDeclAttr(OMPThreadPrivateDeclAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOMPThreadPrivateDeclAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOSConsumedAttr(OSConsumedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOSConsumedAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOSConsumesThisAttr(OSConsumesThisAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOSConsumesThisAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOSReturnsNotRetainedAttr(OSReturnsNotRetainedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOSReturnsNotRetainedAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOSReturnsRetainedAttr(OSReturnsRetainedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOSReturnsRetainedAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOSReturnsRetainedOnNonZeroAttr(OSReturnsRetainedOnNonZeroAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOSReturnsRetainedOnNonZeroAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOSReturnsRetainedOnZeroAttr(OSReturnsRetainedOnZeroAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOSReturnsRetainedOnZeroAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCBoxableAttr(ObjCBoxableAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCBoxableAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCBridgeAttr(ObjCBridgeAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCBridgeAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCBridgeMutableAttr(ObjCBridgeMutableAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCBridgeMutableAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCBridgeRelatedAttr(ObjCBridgeRelatedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCBridgeRelatedAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCClassStubAttr(ObjCClassStubAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCClassStubAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCDesignatedInitializerAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCDirectAttr(ObjCDirectAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCDirectAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCDirectMembersAttr(ObjCDirectMembersAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCDirectMembersAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCExceptionAttr(ObjCExceptionAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCExceptionAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCExplicitProtocolImplAttr(ObjCExplicitProtocolImplAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCExplicitProtocolImplAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCExternallyRetainedAttr(ObjCExternallyRetainedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCExternallyRetainedAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCGCAttr(ObjCGCAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCGCAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCIndependentClassAttr(ObjCIndependentClassAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCIndependentClassAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCInertUnsafeUnretainedAttr(ObjCInertUnsafeUnretainedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCInertUnsafeUnretainedAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCKindOfAttr(ObjCKindOfAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCKindOfAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCMethodFamilyAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCNSObjectAttr(ObjCNSObjectAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCNSObjectAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCNonLazyClassAttr(ObjCNonLazyClassAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCNonLazyClassAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCNonRuntimeProtocolAttr(ObjCNonRuntimeProtocolAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCNonRuntimeProtocolAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCOwnershipAttr(ObjCOwnershipAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCOwnershipAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCPreciseLifetimeAttr(ObjCPreciseLifetimeAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCPreciseLifetimeAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCRequiresPropertyDefsAttr(ObjCRequiresPropertyDefsAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCRequiresPropertyDefsAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCRequiresSuperAttr(ObjCRequiresSuperAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCRequiresSuperAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCReturnsInnerPointerAttr(ObjCReturnsInnerPointerAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCReturnsInnerPointerAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCRootClassAttr(ObjCRootClassAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCRootClassAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCRuntimeNameAttr(ObjCRuntimeNameAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCRuntimeNameAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCRuntimeVisibleAttr(ObjCRuntimeVisibleAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCRuntimeVisibleAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseObjCSubclassingRestrictedAttr(ObjCSubclassingRestrictedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitObjCSubclassingRestrictedAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOpenCLAccessAttr(OpenCLAccessAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOpenCLAccessAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOpenCLConstantAddressSpaceAttr(OpenCLConstantAddressSpaceAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOpenCLConstantAddressSpaceAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOpenCLGenericAddressSpaceAttr(OpenCLGenericAddressSpaceAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOpenCLGenericAddressSpaceAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOpenCLGlobalAddressSpaceAttr(OpenCLGlobalAddressSpaceAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOpenCLGlobalAddressSpaceAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOpenCLGlobalDeviceAddressSpaceAttr(OpenCLGlobalDeviceAddressSpaceAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOpenCLGlobalDeviceAddressSpaceAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOpenCLGlobalHostAddressSpaceAttr(OpenCLGlobalHostAddressSpaceAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOpenCLGlobalHostAddressSpaceAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOpenCLIntelReqdSubGroupSizeAttr(OpenCLIntelReqdSubGroupSizeAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOpenCLIntelReqdSubGroupSizeAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOpenCLKernelAttr(OpenCLKernelAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOpenCLKernelAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOpenCLLocalAddressSpaceAttr(OpenCLLocalAddressSpaceAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOpenCLLocalAddressSpaceAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOpenCLPrivateAddressSpaceAttr(OpenCLPrivateAddressSpaceAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOpenCLPrivateAddressSpaceAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOpenCLUnrollHintAttr(OpenCLUnrollHintAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOpenCLUnrollHintAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOptimizeNoneAttr(OptimizeNoneAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOptimizeNoneAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOverloadableAttr(OverloadableAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOverloadableAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOverrideAttr(OverrideAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOverrideAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOwnerAttr(OwnerAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOwnerAttr(A)) | |
return false; | |
if (auto *TSI = A->getDerefTypeLoc()) | |
if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc())) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseOwnershipAttr(OwnershipAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitOwnershipAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraversePackedAttr(PackedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitPackedAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseParamTypestateAttr(ParamTypestateAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitParamTypestateAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraversePascalAttr(PascalAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitPascalAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraversePassObjectSizeAttr(PassObjectSizeAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitPassObjectSizeAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraversePatchableFunctionEntryAttr(PatchableFunctionEntryAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitPatchableFunctionEntryAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraversePcsAttr(PcsAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitPcsAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraversePointerAttr(PointerAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitPointerAttr(A)) | |
return false; | |
if (auto *TSI = A->getDerefTypeLoc()) | |
if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc())) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraversePragmaClangBSSSectionAttr(PragmaClangBSSSectionAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitPragmaClangBSSSectionAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraversePragmaClangDataSectionAttr(PragmaClangDataSectionAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitPragmaClangDataSectionAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraversePragmaClangRelroSectionAttr(PragmaClangRelroSectionAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitPragmaClangRelroSectionAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraversePragmaClangRodataSectionAttr(PragmaClangRodataSectionAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitPragmaClangRodataSectionAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraversePragmaClangTextSectionAttr(PragmaClangTextSectionAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitPragmaClangTextSectionAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraversePreferredNameAttr(PreferredNameAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitPreferredNameAttr(A)) | |
return false; | |
if (auto *TSI = A->getTypedefTypeLoc()) | |
if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc())) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraversePreserveAllAttr(PreserveAllAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitPreserveAllAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraversePreserveMostAttr(PreserveMostAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitPreserveMostAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraversePtGuardedByAttr(PtGuardedByAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitPtGuardedByAttr(A)) | |
return false; | |
if (!getDerived().TraverseStmt(A->getArg())) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraversePtGuardedVarAttr(PtGuardedVarAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitPtGuardedVarAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraversePtr32Attr(Ptr32Attr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitPtr32Attr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraversePtr64Attr(Ptr64Attr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitPtr64Attr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraversePureAttr(PureAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitPureAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseRISCVInterruptAttr(RISCVInterruptAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitRISCVInterruptAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseRegCallAttr(RegCallAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitRegCallAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseReinitializesAttr(ReinitializesAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitReinitializesAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseReleaseCapabilityAttr(ReleaseCapabilityAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitReleaseCapabilityAttr(A)) | |
return false; | |
{ | |
Expr * *I = A->args_begin(); | |
Expr * *E = A->args_end(); | |
for (; I != E; ++I) { | |
if (!getDerived().TraverseStmt(*I)) | |
return false; | |
} | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseReleaseHandleAttr(ReleaseHandleAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitReleaseHandleAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseRenderScriptKernelAttr(RenderScriptKernelAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitRenderScriptKernelAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitReqdWorkGroupSizeAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseRequiresCapabilityAttr(RequiresCapabilityAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitRequiresCapabilityAttr(A)) | |
return false; | |
{ | |
Expr * *I = A->args_begin(); | |
Expr * *E = A->args_end(); | |
for (; I != E; ++I) { | |
if (!getDerived().TraverseStmt(*I)) | |
return false; | |
} | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseRestrictAttr(RestrictAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitRestrictAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseRetainAttr(RetainAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitRetainAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseReturnTypestateAttr(ReturnTypestateAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitReturnTypestateAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseReturnsNonNullAttr(ReturnsNonNullAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitReturnsNonNullAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseReturnsTwiceAttr(ReturnsTwiceAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitReturnsTwiceAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSPtrAttr(SPtrAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitSPtrAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSYCLKernelAttr(SYCLKernelAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitSYCLKernelAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseScopedLockableAttr(ScopedLockableAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitScopedLockableAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSectionAttr(SectionAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitSectionAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSelectAnyAttr(SelectAnyAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitSelectAnyAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSentinelAttr(SentinelAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitSentinelAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSetTypestateAttr(SetTypestateAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitSetTypestateAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSharedTrylockFunctionAttr(SharedTrylockFunctionAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitSharedTrylockFunctionAttr(A)) | |
return false; | |
if (!getDerived().TraverseStmt(A->getSuccessValue())) | |
return false; | |
{ | |
Expr * *I = A->args_begin(); | |
Expr * *E = A->args_end(); | |
for (; I != E; ++I) { | |
if (!getDerived().TraverseStmt(*I)) | |
return false; | |
} | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSpeculativeLoadHardeningAttr(SpeculativeLoadHardeningAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitSpeculativeLoadHardeningAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseStandaloneDebugAttr(StandaloneDebugAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitStandaloneDebugAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseStdCallAttr(StdCallAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitStdCallAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseStrictFPAttr(StrictFPAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitStrictFPAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSuppressAttr(SuppressAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitSuppressAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSwiftAsyncAttr(SwiftAsyncAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitSwiftAsyncAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSwiftAsyncCallAttr(SwiftAsyncCallAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitSwiftAsyncCallAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSwiftAsyncContextAttr(SwiftAsyncContextAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitSwiftAsyncContextAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSwiftAsyncErrorAttr(SwiftAsyncErrorAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitSwiftAsyncErrorAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSwiftAsyncNameAttr(SwiftAsyncNameAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitSwiftAsyncNameAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSwiftAttrAttr(SwiftAttrAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitSwiftAttrAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSwiftBridgeAttr(SwiftBridgeAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitSwiftBridgeAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSwiftBridgedTypedefAttr(SwiftBridgedTypedefAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitSwiftBridgedTypedefAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSwiftCallAttr(SwiftCallAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitSwiftCallAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSwiftContextAttr(SwiftContextAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitSwiftContextAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSwiftErrorAttr(SwiftErrorAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitSwiftErrorAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSwiftErrorResultAttr(SwiftErrorResultAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitSwiftErrorResultAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSwiftIndirectResultAttr(SwiftIndirectResultAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitSwiftIndirectResultAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSwiftNameAttr(SwiftNameAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitSwiftNameAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSwiftNewTypeAttr(SwiftNewTypeAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitSwiftNewTypeAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSwiftObjCMembersAttr(SwiftObjCMembersAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitSwiftObjCMembersAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSwiftPrivateAttr(SwiftPrivateAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitSwiftPrivateAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSysVABIAttr(SysVABIAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitSysVABIAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseTLSModelAttr(TLSModelAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitTLSModelAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseTargetAttr(TargetAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitTargetAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseTestTypestateAttr(TestTypestateAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitTestTypestateAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseThisCallAttr(ThisCallAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitThisCallAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseThreadAttr(ThreadAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitThreadAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseTransparentUnionAttr(TransparentUnionAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitTransparentUnionAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseTrivialABIAttr(TrivialABIAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitTrivialABIAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitTryAcquireCapabilityAttr(A)) | |
return false; | |
if (!getDerived().TraverseStmt(A->getSuccessValue())) | |
return false; | |
{ | |
Expr * *I = A->args_begin(); | |
Expr * *E = A->args_end(); | |
for (; I != E; ++I) { | |
if (!getDerived().TraverseStmt(*I)) | |
return false; | |
} | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseTypeNonNullAttr(TypeNonNullAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitTypeNonNullAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseTypeNullUnspecifiedAttr(TypeNullUnspecifiedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitTypeNullUnspecifiedAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseTypeNullableAttr(TypeNullableAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitTypeNullableAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseTypeNullableResultAttr(TypeNullableResultAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitTypeNullableResultAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitTypeTagForDatatypeAttr(A)) | |
return false; | |
if (auto *TSI = A->getMatchingCTypeLoc()) | |
if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc())) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseTypeVisibilityAttr(TypeVisibilityAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitTypeVisibilityAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseUPtrAttr(UPtrAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitUPtrAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseUnavailableAttr(UnavailableAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitUnavailableAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseUninitializedAttr(UninitializedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitUninitializedAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseUnlikelyAttr(UnlikelyAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitUnlikelyAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseUnusedAttr(UnusedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitUnusedAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseUseHandleAttr(UseHandleAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitUseHandleAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseUsedAttr(UsedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitUsedAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseUsingIfExistsAttr(UsingIfExistsAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitUsingIfExistsAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseUuidAttr(UuidAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitUuidAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseVecReturnAttr(VecReturnAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitVecReturnAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseVecTypeHintAttr(VecTypeHintAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitVecTypeHintAttr(A)) | |
return false; | |
if (auto *TSI = A->getTypeHintLoc()) | |
if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc())) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseVectorCallAttr(VectorCallAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitVectorCallAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseVisibilityAttr(VisibilityAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitVisibilityAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseWarnUnusedAttr(WarnUnusedAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitWarnUnusedAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseWarnUnusedResultAttr(WarnUnusedResultAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitWarnUnusedResultAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseWeakAttr(WeakAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitWeakAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseWeakImportAttr(WeakImportAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitWeakImportAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseWeakRefAttr(WeakRefAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitWeakRefAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseWebAssemblyExportNameAttr(WebAssemblyExportNameAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitWebAssemblyExportNameAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseWebAssemblyImportModuleAttr(WebAssemblyImportModuleAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitWebAssemblyImportModuleAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseWebAssemblyImportNameAttr(WebAssemblyImportNameAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitWebAssemblyImportNameAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseWorkGroupSizeHintAttr(WorkGroupSizeHintAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitWorkGroupSizeHintAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseX86ForceAlignArgPointerAttr(X86ForceAlignArgPointerAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitX86ForceAlignArgPointerAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseXRayInstrumentAttr(XRayInstrumentAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitXRayInstrumentAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseXRayLogArgsAttr(XRayLogArgsAttr *A) { | |
if (!getDerived().VisitAttr(A)) | |
return false; | |
if (!getDerived().VisitXRayLogArgsAttr(A)) | |
return false; | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseAttr(Attr *A) { | |
if (!A) | |
return true; | |
switch (A->getKind()) { | |
case attr::AArch64VectorPcs: | |
return getDerived().TraverseAArch64VectorPcsAttr(cast<AArch64VectorPcsAttr>(A)); | |
case attr::AMDGPUFlatWorkGroupSize: | |
return getDerived().TraverseAMDGPUFlatWorkGroupSizeAttr(cast<AMDGPUFlatWorkGroupSizeAttr>(A)); | |
case attr::AMDGPUNumSGPR: | |
return getDerived().TraverseAMDGPUNumSGPRAttr(cast<AMDGPUNumSGPRAttr>(A)); | |
case attr::AMDGPUNumVGPR: | |
return getDerived().TraverseAMDGPUNumVGPRAttr(cast<AMDGPUNumVGPRAttr>(A)); | |
case attr::AMDGPUWavesPerEU: | |
return getDerived().TraverseAMDGPUWavesPerEUAttr(cast<AMDGPUWavesPerEUAttr>(A)); | |
case attr::ARMInterrupt: | |
return getDerived().TraverseARMInterruptAttr(cast<ARMInterruptAttr>(A)); | |
case attr::AVRInterrupt: | |
return getDerived().TraverseAVRInterruptAttr(cast<AVRInterruptAttr>(A)); | |
case attr::AVRSignal: | |
return getDerived().TraverseAVRSignalAttr(cast<AVRSignalAttr>(A)); | |
case attr::AbiTag: | |
return getDerived().TraverseAbiTagAttr(cast<AbiTagAttr>(A)); | |
case attr::AcquireCapability: | |
return getDerived().TraverseAcquireCapabilityAttr(cast<AcquireCapabilityAttr>(A)); | |
case attr::AcquireHandle: | |
return getDerived().TraverseAcquireHandleAttr(cast<AcquireHandleAttr>(A)); | |
case attr::AcquiredAfter: | |
return getDerived().TraverseAcquiredAfterAttr(cast<AcquiredAfterAttr>(A)); | |
case attr::AcquiredBefore: | |
return getDerived().TraverseAcquiredBeforeAttr(cast<AcquiredBeforeAttr>(A)); | |
case attr::AddressSpace: | |
return getDerived().TraverseAddressSpaceAttr(cast<AddressSpaceAttr>(A)); | |
case attr::Alias: | |
return getDerived().TraverseAliasAttr(cast<AliasAttr>(A)); | |
case attr::AlignMac68k: | |
return getDerived().TraverseAlignMac68kAttr(cast<AlignMac68kAttr>(A)); | |
case attr::AlignNatural: | |
return getDerived().TraverseAlignNaturalAttr(cast<AlignNaturalAttr>(A)); | |
case attr::AlignValue: | |
return getDerived().TraverseAlignValueAttr(cast<AlignValueAttr>(A)); | |
case attr::Aligned: | |
return getDerived().TraverseAlignedAttr(cast<AlignedAttr>(A)); | |
case attr::AllocAlign: | |
return getDerived().TraverseAllocAlignAttr(cast<AllocAlignAttr>(A)); | |
case attr::AllocSize: | |
return getDerived().TraverseAllocSizeAttr(cast<AllocSizeAttr>(A)); | |
case attr::AlwaysDestroy: | |
return getDerived().TraverseAlwaysDestroyAttr(cast<AlwaysDestroyAttr>(A)); | |
case attr::AlwaysInline: | |
return getDerived().TraverseAlwaysInlineAttr(cast<AlwaysInlineAttr>(A)); | |
case attr::AnalyzerNoReturn: | |
return getDerived().TraverseAnalyzerNoReturnAttr(cast<AnalyzerNoReturnAttr>(A)); | |
case attr::Annotate: | |
return getDerived().TraverseAnnotateAttr(cast<AnnotateAttr>(A)); | |
case attr::AnyX86Interrupt: | |
return getDerived().TraverseAnyX86InterruptAttr(cast<AnyX86InterruptAttr>(A)); | |
case attr::AnyX86NoCallerSavedRegisters: | |
return getDerived().TraverseAnyX86NoCallerSavedRegistersAttr(cast<AnyX86NoCallerSavedRegistersAttr>(A)); | |
case attr::AnyX86NoCfCheck: | |
return getDerived().TraverseAnyX86NoCfCheckAttr(cast<AnyX86NoCfCheckAttr>(A)); | |
case attr::ArcWeakrefUnavailable: | |
return getDerived().TraverseArcWeakrefUnavailableAttr(cast<ArcWeakrefUnavailableAttr>(A)); | |
case attr::ArgumentWithTypeTag: | |
return getDerived().TraverseArgumentWithTypeTagAttr(cast<ArgumentWithTypeTagAttr>(A)); | |
case attr::ArmBuiltinAlias: | |
return getDerived().TraverseArmBuiltinAliasAttr(cast<ArmBuiltinAliasAttr>(A)); | |
case attr::ArmMveStrictPolymorphism: | |
return getDerived().TraverseArmMveStrictPolymorphismAttr(cast<ArmMveStrictPolymorphismAttr>(A)); | |
case attr::Artificial: | |
return getDerived().TraverseArtificialAttr(cast<ArtificialAttr>(A)); | |
case attr::AsmLabel: | |
return getDerived().TraverseAsmLabelAttr(cast<AsmLabelAttr>(A)); | |
case attr::AssertCapability: | |
return getDerived().TraverseAssertCapabilityAttr(cast<AssertCapabilityAttr>(A)); | |
case attr::AssertExclusiveLock: | |
return getDerived().TraverseAssertExclusiveLockAttr(cast<AssertExclusiveLockAttr>(A)); | |
case attr::AssertSharedLock: | |
return getDerived().TraverseAssertSharedLockAttr(cast<AssertSharedLockAttr>(A)); | |
case attr::AssumeAligned: | |
return getDerived().TraverseAssumeAlignedAttr(cast<AssumeAlignedAttr>(A)); | |
case attr::Assumption: | |
return getDerived().TraverseAssumptionAttr(cast<AssumptionAttr>(A)); | |
case attr::Availability: | |
return getDerived().TraverseAvailabilityAttr(cast<AvailabilityAttr>(A)); | |
case attr::BPFPreserveAccessIndex: | |
return getDerived().TraverseBPFPreserveAccessIndexAttr(cast<BPFPreserveAccessIndexAttr>(A)); | |
case attr::Blocks: | |
return getDerived().TraverseBlocksAttr(cast<BlocksAttr>(A)); | |
case attr::Builtin: | |
return getDerived().TraverseBuiltinAttr(cast<BuiltinAttr>(A)); | |
case attr::BuiltinAlias: | |
return getDerived().TraverseBuiltinAliasAttr(cast<BuiltinAliasAttr>(A)); | |
case attr::C11NoReturn: | |
return getDerived().TraverseC11NoReturnAttr(cast<C11NoReturnAttr>(A)); | |
case attr::CDecl: | |
return getDerived().TraverseCDeclAttr(cast<CDeclAttr>(A)); | |
case attr::CFAuditedTransfer: | |
return getDerived().TraverseCFAuditedTransferAttr(cast<CFAuditedTransferAttr>(A)); | |
case attr::CFConsumed: | |
return getDerived().TraverseCFConsumedAttr(cast<CFConsumedAttr>(A)); | |
case attr::CFGuard: | |
return getDerived().TraverseCFGuardAttr(cast<CFGuardAttr>(A)); | |
case attr::CFICanonicalJumpTable: | |
return getDerived().TraverseCFICanonicalJumpTableAttr(cast<CFICanonicalJumpTableAttr>(A)); | |
case attr::CFReturnsNotRetained: | |
return getDerived().TraverseCFReturnsNotRetainedAttr(cast<CFReturnsNotRetainedAttr>(A)); | |
case attr::CFReturnsRetained: | |
return getDerived().TraverseCFReturnsRetainedAttr(cast<CFReturnsRetainedAttr>(A)); | |
case attr::CFUnknownTransfer: | |
return getDerived().TraverseCFUnknownTransferAttr(cast<CFUnknownTransferAttr>(A)); | |
case attr::CPUDispatch: | |
return getDerived().TraverseCPUDispatchAttr(cast<CPUDispatchAttr>(A)); | |
case attr::CPUSpecific: | |
return getDerived().TraverseCPUSpecificAttr(cast<CPUSpecificAttr>(A)); | |
case attr::CUDAConstant: | |
return getDerived().TraverseCUDAConstantAttr(cast<CUDAConstantAttr>(A)); | |
case attr::CUDADevice: | |
return getDerived().TraverseCUDADeviceAttr(cast<CUDADeviceAttr>(A)); | |
case attr::CUDADeviceBuiltinSurfaceType: | |
return getDerived().TraverseCUDADeviceBuiltinSurfaceTypeAttr(cast<CUDADeviceBuiltinSurfaceTypeAttr>(A)); | |
case attr::CUDADeviceBuiltinTextureType: | |
return getDerived().TraverseCUDADeviceBuiltinTextureTypeAttr(cast<CUDADeviceBuiltinTextureTypeAttr>(A)); | |
case attr::CUDAGlobal: | |
return getDerived().TraverseCUDAGlobalAttr(cast<CUDAGlobalAttr>(A)); | |
case attr::CUDAHost: | |
return getDerived().TraverseCUDAHostAttr(cast<CUDAHostAttr>(A)); | |
case attr::CUDAInvalidTarget: | |
return getDerived().TraverseCUDAInvalidTargetAttr(cast<CUDAInvalidTargetAttr>(A)); | |
case attr::CUDALaunchBounds: | |
return getDerived().TraverseCUDALaunchBoundsAttr(cast<CUDALaunchBoundsAttr>(A)); | |
case attr::CUDAShared: | |
return getDerived().TraverseCUDASharedAttr(cast<CUDASharedAttr>(A)); | |
case attr::CXX11NoReturn: | |
return getDerived().TraverseCXX11NoReturnAttr(cast<CXX11NoReturnAttr>(A)); | |
case attr::CallableWhen: | |
return getDerived().TraverseCallableWhenAttr(cast<CallableWhenAttr>(A)); | |
case attr::Callback: | |
return getDerived().TraverseCallbackAttr(cast<CallbackAttr>(A)); | |
case attr::CalledOnce: | |
return getDerived().TraverseCalledOnceAttr(cast<CalledOnceAttr>(A)); | |
case attr::Capability: | |
return getDerived().TraverseCapabilityAttr(cast<CapabilityAttr>(A)); | |
case attr::CapturedRecord: | |
return getDerived().TraverseCapturedRecordAttr(cast<CapturedRecordAttr>(A)); | |
case attr::CarriesDependency: | |
return getDerived().TraverseCarriesDependencyAttr(cast<CarriesDependencyAttr>(A)); | |
case attr::Cleanup: | |
return getDerived().TraverseCleanupAttr(cast<CleanupAttr>(A)); | |
case attr::CmseNSCall: | |
return getDerived().TraverseCmseNSCallAttr(cast<CmseNSCallAttr>(A)); | |
case attr::CmseNSEntry: | |
return getDerived().TraverseCmseNSEntryAttr(cast<CmseNSEntryAttr>(A)); | |
case attr::CodeSeg: | |
return getDerived().TraverseCodeSegAttr(cast<CodeSegAttr>(A)); | |
case attr::Cold: | |
return getDerived().TraverseColdAttr(cast<ColdAttr>(A)); | |
case attr::Common: | |
return getDerived().TraverseCommonAttr(cast<CommonAttr>(A)); | |
case attr::Const: | |
return getDerived().TraverseConstAttr(cast<ConstAttr>(A)); | |
case attr::ConstInit: | |
return getDerived().TraverseConstInitAttr(cast<ConstInitAttr>(A)); | |
case attr::Constructor: | |
return getDerived().TraverseConstructorAttr(cast<ConstructorAttr>(A)); | |
case attr::Consumable: | |
return getDerived().TraverseConsumableAttr(cast<ConsumableAttr>(A)); | |
case attr::ConsumableAutoCast: | |
return getDerived().TraverseConsumableAutoCastAttr(cast<ConsumableAutoCastAttr>(A)); | |
case attr::ConsumableSetOnRead: | |
return getDerived().TraverseConsumableSetOnReadAttr(cast<ConsumableSetOnReadAttr>(A)); | |
case attr::Convergent: | |
return getDerived().TraverseConvergentAttr(cast<ConvergentAttr>(A)); | |
case attr::DLLExport: | |
return getDerived().TraverseDLLExportAttr(cast<DLLExportAttr>(A)); | |
case attr::DLLExportStaticLocal: | |
return getDerived().TraverseDLLExportStaticLocalAttr(cast<DLLExportStaticLocalAttr>(A)); | |
case attr::DLLImport: | |
return getDerived().TraverseDLLImportAttr(cast<DLLImportAttr>(A)); | |
case attr::DLLImportStaticLocal: | |
return getDerived().TraverseDLLImportStaticLocalAttr(cast<DLLImportStaticLocalAttr>(A)); | |
case attr::Deprecated: | |
return getDerived().TraverseDeprecatedAttr(cast<DeprecatedAttr>(A)); | |
case attr::Destructor: | |
return getDerived().TraverseDestructorAttr(cast<DestructorAttr>(A)); | |
case attr::DiagnoseIf: | |
return getDerived().TraverseDiagnoseIfAttr(cast<DiagnoseIfAttr>(A)); | |
case attr::DisableTailCalls: | |
return getDerived().TraverseDisableTailCallsAttr(cast<DisableTailCallsAttr>(A)); | |
case attr::EmptyBases: | |
return getDerived().TraverseEmptyBasesAttr(cast<EmptyBasesAttr>(A)); | |
case attr::EnableIf: | |
return getDerived().TraverseEnableIfAttr(cast<EnableIfAttr>(A)); | |
case attr::EnforceTCB: | |
return getDerived().TraverseEnforceTCBAttr(cast<EnforceTCBAttr>(A)); | |
case attr::EnforceTCBLeaf: | |
return getDerived().TraverseEnforceTCBLeafAttr(cast<EnforceTCBLeafAttr>(A)); | |
case attr::EnumExtensibility: | |
return getDerived().TraverseEnumExtensibilityAttr(cast<EnumExtensibilityAttr>(A)); | |
case attr::ExcludeFromExplicitInstantiation: | |
return getDerived().TraverseExcludeFromExplicitInstantiationAttr(cast<ExcludeFromExplicitInstantiationAttr>(A)); | |
case attr::ExclusiveTrylockFunction: | |
return getDerived().TraverseExclusiveTrylockFunctionAttr(cast<ExclusiveTrylockFunctionAttr>(A)); | |
case attr::ExternalSourceSymbol: | |
return getDerived().TraverseExternalSourceSymbolAttr(cast<ExternalSourceSymbolAttr>(A)); | |
case attr::FallThrough: | |
return getDerived().TraverseFallThroughAttr(cast<FallThroughAttr>(A)); | |
case attr::FastCall: | |
return getDerived().TraverseFastCallAttr(cast<FastCallAttr>(A)); | |
case attr::Final: | |
return getDerived().TraverseFinalAttr(cast<FinalAttr>(A)); | |
case attr::FlagEnum: | |
return getDerived().TraverseFlagEnumAttr(cast<FlagEnumAttr>(A)); | |
case attr::Flatten: | |
return getDerived().TraverseFlattenAttr(cast<FlattenAttr>(A)); | |
case attr::Format: | |
return getDerived().TraverseFormatAttr(cast<FormatAttr>(A)); | |
case attr::FormatArg: | |
return getDerived().TraverseFormatArgAttr(cast<FormatArgAttr>(A)); | |
case attr::GNUInline: | |
return getDerived().TraverseGNUInlineAttr(cast<GNUInlineAttr>(A)); | |
case attr::GuardedBy: | |
return getDerived().TraverseGuardedByAttr(cast<GuardedByAttr>(A)); | |
case attr::GuardedVar: | |
return getDerived().TraverseGuardedVarAttr(cast<GuardedVarAttr>(A)); | |
case attr::HIPManaged: | |
return getDerived().TraverseHIPManagedAttr(cast<HIPManagedAttr>(A)); | |
case attr::Hot: | |
return getDerived().TraverseHotAttr(cast<HotAttr>(A)); | |
case attr::IBAction: | |
return getDerived().TraverseIBActionAttr(cast<IBActionAttr>(A)); | |
case attr::IBOutlet: | |
return getDerived().TraverseIBOutletAttr(cast<IBOutletAttr>(A)); | |
case attr::IBOutletCollection: | |
return getDerived().TraverseIBOutletCollectionAttr(cast<IBOutletCollectionAttr>(A)); | |
case attr::IFunc: | |
return getDerived().TraverseIFuncAttr(cast<IFuncAttr>(A)); | |
case attr::InitPriority: | |
return getDerived().TraverseInitPriorityAttr(cast<InitPriorityAttr>(A)); | |
case attr::InitSeg: | |
return getDerived().TraverseInitSegAttr(cast<InitSegAttr>(A)); | |
case attr::IntelOclBicc: | |
return getDerived().TraverseIntelOclBiccAttr(cast<IntelOclBiccAttr>(A)); | |
case attr::InternalLinkage: | |
return getDerived().TraverseInternalLinkageAttr(cast<InternalLinkageAttr>(A)); | |
case attr::LTOVisibilityPublic: | |
return getDerived().TraverseLTOVisibilityPublicAttr(cast<LTOVisibilityPublicAttr>(A)); | |
case attr::LayoutVersion: | |
return getDerived().TraverseLayoutVersionAttr(cast<LayoutVersionAttr>(A)); | |
case attr::Leaf: | |
return getDerived().TraverseLeafAttr(cast<LeafAttr>(A)); | |
case attr::LifetimeBound: | |
return getDerived().TraverseLifetimeBoundAttr(cast<LifetimeBoundAttr>(A)); | |
case attr::Likely: | |
return getDerived().TraverseLikelyAttr(cast<LikelyAttr>(A)); | |
case attr::LoaderUninitialized: | |
return getDerived().TraverseLoaderUninitializedAttr(cast<LoaderUninitializedAttr>(A)); | |
case attr::LockReturned: | |
return getDerived().TraverseLockReturnedAttr(cast<LockReturnedAttr>(A)); | |
case attr::LocksExcluded: | |
return getDerived().TraverseLocksExcludedAttr(cast<LocksExcludedAttr>(A)); | |
case attr::LoopHint: | |
return getDerived().TraverseLoopHintAttr(cast<LoopHintAttr>(A)); | |
case attr::M68kInterrupt: | |
return getDerived().TraverseM68kInterruptAttr(cast<M68kInterruptAttr>(A)); | |
case attr::MIGServerRoutine: | |
return getDerived().TraverseMIGServerRoutineAttr(cast<MIGServerRoutineAttr>(A)); | |
case attr::MSABI: | |
return getDerived().TraverseMSABIAttr(cast<MSABIAttr>(A)); | |
case attr::MSAllocator: | |
return getDerived().TraverseMSAllocatorAttr(cast<MSAllocatorAttr>(A)); | |
case attr::MSInheritance: | |
return getDerived().TraverseMSInheritanceAttr(cast<MSInheritanceAttr>(A)); | |
case attr::MSNoVTable: | |
return getDerived().TraverseMSNoVTableAttr(cast<MSNoVTableAttr>(A)); | |
case attr::MSP430Interrupt: | |
return getDerived().TraverseMSP430InterruptAttr(cast<MSP430InterruptAttr>(A)); | |
case attr::MSStruct: | |
return getDerived().TraverseMSStructAttr(cast<MSStructAttr>(A)); | |
case attr::MSVtorDisp: | |
return getDerived().TraverseMSVtorDispAttr(cast<MSVtorDispAttr>(A)); | |
case attr::MaxFieldAlignment: | |
return getDerived().TraverseMaxFieldAlignmentAttr(cast<MaxFieldAlignmentAttr>(A)); | |
case attr::MayAlias: | |
return getDerived().TraverseMayAliasAttr(cast<MayAliasAttr>(A)); | |
case attr::MicroMips: | |
return getDerived().TraverseMicroMipsAttr(cast<MicroMipsAttr>(A)); | |
case attr::MinSize: | |
return getDerived().TraverseMinSizeAttr(cast<MinSizeAttr>(A)); | |
case attr::MinVectorWidth: | |
return getDerived().TraverseMinVectorWidthAttr(cast<MinVectorWidthAttr>(A)); | |
case attr::Mips16: | |
return getDerived().TraverseMips16Attr(cast<Mips16Attr>(A)); | |
case attr::MipsInterrupt: | |
return getDerived().TraverseMipsInterruptAttr(cast<MipsInterruptAttr>(A)); | |
case attr::MipsLongCall: | |
return getDerived().TraverseMipsLongCallAttr(cast<MipsLongCallAttr>(A)); | |
case attr::MipsShortCall: | |
return getDerived().TraverseMipsShortCallAttr(cast<MipsShortCallAttr>(A)); | |
case attr::Mode: | |
return getDerived().TraverseModeAttr(cast<ModeAttr>(A)); | |
case attr::MustTail: | |
return getDerived().TraverseMustTailAttr(cast<MustTailAttr>(A)); | |
case attr::NSConsumed: | |
return getDerived().TraverseNSConsumedAttr(cast<NSConsumedAttr>(A)); | |
case attr::NSConsumesSelf: | |
return getDerived().TraverseNSConsumesSelfAttr(cast<NSConsumesSelfAttr>(A)); | |
case attr::NSErrorDomain: | |
return getDerived().TraverseNSErrorDomainAttr(cast<NSErrorDomainAttr>(A)); | |
case attr::NSReturnsAutoreleased: | |
return getDerived().TraverseNSReturnsAutoreleasedAttr(cast<NSReturnsAutoreleasedAttr>(A)); | |
case attr::NSReturnsNotRetained: | |
return getDerived().TraverseNSReturnsNotRetainedAttr(cast<NSReturnsNotRetainedAttr>(A)); | |
case attr::NSReturnsRetained: | |
return getDerived().TraverseNSReturnsRetainedAttr(cast<NSReturnsRetainedAttr>(A)); | |
case attr::Naked: | |
return getDerived().TraverseNakedAttr(cast<NakedAttr>(A)); | |
case attr::NoAlias: | |
return getDerived().TraverseNoAliasAttr(cast<NoAliasAttr>(A)); | |
case attr::NoBuiltin: | |
return getDerived().TraverseNoBuiltinAttr(cast<NoBuiltinAttr>(A)); | |
case attr::NoCommon: | |
return getDerived().TraverseNoCommonAttr(cast<NoCommonAttr>(A)); | |
case attr::NoDebug: | |
return getDerived().TraverseNoDebugAttr(cast<NoDebugAttr>(A)); | |
case attr::NoDeref: | |
return getDerived().TraverseNoDerefAttr(cast<NoDerefAttr>(A)); | |
case attr::NoDestroy: | |
return getDerived().TraverseNoDestroyAttr(cast<NoDestroyAttr>(A)); | |
case attr::NoDuplicate: | |
return getDerived().TraverseNoDuplicateAttr(cast<NoDuplicateAttr>(A)); | |
case attr::NoEscape: | |
return getDerived().TraverseNoEscapeAttr(cast<NoEscapeAttr>(A)); | |
case attr::NoInline: | |
return getDerived().TraverseNoInlineAttr(cast<NoInlineAttr>(A)); | |
case attr::NoInstrumentFunction: | |
return getDerived().TraverseNoInstrumentFunctionAttr(cast<NoInstrumentFunctionAttr>(A)); | |
case attr::NoMerge: | |
return getDerived().TraverseNoMergeAttr(cast<NoMergeAttr>(A)); | |
case attr::NoMicroMips: | |
return getDerived().TraverseNoMicroMipsAttr(cast<NoMicroMipsAttr>(A)); | |
case attr::NoMips16: | |
return getDerived().TraverseNoMips16Attr(cast<NoMips16Attr>(A)); | |
case attr::NoProfileFunction: | |
return getDerived().TraverseNoProfileFunctionAttr(cast<NoProfileFunctionAttr>(A)); | |
case attr::NoReturn: | |
return getDerived().TraverseNoReturnAttr(cast<NoReturnAttr>(A)); | |
case attr::NoSanitize: | |
return getDerived().TraverseNoSanitizeAttr(cast<NoSanitizeAttr>(A)); | |
case attr::NoSpeculativeLoadHardening: | |
return getDerived().TraverseNoSpeculativeLoadHardeningAttr(cast<NoSpeculativeLoadHardeningAttr>(A)); | |
case attr::NoSplitStack: | |
return getDerived().TraverseNoSplitStackAttr(cast<NoSplitStackAttr>(A)); | |
case attr::NoStackProtector: | |
return getDerived().TraverseNoStackProtectorAttr(cast<NoStackProtectorAttr>(A)); | |
case attr::NoThreadSafetyAnalysis: | |
return getDerived().TraverseNoThreadSafetyAnalysisAttr(cast<NoThreadSafetyAnalysisAttr>(A)); | |
case attr::NoThrow: | |
return getDerived().TraverseNoThrowAttr(cast<NoThrowAttr>(A)); | |
case attr::NoUniqueAddress: | |
return getDerived().TraverseNoUniqueAddressAttr(cast<NoUniqueAddressAttr>(A)); | |
case attr::NonNull: | |
return getDerived().TraverseNonNullAttr(cast<NonNullAttr>(A)); | |
case attr::NotTailCalled: | |
return getDerived().TraverseNotTailCalledAttr(cast<NotTailCalledAttr>(A)); | |
case attr::OMPAllocateDecl: | |
return getDerived().TraverseOMPAllocateDeclAttr(cast<OMPAllocateDeclAttr>(A)); | |
case attr::OMPCaptureKind: | |
return getDerived().TraverseOMPCaptureKindAttr(cast<OMPCaptureKindAttr>(A)); | |
case attr::OMPCaptureNoInit: | |
return getDerived().TraverseOMPCaptureNoInitAttr(cast<OMPCaptureNoInitAttr>(A)); | |
case attr::OMPDeclareSimdDecl: | |
return getDerived().TraverseOMPDeclareSimdDeclAttr(cast<OMPDeclareSimdDeclAttr>(A)); | |
case attr::OMPDeclareTargetDecl: | |
return getDerived().TraverseOMPDeclareTargetDeclAttr(cast<OMPDeclareTargetDeclAttr>(A)); | |
case attr::OMPDeclareVariant: | |
return getDerived().TraverseOMPDeclareVariantAttr(cast<OMPDeclareVariantAttr>(A)); | |
case attr::OMPReferencedVar: | |
return getDerived().TraverseOMPReferencedVarAttr(cast<OMPReferencedVarAttr>(A)); | |
case attr::OMPThreadPrivateDecl: | |
return getDerived().TraverseOMPThreadPrivateDeclAttr(cast<OMPThreadPrivateDeclAttr>(A)); | |
case attr::OSConsumed: | |
return getDerived().TraverseOSConsumedAttr(cast<OSConsumedAttr>(A)); | |
case attr::OSConsumesThis: | |
return getDerived().TraverseOSConsumesThisAttr(cast<OSConsumesThisAttr>(A)); | |
case attr::OSReturnsNotRetained: | |
return getDerived().TraverseOSReturnsNotRetainedAttr(cast<OSReturnsNotRetainedAttr>(A)); | |
case attr::OSReturnsRetained: | |
return getDerived().TraverseOSReturnsRetainedAttr(cast<OSReturnsRetainedAttr>(A)); | |
case attr::OSReturnsRetainedOnNonZero: | |
return getDerived().TraverseOSReturnsRetainedOnNonZeroAttr(cast<OSReturnsRetainedOnNonZeroAttr>(A)); | |
case attr::OSReturnsRetainedOnZero: | |
return getDerived().TraverseOSReturnsRetainedOnZeroAttr(cast<OSReturnsRetainedOnZeroAttr>(A)); | |
case attr::ObjCBoxable: | |
return getDerived().TraverseObjCBoxableAttr(cast<ObjCBoxableAttr>(A)); | |
case attr::ObjCBridge: | |
return getDerived().TraverseObjCBridgeAttr(cast<ObjCBridgeAttr>(A)); | |
case attr::ObjCBridgeMutable: | |
return getDerived().TraverseObjCBridgeMutableAttr(cast<ObjCBridgeMutableAttr>(A)); | |
case attr::ObjCBridgeRelated: | |
return getDerived().TraverseObjCBridgeRelatedAttr(cast<ObjCBridgeRelatedAttr>(A)); | |
case attr::ObjCClassStub: | |
return getDerived().TraverseObjCClassStubAttr(cast<ObjCClassStubAttr>(A)); | |
case attr::ObjCDesignatedInitializer: | |
return getDerived().TraverseObjCDesignatedInitializerAttr(cast<ObjCDesignatedInitializerAttr>(A)); | |
case attr::ObjCDirect: | |
return getDerived().TraverseObjCDirectAttr(cast<ObjCDirectAttr>(A)); | |
case attr::ObjCDirectMembers: | |
return getDerived().TraverseObjCDirectMembersAttr(cast<ObjCDirectMembersAttr>(A)); | |
case attr::ObjCException: | |
return getDerived().TraverseObjCExceptionAttr(cast<ObjCExceptionAttr>(A)); | |
case attr::ObjCExplicitProtocolImpl: | |
return getDerived().TraverseObjCExplicitProtocolImplAttr(cast<ObjCExplicitProtocolImplAttr>(A)); | |
case attr::ObjCExternallyRetained: | |
return getDerived().TraverseObjCExternallyRetainedAttr(cast<ObjCExternallyRetainedAttr>(A)); | |
case attr::ObjCGC: | |
return getDerived().TraverseObjCGCAttr(cast<ObjCGCAttr>(A)); | |
case attr::ObjCIndependentClass: | |
return getDerived().TraverseObjCIndependentClassAttr(cast<ObjCIndependentClassAttr>(A)); | |
case attr::ObjCInertUnsafeUnretained: | |
return getDerived().TraverseObjCInertUnsafeUnretainedAttr(cast<ObjCInertUnsafeUnretainedAttr>(A)); | |
case attr::ObjCKindOf: | |
return getDerived().TraverseObjCKindOfAttr(cast<ObjCKindOfAttr>(A)); | |
case attr::ObjCMethodFamily: | |
return getDerived().TraverseObjCMethodFamilyAttr(cast<ObjCMethodFamilyAttr>(A)); | |
case attr::ObjCNSObject: | |
return getDerived().TraverseObjCNSObjectAttr(cast<ObjCNSObjectAttr>(A)); | |
case attr::ObjCNonLazyClass: | |
return getDerived().TraverseObjCNonLazyClassAttr(cast<ObjCNonLazyClassAttr>(A)); | |
case attr::ObjCNonRuntimeProtocol: | |
return getDerived().TraverseObjCNonRuntimeProtocolAttr(cast<ObjCNonRuntimeProtocolAttr>(A)); | |
case attr::ObjCOwnership: | |
return getDerived().TraverseObjCOwnershipAttr(cast<ObjCOwnershipAttr>(A)); | |
case attr::ObjCPreciseLifetime: | |
return getDerived().TraverseObjCPreciseLifetimeAttr(cast<ObjCPreciseLifetimeAttr>(A)); | |
case attr::ObjCRequiresPropertyDefs: | |
return getDerived().TraverseObjCRequiresPropertyDefsAttr(cast<ObjCRequiresPropertyDefsAttr>(A)); | |
case attr::ObjCRequiresSuper: | |
return getDerived().TraverseObjCRequiresSuperAttr(cast<ObjCRequiresSuperAttr>(A)); | |
case attr::ObjCReturnsInnerPointer: | |
return getDerived().TraverseObjCReturnsInnerPointerAttr(cast<ObjCReturnsInnerPointerAttr>(A)); | |
case attr::ObjCRootClass: | |
return getDerived().TraverseObjCRootClassAttr(cast<ObjCRootClassAttr>(A)); | |
case attr::ObjCRuntimeName: | |
return getDerived().TraverseObjCRuntimeNameAttr(cast<ObjCRuntimeNameAttr>(A)); | |
case attr::ObjCRuntimeVisible: | |
return getDerived().TraverseObjCRuntimeVisibleAttr(cast<ObjCRuntimeVisibleAttr>(A)); | |
case attr::ObjCSubclassingRestricted: | |
return getDerived().TraverseObjCSubclassingRestrictedAttr(cast<ObjCSubclassingRestrictedAttr>(A)); | |
case attr::OpenCLAccess: | |
return getDerived().TraverseOpenCLAccessAttr(cast<OpenCLAccessAttr>(A)); | |
case attr::OpenCLConstantAddressSpace: | |
return getDerived().TraverseOpenCLConstantAddressSpaceAttr(cast<OpenCLConstantAddressSpaceAttr>(A)); | |
case attr::OpenCLGenericAddressSpace: | |
return getDerived().TraverseOpenCLGenericAddressSpaceAttr(cast<OpenCLGenericAddressSpaceAttr>(A)); | |
case attr::OpenCLGlobalAddressSpace: | |
return getDerived().TraverseOpenCLGlobalAddressSpaceAttr(cast<OpenCLGlobalAddressSpaceAttr>(A)); | |
case attr::OpenCLGlobalDeviceAddressSpace: | |
return getDerived().TraverseOpenCLGlobalDeviceAddressSpaceAttr(cast<OpenCLGlobalDeviceAddressSpaceAttr>(A)); | |
case attr::OpenCLGlobalHostAddressSpace: | |
return getDerived().TraverseOpenCLGlobalHostAddressSpaceAttr(cast<OpenCLGlobalHostAddressSpaceAttr>(A)); | |
case attr::OpenCLIntelReqdSubGroupSize: | |
return getDerived().TraverseOpenCLIntelReqdSubGroupSizeAttr(cast<OpenCLIntelReqdSubGroupSizeAttr>(A)); | |
case attr::OpenCLKernel: | |
return getDerived().TraverseOpenCLKernelAttr(cast<OpenCLKernelAttr>(A)); | |
case attr::OpenCLLocalAddressSpace: | |
return getDerived().TraverseOpenCLLocalAddressSpaceAttr(cast<OpenCLLocalAddressSpaceAttr>(A)); | |
case attr::OpenCLPrivateAddressSpace: | |
return getDerived().TraverseOpenCLPrivateAddressSpaceAttr(cast<OpenCLPrivateAddressSpaceAttr>(A)); | |
case attr::OpenCLUnrollHint: | |
return getDerived().TraverseOpenCLUnrollHintAttr(cast<OpenCLUnrollHintAttr>(A)); | |
case attr::OptimizeNone: | |
return getDerived().TraverseOptimizeNoneAttr(cast<OptimizeNoneAttr>(A)); | |
case attr::Overloadable: | |
return getDerived().TraverseOverloadableAttr(cast<OverloadableAttr>(A)); | |
case attr::Override: | |
return getDerived().TraverseOverrideAttr(cast<OverrideAttr>(A)); | |
case attr::Owner: | |
return getDerived().TraverseOwnerAttr(cast<OwnerAttr>(A)); | |
case attr::Ownership: | |
return getDerived().TraverseOwnershipAttr(cast<OwnershipAttr>(A)); | |
case attr::Packed: | |
return getDerived().TraversePackedAttr(cast<PackedAttr>(A)); | |
case attr::ParamTypestate: | |
return getDerived().TraverseParamTypestateAttr(cast<ParamTypestateAttr>(A)); | |
case attr::Pascal: | |
return getDerived().TraversePascalAttr(cast<PascalAttr>(A)); | |
case attr::PassObjectSize: | |
return getDerived().TraversePassObjectSizeAttr(cast<PassObjectSizeAttr>(A)); | |
case attr::PatchableFunctionEntry: | |
return getDerived().TraversePatchableFunctionEntryAttr(cast<PatchableFunctionEntryAttr>(A)); | |
case attr::Pcs: | |
return getDerived().TraversePcsAttr(cast<PcsAttr>(A)); | |
case attr::Pointer: | |
return getDerived().TraversePointerAttr(cast<PointerAttr>(A)); | |
case attr::PragmaClangBSSSection: | |
return getDerived().TraversePragmaClangBSSSectionAttr(cast<PragmaClangBSSSectionAttr>(A)); | |
case attr::PragmaClangDataSection: | |
return getDerived().TraversePragmaClangDataSectionAttr(cast<PragmaClangDataSectionAttr>(A)); | |
case attr::PragmaClangRelroSection: | |
return getDerived().TraversePragmaClangRelroSectionAttr(cast<PragmaClangRelroSectionAttr>(A)); | |
case attr::PragmaClangRodataSection: | |
return getDerived().TraversePragmaClangRodataSectionAttr(cast<PragmaClangRodataSectionAttr>(A)); | |
case attr::PragmaClangTextSection: | |
return getDerived().TraversePragmaClangTextSectionAttr(cast<PragmaClangTextSectionAttr>(A)); | |
case attr::PreferredName: | |
return getDerived().TraversePreferredNameAttr(cast<PreferredNameAttr>(A)); | |
case attr::PreserveAll: | |
return getDerived().TraversePreserveAllAttr(cast<PreserveAllAttr>(A)); | |
case attr::PreserveMost: | |
return getDerived().TraversePreserveMostAttr(cast<PreserveMostAttr>(A)); | |
case attr::PtGuardedBy: | |
return getDerived().TraversePtGuardedByAttr(cast<PtGuardedByAttr>(A)); | |
case attr::PtGuardedVar: | |
return getDerived().TraversePtGuardedVarAttr(cast<PtGuardedVarAttr>(A)); | |
case attr::Ptr32: | |
return getDerived().TraversePtr32Attr(cast<Ptr32Attr>(A)); | |
case attr::Ptr64: | |
return getDerived().TraversePtr64Attr(cast<Ptr64Attr>(A)); | |
case attr::Pure: | |
return getDerived().TraversePureAttr(cast<PureAttr>(A)); | |
case attr::RISCVInterrupt: | |
return getDerived().TraverseRISCVInterruptAttr(cast<RISCVInterruptAttr>(A)); | |
case attr::RegCall: | |
return getDerived().TraverseRegCallAttr(cast<RegCallAttr>(A)); | |
case attr::Reinitializes: | |
return getDerived().TraverseReinitializesAttr(cast<ReinitializesAttr>(A)); | |
case attr::ReleaseCapability: | |
return getDerived().TraverseReleaseCapabilityAttr(cast<ReleaseCapabilityAttr>(A)); | |
case attr::ReleaseHandle: | |
return getDerived().TraverseReleaseHandleAttr(cast<ReleaseHandleAttr>(A)); | |
case attr::RenderScriptKernel: | |
return getDerived().TraverseRenderScriptKernelAttr(cast<RenderScriptKernelAttr>(A)); | |
case attr::ReqdWorkGroupSize: | |
return getDerived().TraverseReqdWorkGroupSizeAttr(cast<ReqdWorkGroupSizeAttr>(A)); | |
case attr::RequiresCapability: | |
return getDerived().TraverseRequiresCapabilityAttr(cast<RequiresCapabilityAttr>(A)); | |
case attr::Restrict: | |
return getDerived().TraverseRestrictAttr(cast<RestrictAttr>(A)); | |
case attr::Retain: | |
return getDerived().TraverseRetainAttr(cast<RetainAttr>(A)); | |
case attr::ReturnTypestate: | |
return getDerived().TraverseReturnTypestateAttr(cast<ReturnTypestateAttr>(A)); | |
case attr::ReturnsNonNull: | |
return getDerived().TraverseReturnsNonNullAttr(cast<ReturnsNonNullAttr>(A)); | |
case attr::ReturnsTwice: | |
return getDerived().TraverseReturnsTwiceAttr(cast<ReturnsTwiceAttr>(A)); | |
case attr::SPtr: | |
return getDerived().TraverseSPtrAttr(cast<SPtrAttr>(A)); | |
case attr::SYCLKernel: | |
return getDerived().TraverseSYCLKernelAttr(cast<SYCLKernelAttr>(A)); | |
case attr::ScopedLockable: | |
return getDerived().TraverseScopedLockableAttr(cast<ScopedLockableAttr>(A)); | |
case attr::Section: | |
return getDerived().TraverseSectionAttr(cast<SectionAttr>(A)); | |
case attr::SelectAny: | |
return getDerived().TraverseSelectAnyAttr(cast<SelectAnyAttr>(A)); | |
case attr::Sentinel: | |
return getDerived().TraverseSentinelAttr(cast<SentinelAttr>(A)); | |
case attr::SetTypestate: | |
return getDerived().TraverseSetTypestateAttr(cast<SetTypestateAttr>(A)); | |
case attr::SharedTrylockFunction: | |
return getDerived().TraverseSharedTrylockFunctionAttr(cast<SharedTrylockFunctionAttr>(A)); | |
case attr::SpeculativeLoadHardening: | |
return getDerived().TraverseSpeculativeLoadHardeningAttr(cast<SpeculativeLoadHardeningAttr>(A)); | |
case attr::StandaloneDebug: | |
return getDerived().TraverseStandaloneDebugAttr(cast<StandaloneDebugAttr>(A)); | |
case attr::StdCall: | |
return getDerived().TraverseStdCallAttr(cast<StdCallAttr>(A)); | |
case attr::StrictFP: | |
return getDerived().TraverseStrictFPAttr(cast<StrictFPAttr>(A)); | |
case attr::Suppress: | |
return getDerived().TraverseSuppressAttr(cast<SuppressAttr>(A)); | |
case attr::SwiftAsync: | |
return getDerived().TraverseSwiftAsyncAttr(cast<SwiftAsyncAttr>(A)); | |
case attr::SwiftAsyncCall: | |
return getDerived().TraverseSwiftAsyncCallAttr(cast<SwiftAsyncCallAttr>(A)); | |
case attr::SwiftAsyncContext: | |
return getDerived().TraverseSwiftAsyncContextAttr(cast<SwiftAsyncContextAttr>(A)); | |
case attr::SwiftAsyncError: | |
return getDerived().TraverseSwiftAsyncErrorAttr(cast<SwiftAsyncErrorAttr>(A)); | |
case attr::SwiftAsyncName: | |
return getDerived().TraverseSwiftAsyncNameAttr(cast<SwiftAsyncNameAttr>(A)); | |
case attr::SwiftAttr: | |
return getDerived().TraverseSwiftAttrAttr(cast<SwiftAttrAttr>(A)); | |
case attr::SwiftBridge: | |
return getDerived().TraverseSwiftBridgeAttr(cast<SwiftBridgeAttr>(A)); | |
case attr::SwiftBridgedTypedef: | |
return getDerived().TraverseSwiftBridgedTypedefAttr(cast<SwiftBridgedTypedefAttr>(A)); | |
case attr::SwiftCall: | |
return getDerived().TraverseSwiftCallAttr(cast<SwiftCallAttr>(A)); | |
case attr::SwiftContext: | |
return getDerived().TraverseSwiftContextAttr(cast<SwiftContextAttr>(A)); | |
case attr::SwiftError: | |
return getDerived().TraverseSwiftErrorAttr(cast<SwiftErrorAttr>(A)); | |
case attr::SwiftErrorResult: | |
return getDerived().TraverseSwiftErrorResultAttr(cast<SwiftErrorResultAttr>(A)); | |
case attr::SwiftIndirectResult: | |
return getDerived().TraverseSwiftIndirectResultAttr(cast<SwiftIndirectResultAttr>(A)); | |
case attr::SwiftName: | |
return getDerived().TraverseSwiftNameAttr(cast<SwiftNameAttr>(A)); | |
case attr::SwiftNewType: | |
return getDerived().TraverseSwiftNewTypeAttr(cast<SwiftNewTypeAttr>(A)); | |
case attr::SwiftObjCMembers: | |
return getDerived().TraverseSwiftObjCMembersAttr(cast<SwiftObjCMembersAttr>(A)); | |
case attr::SwiftPrivate: | |
return getDerived().TraverseSwiftPrivateAttr(cast<SwiftPrivateAttr>(A)); | |
case attr::SysVABI: | |
return getDerived().TraverseSysVABIAttr(cast<SysVABIAttr>(A)); | |
case attr::TLSModel: | |
return getDerived().TraverseTLSModelAttr(cast<TLSModelAttr>(A)); | |
case attr::Target: | |
return getDerived().TraverseTargetAttr(cast<TargetAttr>(A)); | |
case attr::TestTypestate: | |
return getDerived().TraverseTestTypestateAttr(cast<TestTypestateAttr>(A)); | |
case attr::ThisCall: | |
return getDerived().TraverseThisCallAttr(cast<ThisCallAttr>(A)); | |
case attr::Thread: | |
return getDerived().TraverseThreadAttr(cast<ThreadAttr>(A)); | |
case attr::TransparentUnion: | |
return getDerived().TraverseTransparentUnionAttr(cast<TransparentUnionAttr>(A)); | |
case attr::TrivialABI: | |
return getDerived().TraverseTrivialABIAttr(cast<TrivialABIAttr>(A)); | |
case attr::TryAcquireCapability: | |
return getDerived().TraverseTryAcquireCapabilityAttr(cast<TryAcquireCapabilityAttr>(A)); | |
case attr::TypeNonNull: | |
return getDerived().TraverseTypeNonNullAttr(cast<TypeNonNullAttr>(A)); | |
case attr::TypeNullUnspecified: | |
return getDerived().TraverseTypeNullUnspecifiedAttr(cast<TypeNullUnspecifiedAttr>(A)); | |
case attr::TypeNullable: | |
return getDerived().TraverseTypeNullableAttr(cast<TypeNullableAttr>(A)); | |
case attr::TypeNullableResult: | |
return getDerived().TraverseTypeNullableResultAttr(cast<TypeNullableResultAttr>(A)); | |
case attr::TypeTagForDatatype: | |
return getDerived().TraverseTypeTagForDatatypeAttr(cast<TypeTagForDatatypeAttr>(A)); | |
case attr::TypeVisibility: | |
return getDerived().TraverseTypeVisibilityAttr(cast<TypeVisibilityAttr>(A)); | |
case attr::UPtr: | |
return getDerived().TraverseUPtrAttr(cast<UPtrAttr>(A)); | |
case attr::Unavailable: | |
return getDerived().TraverseUnavailableAttr(cast<UnavailableAttr>(A)); | |
case attr::Uninitialized: | |
return getDerived().TraverseUninitializedAttr(cast<UninitializedAttr>(A)); | |
case attr::Unlikely: | |
return getDerived().TraverseUnlikelyAttr(cast<UnlikelyAttr>(A)); | |
case attr::Unused: | |
return getDerived().TraverseUnusedAttr(cast<UnusedAttr>(A)); | |
case attr::UseHandle: | |
return getDerived().TraverseUseHandleAttr(cast<UseHandleAttr>(A)); | |
case attr::Used: | |
return getDerived().TraverseUsedAttr(cast<UsedAttr>(A)); | |
case attr::UsingIfExists: | |
return getDerived().TraverseUsingIfExistsAttr(cast<UsingIfExistsAttr>(A)); | |
case attr::Uuid: | |
return getDerived().TraverseUuidAttr(cast<UuidAttr>(A)); | |
case attr::VecReturn: | |
return getDerived().TraverseVecReturnAttr(cast<VecReturnAttr>(A)); | |
case attr::VecTypeHint: | |
return getDerived().TraverseVecTypeHintAttr(cast<VecTypeHintAttr>(A)); | |
case attr::VectorCall: | |
return getDerived().TraverseVectorCallAttr(cast<VectorCallAttr>(A)); | |
case attr::Visibility: | |
return getDerived().TraverseVisibilityAttr(cast<VisibilityAttr>(A)); | |
case attr::WarnUnused: | |
return getDerived().TraverseWarnUnusedAttr(cast<WarnUnusedAttr>(A)); | |
case attr::WarnUnusedResult: | |
return getDerived().TraverseWarnUnusedResultAttr(cast<WarnUnusedResultAttr>(A)); | |
case attr::Weak: | |
return getDerived().TraverseWeakAttr(cast<WeakAttr>(A)); | |
case attr::WeakImport: | |
return getDerived().TraverseWeakImportAttr(cast<WeakImportAttr>(A)); | |
case attr::WeakRef: | |
return getDerived().TraverseWeakRefAttr(cast<WeakRefAttr>(A)); | |
case attr::WebAssemblyExportName: | |
return getDerived().TraverseWebAssemblyExportNameAttr(cast<WebAssemblyExportNameAttr>(A)); | |
case attr::WebAssemblyImportModule: | |
return getDerived().TraverseWebAssemblyImportModuleAttr(cast<WebAssemblyImportModuleAttr>(A)); | |
case attr::WebAssemblyImportName: | |
return getDerived().TraverseWebAssemblyImportNameAttr(cast<WebAssemblyImportNameAttr>(A)); | |
case attr::WorkGroupSizeHint: | |
return getDerived().TraverseWorkGroupSizeHintAttr(cast<WorkGroupSizeHintAttr>(A)); | |
case attr::X86ForceAlignArgPointer: | |
return getDerived().TraverseX86ForceAlignArgPointerAttr(cast<X86ForceAlignArgPointerAttr>(A)); | |
case attr::XRayInstrument: | |
return getDerived().TraverseXRayInstrumentAttr(cast<XRayInstrumentAttr>(A)); | |
case attr::XRayLogArgs: | |
return getDerived().TraverseXRayLogArgsAttr(cast<XRayLogArgsAttr>(A)); | |
} | |
::llvm::llvm_unreachable_internal("bad attribute kind", "/Users/viton/PrivateProject/LLVM/llvm-project/.build_RelWithDebInfo/tools/clang/include/clang/AST/AttrVisitor.inc", 5349); | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseDecl(Decl *D) { | |
if (!D) | |
return true; | |
if (!getDerived().shouldVisitImplicitCode() && D->isImplicit()) { | |
if (auto *TTPD = dyn_cast<TemplateTypeParmDecl>(D)) | |
return TraverseTemplateTypeParamDeclConstraints(TTPD); | |
return true; | |
} | |
switch (D->getKind()) { | |
case Decl::AccessSpec: if (!getDerived().TraverseAccessSpecDecl(static_cast<AccessSpecDecl *>(D))) return false; break; | |
case Decl::Block: if (!getDerived().TraverseBlockDecl(static_cast<BlockDecl *>(D))) return false; break; | |
case Decl::Captured: if (!getDerived().TraverseCapturedDecl(static_cast<CapturedDecl *>(D))) return false; break; | |
case Decl::ClassScopeFunctionSpecialization: if (!getDerived().TraverseClassScopeFunctionSpecializationDecl(static_cast<ClassScopeFunctionSpecializationDecl *>(D))) return false; break; | |
case Decl::Empty: if (!getDerived().TraverseEmptyDecl(static_cast<EmptyDecl *>(D))) return false; break; | |
case Decl::Export: if (!getDerived().TraverseExportDecl(static_cast<ExportDecl *>(D))) return false; break; | |
case Decl::ExternCContext: if (!getDerived().TraverseExternCContextDecl(static_cast<ExternCContextDecl *>(D))) return false; break; | |
case Decl::FileScopeAsm: if (!getDerived().TraverseFileScopeAsmDecl(static_cast<FileScopeAsmDecl *>(D))) return false; break; | |
case Decl::Friend: if (!getDerived().TraverseFriendDecl(static_cast<FriendDecl *>(D))) return false; break; | |
case Decl::FriendTemplate: if (!getDerived().TraverseFriendTemplateDecl(static_cast<FriendTemplateDecl *>(D))) return false; break; | |
case Decl::Import: if (!getDerived().TraverseImportDecl(static_cast<ImportDecl *>(D))) return false; break; | |
case Decl::LifetimeExtendedTemporary: if (!getDerived().TraverseLifetimeExtendedTemporaryDecl(static_cast<LifetimeExtendedTemporaryDecl *>(D))) return false; break; | |
case Decl::LinkageSpec: if (!getDerived().TraverseLinkageSpecDecl(static_cast<LinkageSpecDecl *>(D))) return false; break; | |
case Decl::Using: if (!getDerived().TraverseUsingDecl(static_cast<UsingDecl *>(D))) return false; break; | |
case Decl::UsingEnum: if (!getDerived().TraverseUsingEnumDecl(static_cast<UsingEnumDecl *>(D))) return false; break; | |
case Decl::Label: if (!getDerived().TraverseLabelDecl(static_cast<LabelDecl *>(D))) return false; break; | |
case Decl::Namespace: if (!getDerived().TraverseNamespaceDecl(static_cast<NamespaceDecl *>(D))) return false; break; | |
case Decl::NamespaceAlias: if (!getDerived().TraverseNamespaceAliasDecl(static_cast<NamespaceAliasDecl *>(D))) return false; break; | |
case Decl::ObjCCompatibleAlias: if (!getDerived().TraverseObjCCompatibleAliasDecl(static_cast<ObjCCompatibleAliasDecl *>(D))) return false; break; | |
case Decl::ObjCCategory: if (!getDerived().TraverseObjCCategoryDecl(static_cast<ObjCCategoryDecl *>(D))) return false; break; | |
case Decl::ObjCCategoryImpl: if (!getDerived().TraverseObjCCategoryImplDecl(static_cast<ObjCCategoryImplDecl *>(D))) return false; break; | |
case Decl::ObjCImplementation: if (!getDerived().TraverseObjCImplementationDecl(static_cast<ObjCImplementationDecl *>(D))) return false; break; | |
case Decl::ObjCInterface: if (!getDerived().TraverseObjCInterfaceDecl(static_cast<ObjCInterfaceDecl *>(D))) return false; break; | |
case Decl::ObjCProtocol: if (!getDerived().TraverseObjCProtocolDecl(static_cast<ObjCProtocolDecl *>(D))) return false; break; | |
case Decl::ObjCMethod: if (!getDerived().TraverseObjCMethodDecl(static_cast<ObjCMethodDecl *>(D))) return false; break; | |
case Decl::ObjCProperty: if (!getDerived().TraverseObjCPropertyDecl(static_cast<ObjCPropertyDecl *>(D))) return false; break; | |
case Decl::BuiltinTemplate: if (!getDerived().TraverseBuiltinTemplateDecl(static_cast<BuiltinTemplateDecl *>(D))) return false; break; | |
case Decl::Concept: if (!getDerived().TraverseConceptDecl(static_cast<ConceptDecl *>(D))) return false; break; | |
case Decl::ClassTemplate: if (!getDerived().TraverseClassTemplateDecl(static_cast<ClassTemplateDecl *>(D))) return false; break; | |
case Decl::FunctionTemplate: if (!getDerived().TraverseFunctionTemplateDecl(static_cast<FunctionTemplateDecl *>(D))) return false; break; | |
case Decl::TypeAliasTemplate: if (!getDerived().TraverseTypeAliasTemplateDecl(static_cast<TypeAliasTemplateDecl *>(D))) return false; break; | |
case Decl::VarTemplate: if (!getDerived().TraverseVarTemplateDecl(static_cast<VarTemplateDecl *>(D))) return false; break; | |
case Decl::TemplateTemplateParm: if (!getDerived().TraverseTemplateTemplateParmDecl(static_cast<TemplateTemplateParmDecl *>(D))) return false; break; | |
case Decl::Enum: if (!getDerived().TraverseEnumDecl(static_cast<EnumDecl *>(D))) return false; break; | |
case Decl::Record: if (!getDerived().TraverseRecordDecl(static_cast<RecordDecl *>(D))) return false; break; | |
case Decl::CXXRecord: if (!getDerived().TraverseCXXRecordDecl(static_cast<CXXRecordDecl *>(D))) return false; break; | |
case Decl::ClassTemplateSpecialization: if (!getDerived().TraverseClassTemplateSpecializationDecl(static_cast<ClassTemplateSpecializationDecl *>(D))) return false; break; | |
case Decl::ClassTemplatePartialSpecialization: if (!getDerived().TraverseClassTemplatePartialSpecializationDecl(static_cast<ClassTemplatePartialSpecializationDecl *>(D))) return false; break; | |
case Decl::TemplateTypeParm: if (!getDerived().TraverseTemplateTypeParmDecl(static_cast<TemplateTypeParmDecl *>(D))) return false; break; | |
case Decl::ObjCTypeParam: if (!getDerived().TraverseObjCTypeParamDecl(static_cast<ObjCTypeParamDecl *>(D))) return false; break; | |
case Decl::TypeAlias: if (!getDerived().TraverseTypeAliasDecl(static_cast<TypeAliasDecl *>(D))) return false; break; | |
case Decl::Typedef: if (!getDerived().TraverseTypedefDecl(static_cast<TypedefDecl *>(D))) return false; break; | |
case Decl::UnresolvedUsingTypename: if (!getDerived().TraverseUnresolvedUsingTypenameDecl(static_cast<UnresolvedUsingTypenameDecl *>(D))) return false; break; | |
case Decl::UnresolvedUsingIfExists: if (!getDerived().TraverseUnresolvedUsingIfExistsDecl(static_cast<UnresolvedUsingIfExistsDecl *>(D))) return false; break; | |
case Decl::UsingDirective: if (!getDerived().TraverseUsingDirectiveDecl(static_cast<UsingDirectiveDecl *>(D))) return false; break; | |
case Decl::UsingPack: if (!getDerived().TraverseUsingPackDecl(static_cast<UsingPackDecl *>(D))) return false; break; | |
case Decl::UsingShadow: if (!getDerived().TraverseUsingShadowDecl(static_cast<UsingShadowDecl *>(D))) return false; break; | |
case Decl::ConstructorUsingShadow: if (!getDerived().TraverseConstructorUsingShadowDecl(static_cast<ConstructorUsingShadowDecl *>(D))) return false; break; | |
case Decl::Binding: if (!getDerived().TraverseBindingDecl(static_cast<BindingDecl *>(D))) return false; break; | |
case Decl::Field: if (!getDerived().TraverseFieldDecl(static_cast<FieldDecl *>(D))) return false; break; | |
case Decl::ObjCAtDefsField: if (!getDerived().TraverseObjCAtDefsFieldDecl(static_cast<ObjCAtDefsFieldDecl *>(D))) return false; break; | |
case Decl::ObjCIvar: if (!getDerived().TraverseObjCIvarDecl(static_cast<ObjCIvarDecl *>(D))) return false; break; | |
case Decl::Function: if (!getDerived().TraverseFunctionDecl(static_cast<FunctionDecl *>(D))) return false; break; | |
case Decl::CXXDeductionGuide: if (!getDerived().TraverseCXXDeductionGuideDecl(static_cast<CXXDeductionGuideDecl *>(D))) return false; break; | |
case Decl::CXXMethod: if (!getDerived().TraverseCXXMethodDecl(static_cast<CXXMethodDecl *>(D))) return false; break; | |
case Decl::CXXConstructor: if (!getDerived().TraverseCXXConstructorDecl(static_cast<CXXConstructorDecl *>(D))) return false; break; | |
case Decl::CXXConversion: if (!getDerived().TraverseCXXConversionDecl(static_cast<CXXConversionDecl *>(D))) return false; break; | |
case Decl::CXXDestructor: if (!getDerived().TraverseCXXDestructorDecl(static_cast<CXXDestructorDecl *>(D))) return false; break; | |
case Decl::MSProperty: if (!getDerived().TraverseMSPropertyDecl(static_cast<MSPropertyDecl *>(D))) return false; break; | |
case Decl::NonTypeTemplateParm: if (!getDerived().TraverseNonTypeTemplateParmDecl(static_cast<NonTypeTemplateParmDecl *>(D))) return false; break; | |
case Decl::Var: if (!getDerived().TraverseVarDecl(static_cast<VarDecl *>(D))) return false; break; | |
case Decl::Decomposition: if (!getDerived().TraverseDecompositionDecl(static_cast<DecompositionDecl *>(D))) return false; break; | |
case Decl::ImplicitParam: if (!getDerived().TraverseImplicitParamDecl(static_cast<ImplicitParamDecl *>(D))) return false; break; | |
case Decl::OMPCapturedExpr: if (!getDerived().TraverseOMPCapturedExprDecl(static_cast<OMPCapturedExprDecl *>(D))) return false; break; | |
case Decl::ParmVar: if (!getDerived().TraverseParmVarDecl(static_cast<ParmVarDecl *>(D))) return false; break; | |
case Decl::VarTemplateSpecialization: if (!getDerived().TraverseVarTemplateSpecializationDecl(static_cast<VarTemplateSpecializationDecl *>(D))) return false; break; | |
case Decl::VarTemplatePartialSpecialization: if (!getDerived().TraverseVarTemplatePartialSpecializationDecl(static_cast<VarTemplatePartialSpecializationDecl *>(D))) return false; break; | |
case Decl::EnumConstant: if (!getDerived().TraverseEnumConstantDecl(static_cast<EnumConstantDecl *>(D))) return false; break; | |
case Decl::IndirectField: if (!getDerived().TraverseIndirectFieldDecl(static_cast<IndirectFieldDecl *>(D))) return false; break; | |
case Decl::MSGuid: if (!getDerived().TraverseMSGuidDecl(static_cast<MSGuidDecl *>(D))) return false; break; | |
case Decl::OMPDeclareMapper: if (!getDerived().TraverseOMPDeclareMapperDecl(static_cast<OMPDeclareMapperDecl *>(D))) return false; break; | |
case Decl::OMPDeclareReduction: if (!getDerived().TraverseOMPDeclareReductionDecl(static_cast<OMPDeclareReductionDecl *>(D))) return false; break; | |
case Decl::TemplateParamObject: if (!getDerived().TraverseTemplateParamObjectDecl(static_cast<TemplateParamObjectDecl *>(D))) return false; break; | |
case Decl::UnresolvedUsingValue: if (!getDerived().TraverseUnresolvedUsingValueDecl(static_cast<UnresolvedUsingValueDecl *>(D))) return false; break; | |
case Decl::OMPAllocate: if (!getDerived().TraverseOMPAllocateDecl(static_cast<OMPAllocateDecl *>(D))) return false; break; | |
case Decl::OMPRequires: if (!getDerived().TraverseOMPRequiresDecl(static_cast<OMPRequiresDecl *>(D))) return false; break; | |
case Decl::OMPThreadPrivate: if (!getDerived().TraverseOMPThreadPrivateDecl(static_cast<OMPThreadPrivateDecl *>(D))) return false; break; | |
case Decl::ObjCPropertyImpl: if (!getDerived().TraverseObjCPropertyImplDecl(static_cast<ObjCPropertyImplDecl *>(D))) return false; break; | |
case Decl::PragmaComment: if (!getDerived().TraversePragmaCommentDecl(static_cast<PragmaCommentDecl *>(D))) return false; break; | |
case Decl::PragmaDetectMismatch: if (!getDerived().TraversePragmaDetectMismatchDecl(static_cast<PragmaDetectMismatchDecl *>(D))) return false; break; | |
case Decl::RequiresExprBody: if (!getDerived().TraverseRequiresExprBodyDecl(static_cast<RequiresExprBodyDecl *>(D))) return false; break; | |
case Decl::StaticAssert: if (!getDerived().TraverseStaticAssertDecl(static_cast<StaticAssertDecl *>(D))) return false; break; | |
case Decl::TranslationUnit: if (!getDerived().TraverseTranslationUnitDecl(static_cast<TranslationUnitDecl *>(D))) return false; break; | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNestedNameSpecifier( | |
NestedNameSpecifier *NNS) { | |
if (!NNS) | |
return true; | |
if (NNS->getPrefix()) | |
do { if (!getDerived().TraverseNestedNameSpecifier(NNS->getPrefix())) return false; } while (false); | |
switch (NNS->getKind()) { | |
case NestedNameSpecifier::Identifier: | |
case NestedNameSpecifier::Namespace: | |
case NestedNameSpecifier::NamespaceAlias: | |
case NestedNameSpecifier::Global: | |
case NestedNameSpecifier::Super: | |
return true; | |
case NestedNameSpecifier::TypeSpec: | |
case NestedNameSpecifier::TypeSpecWithTemplate: | |
do { if (!getDerived().TraverseType(QualType(NNS->getAsType(), 0))) return false; } while (false); | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseNestedNameSpecifierLoc( | |
NestedNameSpecifierLoc NNS) { | |
if (!NNS) | |
return true; | |
if (NestedNameSpecifierLoc Prefix = NNS.getPrefix()) | |
do { if (!getDerived().TraverseNestedNameSpecifierLoc(Prefix)) return false; } while (false); | |
switch (NNS.getNestedNameSpecifier()->getKind()) { | |
case NestedNameSpecifier::Identifier: | |
case NestedNameSpecifier::Namespace: | |
case NestedNameSpecifier::NamespaceAlias: | |
case NestedNameSpecifier::Global: | |
case NestedNameSpecifier::Super: | |
return true; | |
case NestedNameSpecifier::TypeSpec: | |
case NestedNameSpecifier::TypeSpecWithTemplate: | |
do { if (!getDerived().TraverseTypeLoc(NNS.getTypeLoc())) return false; } while (false); | |
break; | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseDeclarationNameInfo( | |
DeclarationNameInfo NameInfo) { | |
switch (NameInfo.getName().getNameKind()) { | |
case DeclarationName::CXXConstructorName: | |
case DeclarationName::CXXDestructorName: | |
case DeclarationName::CXXConversionFunctionName: | |
if (TypeSourceInfo *TSInfo = NameInfo.getNamedTypeInfo()) | |
do { if (!getDerived().TraverseTypeLoc(TSInfo->getTypeLoc())) return false; } while (false); | |
break; | |
case DeclarationName::CXXDeductionGuideName: | |
do { if (!getDerived().TraverseTemplateName( TemplateName(NameInfo.getName().getCXXDeductionGuideTemplate()))) return false; } while (false); | |
break; | |
case DeclarationName::Identifier: | |
case DeclarationName::ObjCZeroArgSelector: | |
case DeclarationName::ObjCOneArgSelector: | |
case DeclarationName::ObjCMultiArgSelector: | |
case DeclarationName::CXXOperatorName: | |
case DeclarationName::CXXLiteralOperatorName: | |
case DeclarationName::CXXUsingDirective: | |
break; | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseTemplateName(TemplateName Template) { | |
if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) | |
do { if (!getDerived().TraverseNestedNameSpecifier(DTN->getQualifier())) return false; } while (false); | |
else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) | |
do { if (!getDerived().TraverseNestedNameSpecifier(QTN->getQualifier())) return false; } while (false); | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseTemplateArgument( | |
const TemplateArgument &Arg) { | |
switch (Arg.getKind()) { | |
case TemplateArgument::Null: | |
case TemplateArgument::Declaration: | |
case TemplateArgument::Integral: | |
case TemplateArgument::NullPtr: | |
return true; | |
case TemplateArgument::Type: | |
return getDerived().TraverseType(Arg.getAsType()); | |
case TemplateArgument::Template: | |
case TemplateArgument::TemplateExpansion: | |
return getDerived().TraverseTemplateName( | |
Arg.getAsTemplateOrTemplatePattern()); | |
case TemplateArgument::Expression: | |
return getDerived().TraverseStmt(Arg.getAsExpr()); | |
case TemplateArgument::Pack: | |
return getDerived().TraverseTemplateArguments(Arg.pack_begin(), | |
Arg.pack_size()); | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseTemplateArgumentLoc( | |
const TemplateArgumentLoc &ArgLoc) { | |
const TemplateArgument &Arg = ArgLoc.getArgument(); | |
switch (Arg.getKind()) { | |
case TemplateArgument::Null: | |
case TemplateArgument::Declaration: | |
case TemplateArgument::Integral: | |
case TemplateArgument::NullPtr: | |
return true; | |
case TemplateArgument::Type: { | |
if (TypeSourceInfo *TSI = ArgLoc.getTypeSourceInfo()) | |
return getDerived().TraverseTypeLoc(TSI->getTypeLoc()); | |
else | |
return getDerived().TraverseType(Arg.getAsType()); | |
} | |
case TemplateArgument::Template: | |
case TemplateArgument::TemplateExpansion: | |
if (ArgLoc.getTemplateQualifierLoc()) | |
do { if (!getDerived().getDerived().TraverseNestedNameSpecifierLoc( ArgLoc.getTemplateQualifierLoc())) return false; } while (false); | |
return getDerived().TraverseTemplateName( | |
Arg.getAsTemplateOrTemplatePattern()); | |
case TemplateArgument::Expression: | |
return getDerived().TraverseStmt(ArgLoc.getSourceExpression()); | |
case TemplateArgument::Pack: | |
return getDerived().TraverseTemplateArguments(Arg.pack_begin(), | |
Arg.pack_size()); | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseTemplateArguments( | |
const TemplateArgument *Args, unsigned NumArgs) { | |
for (unsigned I = 0; I != NumArgs; ++I) { | |
do { if (!getDerived().TraverseTemplateArgument(Args[I])) return false; } while (false); | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseConstructorInitializer( | |
CXXCtorInitializer *Init) { | |
if (TypeSourceInfo *TInfo = Init->getTypeSourceInfo()) | |
do { if (!getDerived().TraverseTypeLoc(TInfo->getTypeLoc())) return false; } while (false); | |
if (Init->isWritten() || getDerived().shouldVisitImplicitCode()) | |
do { if (!getDerived().TraverseStmt(Init->getInit())) return false; } while (false); | |
return true; | |
} | |
template <typename Derived> | |
bool | |
RecursiveASTVisitor<Derived>::TraverseLambdaCapture(LambdaExpr *LE, | |
const LambdaCapture *C, | |
Expr *Init) { | |
if (LE->isInitCapture(C)) | |
do { if (!getDerived().TraverseDecl(C->getCapturedVar())) return false; } while (false); | |
else | |
do { if (!getDerived().TraverseStmt(Init)) return false; } while (false); | |
return true; | |
} | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseBuiltinType(BuiltinType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBuiltinType(T)) return false; } while (false); { {}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBuiltinType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseComplexType(ComplexType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromComplexType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getElementType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromComplexType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraversePointerType(PointerType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromPointerType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getPointeeType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromPointerType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseBlockPointerType(BlockPointerType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBlockPointerType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getPointeeType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBlockPointerType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseLValueReferenceType(LValueReferenceType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromLValueReferenceType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getPointeeType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromLValueReferenceType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseRValueReferenceType(RValueReferenceType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromRValueReferenceType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getPointeeType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromRValueReferenceType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseMemberPointerType(MemberPointerType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMemberPointerType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(QualType(T->getClass(), 0))) return false; } while (false); do { if (!getDerived().TraverseType(T->getPointeeType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMemberPointerType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseAdjustedType(AdjustedType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromAdjustedType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getOriginalType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromAdjustedType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDecayedType(DecayedType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDecayedType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getOriginalType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDecayedType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseConstantArrayType(ConstantArrayType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromConstantArrayType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getElementType())) return false; } while (false); if (T->getSizeExpr()) do { if (!getDerived().TraverseStmt(const_cast<Expr*>(T->getSizeExpr()))) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromConstantArrayType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseIncompleteArrayType(IncompleteArrayType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromIncompleteArrayType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getElementType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromIncompleteArrayType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseVariableArrayType(VariableArrayType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromVariableArrayType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getElementType())) return false; } while (false); do { if (!getDerived().TraverseStmt(T->getSizeExpr())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromVariableArrayType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentSizedArrayType(DependentSizedArrayType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentSizedArrayType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getElementType())) return false; } while (false); if (T->getSizeExpr()) do { if (!getDerived().TraverseStmt(T->getSizeExpr())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentSizedArrayType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentAddressSpaceType(DependentAddressSpaceType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentAddressSpaceType(T)) return false; } while (false); { { do { if (!getDerived().TraverseStmt(T->getAddrSpaceExpr())) return false; } while (false); do { if (!getDerived().TraverseType(T->getPointeeType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentAddressSpaceType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentVectorType(DependentVectorType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentVectorType(T)) return false; } while (false); { { if (T->getSizeExpr()) do { if (!getDerived().TraverseStmt(T->getSizeExpr())) return false; } while (false); do { if (!getDerived().TraverseType(T->getElementType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentVectorType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentSizedExtVectorType(DependentSizedExtVectorType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentSizedExtVectorType(T)) return false; } while (false); { { if (T->getSizeExpr()) do { if (!getDerived().TraverseStmt(T->getSizeExpr())) return false; } while (false); do { if (!getDerived().TraverseType(T->getElementType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentSizedExtVectorType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseVectorType(VectorType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromVectorType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getElementType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromVectorType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseExtVectorType(ExtVectorType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromExtVectorType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getElementType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromExtVectorType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseConstantMatrixType(ConstantMatrixType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromConstantMatrixType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getElementType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromConstantMatrixType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentSizedMatrixType(DependentSizedMatrixType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentSizedMatrixType(T)) return false; } while (false); { { if (T->getRowExpr()) do { if (!getDerived().TraverseStmt(T->getRowExpr())) return false; } while (false); if (T->getColumnExpr()) do { if (!getDerived().TraverseStmt(T->getColumnExpr())) return false; } while (false); do { if (!getDerived().TraverseType(T->getElementType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentSizedMatrixType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseFunctionNoProtoType(FunctionNoProtoType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFunctionNoProtoType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getReturnType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFunctionNoProtoType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseFunctionProtoType(FunctionProtoType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFunctionProtoType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getReturnType())) return false; } while (false); for (const auto &A : T->param_types()) { do { if (!getDerived().TraverseType(A)) return false; } while (false); } for (const auto &E : T->exceptions()) { do { if (!getDerived().TraverseType(E)) return false; } while (false); } if (Expr *NE = T->getNoexceptExpr()) do { if (!getDerived().TraverseStmt(NE)) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFunctionProtoType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUnresolvedUsingType(UnresolvedUsingType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnresolvedUsingType(T)) return false; } while (false); { {}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnresolvedUsingType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTypedefType(TypedefType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypedefType(T)) return false; } while (false); { {}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypedefType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTypeOfExprType(TypeOfExprType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypeOfExprType(T)) return false; } while (false); { { do { if (!getDerived().TraverseStmt(T->getUnderlyingExpr())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypeOfExprType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTypeOfType(TypeOfType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypeOfType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getUnderlyingType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypeOfType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDecltypeType(DecltypeType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDecltypeType(T)) return false; } while (false); { { do { if (!getDerived().TraverseStmt(T->getUnderlyingExpr())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDecltypeType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUnaryTransformType(UnaryTransformType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnaryTransformType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getBaseType())) return false; } while (false); do { if (!getDerived().TraverseType(T->getUnderlyingType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnaryTransformType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseAutoType(AutoType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromAutoType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getDeducedType())) return false; } while (false); if (T->isConstrained()) { do { if (!getDerived().TraverseDecl(T->getTypeConstraintConcept())) return false; } while (false); do { if (!getDerived().TraverseTemplateArguments(T->getArgs(), T->getNumArgs())) return false; } while (false); }}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromAutoType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDeducedTemplateSpecializationType(DeducedTemplateSpecializationType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDeducedTemplateSpecializationType(T)) return false; } while (false); { { do { if (!getDerived().TraverseTemplateName(T->getTemplateName())) return false; } while (false); do { if (!getDerived().TraverseType(T->getDeducedType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDeducedTemplateSpecializationType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseRecordType(RecordType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromRecordType(T)) return false; } while (false); { {}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromRecordType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseEnumType(EnumType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromEnumType(T)) return false; } while (false); { {}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromEnumType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTemplateTypeParmType(TemplateTypeParmType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTemplateTypeParmType(T)) return false; } while (false); { {}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTemplateTypeParmType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSubstTemplateTypeParmType(SubstTemplateTypeParmType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSubstTemplateTypeParmType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getReplacementType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSubstTemplateTypeParmType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSubstTemplateTypeParmPackType(SubstTemplateTypeParmPackType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSubstTemplateTypeParmPackType(T)) return false; } while (false); { { do { if (!getDerived().TraverseTemplateArgument(T->getArgumentPack())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSubstTemplateTypeParmPackType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTemplateSpecializationType(TemplateSpecializationType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTemplateSpecializationType(T)) return false; } while (false); { { do { if (!getDerived().TraverseTemplateName(T->getTemplateName())) return false; } while (false); do { if (!getDerived().TraverseTemplateArguments(T->getArgs(), T->getNumArgs())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTemplateSpecializationType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseInjectedClassNameType(InjectedClassNameType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromInjectedClassNameType(T)) return false; } while (false); { {}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromInjectedClassNameType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseAttributedType(AttributedType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromAttributedType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getModifiedType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromAttributedType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseParenType(ParenType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromParenType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getInnerType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromParenType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseMacroQualifiedType(MacroQualifiedType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMacroQualifiedType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getUnderlyingType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMacroQualifiedType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseElaboratedType(ElaboratedType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromElaboratedType(T)) return false; } while (false); { { if (T->getQualifier()) { do { if (!getDerived().TraverseNestedNameSpecifier(T->getQualifier())) return false; } while (false); } do { if (!getDerived().TraverseType(T->getNamedType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromElaboratedType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentNameType(DependentNameType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentNameType(T)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifier(T->getQualifier())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentNameType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentTemplateSpecializationType(DependentTemplateSpecializationType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentTemplateSpecializationType(T)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifier(T->getQualifier())) return false; } while (false); do { if (!getDerived().TraverseTemplateArguments(T->getArgs(), T->getNumArgs())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentTemplateSpecializationType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraversePackExpansionType(PackExpansionType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromPackExpansionType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getPattern())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromPackExpansionType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCTypeParamType(ObjCTypeParamType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCTypeParamType(T)) return false; } while (false); { {}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCTypeParamType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCInterfaceType(ObjCInterfaceType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCInterfaceType(T)) return false; } while (false); { {}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCInterfaceType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCObjectType(ObjCObjectType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCObjectType(T)) return false; } while (false); { { if (T->getBaseType().getTypePtr() != T) do { if (!getDerived().TraverseType(T->getBaseType())) return false; } while (false); for (auto typeArg : T->getTypeArgsAsWritten()) { do { if (!getDerived().TraverseType(typeArg)) return false; } while (false); }}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCObjectType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCObjectPointerType(ObjCObjectPointerType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCObjectPointerType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getPointeeType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCObjectPointerType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseAtomicType(AtomicType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromAtomicType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getValueType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromAtomicType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraversePipeType(PipeType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromPipeType(T)) return false; } while (false); { { do { if (!getDerived().TraverseType(T->getElementType())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromPipeType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseExtIntType(ExtIntType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromExtIntType(T)) return false; } while (false); { {}; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromExtIntType(T)) return false; } while (false); return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentExtIntType(DependentExtIntType *T) { if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentExtIntType(T)) return false; } while (false); { { do { if (!getDerived().TraverseStmt(T->getNumBitsExpr())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentExtIntType(T)) return false; } while (false); return true; } | |
template <typename Derived> | |
bool | |
RecursiveASTVisitor<Derived>::TraverseQualifiedTypeLoc(QualifiedTypeLoc TL) { | |
return TraverseTypeLoc(TL.getUnqualifiedLoc()); | |
} | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseBuiltinTypeLoc(BuiltinTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromBuiltinTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromBuiltinType(const_cast<BuiltinType *>(TL.getTypePtr()))) return false; } while (false); } { {}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromBuiltinTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromBuiltinType(const_cast<BuiltinType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseComplexTypeLoc(ComplexTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromComplexTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromComplexType(const_cast<ComplexType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseType(TL.getTypePtr()->getElementType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromComplexTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromComplexType(const_cast<ComplexType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraversePointerTypeLoc(PointerTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromPointerTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromPointerType(const_cast<PointerType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getPointeeLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromPointerTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromPointerType(const_cast<PointerType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseBlockPointerTypeLoc(BlockPointerTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromBlockPointerTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromBlockPointerType(const_cast<BlockPointerType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getPointeeLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromBlockPointerTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromBlockPointerType(const_cast<BlockPointerType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromLValueReferenceTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromLValueReferenceType(const_cast<LValueReferenceType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getPointeeLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromLValueReferenceTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromLValueReferenceType(const_cast<LValueReferenceType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromRValueReferenceTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromRValueReferenceType(const_cast<RValueReferenceType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getPointeeLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromRValueReferenceTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromRValueReferenceType(const_cast<RValueReferenceType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseMemberPointerTypeLoc(MemberPointerTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromMemberPointerTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromMemberPointerType(const_cast<MemberPointerType *>(TL.getTypePtr()))) return false; } while (false); } { { if (auto *TSI = TL.getClassTInfo()) do { if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc())) return false; } while (false); else do { if (!getDerived().TraverseType(QualType(TL.getTypePtr()->getClass(), 0))) return false; } while (false); do { if (!getDerived().TraverseTypeLoc(TL.getPointeeLoc())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromMemberPointerTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromMemberPointerType(const_cast<MemberPointerType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseAdjustedTypeLoc(AdjustedTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromAdjustedTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromAdjustedType(const_cast<AdjustedType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getOriginalLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromAdjustedTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromAdjustedType(const_cast<AdjustedType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDecayedTypeLoc(DecayedTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDecayedTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDecayedType(const_cast<DecayedType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getOriginalLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDecayedTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDecayedType(const_cast<DecayedType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseArrayTypeLocHelper(ArrayTypeLoc TL) { | |
do { if (!getDerived().TraverseStmt(TL.getSizeExpr())) return false; } while (false); | |
return true; | |
} | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromConstantArrayTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromConstantArrayType(const_cast<ConstantArrayType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getElementLoc())) return false; } while (false); do { if (!getDerived().TraverseArrayTypeLocHelper(TL)) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromConstantArrayTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromConstantArrayType(const_cast<ConstantArrayType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromIncompleteArrayTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromIncompleteArrayType(const_cast<IncompleteArrayType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getElementLoc())) return false; } while (false); do { if (!getDerived().TraverseArrayTypeLocHelper(TL)) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromIncompleteArrayTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromIncompleteArrayType(const_cast<IncompleteArrayType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseVariableArrayTypeLoc(VariableArrayTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromVariableArrayTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromVariableArrayType(const_cast<VariableArrayType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getElementLoc())) return false; } while (false); do { if (!getDerived().TraverseArrayTypeLocHelper(TL)) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromVariableArrayTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromVariableArrayType(const_cast<VariableArrayType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentSizedArrayTypeLoc(DependentSizedArrayTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentSizedArrayTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentSizedArrayType(const_cast<DependentSizedArrayType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getElementLoc())) return false; } while (false); do { if (!getDerived().TraverseArrayTypeLocHelper(TL)) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentSizedArrayTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentSizedArrayType(const_cast<DependentSizedArrayType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentAddressSpaceTypeLoc(DependentAddressSpaceTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentAddressSpaceTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentAddressSpaceType(const_cast<DependentAddressSpaceType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseStmt(TL.getTypePtr()->getAddrSpaceExpr())) return false; } while (false); do { if (!getDerived().TraverseType(TL.getTypePtr()->getPointeeType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentAddressSpaceTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentAddressSpaceType(const_cast<DependentAddressSpaceType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentSizedExtVectorTypeLoc(DependentSizedExtVectorTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentSizedExtVectorTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentSizedExtVectorType(const_cast<DependentSizedExtVectorType *>(TL.getTypePtr()))) return false; } while (false); } { { if (TL.getTypePtr()->getSizeExpr()) do { if (!getDerived().TraverseStmt(TL.getTypePtr()->getSizeExpr())) return false; } while (false); do { if (!getDerived().TraverseType(TL.getTypePtr()->getElementType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentSizedExtVectorTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentSizedExtVectorType(const_cast<DependentSizedExtVectorType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseVectorTypeLoc(VectorTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromVectorTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromVectorType(const_cast<VectorType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseType(TL.getTypePtr()->getElementType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromVectorTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromVectorType(const_cast<VectorType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentVectorTypeLoc(DependentVectorTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentVectorTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentVectorType(const_cast<DependentVectorType *>(TL.getTypePtr()))) return false; } while (false); } { { if (TL.getTypePtr()->getSizeExpr()) do { if (!getDerived().TraverseStmt(TL.getTypePtr()->getSizeExpr())) return false; } while (false); do { if (!getDerived().TraverseType(TL.getTypePtr()->getElementType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentVectorTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentVectorType(const_cast<DependentVectorType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseExtVectorTypeLoc(ExtVectorTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromExtVectorTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromExtVectorType(const_cast<ExtVectorType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseType(TL.getTypePtr()->getElementType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromExtVectorTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromExtVectorType(const_cast<ExtVectorType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseConstantMatrixTypeLoc(ConstantMatrixTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromConstantMatrixTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromConstantMatrixType(const_cast<ConstantMatrixType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseStmt(TL.getAttrRowOperand())) return false; } while (false); do { if (!getDerived().TraverseStmt(TL.getAttrColumnOperand())) return false; } while (false); do { if (!getDerived().TraverseType(TL.getTypePtr()->getElementType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromConstantMatrixTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromConstantMatrixType(const_cast<ConstantMatrixType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentSizedMatrixTypeLoc(DependentSizedMatrixTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentSizedMatrixTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentSizedMatrixType(const_cast<DependentSizedMatrixType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseStmt(TL.getAttrRowOperand())) return false; } while (false); do { if (!getDerived().TraverseStmt(TL.getAttrColumnOperand())) return false; } while (false); do { if (!getDerived().TraverseType(TL.getTypePtr()->getElementType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentSizedMatrixTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentSizedMatrixType(const_cast<DependentSizedMatrixType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromFunctionNoProtoTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromFunctionNoProtoType(const_cast<FunctionNoProtoType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getReturnLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromFunctionNoProtoTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromFunctionNoProtoType(const_cast<FunctionNoProtoType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromFunctionProtoTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromFunctionProtoType(const_cast<FunctionProtoType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getReturnLoc())) return false; } while (false); const FunctionProtoType *T = TL.getTypePtr(); for (unsigned I = 0, E = TL.getNumParams(); I != E; ++I) { if (TL.getParam(I)) { do { if (!getDerived().TraverseDecl(TL.getParam(I))) return false; } while (false); } else if (I < T->getNumParams()) { do { if (!getDerived().TraverseType(T->getParamType(I))) return false; } while (false); } } for (const auto &E : T->exceptions()) { do { if (!getDerived().TraverseType(E)) return false; } while (false); } if (Expr *NE = T->getNoexceptExpr()) do { if (!getDerived().TraverseStmt(NE)) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromFunctionProtoTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromFunctionProtoType(const_cast<FunctionProtoType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromUnresolvedUsingTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromUnresolvedUsingType(const_cast<UnresolvedUsingType *>(TL.getTypePtr()))) return false; } while (false); } { {}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromUnresolvedUsingTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromUnresolvedUsingType(const_cast<UnresolvedUsingType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTypedefTypeLoc(TypedefTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromTypedefTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromTypedefType(const_cast<TypedefType *>(TL.getTypePtr()))) return false; } while (false); } { {}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromTypedefTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromTypedefType(const_cast<TypedefType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromTypeOfExprTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromTypeOfExprType(const_cast<TypeOfExprType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseStmt(TL.getUnderlyingExpr())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromTypeOfExprTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromTypeOfExprType(const_cast<TypeOfExprType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTypeOfTypeLoc(TypeOfTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromTypeOfTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromTypeOfType(const_cast<TypeOfType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getUnderlyingTInfo()->getTypeLoc())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromTypeOfTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromTypeOfType(const_cast<TypeOfType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDecltypeTypeLoc(DecltypeTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDecltypeTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDecltypeType(const_cast<DecltypeType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseStmt(TL.getTypePtr()->getUnderlyingExpr())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDecltypeTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDecltypeType(const_cast<DecltypeType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromUnaryTransformTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromUnaryTransformType(const_cast<UnaryTransformType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getUnderlyingTInfo()->getTypeLoc())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromUnaryTransformTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromUnaryTransformType(const_cast<UnaryTransformType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseAutoTypeLoc(AutoTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromAutoTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromAutoType(const_cast<AutoType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseType(TL.getTypePtr()->getDeducedType())) return false; } while (false); if (TL.isConstrained()) { do { if (!getDerived().TraverseNestedNameSpecifierLoc(TL.getNestedNameSpecifierLoc())) return false; } while (false); do { if (!getDerived().TraverseDeclarationNameInfo(TL.getConceptNameInfo())) return false; } while (false); for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) do { if (!getDerived().TraverseTemplateArgumentLoc(TL.getArgLoc(I))) return false; } while (false); }}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromAutoTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromAutoType(const_cast<AutoType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDeducedTemplateSpecializationTypeLoc(DeducedTemplateSpecializationTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDeducedTemplateSpecializationTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDeducedTemplateSpecializationType(const_cast<DeducedTemplateSpecializationType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTemplateName(TL.getTypePtr()->getTemplateName())) return false; } while (false); do { if (!getDerived().TraverseType(TL.getTypePtr()->getDeducedType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDeducedTemplateSpecializationTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDeducedTemplateSpecializationType(const_cast<DeducedTemplateSpecializationType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseRecordTypeLoc(RecordTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromRecordTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromRecordType(const_cast<RecordType *>(TL.getTypePtr()))) return false; } while (false); } { {}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromRecordTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromRecordType(const_cast<RecordType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseEnumTypeLoc(EnumTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromEnumTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromEnumType(const_cast<EnumType *>(TL.getTypePtr()))) return false; } while (false); } { {}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromEnumTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromEnumType(const_cast<EnumType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromTemplateTypeParmTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromTemplateTypeParmType(const_cast<TemplateTypeParmType *>(TL.getTypePtr()))) return false; } while (false); } { {}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromTemplateTypeParmTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromTemplateTypeParmType(const_cast<TemplateTypeParmType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSubstTemplateTypeParmTypeLoc(SubstTemplateTypeParmTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSubstTemplateTypeParmTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromSubstTemplateTypeParmType(const_cast<SubstTemplateTypeParmType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseType(TL.getTypePtr()->getReplacementType())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSubstTemplateTypeParmTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromSubstTemplateTypeParmType(const_cast<SubstTemplateTypeParmType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSubstTemplateTypeParmPackTypeLoc(SubstTemplateTypeParmPackTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSubstTemplateTypeParmPackTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromSubstTemplateTypeParmPackType(const_cast<SubstTemplateTypeParmPackType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTemplateArgument(TL.getTypePtr()->getArgumentPack())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSubstTemplateTypeParmPackTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromSubstTemplateTypeParmPackType(const_cast<SubstTemplateTypeParmPackType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromTemplateSpecializationTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromTemplateSpecializationType(const_cast<TemplateSpecializationType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTemplateName(TL.getTypePtr()->getTemplateName())) return false; } while (false); for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) { do { if (!getDerived().TraverseTemplateArgumentLoc(TL.getArgLoc(I))) return false; } while (false); }}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromTemplateSpecializationTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromTemplateSpecializationType(const_cast<TemplateSpecializationType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromInjectedClassNameTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromInjectedClassNameType(const_cast<InjectedClassNameType *>(TL.getTypePtr()))) return false; } while (false); } { {}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromInjectedClassNameTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromInjectedClassNameType(const_cast<InjectedClassNameType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseParenTypeLoc(ParenTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromParenTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromParenType(const_cast<ParenType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getInnerLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromParenTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromParenType(const_cast<ParenType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromMacroQualifiedTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromMacroQualifiedType(const_cast<MacroQualifiedType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getInnerLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromMacroQualifiedTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromMacroQualifiedType(const_cast<MacroQualifiedType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseAttributedTypeLoc(AttributedTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromAttributedTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromAttributedType(const_cast<AttributedType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getModifiedLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromAttributedTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromAttributedType(const_cast<AttributedType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseElaboratedTypeLoc(ElaboratedTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromElaboratedTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromElaboratedType(const_cast<ElaboratedType *>(TL.getTypePtr()))) return false; } while (false); } { { if (TL.getQualifierLoc()) { do { if (!getDerived().TraverseNestedNameSpecifierLoc(TL.getQualifierLoc())) return false; } while (false); } do { if (!getDerived().TraverseTypeLoc(TL.getNamedTypeLoc())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromElaboratedTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromElaboratedType(const_cast<ElaboratedType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentNameTypeLoc(DependentNameTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentNameTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentNameType(const_cast<DependentNameType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(TL.getQualifierLoc())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentNameTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentNameType(const_cast<DependentNameType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentTemplateSpecializationTypeLoc(DependentTemplateSpecializationTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentTemplateSpecializationTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentTemplateSpecializationType(const_cast<DependentTemplateSpecializationType *>(TL.getTypePtr()))) return false; } while (false); } { { if (TL.getQualifierLoc()) { do { if (!getDerived().TraverseNestedNameSpecifierLoc(TL.getQualifierLoc())) return false; } while (false); } for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) { do { if (!getDerived().TraverseTemplateArgumentLoc(TL.getArgLoc(I))) return false; } while (false); }}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentTemplateSpecializationTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentTemplateSpecializationType(const_cast<DependentTemplateSpecializationType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraversePackExpansionTypeLoc(PackExpansionTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromPackExpansionTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromPackExpansionType(const_cast<PackExpansionType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getPatternLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromPackExpansionTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromPackExpansionType(const_cast<PackExpansionType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCTypeParamTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromObjCTypeParamType(const_cast<ObjCTypeParamType *>(TL.getTypePtr()))) return false; } while (false); } { {}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCTypeParamTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromObjCTypeParamType(const_cast<ObjCTypeParamType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCInterfaceTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromObjCInterfaceType(const_cast<ObjCInterfaceType *>(TL.getTypePtr()))) return false; } while (false); } { {}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCInterfaceTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromObjCInterfaceType(const_cast<ObjCInterfaceType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCObjectTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromObjCObjectType(const_cast<ObjCObjectType *>(TL.getTypePtr()))) return false; } while (false); } { { if (TL.getTypePtr()->getBaseType().getTypePtr() != TL.getTypePtr()) do { if (!getDerived().TraverseTypeLoc(TL.getBaseLoc())) return false; } while (false); for (unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i) do { if (!getDerived().TraverseTypeLoc(TL.getTypeArgTInfo(i)->getTypeLoc())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCObjectTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromObjCObjectType(const_cast<ObjCObjectType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCObjectPointerTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromObjCObjectPointerType(const_cast<ObjCObjectPointerType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getPointeeLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCObjectPointerTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromObjCObjectPointerType(const_cast<ObjCObjectPointerType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseAtomicTypeLoc(AtomicTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromAtomicTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromAtomicType(const_cast<AtomicType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getValueLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromAtomicTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromAtomicType(const_cast<AtomicType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraversePipeTypeLoc(PipeTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromPipeTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromPipeType(const_cast<PipeType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseTypeLoc(TL.getValueLoc())) return false; } while (false); }; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromPipeTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromPipeType(const_cast<PipeType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseExtIntTypeLoc(ExtIntTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromExtIntTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromExtIntType(const_cast<ExtIntType *>(TL.getTypePtr()))) return false; } while (false); } { {}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromExtIntTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromExtIntType(const_cast<ExtIntType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentExtIntTypeLoc(DependentExtIntTypeLoc TL) { if (!getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentExtIntTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentExtIntType(const_cast<DependentExtIntType *>(TL.getTypePtr()))) return false; } while (false); } { { do { if (!getDerived().TraverseStmt(TL.getTypePtr()->getNumBitsExpr())) return false; } while (false);}; } if (getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentExtIntTypeLoc(TL)) return false; } while (false); if (getDerived().shouldWalkTypesOfTypeLocs()) do { if (!getDerived().WalkUpFromDependentExtIntType(const_cast<DependentExtIntType *>(TL.getTypePtr()))) return false; } while (false); } return true; } | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::canIgnoreChildDeclWhileTraversingDeclContext( | |
const Decl *Child) { | |
if (isa<BlockDecl>(Child) || isa<CapturedDecl>(Child)) | |
return true; | |
if (const CXXRecordDecl* Cls = dyn_cast<CXXRecordDecl>(Child)) | |
return Cls->isLambda(); | |
return false; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseDeclContextHelper(DeclContext *DC) { | |
if (!DC) | |
return true; | |
for (auto *Child : DC->decls()) { | |
if (!canIgnoreChildDeclWhileTraversingDeclContext(Child)) | |
do { if (!getDerived().TraverseDecl(Child)) return false; } while (false); | |
} | |
return true; | |
} | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseAccessSpecDecl(AccessSpecDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromAccessSpecDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromAccessSpecDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseBlockDecl(BlockDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBlockDecl(D)) return false; } while (false); { { if (TypeSourceInfo *TInfo = D->getSignatureAsWritten()) do { if (!getDerived().TraverseTypeLoc(TInfo->getTypeLoc())) return false; } while (false); do { if (!getDerived().TraverseStmt(D->getBody())) return false; } while (false); for (const auto &I : D->captures()) { if (I.hasCopyExpr()) { do { if (!getDerived().TraverseStmt(I.getCopyExpr())) return false; } while (false); } } ShouldVisitChildren = false;}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBlockDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCapturedDecl(CapturedDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCapturedDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseStmt(D->getBody())) return false; } while (false); ShouldVisitChildren = false;}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCapturedDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseEmptyDecl(EmptyDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromEmptyDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromEmptyDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromLifetimeExtendedTemporaryDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseStmt(D->getTemporaryExpr())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromLifetimeExtendedTemporaryDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseFileScopeAsmDecl(FileScopeAsmDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFileScopeAsmDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseStmt(D->getAsmString())) return false; } while (false); }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFileScopeAsmDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseImportDecl(ImportDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromImportDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromImportDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseFriendDecl(FriendDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFriendDecl(D)) return false; } while (false); { { if (D->getFriendType()) do { if (!getDerived().TraverseTypeLoc(D->getFriendType()->getTypeLoc())) return false; } while (false); else do { if (!getDerived().TraverseDecl(D->getFriendDecl())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFriendDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseFriendTemplateDecl(FriendTemplateDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFriendTemplateDecl(D)) return false; } while (false); { { if (D->getFriendType()) do { if (!getDerived().TraverseTypeLoc(D->getFriendType()->getTypeLoc())) return false; } while (false); else do { if (!getDerived().TraverseDecl(D->getFriendDecl())) return false; } while (false); for (unsigned I = 0, E = D->getNumTemplateParameters(); I < E; ++I) { TemplateParameterList *TPL = D->getTemplateParameterList(I); for (TemplateParameterList::iterator ITPL = TPL->begin(), ETPL = TPL->end(); ITPL != ETPL; ++ITPL) { do { if (!getDerived().TraverseDecl(*ITPL)) return false; } while (false); } }}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFriendTemplateDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseClassScopeFunctionSpecializationDecl(ClassScopeFunctionSpecializationDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromClassScopeFunctionSpecializationDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseDecl(D->getSpecialization())) return false; } while (false); if (D->hasExplicitTemplateArgs()) { do { if (!getDerived().TraverseTemplateArgumentLocsHelper( D->getTemplateArgsAsWritten()->getTemplateArgs(), D->getTemplateArgsAsWritten()->NumTemplateArgs)) return false; } while (false); }}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromClassScopeFunctionSpecializationDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseLinkageSpecDecl(LinkageSpecDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromLinkageSpecDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromLinkageSpecDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseExportDecl(ExportDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromExportDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromExportDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCPropertyImplDecl(ObjCPropertyImplDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCPropertyImplDecl(D)) return false; } while (false); { { }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCPropertyImplDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseStaticAssertDecl(StaticAssertDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromStaticAssertDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseStmt(D->getAssertExpr())) return false; } while (false); do { if (!getDerived().TraverseStmt(D->getMessage())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromStaticAssertDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTranslationUnitDecl(TranslationUnitDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTranslationUnitDecl(D)) return false; } while (false); { { auto Scope = D->getASTContext().getTraversalScope(); bool HasLimitedScope = Scope.size() != 1 || !isa<TranslationUnitDecl>(Scope.front()); if (HasLimitedScope) { ShouldVisitChildren = false; for (auto *Child : Scope) { if (!canIgnoreChildDeclWhileTraversingDeclContext(Child)) do { if (!getDerived().TraverseDecl(Child)) return false; } while (false); } }}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTranslationUnitDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraversePragmaCommentDecl(PragmaCommentDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromPragmaCommentDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromPragmaCommentDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraversePragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromPragmaDetectMismatchDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromPragmaDetectMismatchDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseExternCContextDecl(ExternCContextDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromExternCContextDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromExternCContextDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseNamespaceAliasDecl(NamespaceAliasDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromNamespaceAliasDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(D->getQualifierLoc())) return false; } while (false); ShouldVisitChildren = false;}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromNamespaceAliasDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseLabelDecl(LabelDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromLabelDecl(D)) return false; } while (false); { { }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromLabelDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseNamespaceDecl(NamespaceDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromNamespaceDecl(D)) return false; } while (false); { { }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromNamespaceDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCCompatibleAliasDecl(D)) return false; } while (false); { { }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCCompatibleAliasDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCCategoryDecl(ObjCCategoryDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCCategoryDecl(D)) return false; } while (false); { { if (ObjCTypeParamList *typeParamList = D->getTypeParamList()) { for (auto typeParam : *typeParamList) { do { if (!getDerived().TraverseObjCTypeParamDecl(typeParam)) return false; } while (false); } }}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCCategoryDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCCategoryImplDecl(ObjCCategoryImplDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCCategoryImplDecl(D)) return false; } while (false); { { }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCCategoryImplDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCImplementationDecl(ObjCImplementationDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCImplementationDecl(D)) return false; } while (false); { { }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCImplementationDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCInterfaceDecl(ObjCInterfaceDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCInterfaceDecl(D)) return false; } while (false); { { if (ObjCTypeParamList *typeParamList = D->getTypeParamListAsWritten()) { for (auto typeParam : *typeParamList) { do { if (!getDerived().TraverseObjCTypeParamDecl(typeParam)) return false; } while (false); } } if (TypeSourceInfo *superTInfo = D->getSuperClassTInfo()) { do { if (!getDerived().TraverseTypeLoc(superTInfo->getTypeLoc())) return false; } while (false); }}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCInterfaceDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCProtocolDecl(ObjCProtocolDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCProtocolDecl(D)) return false; } while (false); { { }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCProtocolDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCMethodDecl(ObjCMethodDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCMethodDecl(D)) return false; } while (false); { { if (D->getReturnTypeSourceInfo()) { do { if (!getDerived().TraverseTypeLoc(D->getReturnTypeSourceInfo()->getTypeLoc())) return false; } while (false); } for (ParmVarDecl *Parameter : D->parameters()) { do { if (!getDerived().TraverseDecl(Parameter)) return false; } while (false); } if (D->isThisDeclarationADefinition()) { do { if (!getDerived().TraverseStmt(D->getBody())) return false; } while (false); } ShouldVisitChildren = false;}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCMethodDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCTypeParamDecl(ObjCTypeParamDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCTypeParamDecl(D)) return false; } while (false); { { if (D->hasExplicitBound()) { do { if (!getDerived().TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc())) return false; } while (false); }}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCTypeParamDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCPropertyDecl(ObjCPropertyDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCPropertyDecl(D)) return false; } while (false); { { if (D->getTypeSourceInfo()) do { if (!getDerived().TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc())) return false; } while (false); else do { if (!getDerived().TraverseType(D->getType())) return false; } while (false); ShouldVisitChildren = false;}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCPropertyDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUsingDecl(UsingDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUsingDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(D->getQualifierLoc())) return false; } while (false); do { if (!getDerived().TraverseDeclarationNameInfo(D->getNameInfo())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUsingDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUsingEnumDecl(UsingEnumDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUsingEnumDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUsingEnumDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUsingPackDecl(UsingPackDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUsingPackDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUsingPackDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUsingDirectiveDecl(UsingDirectiveDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUsingDirectiveDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(D->getQualifierLoc())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUsingDirectiveDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUsingShadowDecl(UsingShadowDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUsingShadowDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUsingShadowDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseConstructorUsingShadowDecl(ConstructorUsingShadowDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromConstructorUsingShadowDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromConstructorUsingShadowDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPThreadPrivateDecl(D)) return false; } while (false); { { for (auto *I : D->varlists()) { do { if (!getDerived().TraverseStmt(I)) return false; } while (false); } }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPThreadPrivateDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseOMPRequiresDecl(OMPRequiresDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPRequiresDecl(D)) return false; } while (false); { { for (auto *C : D->clauselists()) { do { if (!getDerived().TraverseOMPClause(C)) return false; } while (false); }}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPRequiresDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseOMPDeclareReductionDecl(OMPDeclareReductionDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPDeclareReductionDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseStmt(D->getCombiner())) return false; } while (false); if (auto *Initializer = D->getInitializer()) do { if (!getDerived().TraverseStmt(Initializer)) return false; } while (false); do { if (!getDerived().TraverseType(D->getType())) return false; } while (false); return true;}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPDeclareReductionDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseOMPDeclareMapperDecl(OMPDeclareMapperDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPDeclareMapperDecl(D)) return false; } while (false); { { for (auto *C : D->clauselists()) do { if (!getDerived().TraverseOMPClause(C)) return false; } while (false); do { if (!getDerived().TraverseType(D->getType())) return false; } while (false); return true;}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPDeclareMapperDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseOMPCapturedExprDecl(OMPCapturedExprDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPCapturedExprDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseVarHelper(D)) return false; } while (false); }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPCapturedExprDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseOMPAllocateDecl(OMPAllocateDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPAllocateDecl(D)) return false; } while (false); { { for (auto *I : D->varlists()) do { if (!getDerived().TraverseStmt(I)) return false; } while (false); for (auto *C : D->clauselists()) do { if (!getDerived().TraverseOMPClause(C)) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPAllocateDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseTemplateParameterListHelper( | |
TemplateParameterList *TPL) { | |
if (TPL) { | |
for (NamedDecl *D : *TPL) { | |
do { if (!getDerived().TraverseDecl(D)) return false; } while (false); | |
} | |
if (Expr *RequiresClause = TPL->getRequiresClause()) { | |
do { if (!getDerived().TraverseStmt(RequiresClause)) return false; } while (false); | |
} | |
} | |
return true; | |
} | |
template <typename Derived> | |
template <typename T> | |
bool RecursiveASTVisitor<Derived>::TraverseDeclTemplateParameterLists(T *D) { | |
for (unsigned i = 0; i < D->getNumTemplateParameterLists(); i++) { | |
TemplateParameterList *TPL = D->getTemplateParameterList(i); | |
TraverseTemplateParameterListHelper(TPL); | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseTemplateInstantiations( | |
ClassTemplateDecl *D) { | |
for (auto *SD : D->specializations()) { | |
for (auto *RD : SD->redecls()) { | |
if (cast<CXXRecordDecl>(RD)->isInjectedClassName()) | |
continue; | |
switch ( | |
cast<ClassTemplateSpecializationDecl>(RD)->getSpecializationKind()) { | |
case TSK_Undeclared: | |
case TSK_ImplicitInstantiation: | |
do { if (!getDerived().TraverseDecl(RD)) return false; } while (false); | |
break; | |
case TSK_ExplicitInstantiationDeclaration: | |
case TSK_ExplicitInstantiationDefinition: | |
case TSK_ExplicitSpecialization: | |
break; | |
} | |
} | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseTemplateInstantiations( | |
VarTemplateDecl *D) { | |
for (auto *SD : D->specializations()) { | |
for (auto *RD : SD->redecls()) { | |
switch ( | |
cast<VarTemplateSpecializationDecl>(RD)->getSpecializationKind()) { | |
case TSK_Undeclared: | |
case TSK_ImplicitInstantiation: | |
do { if (!getDerived().TraverseDecl(RD)) return false; } while (false); | |
break; | |
case TSK_ExplicitInstantiationDeclaration: | |
case TSK_ExplicitInstantiationDefinition: | |
case TSK_ExplicitSpecialization: | |
break; | |
} | |
} | |
} | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseTemplateInstantiations( | |
FunctionTemplateDecl *D) { | |
for (auto *FD : D->specializations()) { | |
for (auto *RD : FD->redecls()) { | |
switch (RD->getTemplateSpecializationKind()) { | |
case TSK_Undeclared: | |
case TSK_ImplicitInstantiation: | |
do { if (!getDerived().TraverseDecl(RD)) return false; } while (false); | |
break; | |
case TSK_ExplicitInstantiationDeclaration: | |
case TSK_ExplicitInstantiationDefinition: | |
do { if (!getDerived().TraverseDecl(RD)) return false; } while (false); | |
break; | |
case TSK_ExplicitSpecialization: | |
break; | |
} | |
} | |
} | |
return true; | |
} | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseClassTemplateDecl(ClassTemplateDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromClassTemplateDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseTemplateParameterListHelper(D->getTemplateParameters())) return false; } while (false); do { if (!getDerived().TraverseDecl(D->getTemplatedDecl())) return false; } while (false); if (getDerived().shouldVisitTemplateInstantiations() && D == D->getCanonicalDecl()) do { if (!getDerived().TraverseTemplateInstantiations(D)) return false; } while (false); }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromClassTemplateDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseVarTemplateDecl(VarTemplateDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromVarTemplateDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseTemplateParameterListHelper(D->getTemplateParameters())) return false; } while (false); do { if (!getDerived().TraverseDecl(D->getTemplatedDecl())) return false; } while (false); if (getDerived().shouldVisitTemplateInstantiations() && D == D->getCanonicalDecl()) do { if (!getDerived().TraverseTemplateInstantiations(D)) return false; } while (false); }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromVarTemplateDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseFunctionTemplateDecl(FunctionTemplateDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFunctionTemplateDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseTemplateParameterListHelper(D->getTemplateParameters())) return false; } while (false); do { if (!getDerived().TraverseDecl(D->getTemplatedDecl())) return false; } while (false); if (getDerived().shouldVisitTemplateInstantiations() && D == D->getCanonicalDecl()) do { if (!getDerived().TraverseTemplateInstantiations(D)) return false; } while (false); }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFunctionTemplateDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTemplateTemplateParmDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseDecl(D->getTemplatedDecl())) return false; } while (false); if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) do { if (!getDerived().TraverseTemplateArgumentLoc(D->getDefaultArgument())) return false; } while (false); do { if (!getDerived().TraverseTemplateParameterListHelper(D->getTemplateParameters())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTemplateTemplateParmDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseBuiltinTemplateDecl(BuiltinTemplateDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBuiltinTemplateDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseTemplateParameterListHelper(D->getTemplateParameters())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBuiltinTemplateDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseTemplateTypeParamDeclConstraints( | |
const TemplateTypeParmDecl *D) { | |
if (const auto *TC = D->getTypeConstraint()) { | |
if (Expr *IDC = TC->getImmediatelyDeclaredConstraint()) { | |
do { if (!getDerived().TraverseStmt(IDC)) return false; } while (false); | |
} else { | |
do { if (!getDerived().TraverseConceptReference(*TC)) return false; } while (false); | |
} | |
} | |
return true; | |
} | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTemplateTypeParmDecl(TemplateTypeParmDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTemplateTypeParmDecl(D)) return false; } while (false); { { if (D->getTypeForDecl()) do { if (!getDerived().TraverseType(QualType(D->getTypeForDecl(), 0))) return false; } while (false); do { if (!getDerived().TraverseTemplateTypeParamDeclConstraints(D)) return false; } while (false); if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) do { if (!getDerived().TraverseTypeLoc(D->getDefaultArgumentInfo()->getTypeLoc())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTemplateTypeParmDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTypedefDecl(TypedefDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypedefDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypedefDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTypeAliasDecl(TypeAliasDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypeAliasDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypeAliasDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypeAliasTemplateDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseDecl(D->getTemplatedDecl())) return false; } while (false); do { if (!getDerived().TraverseTemplateParameterListHelper(D->getTemplateParameters())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypeAliasTemplateDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseConceptDecl(ConceptDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromConceptDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseTemplateParameterListHelper(D->getTemplateParameters())) return false; } while (false); do { if (!getDerived().TraverseStmt(D->getConstraintExpr())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromConceptDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnresolvedUsingTypenameDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(D->getQualifierLoc())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnresolvedUsingTypenameDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUnresolvedUsingIfExistsDecl(UnresolvedUsingIfExistsDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnresolvedUsingIfExistsDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnresolvedUsingIfExistsDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseEnumDecl(EnumDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromEnumDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseDeclTemplateParameterLists(D)) return false; } while (false); if (D->getTypeForDecl()) do { if (!getDerived().TraverseType(QualType(D->getTypeForDecl(), 0))) return false; } while (false); do { if (!getDerived().TraverseNestedNameSpecifierLoc(D->getQualifierLoc())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromEnumDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseRecordHelper(RecordDecl *D) { | |
do { if (!getDerived().TraverseDeclTemplateParameterLists(D)) return false; } while (false); | |
do { if (!getDerived().TraverseNestedNameSpecifierLoc(D->getQualifierLoc())) return false; } while (false); | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCXXBaseSpecifier( | |
const CXXBaseSpecifier &Base) { | |
do { if (!getDerived().TraverseTypeLoc(Base.getTypeSourceInfo()->getTypeLoc())) return false; } while (false); | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseCXXRecordHelper(CXXRecordDecl *D) { | |
if (!TraverseRecordHelper(D)) | |
return false; | |
if (D->isCompleteDefinition()) { | |
for (const auto &I : D->bases()) { | |
do { if (!getDerived().TraverseCXXBaseSpecifier(I)) return false; } while (false); | |
} | |
} | |
return true; | |
} | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseRecordDecl(RecordDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromRecordDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseRecordHelper(D)) return false; } while (false); }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromRecordDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXRecordDecl(CXXRecordDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXRecordDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseCXXRecordHelper(D)) return false; } while (false); }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXRecordDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromClassTemplateSpecializationDecl(D)) return false; } while (false); { { if (TypeSourceInfo *TSI = D->getTypeAsWritten()) do { if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc())) return false; } while (false); do { if (!getDerived().TraverseNestedNameSpecifierLoc(D->getQualifierLoc())) return false; } while (false); if (!getDerived().shouldVisitTemplateInstantiations() && D->getTemplateSpecializationKind() != TSK_ExplicitSpecialization) return true; }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromClassTemplateSpecializationDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromVarTemplateSpecializationDecl(D)) return false; } while (false); { { if (TypeSourceInfo *TSI = D->getTypeAsWritten()) do { if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc())) return false; } while (false); do { if (!getDerived().TraverseNestedNameSpecifierLoc(D->getQualifierLoc())) return false; } while (false); if (!getDerived().shouldVisitTemplateInstantiations() && D->getTemplateSpecializationKind() != TSK_ExplicitSpecialization) return true; }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromVarTemplateSpecializationDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseTemplateArgumentLocsHelper( | |
const TemplateArgumentLoc *TAL, unsigned Count) { | |
for (unsigned I = 0; I < Count; ++I) { | |
do { if (!getDerived().TraverseTemplateArgumentLoc(TAL[I])) return false; } while (false); | |
} | |
return true; | |
} | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseClassTemplatePartialSpecializationDecl(ClassTemplatePartialSpecializationDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromClassTemplatePartialSpecializationDecl(D)) return false; } while (false); { { if (TemplateParameterList *TPL = D->getTemplateParameters()) { for (TemplateParameterList::iterator I = TPL->begin(), E = TPL->end(); I != E; ++I) { do { if (!getDerived().TraverseDecl(*I)) return false; } while (false); } } do { if (!getDerived().TraverseTemplateArgumentLocsHelper( D->getTemplateArgsAsWritten()->getTemplateArgs(), D->getTemplateArgsAsWritten()->NumTemplateArgs)) return false; } while (false); do { if (!getDerived().TraverseCXXRecordHelper(D)) return false; } while (false); }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromClassTemplatePartialSpecializationDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseVarTemplatePartialSpecializationDecl(VarTemplatePartialSpecializationDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromVarTemplatePartialSpecializationDecl(D)) return false; } while (false); { { if (TemplateParameterList *TPL = D->getTemplateParameters()) { for (TemplateParameterList::iterator I = TPL->begin(), E = TPL->end(); I != E; ++I) { do { if (!getDerived().TraverseDecl(*I)) return false; } while (false); } } do { if (!getDerived().TraverseTemplateArgumentLocsHelper( D->getTemplateArgsAsWritten()->getTemplateArgs(), D->getTemplateArgsAsWritten()->NumTemplateArgs)) return false; } while (false); do { if (!getDerived().TraverseVarHelper(D)) return false; } while (false); }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromVarTemplatePartialSpecializationDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseEnumConstantDecl(EnumConstantDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromEnumConstantDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseStmt(D->getInitExpr())) return false; } while (false); }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromEnumConstantDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnresolvedUsingValueDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(D->getQualifierLoc())) return false; } while (false); do { if (!getDerived().TraverseDeclarationNameInfo(D->getNameInfo())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnresolvedUsingValueDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseIndirectFieldDecl(IndirectFieldDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromIndirectFieldDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromIndirectFieldDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseDeclaratorHelper(DeclaratorDecl *D) { | |
do { if (!getDerived().TraverseDeclTemplateParameterLists(D)) return false; } while (false); | |
do { if (!getDerived().TraverseNestedNameSpecifierLoc(D->getQualifierLoc())) return false; } while (false); | |
if (D->getTypeSourceInfo()) | |
do { if (!getDerived().TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc())) return false; } while (false); | |
else | |
do { if (!getDerived().TraverseType(D->getType())) return false; } while (false); | |
return true; | |
} | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDecompositionDecl(DecompositionDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDecompositionDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseVarHelper(D)) return false; } while (false); for (auto *Binding : D->bindings()) { do { if (!getDerived().TraverseDecl(Binding)) return false; } while (false); }}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDecompositionDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseBindingDecl(BindingDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBindingDecl(D)) return false; } while (false); { { if (getDerived().shouldVisitImplicitCode()) do { if (!getDerived().TraverseStmt(D->getBinding())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBindingDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseMSPropertyDecl(MSPropertyDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMSPropertyDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseDeclaratorHelper(D)) return false; } while (false); }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMSPropertyDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseMSGuidDecl(MSGuidDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMSGuidDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMSGuidDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTemplateParamObjectDecl(TemplateParamObjectDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTemplateParamObjectDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTemplateParamObjectDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseFieldDecl(FieldDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFieldDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseDeclaratorHelper(D)) return false; } while (false); if (D->isBitField()) do { if (!getDerived().TraverseStmt(D->getBitWidth())) return false; } while (false); else if (D->hasInClassInitializer()) do { if (!getDerived().TraverseStmt(D->getInClassInitializer())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFieldDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCAtDefsFieldDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseDeclaratorHelper(D)) return false; } while (false); if (D->isBitField()) do { if (!getDerived().TraverseStmt(D->getBitWidth())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCAtDefsFieldDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCIvarDecl(ObjCIvarDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCIvarDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseDeclaratorHelper(D)) return false; } while (false); if (D->isBitField()) do { if (!getDerived().TraverseStmt(D->getBitWidth())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCIvarDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseFunctionHelper(FunctionDecl *D) { | |
do { if (!getDerived().TraverseDeclTemplateParameterLists(D)) return false; } while (false); | |
do { if (!getDerived().TraverseNestedNameSpecifierLoc(D->getQualifierLoc())) return false; } while (false); | |
do { if (!getDerived().TraverseDeclarationNameInfo(D->getNameInfo())) return false; } while (false); | |
if (const FunctionTemplateSpecializationInfo *FTSI = | |
D->getTemplateSpecializationInfo()) { | |
if (FTSI->getTemplateSpecializationKind() != TSK_Undeclared && | |
FTSI->getTemplateSpecializationKind() != TSK_ImplicitInstantiation) { | |
if (const ASTTemplateArgumentListInfo *TALI = | |
FTSI->TemplateArgumentsAsWritten) { | |
do { if (!getDerived().TraverseTemplateArgumentLocsHelper(TALI->getTemplateArgs(), TALI->NumTemplateArgs)) return false; } while (false); | |
} | |
} | |
} | |
if (TypeSourceInfo *TSI = D->getTypeSourceInfo()) { | |
do { if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc())) return false; } while (false); | |
} else if (getDerived().shouldVisitImplicitCode()) { | |
for (ParmVarDecl *Parameter : D->parameters()) { | |
do { if (!getDerived().TraverseDecl(Parameter)) return false; } while (false); | |
} | |
} | |
if (Expr *TrailingRequiresClause = D->getTrailingRequiresClause()) { | |
do { if (!getDerived().TraverseStmt(TrailingRequiresClause)) return false; } while (false); | |
} | |
if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(D)) { | |
for (auto *I : Ctor->inits()) { | |
if (I->isWritten() || getDerived().shouldVisitImplicitCode()) | |
do { if (!getDerived().TraverseConstructorInitializer(I)) return false; } while (false); | |
} | |
} | |
bool VisitBody = | |
D->isThisDeclarationADefinition() && | |
(!D->isDefaulted() || getDerived().shouldVisitImplicitCode()); | |
if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) { | |
if (const CXXRecordDecl *RD = MD->getParent()) { | |
if (RD->isLambda() && | |
declaresSameEntity(RD->getLambdaCallOperator(), MD)) { | |
VisitBody = VisitBody && getDerived().shouldVisitLambdaBody(); | |
} | |
} | |
} | |
if (VisitBody) { | |
do { if (!getDerived().TraverseStmt(D->getBody())) return false; } while (false); | |
} | |
return true; | |
} | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseFunctionDecl(FunctionDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFunctionDecl(D)) return false; } while (false); { { ShouldVisitChildren = false; ReturnValue = TraverseFunctionHelper(D);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFunctionDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXDeductionGuideDecl(D)) return false; } while (false); { { ShouldVisitChildren = false; ReturnValue = TraverseFunctionHelper(D);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXDeductionGuideDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXMethodDecl(CXXMethodDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXMethodDecl(D)) return false; } while (false); { { ShouldVisitChildren = false; ReturnValue = TraverseFunctionHelper(D);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXMethodDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXConstructorDecl(CXXConstructorDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXConstructorDecl(D)) return false; } while (false); { { ShouldVisitChildren = false; ReturnValue = TraverseFunctionHelper(D);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXConstructorDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXConversionDecl(CXXConversionDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXConversionDecl(D)) return false; } while (false); { { ShouldVisitChildren = false; ReturnValue = TraverseFunctionHelper(D);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXConversionDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXDestructorDecl(CXXDestructorDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXDestructorDecl(D)) return false; } while (false); { { ShouldVisitChildren = false; ReturnValue = TraverseFunctionHelper(D);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXDestructorDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseVarHelper(VarDecl *D) { | |
do { if (!getDerived().TraverseDeclaratorHelper(D)) return false; } while (false); | |
if (!isa<ParmVarDecl>(D) && | |
(!D->isCXXForRangeDecl() || getDerived().shouldVisitImplicitCode())) | |
do { if (!getDerived().TraverseStmt(D->getInit())) return false; } while (false); | |
return true; | |
} | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseVarDecl(VarDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromVarDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseVarHelper(D)) return false; } while (false); }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromVarDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseImplicitParamDecl(ImplicitParamDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromImplicitParamDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseVarHelper(D)) return false; } while (false); }; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromImplicitParamDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromNonTypeTemplateParmDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseDeclaratorHelper(D)) return false; } while (false); if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) do { if (!getDerived().TraverseStmt(D->getDefaultArgument())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromNonTypeTemplateParmDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseParmVarDecl(ParmVarDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromParmVarDecl(D)) return false; } while (false); { { do { if (!getDerived().TraverseVarHelper(D)) return false; } while (false); if (D->hasDefaultArg() && D->hasUninstantiatedDefaultArg() && !D->hasUnparsedDefaultArg()) do { if (!getDerived().TraverseStmt(D->getUninstantiatedDefaultArg())) return false; } while (false); if (D->hasDefaultArg() && !D->hasUninstantiatedDefaultArg() && !D->hasUnparsedDefaultArg()) do { if (!getDerived().TraverseStmt(D->getDefaultArg())) return false; } while (false);}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromParmVarDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseRequiresExprBodyDecl(RequiresExprBodyDecl *D) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromRequiresExprBodyDecl(D)) return false; } while (false); { {}; } if (ReturnValue && ShouldVisitChildren) do { if (!getDerived().TraverseDeclContextHelper(dyn_cast<DeclContext>(D))) return false; } while (false); if (ReturnValue) { for (auto *I : D->attrs()) do { if (!getDerived().getDerived().TraverseAttr(I)) return false; } while (false); } if (ReturnValue && getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromRequiresExprBodyDecl(D)) return false; } while (false); return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseGCCAsmStmt( GCCAsmStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromGCCAsmStmt(S)) return false; } while (false); { { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getAsmString()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getAsmString())))) return false; } while (false); for (unsigned I = 0, E = S->getNumInputs(); I < E; ++I) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getInputConstraintLiteral(I)), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getInputConstraintLiteral(I))))) return false; } while (false); } for (unsigned I = 0, E = S->getNumOutputs(); I < E; ++I) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getOutputConstraintLiteral(I)), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getOutputConstraintLiteral(I))))) return false; } while (false); } for (unsigned I = 0, E = S->getNumClobbers(); I < E; ++I) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getClobberStringLiteral(I)), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getClobberStringLiteral(I))))) return false; } while (false); }}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromGCCAsmStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseMSAsmStmt( MSAsmStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMSAsmStmt(S)) return false; } while (false); { { }; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromMSAsmStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXCatchStmt( CXXCatchStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXCatchStmt(S)) return false; } while (false); { { do { if (!getDerived().TraverseDecl(S->getExceptionDecl())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXCatchStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDeclStmt( DeclStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDeclStmt(S)) return false; } while (false); { { for (auto *I : S->decls()) { do { if (!getDerived().TraverseDecl(I)) return false; } while (false); } ShouldVisitChildren = false;}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDeclStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseBreakStmt( BreakStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBreakStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromBreakStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXTryStmt( CXXTryStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXTryStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXTryStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCaseStmt( CaseStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCaseStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCaseStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCompoundStmt( CompoundStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCompoundStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCompoundStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseContinueStmt( ContinueStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromContinueStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromContinueStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDefaultStmt( DefaultStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDefaultStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDefaultStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDoStmt( DoStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDoStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDoStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseForStmt( ForStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromForStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromForStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseGotoStmt( GotoStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromGotoStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromGotoStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseIfStmt( IfStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromIfStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromIfStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseIndirectGotoStmt( IndirectGotoStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromIndirectGotoStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromIndirectGotoStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseLabelStmt( LabelStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromLabelStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromLabelStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseAttributedStmt( AttributedStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromAttributedStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromAttributedStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseNullStmt( NullStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromNullStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromNullStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCAtCatchStmt( ObjCAtCatchStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCAtCatchStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCAtCatchStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCAtFinallyStmt( ObjCAtFinallyStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCAtFinallyStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCAtFinallyStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCAtSynchronizedStmt( ObjCAtSynchronizedStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCAtSynchronizedStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCAtSynchronizedStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCAtThrowStmt( ObjCAtThrowStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCAtThrowStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCAtThrowStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCAtTryStmt( ObjCAtTryStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCAtTryStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCAtTryStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCForCollectionStmt( ObjCForCollectionStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCForCollectionStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCForCollectionStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCAutoreleasePoolStmt( ObjCAutoreleasePoolStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCAutoreleasePoolStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCAutoreleasePoolStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXForRangeStmt( CXXForRangeStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXForRangeStmt(S)) return false; } while (false); { { if (!getDerived().shouldVisitImplicitCode()) { if (S->getInit()) do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getInit()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getInit())))) return false; } while (false); do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getLoopVarStmt()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getLoopVarStmt())))) return false; } while (false); do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getRangeInit()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getRangeInit())))) return false; } while (false); do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getBody()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getBody())))) return false; } while (false); ShouldVisitChildren = false; }}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXForRangeStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseMSDependentExistsStmt( MSDependentExistsStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMSDependentExistsStmt(S)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(S->getQualifierLoc())) return false; } while (false); do { if (!getDerived().TraverseDeclarationNameInfo(S->getNameInfo())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromMSDependentExistsStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseReturnStmt( ReturnStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromReturnStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromReturnStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSwitchStmt( SwitchStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSwitchStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSwitchStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseWhileStmt( WhileStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromWhileStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromWhileStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseConstantExpr( ConstantExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromConstantExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromConstantExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXDependentScopeMemberExpr( CXXDependentScopeMemberExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXDependentScopeMemberExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(S->getQualifierLoc())) return false; } while (false); do { if (!getDerived().TraverseDeclarationNameInfo(S->getMemberNameInfo())) return false; } while (false); if (S->hasExplicitTemplateArgs()) { do { if (!getDerived().TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(), S->getNumTemplateArgs())) return false; } while (false); }}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXDependentScopeMemberExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDeclRefExpr( DeclRefExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDeclRefExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(S->getQualifierLoc())) return false; } while (false); do { if (!getDerived().TraverseDeclarationNameInfo(S->getNameInfo())) return false; } while (false); do { if (!getDerived().TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(), S->getNumTemplateArgs())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDeclRefExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDependentScopeDeclRefExpr( DependentScopeDeclRefExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDependentScopeDeclRefExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(S->getQualifierLoc())) return false; } while (false); do { if (!getDerived().TraverseDeclarationNameInfo(S->getNameInfo())) return false; } while (false); if (S->hasExplicitTemplateArgs()) { do { if (!getDerived().TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(), S->getNumTemplateArgs())) return false; } while (false); }}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDependentScopeDeclRefExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseMemberExpr( MemberExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMemberExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(S->getQualifierLoc())) return false; } while (false); do { if (!getDerived().TraverseDeclarationNameInfo(S->getMemberNameInfo())) return false; } while (false); do { if (!getDerived().TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(), S->getNumTemplateArgs())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromMemberExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseImplicitCastExpr( ImplicitCastExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromImplicitCastExpr(S)) return false; } while (false); { { }; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromImplicitCastExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCStyleCastExpr( CStyleCastExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCStyleCastExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCStyleCastExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXFunctionalCastExpr( CXXFunctionalCastExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXFunctionalCastExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXFunctionalCastExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXAddrspaceCastExpr( CXXAddrspaceCastExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXAddrspaceCastExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXAddrspaceCastExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXConstCastExpr( CXXConstCastExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXConstCastExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXConstCastExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXDynamicCastExpr( CXXDynamicCastExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXDynamicCastExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXDynamicCastExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXReinterpretCastExpr( CXXReinterpretCastExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXReinterpretCastExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXReinterpretCastExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXStaticCastExpr( CXXStaticCastExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXStaticCastExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXStaticCastExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseBuiltinBitCastExpr( BuiltinBitCastExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBuiltinBitCastExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromBuiltinBitCastExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseSynOrSemInitListExpr( | |
InitListExpr *S, DataRecursionQueue *Queue) { | |
if (S) { | |
if (!getDerived().shouldTraversePostOrder()) | |
do { if (!getDerived().WalkUpFromInitListExpr(S)) return false; } while (false); | |
for (Stmt *SubStmt : S->children()) { | |
do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); | |
} | |
if (!Queue && getDerived().shouldTraversePostOrder()) | |
do { if (!getDerived().WalkUpFromInitListExpr(S)) return false; } while (false); | |
} | |
return true; | |
} | |
template<typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseConceptReference( | |
const ConceptReference &C) { | |
do { if (!getDerived().TraverseNestedNameSpecifierLoc(C.getNestedNameSpecifierLoc())) return false; } while (false); | |
do { if (!getDerived().TraverseDeclarationNameInfo(C.getConceptNameInfo())) return false; } while (false); | |
if (C.hasExplicitTemplateArgs()) | |
do { if (!getDerived().TraverseTemplateArgumentLocsHelper( C.getTemplateArgsAsWritten()->getTemplateArgs(), C.getTemplateArgsAsWritten()->NumTemplateArgs)) return false; } while (false); | |
return true; | |
} | |
template <typename Derived> | |
bool RecursiveASTVisitor<Derived>::TraverseInitListExpr( | |
InitListExpr *S, DataRecursionQueue *Queue) { | |
if (S->isSemanticForm() && S->isSyntacticForm()) { | |
do { if (!getDerived().TraverseSynOrSemInitListExpr(S, Queue)) return false; } while (false); | |
return true; | |
} | |
do { if (!getDerived().TraverseSynOrSemInitListExpr( S->isSemanticForm() ? S->getSyntacticForm() : S, Queue)) return false; } while (false); | |
if (getDerived().shouldVisitImplicitCode()) { | |
do { if (!getDerived().TraverseSynOrSemInitListExpr( S->isSemanticForm() ? S : S->getSemanticForm(), Queue)) return false; } while (false); | |
} | |
return true; | |
} | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseGenericSelectionExpr( GenericSelectionExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromGenericSelectionExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseStmt(S->getControllingExpr())) return false; } while (false); for (const GenericSelectionExpr::Association Assoc : S->associations()) { if (TypeSourceInfo *TSI = Assoc.getTypeSourceInfo()) do { if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc())) return false; } while (false); do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(Assoc.getAssociationExpr()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(Assoc.getAssociationExpr())))) return false; } while (false); } ShouldVisitChildren = false;}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromGenericSelectionExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraversePseudoObjectExpr( PseudoObjectExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromPseudoObjectExpr(S)) return false; } while (false); { { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getSyntacticForm()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getSyntacticForm())))) return false; } while (false); for (PseudoObjectExpr::semantics_iterator i = S->semantics_begin(), e = S->semantics_end(); i != e; ++i) { Expr *sub = *i; if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(sub)) sub = OVE->getSourceExpr(); do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(sub), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(sub)))) return false; } while (false); } ShouldVisitChildren = false;}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromPseudoObjectExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXScalarValueInitExpr( CXXScalarValueInitExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXScalarValueInitExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXScalarValueInitExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXNewExpr( CXXNewExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXNewExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getAllocatedTypeSourceInfo()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXNewExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseOffsetOfExpr( OffsetOfExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOffsetOfExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromOffsetOfExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUnaryExprOrTypeTraitExpr( UnaryExprOrTypeTraitExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnaryExprOrTypeTraitExpr(S)) return false; } while (false); { { if (S->isArgumentType()) do { if (!getDerived().TraverseTypeLoc(S->getArgumentTypeInfo()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromUnaryExprOrTypeTraitExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXTypeidExpr( CXXTypeidExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXTypeidExpr(S)) return false; } while (false); { { if (S->isTypeOperand()) do { if (!getDerived().TraverseTypeLoc(S->getTypeOperandSourceInfo()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXTypeidExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseMSPropertyRefExpr( MSPropertyRefExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMSPropertyRefExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(S->getQualifierLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromMSPropertyRefExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseMSPropertySubscriptExpr( MSPropertySubscriptExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMSPropertySubscriptExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromMSPropertySubscriptExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXUuidofExpr( CXXUuidofExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXUuidofExpr(S)) return false; } while (false); { { if (S->isTypeOperand()) do { if (!getDerived().TraverseTypeLoc(S->getTypeOperandSourceInfo()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXUuidofExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTypeTraitExpr( TypeTraitExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypeTraitExpr(S)) return false; } while (false); { { for (unsigned I = 0, N = S->getNumArgs(); I != N; ++I) do { if (!getDerived().TraverseTypeLoc(S->getArg(I)->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromTypeTraitExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseArrayTypeTraitExpr( ArrayTypeTraitExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromArrayTypeTraitExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getQueriedTypeSourceInfo()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromArrayTypeTraitExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseExpressionTraitExpr( ExpressionTraitExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromExpressionTraitExpr(S)) return false; } while (false); { { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getQueriedExpression()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getQueriedExpression())))) return false; } while (false); }; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromExpressionTraitExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseVAArgExpr( VAArgExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromVAArgExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getWrittenTypeInfo()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromVAArgExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXTemporaryObjectExpr( CXXTemporaryObjectExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXTemporaryObjectExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXTemporaryObjectExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseLambdaExpr( LambdaExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromLambdaExpr(S)) return false; } while (false); { { for (unsigned I = 0, N = S->capture_size(); I != N; ++I) { const LambdaCapture *C = S->capture_begin() + I; if (C->isExplicit() || getDerived().shouldVisitImplicitCode()) { do { if (!getDerived().TraverseLambdaCapture(S, C, S->capture_init_begin()[I])) return false; } while (false); } } if (getDerived().shouldVisitImplicitCode()) { do { if (!getDerived().TraverseDecl(S->getLambdaClass())) return false; } while (false); } else { TypeLoc TL = S->getCallOperator()->getTypeSourceInfo()->getTypeLoc(); FunctionProtoTypeLoc Proto = TL.getAsAdjusted<FunctionProtoTypeLoc>(); do { if (!getDerived().TraverseTemplateParameterListHelper(S->getTemplateParameterList())) return false; } while (false); if (S->hasExplicitParameters()) { for (unsigned I = 0, N = Proto.getNumParams(); I != N; ++I) do { if (!getDerived().TraverseDecl(Proto.getParam(I))) return false; } while (false); } auto *T = Proto.getTypePtr(); for (const auto &E : T->exceptions()) do { if (!getDerived().TraverseType(E)) return false; } while (false); if (Expr *NE = T->getNoexceptExpr()) do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(NE), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(NE)))) return false; } while (false); if (S->hasExplicitResultType()) do { if (!getDerived().TraverseTypeLoc(Proto.getReturnLoc())) return false; } while (false); do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getTrailingRequiresClause()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getTrailingRequiresClause())))) return false; } while (false); do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getBody()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getBody())))) return false; } while (false); } ShouldVisitChildren = false;}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromLambdaExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXUnresolvedConstructExpr( CXXUnresolvedConstructExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXUnresolvedConstructExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXUnresolvedConstructExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXConstructExpr( CXXConstructExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXConstructExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXConstructExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCallExpr( CallExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCallExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCallExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXMemberCallExpr( CXXMemberCallExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXMemberCallExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXMemberCallExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseAddrLabelExpr( AddrLabelExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromAddrLabelExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromAddrLabelExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseArraySubscriptExpr( ArraySubscriptExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromArraySubscriptExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromArraySubscriptExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseMatrixSubscriptExpr( MatrixSubscriptExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMatrixSubscriptExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromMatrixSubscriptExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseOMPArraySectionExpr( OMPArraySectionExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPArraySectionExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromOMPArraySectionExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseOMPArrayShapingExpr( OMPArrayShapingExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPArrayShapingExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromOMPArrayShapingExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseOMPIteratorExpr( OMPIteratorExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOMPIteratorExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromOMPIteratorExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseBlockExpr( BlockExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBlockExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseDecl(S->getBlockDecl())) return false; } while (false); return true;}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromBlockExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseChooseExpr( ChooseExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromChooseExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromChooseExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCompoundLiteralExpr( CompoundLiteralExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCompoundLiteralExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCompoundLiteralExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXBindTemporaryExpr( CXXBindTemporaryExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXBindTemporaryExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXBindTemporaryExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXBoolLiteralExpr( CXXBoolLiteralExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXBoolLiteralExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXBoolLiteralExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXDefaultArgExpr( CXXDefaultArgExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXDefaultArgExpr(S)) return false; } while (false); { { if (getDerived().shouldVisitImplicitCode()) do { if (!getDerived().TraverseStmt(S->getExpr())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXDefaultArgExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXDefaultInitExpr( CXXDefaultInitExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXDefaultInitExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXDefaultInitExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXDeleteExpr( CXXDeleteExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXDeleteExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXDeleteExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseExprWithCleanups( ExprWithCleanups *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromExprWithCleanups(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromExprWithCleanups(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXInheritedCtorInitExpr( CXXInheritedCtorInitExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXInheritedCtorInitExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXInheritedCtorInitExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXNullPtrLiteralExpr( CXXNullPtrLiteralExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXNullPtrLiteralExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXNullPtrLiteralExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXStdInitializerListExpr( CXXStdInitializerListExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXStdInitializerListExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXStdInitializerListExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXPseudoDestructorExpr( CXXPseudoDestructorExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXPseudoDestructorExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(S->getQualifierLoc())) return false; } while (false); if (TypeSourceInfo *ScopeInfo = S->getScopeTypeInfo()) do { if (!getDerived().TraverseTypeLoc(ScopeInfo->getTypeLoc())) return false; } while (false); if (TypeSourceInfo *DestroyedTypeInfo = S->getDestroyedTypeInfo()) do { if (!getDerived().TraverseTypeLoc(DestroyedTypeInfo->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXPseudoDestructorExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXThisExpr( CXXThisExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXThisExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXThisExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXThrowExpr( CXXThrowExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXThrowExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXThrowExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUserDefinedLiteral( UserDefinedLiteral *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUserDefinedLiteral(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromUserDefinedLiteral(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDesignatedInitExpr( DesignatedInitExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDesignatedInitExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDesignatedInitExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseDesignatedInitUpdateExpr( DesignatedInitUpdateExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromDesignatedInitUpdateExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromDesignatedInitUpdateExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseExtVectorElementExpr( ExtVectorElementExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromExtVectorElementExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromExtVectorElementExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseGNUNullExpr( GNUNullExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromGNUNullExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromGNUNullExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseImplicitValueInitExpr( ImplicitValueInitExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromImplicitValueInitExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromImplicitValueInitExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseNoInitExpr( NoInitExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromNoInitExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromNoInitExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseArrayInitLoopExpr( ArrayInitLoopExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromArrayInitLoopExpr(S)) return false; } while (false); { { if (OpaqueValueExpr *OVE = S->getCommonExpr()) do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(OVE->getSourceExpr()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(OVE->getSourceExpr())))) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromArrayInitLoopExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseArrayInitIndexExpr( ArrayInitIndexExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromArrayInitIndexExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromArrayInitIndexExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCBoolLiteralExpr( ObjCBoolLiteralExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCBoolLiteralExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCBoolLiteralExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCEncodeExpr( ObjCEncodeExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCEncodeExpr(S)) return false; } while (false); { { if (TypeSourceInfo *TInfo = S->getEncodedTypeSourceInfo()) do { if (!getDerived().TraverseTypeLoc(TInfo->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCEncodeExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCIsaExpr( ObjCIsaExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCIsaExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCIsaExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCIvarRefExpr( ObjCIvarRefExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCIvarRefExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCIvarRefExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCMessageExpr( ObjCMessageExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCMessageExpr(S)) return false; } while (false); { { if (TypeSourceInfo *TInfo = S->getClassReceiverTypeInfo()) do { if (!getDerived().TraverseTypeLoc(TInfo->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCMessageExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCPropertyRefExpr( ObjCPropertyRefExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCPropertyRefExpr(S)) return false; } while (false); { { if (S->isClassReceiver()) { ObjCInterfaceDecl *IDecl = S->getClassReceiver(); QualType Type = IDecl->getASTContext().getObjCInterfaceType(IDecl); ObjCInterfaceLocInfo Data; Data.NameLoc = S->getReceiverLocation(); Data.NameEndLoc = Data.NameLoc; do { if (!getDerived().TraverseTypeLoc(TypeLoc(Type, &Data))) return false; } while (false); }}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCPropertyRefExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCSubscriptRefExpr( ObjCSubscriptRefExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCSubscriptRefExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCSubscriptRefExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCProtocolExpr( ObjCProtocolExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCProtocolExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCProtocolExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCSelectorExpr( ObjCSelectorExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCSelectorExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCSelectorExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCIndirectCopyRestoreExpr( ObjCIndirectCopyRestoreExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCIndirectCopyRestoreExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCIndirectCopyRestoreExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCBridgedCastExpr( ObjCBridgedCastExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCBridgedCastExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCBridgedCastExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseObjCAvailabilityCheckExpr( ObjCAvailabilityCheckExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromObjCAvailabilityCheckExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromObjCAvailabilityCheckExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseParenExpr( ParenExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromParenExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromParenExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseParenListExpr( ParenListExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromParenListExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromParenListExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSYCLUniqueStableNameExpr( SYCLUniqueStableNameExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSYCLUniqueStableNameExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc())) return false; } while (false);}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSYCLUniqueStableNameExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraversePredefinedExpr( PredefinedExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromPredefinedExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromPredefinedExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseShuffleVectorExpr( ShuffleVectorExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromShuffleVectorExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromShuffleVectorExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseConvertVectorExpr( ConvertVectorExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromConvertVectorExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromConvertVectorExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseStmtExpr( StmtExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromStmtExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromStmtExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSourceLocExpr( SourceLocExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSourceLocExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSourceLocExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUnresolvedLookupExpr( UnresolvedLookupExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnresolvedLookupExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(S->getQualifierLoc())) return false; } while (false); if (S->hasExplicitTemplateArgs()) { do { if (!getDerived().TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(), S->getNumTemplateArgs())) return false; } while (false); }}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromUnresolvedLookupExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUnresolvedMemberExpr( UnresolvedMemberExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnresolvedMemberExpr(S)) return false; } while (false); { { do { if (!getDerived().TraverseNestedNameSpecifierLoc(S->getQualifierLoc())) return false; } while (false); if (S->hasExplicitTemplateArgs()) { do { if (!getDerived().TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(), S->getNumTemplateArgs())) return false; } while (false); }}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromUnresolvedMemberExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSEHTryStmt( SEHTryStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSEHTryStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSEHTryStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSEHExceptStmt( SEHExceptStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSEHExceptStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSEHExceptStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSEHFinallyStmt( SEHFinallyStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSEHFinallyStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSEHFinallyStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSEHLeaveStmt( SEHLeaveStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSEHLeaveStmt(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSEHLeaveStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCapturedStmt( CapturedStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCapturedStmt(S)) return false; } while (false); { { do { if (!getDerived().TraverseDecl(S->getCapturedDecl())) return false; } while (false); }; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCapturedStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXOperatorCallExpr( CXXOperatorCallExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXOperatorCallExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXOperatorCallExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXRewrittenBinaryOperator( CXXRewrittenBinaryOperator *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXRewrittenBinaryOperator(S)) return false; } while (false); { { if (!getDerived().shouldVisitImplicitCode()) { CXXRewrittenBinaryOperator::DecomposedForm Decomposed = S->getDecomposedForm(); do { if (!getDerived().TraverseStmt(const_cast<Expr*>(Decomposed.LHS))) return false; } while (false); do { if (!getDerived().TraverseStmt(const_cast<Expr*>(Decomposed.RHS))) return false; } while (false); ShouldVisitChildren = false; }}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXRewrittenBinaryOperator(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseOpaqueValueExpr( OpaqueValueExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromOpaqueValueExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromOpaqueValueExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTypoExpr( TypoExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromTypoExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromTypoExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseRecoveryExpr( RecoveryExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromRecoveryExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromRecoveryExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCUDAKernelCallExpr( CUDAKernelCallExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCUDAKernelCallExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCUDAKernelCallExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseBinaryConditionalOperator( BinaryConditionalOperator *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBinaryConditionalOperator(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromBinaryConditionalOperator(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseConditionalOperator( ConditionalOperator *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromConditionalOperator(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromConditionalOperator(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseUnaryOperator( UnaryOperator *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromUnaryOperator(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromUnaryOperator(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseBinaryOperator( BinaryOperator *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromBinaryOperator(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromBinaryOperator(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCompoundAssignOperator( CompoundAssignOperator *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCompoundAssignOperator(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCompoundAssignOperator(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXNoexceptExpr( CXXNoexceptExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXNoexceptExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXNoexceptExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraversePackExpansionExpr( PackExpansionExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromPackExpansionExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromPackExpansionExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSizeOfPackExpr( SizeOfPackExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSizeOfPackExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSizeOfPackExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSubstNonTypeTemplateParmPackExpr( SubstNonTypeTemplateParmPackExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSubstNonTypeTemplateParmPackExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSubstNonTypeTemplateParmPackExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseSubstNonTypeTemplateParmExpr( SubstNonTypeTemplateParmExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromSubstNonTypeTemplateParmExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromSubstNonTypeTemplateParmExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseFunctionParmPackExpr( FunctionParmPackExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromFunctionParmPackExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromFunctionParmPackExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCXXFoldExpr( CXXFoldExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCXXFoldExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCXXFoldExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseAtomicExpr( AtomicExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromAtomicExpr(S)) return false; } while (false); { {}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromAtomicExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseMaterializeTemporaryExpr( MaterializeTemporaryExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromMaterializeTemporaryExpr(S)) return false; } while (false); { { if (S->getLifetimeExtendedTemporaryDecl()) { do { if (!getDerived().TraverseLifetimeExtendedTemporaryDecl( S->getLifetimeExtendedTemporaryDecl())) return false; } while (false); ShouldVisitChildren = false; }}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromMaterializeTemporaryExpr(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCoroutineBodyStmt( CoroutineBodyStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCoroutineBodyStmt(S)) return false; } while (false); { { if (!getDerived().shouldVisitImplicitCode()) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getBody()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getBody())))) return false; } while (false); ShouldVisitChildren = false; }}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCoroutineBodyStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCoreturnStmt( CoreturnStmt *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCoreturnStmt(S)) return false; } while (false); { { if (!getDerived().shouldVisitImplicitCode()) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getOperand()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getOperand())))) return false; } while (false); ShouldVisitChildren = false; }}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCoreturnStmt(S)) return false; } while (false); } return ReturnValue; } | |
template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseCoawaitExpr( CoawaitExpr *S, DataRecursionQueue *Queue) { bool ShouldVisitChildren = true; bool ReturnValue = true; if (!getDerived().shouldTraversePostOrder()) do { if (!getDerived().WalkUpFromCoawaitExpr(S)) return false; } while (false); { { if (!getDerived().shouldVisitImplicitCode()) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(S->getOperand()), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(S->getOperand())))) return false; } while (false); ShouldVisitChildren = false; }}; } if (ShouldVisitChildren) { for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { do { if (!(::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value ? static_cast<std::conditional_t< ::clang::detail::has_same_member_pointer_type< decltype(&RecursiveASTVisitor::TraverseStmt), decltype(&Derived::TraverseStmt)>::value, Derived &, RecursiveASTVisitor &>>(*this) .TraverseStmt(static_cast<Stmt *>(SubStmt), Queue) : getDerived().TraverseStmt(static_cast<Stmt *>(SubStmt)))) return false; } while (false); } } if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { do { if (!getDerived().WalkUpFromCoawaitExpr(S)) return false; } while (false); } return ReturnValue; } |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment