kitty/clang-r547379
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
6024e5c395b1f86aa76def3fcf0193f49312fe30
clang-r547379/include/clang/AST/AttrVisitor.inc
Ryan Prichard 6024e5c395 Update prebuilt Clang to r547379 (20.0.0). 
clang 20.0.0 (based on r547379) from build 12806354.

Bug: http://b/379133546
Test: N/A
Change-Id: I2eb8938af55d809de674be63cb30cf27e801862b

Upstream-Commit: ad834e67b1105d15ef907f6255d4c96e8e733f57
2025-11-26 14:59:46 -05:00

6549 lines
207 KiB
C++
Raw Blame History

/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|* *|
|* Used by RecursiveASTVisitor to visit attributes. *|
|* *|
|* Automatically generated file, do not edit! *|
|* From: Attr.td *|
|* *|
\*===----------------------------------------------------------------------===*/
#ifdef ATTR_VISITOR_DECLS_ONLY
bool TraverseAArch64SVEPcsAttr(AArch64SVEPcsAttr *A);
bool VisitAArch64SVEPcsAttr(AArch64SVEPcsAttr *A) {
return true;
}
bool TraverseAArch64VectorPcsAttr(AArch64VectorPcsAttr *A);
bool VisitAArch64VectorPcsAttr(AArch64VectorPcsAttr *A) {
return true;
}
bool TraverseAMDGPUFlatWorkGroupSizeAttr(AMDGPUFlatWorkGroupSizeAttr *A);
bool VisitAMDGPUFlatWorkGroupSizeAttr(AMDGPUFlatWorkGroupSizeAttr *A) {
return true;
}
bool TraverseAMDGPUKernelCallAttr(AMDGPUKernelCallAttr *A);
bool VisitAMDGPUKernelCallAttr(AMDGPUKernelCallAttr *A) {
return true;
}
bool TraverseAMDGPUMaxNumWorkGroupsAttr(AMDGPUMaxNumWorkGroupsAttr *A);
bool VisitAMDGPUMaxNumWorkGroupsAttr(AMDGPUMaxNumWorkGroupsAttr *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 TraverseAllocatingAttr(AllocatingAttr *A);
bool VisitAllocatingAttr(AllocatingAttr *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 TraverseAnnotateTypeAttr(AnnotateTypeAttr *A);
bool VisitAnnotateTypeAttr(AnnotateTypeAttr *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 TraverseArmInAttr(ArmInAttr *A);
bool VisitArmInAttr(ArmInAttr *A) {
return true;
}
bool TraverseArmInOutAttr(ArmInOutAttr *A);
bool VisitArmInOutAttr(ArmInOutAttr *A) {
return true;
}
bool TraverseArmLocallyStreamingAttr(ArmLocallyStreamingAttr *A);
bool VisitArmLocallyStreamingAttr(ArmLocallyStreamingAttr *A) {
return true;
}
bool TraverseArmMveStrictPolymorphismAttr(ArmMveStrictPolymorphismAttr *A);
bool VisitArmMveStrictPolymorphismAttr(ArmMveStrictPolymorphismAttr *A) {
return true;
}
bool TraverseArmNewAttr(ArmNewAttr *A);
bool VisitArmNewAttr(ArmNewAttr *A) {
return true;
}
bool TraverseArmOutAttr(ArmOutAttr *A);
bool VisitArmOutAttr(ArmOutAttr *A) {
return true;
}
bool TraverseArmPreservesAttr(ArmPreservesAttr *A);
bool VisitArmPreservesAttr(ArmPreservesAttr *A) {
return true;
}
bool TraverseArmStreamingAttr(ArmStreamingAttr *A);
bool VisitArmStreamingAttr(ArmStreamingAttr *A) {
return true;
}
bool TraverseArmStreamingCompatibleAttr(ArmStreamingCompatibleAttr *A);
bool VisitArmStreamingCompatibleAttr(ArmStreamingCompatibleAttr *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 TraverseAvailabilityAttr(AvailabilityAttr *A);
bool VisitAvailabilityAttr(AvailabilityAttr *A) {
return true;
}
bool TraverseAvailableOnlyInDefaultEvalMethodAttr(AvailableOnlyInDefaultEvalMethodAttr *A);
bool VisitAvailableOnlyInDefaultEvalMethodAttr(AvailableOnlyInDefaultEvalMethodAttr *A) {
return true;
}
bool TraverseBPFFastCallAttr(BPFFastCallAttr *A);
bool VisitBPFFastCallAttr(BPFFastCallAttr *A) {
return true;
}
bool TraverseBPFPreserveAccessIndexAttr(BPFPreserveAccessIndexAttr *A);
bool VisitBPFPreserveAccessIndexAttr(BPFPreserveAccessIndexAttr *A) {
return true;
}
bool TraverseBPFPreserveStaticOffsetAttr(BPFPreserveStaticOffsetAttr *A);
bool VisitBPFPreserveStaticOffsetAttr(BPFPreserveStaticOffsetAttr *A) {
return true;
}
bool TraverseBTFDeclTagAttr(BTFDeclTagAttr *A);
bool VisitBTFDeclTagAttr(BTFDeclTagAttr *A) {
return true;
}
bool TraverseBTFTypeTagAttr(BTFTypeTagAttr *A);
bool VisitBTFTypeTagAttr(BTFTypeTagAttr *A) {
return true;
}
bool TraverseBlockingAttr(BlockingAttr *A);
bool VisitBlockingAttr(BlockingAttr *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 TraverseCXXAssumeAttr(CXXAssumeAttr *A);
bool VisitCXXAssumeAttr(CXXAssumeAttr *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 TraverseClspvLibclcBuiltinAttr(ClspvLibclcBuiltinAttr *A);
bool VisitClspvLibclcBuiltinAttr(ClspvLibclcBuiltinAttr *A) {
return true;
}
bool TraverseCmseNSCallAttr(CmseNSCallAttr *A);
bool VisitCmseNSCallAttr(CmseNSCallAttr *A) {
return true;
}
bool TraverseCmseNSEntryAttr(CmseNSEntryAttr *A);
bool VisitCmseNSEntryAttr(CmseNSEntryAttr *A) {
return true;
}
bool TraverseCodeAlignAttr(CodeAlignAttr *A);
bool VisitCodeAlignAttr(CodeAlignAttr *A) {
return true;
}
bool TraverseCodeModelAttr(CodeModelAttr *A);
bool VisitCodeModelAttr(CodeModelAttr *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 TraverseCoroDisableLifetimeBoundAttr(CoroDisableLifetimeBoundAttr *A);
bool VisitCoroDisableLifetimeBoundAttr(CoroDisableLifetimeBoundAttr *A) {
return true;
}
bool TraverseCoroLifetimeBoundAttr(CoroLifetimeBoundAttr *A);
bool VisitCoroLifetimeBoundAttr(CoroLifetimeBoundAttr *A) {
return true;
}
bool TraverseCoroOnlyDestroyWhenCompleteAttr(CoroOnlyDestroyWhenCompleteAttr *A);
bool VisitCoroOnlyDestroyWhenCompleteAttr(CoroOnlyDestroyWhenCompleteAttr *A) {
return true;
}
bool TraverseCoroReturnTypeAttr(CoroReturnTypeAttr *A);
bool VisitCoroReturnTypeAttr(CoroReturnTypeAttr *A) {
return true;
}
bool TraverseCoroWrapperAttr(CoroWrapperAttr *A);
bool VisitCoroWrapperAttr(CoroWrapperAttr *A) {
return true;
}
bool TraverseCountedByAttr(CountedByAttr *A);
bool VisitCountedByAttr(CountedByAttr *A) {
return true;
}
bool TraverseCountedByOrNullAttr(CountedByOrNullAttr *A);
bool VisitCountedByOrNullAttr(CountedByOrNullAttr *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 TraverseDiagnoseAsBuiltinAttr(DiagnoseAsBuiltinAttr *A);
bool VisitDiagnoseAsBuiltinAttr(DiagnoseAsBuiltinAttr *A) {
return true;
}
bool TraverseDiagnoseIfAttr(DiagnoseIfAttr *A);
bool VisitDiagnoseIfAttr(DiagnoseIfAttr *A) {
return true;
}
bool TraverseDisableSanitizerInstrumentationAttr(DisableSanitizerInstrumentationAttr *A);
bool VisitDisableSanitizerInstrumentationAttr(DisableSanitizerInstrumentationAttr *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 TraverseErrorAttr(ErrorAttr *A);
bool VisitErrorAttr(ErrorAttr *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 TraverseFunctionReturnThunksAttr(FunctionReturnThunksAttr *A);
bool VisitFunctionReturnThunksAttr(FunctionReturnThunksAttr *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 TraverseHLSLGroupSharedAddressSpaceAttr(HLSLGroupSharedAddressSpaceAttr *A);
bool VisitHLSLGroupSharedAddressSpaceAttr(HLSLGroupSharedAddressSpaceAttr *A) {
return true;
}
bool TraverseHLSLLoopHintAttr(HLSLLoopHintAttr *A);
bool VisitHLSLLoopHintAttr(HLSLLoopHintAttr *A) {
return true;
}
bool TraverseHLSLNumThreadsAttr(HLSLNumThreadsAttr *A);
bool VisitHLSLNumThreadsAttr(HLSLNumThreadsAttr *A) {
return true;
}
bool TraverseHLSLPackOffsetAttr(HLSLPackOffsetAttr *A);
bool VisitHLSLPackOffsetAttr(HLSLPackOffsetAttr *A) {
return true;
}
bool TraverseHLSLParamModifierAttr(HLSLParamModifierAttr *A);
bool VisitHLSLParamModifierAttr(HLSLParamModifierAttr *A) {
return true;
}
bool TraverseHLSLROVAttr(HLSLROVAttr *A);
bool VisitHLSLROVAttr(HLSLROVAttr *A) {
return true;
}
bool TraverseHLSLResourceAttr(HLSLResourceAttr *A);
bool VisitHLSLResourceAttr(HLSLResourceAttr *A) {
return true;
}
bool TraverseHLSLResourceBindingAttr(HLSLResourceBindingAttr *A);
bool VisitHLSLResourceBindingAttr(HLSLResourceBindingAttr *A) {
return true;
}
bool TraverseHLSLResourceClassAttr(HLSLResourceClassAttr *A);
bool VisitHLSLResourceClassAttr(HLSLResourceClassAttr *A) {
return true;
}
bool TraverseHLSLSV_DispatchThreadIDAttr(HLSLSV_DispatchThreadIDAttr *A);
bool VisitHLSLSV_DispatchThreadIDAttr(HLSLSV_DispatchThreadIDAttr *A) {
return true;
}
bool TraverseHLSLSV_GroupIndexAttr(HLSLSV_GroupIndexAttr *A);
bool VisitHLSLSV_GroupIndexAttr(HLSLSV_GroupIndexAttr *A) {
return true;
}
bool TraverseHLSLShaderAttr(HLSLShaderAttr *A);
bool VisitHLSLShaderAttr(HLSLShaderAttr *A) {
return true;
}
bool TraverseHotAttr(HotAttr *A);
bool VisitHotAttr(HotAttr *A) {
return true;
}
bool TraverseHybridPatchableAttr(HybridPatchableAttr *A);
bool VisitHybridPatchableAttr(HybridPatchableAttr *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 TraverseM68kRTDAttr(M68kRTDAttr *A);
bool VisitM68kRTDAttr(M68kRTDAttr *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 TraverseMSConstexprAttr(MSConstexprAttr *A);
bool VisitMSConstexprAttr(MSConstexprAttr *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 TraverseMaybeUndefAttr(MaybeUndefAttr *A);
bool VisitMaybeUndefAttr(MaybeUndefAttr *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 TraverseNVPTXKernelAttr(NVPTXKernelAttr *A);
bool VisitNVPTXKernelAttr(NVPTXKernelAttr *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 TraverseNoConvergentAttr(NoConvergentAttr *A);
bool VisitNoConvergentAttr(NoConvergentAttr *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 TraverseNoRandomizeLayoutAttr(NoRandomizeLayoutAttr *A);
bool VisitNoRandomizeLayoutAttr(NoRandomizeLayoutAttr *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 TraverseNoUwtableAttr(NoUwtableAttr *A);
bool VisitNoUwtableAttr(NoUwtableAttr *A) {
return true;
}
bool TraverseNonAllocatingAttr(NonAllocatingAttr *A);
bool VisitNonAllocatingAttr(NonAllocatingAttr *A) {
return true;
}
bool TraverseNonBlockingAttr(NonBlockingAttr *A);
bool VisitNonBlockingAttr(NonBlockingAttr *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 TraverseOMPAssumeAttr(OMPAssumeAttr *A);
bool VisitOMPAssumeAttr(OMPAssumeAttr *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 TraversePreferredTypeAttr(PreferredTypeAttr *A);
bool VisitPreferredTypeAttr(PreferredTypeAttr *A) {
return true;
}
bool TraversePreserveAllAttr(PreserveAllAttr *A);
bool VisitPreserveAllAttr(PreserveAllAttr *A) {
return true;
}
bool TraversePreserveMostAttr(PreserveMostAttr *A);
bool VisitPreserveMostAttr(PreserveMostAttr *A) {
return true;
}
bool TraversePreserveNoneAttr(PreserveNoneAttr *A);
bool VisitPreserveNoneAttr(PreserveNoneAttr *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 TraverseRISCVVectorCCAttr(RISCVVectorCCAttr *A);
bool VisitRISCVVectorCCAttr(RISCVVectorCCAttr *A) {
return true;
}
bool TraverseRandomizeLayoutAttr(RandomizeLayoutAttr *A);
bool VisitRandomizeLayoutAttr(RandomizeLayoutAttr *A) {
return true;
}
bool TraverseReadOnlyPlacementAttr(ReadOnlyPlacementAttr *A);
bool VisitReadOnlyPlacementAttr(ReadOnlyPlacementAttr *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 TraverseSYCLSpecialClassAttr(SYCLSpecialClassAttr *A);
bool VisitSYCLSpecialClassAttr(SYCLSpecialClassAttr *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 TraverseSizedByAttr(SizedByAttr *A);
bool VisitSizedByAttr(SizedByAttr *A) {
return true;
}
bool TraverseSizedByOrNullAttr(SizedByOrNullAttr *A);
bool VisitSizedByOrNullAttr(SizedByOrNullAttr *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 TraverseStrictGuardStackCheckAttr(StrictGuardStackCheckAttr *A);
bool VisitStrictGuardStackCheckAttr(StrictGuardStackCheckAttr *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 TraverseSwiftImportAsNonGenericAttr(SwiftImportAsNonGenericAttr *A);
bool VisitSwiftImportAsNonGenericAttr(SwiftImportAsNonGenericAttr *A) {
return true;
}
bool TraverseSwiftImportPropertyAsAccessorsAttr(SwiftImportPropertyAsAccessorsAttr *A);
bool VisitSwiftImportPropertyAsAccessorsAttr(SwiftImportPropertyAsAccessorsAttr *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 TraverseSwiftVersionedAdditionAttr(SwiftVersionedAdditionAttr *A);
bool VisitSwiftVersionedAdditionAttr(SwiftVersionedAdditionAttr *A) {
return true;
}
bool TraverseSwiftVersionedRemovalAttr(SwiftVersionedRemovalAttr *A);
bool VisitSwiftVersionedRemovalAttr(SwiftVersionedRemovalAttr *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 TraverseTargetClonesAttr(TargetClonesAttr *A);
bool VisitTargetClonesAttr(TargetClonesAttr *A) {
return true;
}
bool TraverseTargetVersionAttr(TargetVersionAttr *A);
bool VisitTargetVersionAttr(TargetVersionAttr *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 TraverseUnsafeBufferUsageAttr(UnsafeBufferUsageAttr *A);
bool VisitUnsafeBufferUsageAttr(UnsafeBufferUsageAttr *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 TraverseVTablePointerAuthenticationAttr(VTablePointerAuthenticationAttr *A);
bool VisitVTablePointerAuthenticationAttr(VTablePointerAuthenticationAttr *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 TraverseWebAssemblyFuncrefAttr(WebAssemblyFuncrefAttr *A);
bool VisitWebAssemblyFuncrefAttr(WebAssemblyFuncrefAttr *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;
}
bool TraverseZeroCallUsedRegsAttr(ZeroCallUsedRegsAttr *A);
bool VisitZeroCallUsedRegsAttr(ZeroCallUsedRegsAttr *A) {
return true;
}
#else // ATTR_VISITOR_DECLS_ONLY
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAArch64SVEPcsAttr(AArch64SVEPcsAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitAArch64SVEPcsAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAArch64VectorPcsAttr(AArch64VectorPcsAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitAArch64VectorPcsAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<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 VISITORCLASS<Derived>::TraverseAMDGPUKernelCallAttr(AMDGPUKernelCallAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitAMDGPUKernelCallAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAMDGPUMaxNumWorkGroupsAttr(AMDGPUMaxNumWorkGroupsAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitAMDGPUMaxNumWorkGroupsAttr(A))
return false;
if (!getDerived().TraverseStmt(A->getMaxNumWorkGroupsX()))
return false;
if (!getDerived().TraverseStmt(A->getMaxNumWorkGroupsY()))
return false;
if (!getDerived().TraverseStmt(A->getMaxNumWorkGroupsZ()))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAMDGPUNumSGPRAttr(AMDGPUNumSGPRAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitAMDGPUNumSGPRAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAMDGPUNumVGPRAttr(AMDGPUNumVGPRAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitAMDGPUNumVGPRAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<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 VISITORCLASS<Derived>::TraverseARMInterruptAttr(ARMInterruptAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitARMInterruptAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAVRInterruptAttr(AVRInterruptAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitAVRInterruptAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAVRSignalAttr(AVRSignalAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitAVRSignalAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAbiTagAttr(AbiTagAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitAbiTagAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<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 VISITORCLASS<Derived>::TraverseAcquireHandleAttr(AcquireHandleAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitAcquireHandleAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<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 VISITORCLASS<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 VISITORCLASS<Derived>::TraverseAddressSpaceAttr(AddressSpaceAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitAddressSpaceAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAliasAttr(AliasAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitAliasAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAlignMac68kAttr(AlignMac68kAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitAlignMac68kAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAlignNaturalAttr(AlignNaturalAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitAlignNaturalAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<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 VISITORCLASS<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 VISITORCLASS<Derived>::TraverseAllocAlignAttr(AllocAlignAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitAllocAlignAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAllocSizeAttr(AllocSizeAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitAllocSizeAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAllocatingAttr(AllocatingAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitAllocatingAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAlwaysDestroyAttr(AlwaysDestroyAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitAlwaysDestroyAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAlwaysInlineAttr(AlwaysInlineAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitAlwaysInlineAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAnalyzerNoReturnAttr(AnalyzerNoReturnAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitAnalyzerNoReturnAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<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;
}
}
{
Expr * *I = A->delayedArgs_begin();
Expr * *E = A->delayedArgs_end();
for (; I != E; ++I) {
if (!getDerived().TraverseStmt(*I))
return false;
}
}
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAnnotateTypeAttr(AnnotateTypeAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitAnnotateTypeAttr(A))
return false;
{
Expr * *I = A->args_begin();
Expr * *E = A->args_end();
for (; I != E; ++I) {
if (!getDerived().TraverseStmt(*I))
return false;
}
}
{
Expr * *I = A->delayedArgs_begin();
Expr * *E = A->delayedArgs_end();
for (; I != E; ++I) {
if (!getDerived().TraverseStmt(*I))
return false;
}
}
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAnyX86InterruptAttr(AnyX86InterruptAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitAnyX86InterruptAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAnyX86NoCallerSavedRegistersAttr(AnyX86NoCallerSavedRegistersAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitAnyX86NoCallerSavedRegistersAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAnyX86NoCfCheckAttr(AnyX86NoCfCheckAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitAnyX86NoCfCheckAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitArcWeakrefUnavailableAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitArgumentWithTypeTagAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseArmBuiltinAliasAttr(ArmBuiltinAliasAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitArmBuiltinAliasAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseArmInAttr(ArmInAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitArmInAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseArmInOutAttr(ArmInOutAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitArmInOutAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseArmLocallyStreamingAttr(ArmLocallyStreamingAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitArmLocallyStreamingAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseArmMveStrictPolymorphismAttr(ArmMveStrictPolymorphismAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitArmMveStrictPolymorphismAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseArmNewAttr(ArmNewAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitArmNewAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseArmOutAttr(ArmOutAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitArmOutAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseArmPreservesAttr(ArmPreservesAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitArmPreservesAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseArmStreamingAttr(ArmStreamingAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitArmStreamingAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseArmStreamingCompatibleAttr(ArmStreamingCompatibleAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitArmStreamingCompatibleAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseArtificialAttr(ArtificialAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitArtificialAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAsmLabelAttr(AsmLabelAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitAsmLabelAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<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 VISITORCLASS<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 VISITORCLASS<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 VISITORCLASS<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 VISITORCLASS<Derived>::TraverseAvailabilityAttr(AvailabilityAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitAvailabilityAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAvailableOnlyInDefaultEvalMethodAttr(AvailableOnlyInDefaultEvalMethodAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitAvailableOnlyInDefaultEvalMethodAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseBPFFastCallAttr(BPFFastCallAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitBPFFastCallAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseBPFPreserveAccessIndexAttr(BPFPreserveAccessIndexAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitBPFPreserveAccessIndexAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseBPFPreserveStaticOffsetAttr(BPFPreserveStaticOffsetAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitBPFPreserveStaticOffsetAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseBTFDeclTagAttr(BTFDeclTagAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitBTFDeclTagAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseBTFTypeTagAttr(BTFTypeTagAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitBTFTypeTagAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseBlockingAttr(BlockingAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitBlockingAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseBlocksAttr(BlocksAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitBlocksAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseBuiltinAttr(BuiltinAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitBuiltinAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseBuiltinAliasAttr(BuiltinAliasAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitBuiltinAliasAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseC11NoReturnAttr(C11NoReturnAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitC11NoReturnAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCDeclAttr(CDeclAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCDeclAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCFAuditedTransferAttr(CFAuditedTransferAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCFAuditedTransferAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCFConsumedAttr(CFConsumedAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCFConsumedAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCFGuardAttr(CFGuardAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCFGuardAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCFICanonicalJumpTableAttr(CFICanonicalJumpTableAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCFICanonicalJumpTableAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCFReturnsNotRetainedAttr(CFReturnsNotRetainedAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCFReturnsNotRetainedAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCFReturnsRetainedAttr(CFReturnsRetainedAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCFReturnsRetainedAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCFUnknownTransferAttr(CFUnknownTransferAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCFUnknownTransferAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCPUDispatchAttr(CPUDispatchAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCPUDispatchAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCPUSpecificAttr(CPUSpecificAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCPUSpecificAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCUDAConstantAttr(CUDAConstantAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCUDAConstantAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCUDADeviceAttr(CUDADeviceAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCUDADeviceAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCUDADeviceBuiltinSurfaceTypeAttr(CUDADeviceBuiltinSurfaceTypeAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCUDADeviceBuiltinSurfaceTypeAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCUDADeviceBuiltinTextureTypeAttr(CUDADeviceBuiltinTextureTypeAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCUDADeviceBuiltinTextureTypeAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCUDAGlobalAttr(CUDAGlobalAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCUDAGlobalAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCUDAHostAttr(CUDAHostAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCUDAHostAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCUDAInvalidTargetAttr(CUDAInvalidTargetAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCUDAInvalidTargetAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<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;
if (!getDerived().TraverseStmt(A->getMaxBlocks()))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCUDASharedAttr(CUDASharedAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCUDASharedAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCXX11NoReturnAttr(CXX11NoReturnAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCXX11NoReturnAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCXXAssumeAttr(CXXAssumeAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCXXAssumeAttr(A))
return false;
if (!getDerived().TraverseStmt(A->getAssumption()))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCallableWhenAttr(CallableWhenAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCallableWhenAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCallbackAttr(CallbackAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCallbackAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCalledOnceAttr(CalledOnceAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCalledOnceAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCapabilityAttr(CapabilityAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCapabilityAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCapturedRecordAttr(CapturedRecordAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCapturedRecordAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCarriesDependencyAttr(CarriesDependencyAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCarriesDependencyAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCleanupAttr(CleanupAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCleanupAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseClspvLibclcBuiltinAttr(ClspvLibclcBuiltinAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitClspvLibclcBuiltinAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCmseNSCallAttr(CmseNSCallAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCmseNSCallAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCmseNSEntryAttr(CmseNSEntryAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCmseNSEntryAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCodeAlignAttr(CodeAlignAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCodeAlignAttr(A))
return false;
if (!getDerived().TraverseStmt(A->getAlignment()))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCodeModelAttr(CodeModelAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCodeModelAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCodeSegAttr(CodeSegAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCodeSegAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseColdAttr(ColdAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitColdAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCommonAttr(CommonAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCommonAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseConstAttr(ConstAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitConstAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseConstInitAttr(ConstInitAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitConstInitAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseConstructorAttr(ConstructorAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitConstructorAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseConsumableAttr(ConsumableAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitConsumableAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseConsumableAutoCastAttr(ConsumableAutoCastAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitConsumableAutoCastAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitConsumableSetOnReadAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseConvergentAttr(ConvergentAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitConvergentAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCoroDisableLifetimeBoundAttr(CoroDisableLifetimeBoundAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCoroDisableLifetimeBoundAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCoroLifetimeBoundAttr(CoroLifetimeBoundAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCoroLifetimeBoundAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCoroOnlyDestroyWhenCompleteAttr(CoroOnlyDestroyWhenCompleteAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCoroOnlyDestroyWhenCompleteAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCoroReturnTypeAttr(CoroReturnTypeAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCoroReturnTypeAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCoroWrapperAttr(CoroWrapperAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCoroWrapperAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCountedByAttr(CountedByAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCountedByAttr(A))
return false;
if (!getDerived().TraverseStmt(A->getCount()))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCountedByOrNullAttr(CountedByOrNullAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitCountedByOrNullAttr(A))
return false;
if (!getDerived().TraverseStmt(A->getCount()))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseDLLExportAttr(DLLExportAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitDLLExportAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseDLLExportStaticLocalAttr(DLLExportStaticLocalAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitDLLExportStaticLocalAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseDLLImportAttr(DLLImportAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitDLLImportAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseDLLImportStaticLocalAttr(DLLImportStaticLocalAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitDLLImportStaticLocalAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseDeprecatedAttr(DeprecatedAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitDeprecatedAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseDestructorAttr(DestructorAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitDestructorAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseDiagnoseAsBuiltinAttr(DiagnoseAsBuiltinAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitDiagnoseAsBuiltinAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<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 VISITORCLASS<Derived>::TraverseDisableSanitizerInstrumentationAttr(DisableSanitizerInstrumentationAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitDisableSanitizerInstrumentationAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseDisableTailCallsAttr(DisableTailCallsAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitDisableTailCallsAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseEmptyBasesAttr(EmptyBasesAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitEmptyBasesAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<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 VISITORCLASS<Derived>::TraverseEnforceTCBAttr(EnforceTCBAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitEnforceTCBAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseEnforceTCBLeafAttr(EnforceTCBLeafAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitEnforceTCBLeafAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseEnumExtensibilityAttr(EnumExtensibilityAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitEnumExtensibilityAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseErrorAttr(ErrorAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitErrorAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseExcludeFromExplicitInstantiationAttr(ExcludeFromExplicitInstantiationAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitExcludeFromExplicitInstantiationAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<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 VISITORCLASS<Derived>::TraverseExternalSourceSymbolAttr(ExternalSourceSymbolAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitExternalSourceSymbolAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseFallThroughAttr(FallThroughAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitFallThroughAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseFastCallAttr(FastCallAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitFastCallAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseFinalAttr(FinalAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitFinalAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseFlagEnumAttr(FlagEnumAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitFlagEnumAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseFlattenAttr(FlattenAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitFlattenAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseFormatAttr(FormatAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitFormatAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseFormatArgAttr(FormatArgAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitFormatArgAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseFunctionReturnThunksAttr(FunctionReturnThunksAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitFunctionReturnThunksAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseGNUInlineAttr(GNUInlineAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitGNUInlineAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<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 VISITORCLASS<Derived>::TraverseGuardedVarAttr(GuardedVarAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitGuardedVarAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseHIPManagedAttr(HIPManagedAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitHIPManagedAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseHLSLGroupSharedAddressSpaceAttr(HLSLGroupSharedAddressSpaceAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitHLSLGroupSharedAddressSpaceAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseHLSLLoopHintAttr(HLSLLoopHintAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitHLSLLoopHintAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseHLSLNumThreadsAttr(HLSLNumThreadsAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitHLSLNumThreadsAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseHLSLPackOffsetAttr(HLSLPackOffsetAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitHLSLPackOffsetAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseHLSLParamModifierAttr(HLSLParamModifierAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitHLSLParamModifierAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseHLSLROVAttr(HLSLROVAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitHLSLROVAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseHLSLResourceAttr(HLSLResourceAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitHLSLResourceAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseHLSLResourceBindingAttr(HLSLResourceBindingAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitHLSLResourceBindingAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseHLSLResourceClassAttr(HLSLResourceClassAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitHLSLResourceClassAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseHLSLSV_DispatchThreadIDAttr(HLSLSV_DispatchThreadIDAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitHLSLSV_DispatchThreadIDAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseHLSLSV_GroupIndexAttr(HLSLSV_GroupIndexAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitHLSLSV_GroupIndexAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseHLSLShaderAttr(HLSLShaderAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitHLSLShaderAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseHotAttr(HotAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitHotAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseHybridPatchableAttr(HybridPatchableAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitHybridPatchableAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseIBActionAttr(IBActionAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitIBActionAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseIBOutletAttr(IBOutletAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitIBOutletAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<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 VISITORCLASS<Derived>::TraverseIFuncAttr(IFuncAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitIFuncAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseInitPriorityAttr(InitPriorityAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitInitPriorityAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseInitSegAttr(InitSegAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitInitSegAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseIntelOclBiccAttr(IntelOclBiccAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitIntelOclBiccAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseInternalLinkageAttr(InternalLinkageAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitInternalLinkageAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseLTOVisibilityPublicAttr(LTOVisibilityPublicAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitLTOVisibilityPublicAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseLayoutVersionAttr(LayoutVersionAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitLayoutVersionAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseLeafAttr(LeafAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitLeafAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseLifetimeBoundAttr(LifetimeBoundAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitLifetimeBoundAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseLikelyAttr(LikelyAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitLikelyAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseLoaderUninitializedAttr(LoaderUninitializedAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitLoaderUninitializedAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<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 VISITORCLASS<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 VISITORCLASS<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 VISITORCLASS<Derived>::TraverseM68kInterruptAttr(M68kInterruptAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitM68kInterruptAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseM68kRTDAttr(M68kRTDAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitM68kRTDAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMIGServerRoutineAttr(MIGServerRoutineAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitMIGServerRoutineAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMSABIAttr(MSABIAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitMSABIAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMSAllocatorAttr(MSAllocatorAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitMSAllocatorAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMSConstexprAttr(MSConstexprAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitMSConstexprAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMSInheritanceAttr(MSInheritanceAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitMSInheritanceAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMSNoVTableAttr(MSNoVTableAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitMSNoVTableAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMSP430InterruptAttr(MSP430InterruptAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitMSP430InterruptAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMSStructAttr(MSStructAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitMSStructAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMSVtorDispAttr(MSVtorDispAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitMSVtorDispAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitMaxFieldAlignmentAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMayAliasAttr(MayAliasAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitMayAliasAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMaybeUndefAttr(MaybeUndefAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitMaybeUndefAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMicroMipsAttr(MicroMipsAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitMicroMipsAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMinSizeAttr(MinSizeAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitMinSizeAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMinVectorWidthAttr(MinVectorWidthAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitMinVectorWidthAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMips16Attr(Mips16Attr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitMips16Attr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMipsInterruptAttr(MipsInterruptAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitMipsInterruptAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMipsLongCallAttr(MipsLongCallAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitMipsLongCallAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMipsShortCallAttr(MipsShortCallAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitMipsShortCallAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseModeAttr(ModeAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitModeAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMustTailAttr(MustTailAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitMustTailAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNSConsumedAttr(NSConsumedAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNSConsumedAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNSConsumesSelfAttr(NSConsumesSelfAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNSConsumesSelfAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNSErrorDomainAttr(NSErrorDomainAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNSErrorDomainAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNSReturnsAutoreleasedAttr(NSReturnsAutoreleasedAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNSReturnsAutoreleasedAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNSReturnsNotRetainedAttr(NSReturnsNotRetainedAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNSReturnsNotRetainedAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNSReturnsRetainedAttr(NSReturnsRetainedAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNSReturnsRetainedAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNVPTXKernelAttr(NVPTXKernelAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNVPTXKernelAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNakedAttr(NakedAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNakedAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoAliasAttr(NoAliasAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNoAliasAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoBuiltinAttr(NoBuiltinAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNoBuiltinAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoCommonAttr(NoCommonAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNoCommonAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoConvergentAttr(NoConvergentAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNoConvergentAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoDebugAttr(NoDebugAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNoDebugAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoDerefAttr(NoDerefAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNoDerefAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoDestroyAttr(NoDestroyAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNoDestroyAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoDuplicateAttr(NoDuplicateAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNoDuplicateAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoEscapeAttr(NoEscapeAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNoEscapeAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoInlineAttr(NoInlineAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNoInlineAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNoInstrumentFunctionAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoMergeAttr(NoMergeAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNoMergeAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoMicroMipsAttr(NoMicroMipsAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNoMicroMipsAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoMips16Attr(NoMips16Attr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNoMips16Attr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoProfileFunctionAttr(NoProfileFunctionAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNoProfileFunctionAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoRandomizeLayoutAttr(NoRandomizeLayoutAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNoRandomizeLayoutAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoReturnAttr(NoReturnAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNoReturnAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoSanitizeAttr(NoSanitizeAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNoSanitizeAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoSpeculativeLoadHardeningAttr(NoSpeculativeLoadHardeningAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNoSpeculativeLoadHardeningAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoSplitStackAttr(NoSplitStackAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNoSplitStackAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoStackProtectorAttr(NoStackProtectorAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNoStackProtectorAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoThreadSafetyAnalysisAttr(NoThreadSafetyAnalysisAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNoThreadSafetyAnalysisAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoThrowAttr(NoThrowAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNoThrowAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoUniqueAddressAttr(NoUniqueAddressAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNoUniqueAddressAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoUwtableAttr(NoUwtableAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNoUwtableAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNonAllocatingAttr(NonAllocatingAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNonAllocatingAttr(A))
return false;
if (!getDerived().TraverseStmt(A->getCond()))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNonBlockingAttr(NonBlockingAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNonBlockingAttr(A))
return false;
if (!getDerived().TraverseStmt(A->getCond()))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNonNullAttr(NonNullAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNonNullAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNotTailCalledAttr(NotTailCalledAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitNotTailCalledAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOMPAllocateDeclAttr(OMPAllocateDeclAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOMPAllocateDeclAttr(A))
return false;
if (!getDerived().TraverseStmt(A->getAllocator()))
return false;
if (!getDerived().TraverseStmt(A->getAlignment()))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOMPAssumeAttr(OMPAssumeAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOMPAssumeAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOMPCaptureKindAttr(OMPCaptureKindAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOMPCaptureKindAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOMPCaptureNoInitAttr(OMPCaptureNoInitAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOMPCaptureNoInitAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<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 VISITORCLASS<Derived>::TraverseOMPDeclareTargetDeclAttr(OMPDeclareTargetDeclAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOMPDeclareTargetDeclAttr(A))
return false;
if (!getDerived().TraverseStmt(A->getIndirectExpr()))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOMPDeclareVariantAttr(OMPDeclareVariantAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOMPDeclareVariantAttr(A))
return false;
if (!getDerived().TraverseStmt(A->getVariantFuncRef()))
return false;
{
Expr * *I = A->adjustArgsNothing_begin();
Expr * *E = A->adjustArgsNothing_end();
for (; I != E; ++I) {
if (!getDerived().TraverseStmt(*I))
return false;
}
}
{
Expr * *I = A->adjustArgsNeedDevicePtr_begin();
Expr * *E = A->adjustArgsNeedDevicePtr_end();
for (; I != E; ++I) {
if (!getDerived().TraverseStmt(*I))
return false;
}
}
return true;
}
template <typename Derived>
bool VISITORCLASS<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 VISITORCLASS<Derived>::TraverseOMPThreadPrivateDeclAttr(OMPThreadPrivateDeclAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOMPThreadPrivateDeclAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOSConsumedAttr(OSConsumedAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOSConsumedAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOSConsumesThisAttr(OSConsumesThisAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOSConsumesThisAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOSReturnsNotRetainedAttr(OSReturnsNotRetainedAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOSReturnsNotRetainedAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOSReturnsRetainedAttr(OSReturnsRetainedAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOSReturnsRetainedAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOSReturnsRetainedOnNonZeroAttr(OSReturnsRetainedOnNonZeroAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOSReturnsRetainedOnNonZeroAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOSReturnsRetainedOnZeroAttr(OSReturnsRetainedOnZeroAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOSReturnsRetainedOnZeroAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCBoxableAttr(ObjCBoxableAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCBoxableAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCBridgeAttr(ObjCBridgeAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCBridgeAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCBridgeMutableAttr(ObjCBridgeMutableAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCBridgeMutableAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCBridgeRelatedAttr(ObjCBridgeRelatedAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCBridgeRelatedAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCClassStubAttr(ObjCClassStubAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCClassStubAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCDesignatedInitializerAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCDirectAttr(ObjCDirectAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCDirectAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCDirectMembersAttr(ObjCDirectMembersAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCDirectMembersAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCExceptionAttr(ObjCExceptionAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCExceptionAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCExplicitProtocolImplAttr(ObjCExplicitProtocolImplAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCExplicitProtocolImplAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCExternallyRetainedAttr(ObjCExternallyRetainedAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCExternallyRetainedAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCGCAttr(ObjCGCAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCGCAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCIndependentClassAttr(ObjCIndependentClassAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCIndependentClassAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCInertUnsafeUnretainedAttr(ObjCInertUnsafeUnretainedAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCInertUnsafeUnretainedAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCKindOfAttr(ObjCKindOfAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCKindOfAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCMethodFamilyAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCNSObjectAttr(ObjCNSObjectAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCNSObjectAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCNonLazyClassAttr(ObjCNonLazyClassAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCNonLazyClassAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCNonRuntimeProtocolAttr(ObjCNonRuntimeProtocolAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCNonRuntimeProtocolAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCOwnershipAttr(ObjCOwnershipAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCOwnershipAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCPreciseLifetimeAttr(ObjCPreciseLifetimeAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCPreciseLifetimeAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCRequiresPropertyDefsAttr(ObjCRequiresPropertyDefsAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCRequiresPropertyDefsAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCRequiresSuperAttr(ObjCRequiresSuperAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCRequiresSuperAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCReturnsInnerPointerAttr(ObjCReturnsInnerPointerAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCReturnsInnerPointerAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCRootClassAttr(ObjCRootClassAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCRootClassAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCRuntimeNameAttr(ObjCRuntimeNameAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCRuntimeNameAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCRuntimeVisibleAttr(ObjCRuntimeVisibleAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCRuntimeVisibleAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCSubclassingRestrictedAttr(ObjCSubclassingRestrictedAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitObjCSubclassingRestrictedAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOpenCLAccessAttr(OpenCLAccessAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOpenCLAccessAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOpenCLConstantAddressSpaceAttr(OpenCLConstantAddressSpaceAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOpenCLConstantAddressSpaceAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOpenCLGenericAddressSpaceAttr(OpenCLGenericAddressSpaceAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOpenCLGenericAddressSpaceAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOpenCLGlobalAddressSpaceAttr(OpenCLGlobalAddressSpaceAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOpenCLGlobalAddressSpaceAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOpenCLGlobalDeviceAddressSpaceAttr(OpenCLGlobalDeviceAddressSpaceAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOpenCLGlobalDeviceAddressSpaceAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOpenCLGlobalHostAddressSpaceAttr(OpenCLGlobalHostAddressSpaceAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOpenCLGlobalHostAddressSpaceAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOpenCLIntelReqdSubGroupSizeAttr(OpenCLIntelReqdSubGroupSizeAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOpenCLIntelReqdSubGroupSizeAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOpenCLKernelAttr(OpenCLKernelAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOpenCLKernelAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOpenCLLocalAddressSpaceAttr(OpenCLLocalAddressSpaceAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOpenCLLocalAddressSpaceAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOpenCLPrivateAddressSpaceAttr(OpenCLPrivateAddressSpaceAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOpenCLPrivateAddressSpaceAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOpenCLUnrollHintAttr(OpenCLUnrollHintAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOpenCLUnrollHintAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOptimizeNoneAttr(OptimizeNoneAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOptimizeNoneAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOverloadableAttr(OverloadableAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOverloadableAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOverrideAttr(OverrideAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOverrideAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<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 VISITORCLASS<Derived>::TraverseOwnershipAttr(OwnershipAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitOwnershipAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraversePackedAttr(PackedAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitPackedAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseParamTypestateAttr(ParamTypestateAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitParamTypestateAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraversePascalAttr(PascalAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitPascalAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraversePassObjectSizeAttr(PassObjectSizeAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitPassObjectSizeAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraversePatchableFunctionEntryAttr(PatchableFunctionEntryAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitPatchableFunctionEntryAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraversePcsAttr(PcsAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitPcsAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<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 VISITORCLASS<Derived>::TraversePragmaClangBSSSectionAttr(PragmaClangBSSSectionAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitPragmaClangBSSSectionAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraversePragmaClangDataSectionAttr(PragmaClangDataSectionAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitPragmaClangDataSectionAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraversePragmaClangRelroSectionAttr(PragmaClangRelroSectionAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitPragmaClangRelroSectionAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraversePragmaClangRodataSectionAttr(PragmaClangRodataSectionAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitPragmaClangRodataSectionAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraversePragmaClangTextSectionAttr(PragmaClangTextSectionAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitPragmaClangTextSectionAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<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 VISITORCLASS<Derived>::TraversePreferredTypeAttr(PreferredTypeAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitPreferredTypeAttr(A))
return false;
if (auto *TSI = A->getTypeLoc())
if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraversePreserveAllAttr(PreserveAllAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitPreserveAllAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraversePreserveMostAttr(PreserveMostAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitPreserveMostAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraversePreserveNoneAttr(PreserveNoneAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitPreserveNoneAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<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 VISITORCLASS<Derived>::TraversePtGuardedVarAttr(PtGuardedVarAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitPtGuardedVarAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraversePtr32Attr(Ptr32Attr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitPtr32Attr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraversePtr64Attr(Ptr64Attr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitPtr64Attr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraversePureAttr(PureAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitPureAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseRISCVInterruptAttr(RISCVInterruptAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitRISCVInterruptAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseRISCVVectorCCAttr(RISCVVectorCCAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitRISCVVectorCCAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseRandomizeLayoutAttr(RandomizeLayoutAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitRandomizeLayoutAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseReadOnlyPlacementAttr(ReadOnlyPlacementAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitReadOnlyPlacementAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseRegCallAttr(RegCallAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitRegCallAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseReinitializesAttr(ReinitializesAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitReinitializesAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<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 VISITORCLASS<Derived>::TraverseReleaseHandleAttr(ReleaseHandleAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitReleaseHandleAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseRenderScriptKernelAttr(RenderScriptKernelAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitRenderScriptKernelAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitReqdWorkGroupSizeAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<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 VISITORCLASS<Derived>::TraverseRestrictAttr(RestrictAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitRestrictAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseRetainAttr(RetainAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitRetainAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseReturnTypestateAttr(ReturnTypestateAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitReturnTypestateAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseReturnsNonNullAttr(ReturnsNonNullAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitReturnsNonNullAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseReturnsTwiceAttr(ReturnsTwiceAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitReturnsTwiceAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSPtrAttr(SPtrAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSPtrAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSYCLKernelAttr(SYCLKernelAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSYCLKernelAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSYCLSpecialClassAttr(SYCLSpecialClassAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSYCLSpecialClassAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseScopedLockableAttr(ScopedLockableAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitScopedLockableAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSectionAttr(SectionAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSectionAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSelectAnyAttr(SelectAnyAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSelectAnyAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSentinelAttr(SentinelAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSentinelAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSetTypestateAttr(SetTypestateAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSetTypestateAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<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 VISITORCLASS<Derived>::TraverseSizedByAttr(SizedByAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSizedByAttr(A))
return false;
if (!getDerived().TraverseStmt(A->getSize()))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSizedByOrNullAttr(SizedByOrNullAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSizedByOrNullAttr(A))
return false;
if (!getDerived().TraverseStmt(A->getSize()))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSpeculativeLoadHardeningAttr(SpeculativeLoadHardeningAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSpeculativeLoadHardeningAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseStandaloneDebugAttr(StandaloneDebugAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitStandaloneDebugAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseStdCallAttr(StdCallAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitStdCallAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseStrictFPAttr(StrictFPAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitStrictFPAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseStrictGuardStackCheckAttr(StrictGuardStackCheckAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitStrictGuardStackCheckAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSuppressAttr(SuppressAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSuppressAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftAsyncAttr(SwiftAsyncAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSwiftAsyncAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftAsyncCallAttr(SwiftAsyncCallAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSwiftAsyncCallAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftAsyncContextAttr(SwiftAsyncContextAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSwiftAsyncContextAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftAsyncErrorAttr(SwiftAsyncErrorAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSwiftAsyncErrorAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftAsyncNameAttr(SwiftAsyncNameAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSwiftAsyncNameAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftAttrAttr(SwiftAttrAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSwiftAttrAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftBridgeAttr(SwiftBridgeAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSwiftBridgeAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftBridgedTypedefAttr(SwiftBridgedTypedefAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSwiftBridgedTypedefAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftCallAttr(SwiftCallAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSwiftCallAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftContextAttr(SwiftContextAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSwiftContextAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftErrorAttr(SwiftErrorAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSwiftErrorAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftErrorResultAttr(SwiftErrorResultAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSwiftErrorResultAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftImportAsNonGenericAttr(SwiftImportAsNonGenericAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSwiftImportAsNonGenericAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftImportPropertyAsAccessorsAttr(SwiftImportPropertyAsAccessorsAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSwiftImportPropertyAsAccessorsAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftIndirectResultAttr(SwiftIndirectResultAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSwiftIndirectResultAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftNameAttr(SwiftNameAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSwiftNameAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftNewTypeAttr(SwiftNewTypeAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSwiftNewTypeAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftObjCMembersAttr(SwiftObjCMembersAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSwiftObjCMembersAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftPrivateAttr(SwiftPrivateAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSwiftPrivateAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftVersionedAdditionAttr(SwiftVersionedAdditionAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSwiftVersionedAdditionAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftVersionedRemovalAttr(SwiftVersionedRemovalAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSwiftVersionedRemovalAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSysVABIAttr(SysVABIAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitSysVABIAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseTLSModelAttr(TLSModelAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitTLSModelAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseTargetAttr(TargetAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitTargetAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseTargetClonesAttr(TargetClonesAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitTargetClonesAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseTargetVersionAttr(TargetVersionAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitTargetVersionAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseTestTypestateAttr(TestTypestateAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitTestTypestateAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseThisCallAttr(ThisCallAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitThisCallAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseThreadAttr(ThreadAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitThreadAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseTransparentUnionAttr(TransparentUnionAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitTransparentUnionAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseTrivialABIAttr(TrivialABIAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitTrivialABIAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<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 VISITORCLASS<Derived>::TraverseTypeNonNullAttr(TypeNonNullAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitTypeNonNullAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseTypeNullUnspecifiedAttr(TypeNullUnspecifiedAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitTypeNullUnspecifiedAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseTypeNullableAttr(TypeNullableAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitTypeNullableAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseTypeNullableResultAttr(TypeNullableResultAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitTypeNullableResultAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<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 VISITORCLASS<Derived>::TraverseTypeVisibilityAttr(TypeVisibilityAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitTypeVisibilityAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseUPtrAttr(UPtrAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitUPtrAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseUnavailableAttr(UnavailableAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitUnavailableAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseUninitializedAttr(UninitializedAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitUninitializedAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseUnlikelyAttr(UnlikelyAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitUnlikelyAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseUnsafeBufferUsageAttr(UnsafeBufferUsageAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitUnsafeBufferUsageAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseUnusedAttr(UnusedAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitUnusedAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseUseHandleAttr(UseHandleAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitUseHandleAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseUsedAttr(UsedAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitUsedAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseUsingIfExistsAttr(UsingIfExistsAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitUsingIfExistsAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseUuidAttr(UuidAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitUuidAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseVTablePointerAuthenticationAttr(VTablePointerAuthenticationAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitVTablePointerAuthenticationAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseVecReturnAttr(VecReturnAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitVecReturnAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<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 VISITORCLASS<Derived>::TraverseVectorCallAttr(VectorCallAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitVectorCallAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseVisibilityAttr(VisibilityAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitVisibilityAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseWarnUnusedAttr(WarnUnusedAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitWarnUnusedAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseWarnUnusedResultAttr(WarnUnusedResultAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitWarnUnusedResultAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseWeakAttr(WeakAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitWeakAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseWeakImportAttr(WeakImportAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitWeakImportAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseWeakRefAttr(WeakRefAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitWeakRefAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseWebAssemblyExportNameAttr(WebAssemblyExportNameAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitWebAssemblyExportNameAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseWebAssemblyFuncrefAttr(WebAssemblyFuncrefAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitWebAssemblyFuncrefAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseWebAssemblyImportModuleAttr(WebAssemblyImportModuleAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitWebAssemblyImportModuleAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseWebAssemblyImportNameAttr(WebAssemblyImportNameAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitWebAssemblyImportNameAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseWorkGroupSizeHintAttr(WorkGroupSizeHintAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitWorkGroupSizeHintAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseX86ForceAlignArgPointerAttr(X86ForceAlignArgPointerAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitX86ForceAlignArgPointerAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseXRayInstrumentAttr(XRayInstrumentAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitXRayInstrumentAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseXRayLogArgsAttr(XRayLogArgsAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitXRayLogArgsAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseZeroCallUsedRegsAttr(ZeroCallUsedRegsAttr *A) {
if (!getDerived().VisitAttr(A))
return false;
if (!getDerived().VisitZeroCallUsedRegsAttr(A))
return false;
return true;
}
template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAttr(Attr *A) {
if (!A)
return true;
switch (A->getKind()) {
case attr::AArch64SVEPcs:
return getDerived().TraverseAArch64SVEPcsAttr(cast<AArch64SVEPcsAttr>(A));
case attr::AArch64VectorPcs:
return getDerived().TraverseAArch64VectorPcsAttr(cast<AArch64VectorPcsAttr>(A));
case attr::AMDGPUFlatWorkGroupSize:
return getDerived().TraverseAMDGPUFlatWorkGroupSizeAttr(cast<AMDGPUFlatWorkGroupSizeAttr>(A));
case attr::AMDGPUKernelCall:
return getDerived().TraverseAMDGPUKernelCallAttr(cast<AMDGPUKernelCallAttr>(A));
case attr::AMDGPUMaxNumWorkGroups:
return getDerived().TraverseAMDGPUMaxNumWorkGroupsAttr(cast<AMDGPUMaxNumWorkGroupsAttr>(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::Allocating:
return getDerived().TraverseAllocatingAttr(cast<AllocatingAttr>(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::AnnotateType:
return getDerived().TraverseAnnotateTypeAttr(cast<AnnotateTypeAttr>(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::ArmIn:
return getDerived().TraverseArmInAttr(cast<ArmInAttr>(A));
case attr::ArmInOut:
return getDerived().TraverseArmInOutAttr(cast<ArmInOutAttr>(A));
case attr::ArmLocallyStreaming:
return getDerived().TraverseArmLocallyStreamingAttr(cast<ArmLocallyStreamingAttr>(A));
case attr::ArmMveStrictPolymorphism:
return getDerived().TraverseArmMveStrictPolymorphismAttr(cast<ArmMveStrictPolymorphismAttr>(A));
case attr::ArmNew:
return getDerived().TraverseArmNewAttr(cast<ArmNewAttr>(A));
case attr::ArmOut:
return getDerived().TraverseArmOutAttr(cast<ArmOutAttr>(A));
case attr::ArmPreserves:
return getDerived().TraverseArmPreservesAttr(cast<ArmPreservesAttr>(A));
case attr::ArmStreaming:
return getDerived().TraverseArmStreamingAttr(cast<ArmStreamingAttr>(A));
case attr::ArmStreamingCompatible:
return getDerived().TraverseArmStreamingCompatibleAttr(cast<ArmStreamingCompatibleAttr>(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::Availability:
return getDerived().TraverseAvailabilityAttr(cast<AvailabilityAttr>(A));
case attr::AvailableOnlyInDefaultEvalMethod:
return getDerived().TraverseAvailableOnlyInDefaultEvalMethodAttr(cast<AvailableOnlyInDefaultEvalMethodAttr>(A));
case attr::BPFFastCall:
return getDerived().TraverseBPFFastCallAttr(cast<BPFFastCallAttr>(A));
case attr::BPFPreserveAccessIndex:
return getDerived().TraverseBPFPreserveAccessIndexAttr(cast<BPFPreserveAccessIndexAttr>(A));
case attr::BPFPreserveStaticOffset:
return getDerived().TraverseBPFPreserveStaticOffsetAttr(cast<BPFPreserveStaticOffsetAttr>(A));
case attr::BTFDeclTag:
return getDerived().TraverseBTFDeclTagAttr(cast<BTFDeclTagAttr>(A));
case attr::BTFTypeTag:
return getDerived().TraverseBTFTypeTagAttr(cast<BTFTypeTagAttr>(A));
case attr::Blocking:
return getDerived().TraverseBlockingAttr(cast<BlockingAttr>(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::CXXAssume:
return getDerived().TraverseCXXAssumeAttr(cast<CXXAssumeAttr>(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::ClspvLibclcBuiltin:
return getDerived().TraverseClspvLibclcBuiltinAttr(cast<ClspvLibclcBuiltinAttr>(A));
case attr::CmseNSCall:
return getDerived().TraverseCmseNSCallAttr(cast<CmseNSCallAttr>(A));
case attr::CmseNSEntry:
return getDerived().TraverseCmseNSEntryAttr(cast<CmseNSEntryAttr>(A));
case attr::CodeAlign:
return getDerived().TraverseCodeAlignAttr(cast<CodeAlignAttr>(A));
case attr::CodeModel:
return getDerived().TraverseCodeModelAttr(cast<CodeModelAttr>(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::CoroDisableLifetimeBound:
return getDerived().TraverseCoroDisableLifetimeBoundAttr(cast<CoroDisableLifetimeBoundAttr>(A));
case attr::CoroLifetimeBound:
return getDerived().TraverseCoroLifetimeBoundAttr(cast<CoroLifetimeBoundAttr>(A));
case attr::CoroOnlyDestroyWhenComplete:
return getDerived().TraverseCoroOnlyDestroyWhenCompleteAttr(cast<CoroOnlyDestroyWhenCompleteAttr>(A));
case attr::CoroReturnType:
return getDerived().TraverseCoroReturnTypeAttr(cast<CoroReturnTypeAttr>(A));
case attr::CoroWrapper:
return getDerived().TraverseCoroWrapperAttr(cast<CoroWrapperAttr>(A));
case attr::CountedBy:
return getDerived().TraverseCountedByAttr(cast<CountedByAttr>(A));
case attr::CountedByOrNull:
return getDerived().TraverseCountedByOrNullAttr(cast<CountedByOrNullAttr>(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::DiagnoseAsBuiltin:
return getDerived().TraverseDiagnoseAsBuiltinAttr(cast<DiagnoseAsBuiltinAttr>(A));
case attr::DiagnoseIf:
return getDerived().TraverseDiagnoseIfAttr(cast<DiagnoseIfAttr>(A));
case attr::DisableSanitizerInstrumentation:
return getDerived().TraverseDisableSanitizerInstrumentationAttr(cast<DisableSanitizerInstrumentationAttr>(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::Error:
return getDerived().TraverseErrorAttr(cast<ErrorAttr>(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::FunctionReturnThunks:
return getDerived().TraverseFunctionReturnThunksAttr(cast<FunctionReturnThunksAttr>(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::HLSLGroupSharedAddressSpace:
return getDerived().TraverseHLSLGroupSharedAddressSpaceAttr(cast<HLSLGroupSharedAddressSpaceAttr>(A));
case attr::HLSLLoopHint:
return getDerived().TraverseHLSLLoopHintAttr(cast<HLSLLoopHintAttr>(A));
case attr::HLSLNumThreads:
return getDerived().TraverseHLSLNumThreadsAttr(cast<HLSLNumThreadsAttr>(A));
case attr::HLSLPackOffset:
return getDerived().TraverseHLSLPackOffsetAttr(cast<HLSLPackOffsetAttr>(A));
case attr::HLSLParamModifier:
return getDerived().TraverseHLSLParamModifierAttr(cast<HLSLParamModifierAttr>(A));
case attr::HLSLROV:
return getDerived().TraverseHLSLROVAttr(cast<HLSLROVAttr>(A));
case attr::HLSLResource:
return getDerived().TraverseHLSLResourceAttr(cast<HLSLResourceAttr>(A));
case attr::HLSLResourceBinding:
return getDerived().TraverseHLSLResourceBindingAttr(cast<HLSLResourceBindingAttr>(A));
case attr::HLSLResourceClass:
return getDerived().TraverseHLSLResourceClassAttr(cast<HLSLResourceClassAttr>(A));
case attr::HLSLSV_DispatchThreadID:
return getDerived().TraverseHLSLSV_DispatchThreadIDAttr(cast<HLSLSV_DispatchThreadIDAttr>(A));
case attr::HLSLSV_GroupIndex:
return getDerived().TraverseHLSLSV_GroupIndexAttr(cast<HLSLSV_GroupIndexAttr>(A));
case attr::HLSLShader:
return getDerived().TraverseHLSLShaderAttr(cast<HLSLShaderAttr>(A));
case attr::Hot:
return getDerived().TraverseHotAttr(cast<HotAttr>(A));
case attr::HybridPatchable:
return getDerived().TraverseHybridPatchableAttr(cast<HybridPatchableAttr>(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::M68kRTD:
return getDerived().TraverseM68kRTDAttr(cast<M68kRTDAttr>(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::MSConstexpr:
return getDerived().TraverseMSConstexprAttr(cast<MSConstexprAttr>(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::MaybeUndef:
return getDerived().TraverseMaybeUndefAttr(cast<MaybeUndefAttr>(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::NVPTXKernel:
return getDerived().TraverseNVPTXKernelAttr(cast<NVPTXKernelAttr>(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::NoConvergent:
return getDerived().TraverseNoConvergentAttr(cast<NoConvergentAttr>(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::NoRandomizeLayout:
return getDerived().TraverseNoRandomizeLayoutAttr(cast<NoRandomizeLayoutAttr>(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::NoUwtable:
return getDerived().TraverseNoUwtableAttr(cast<NoUwtableAttr>(A));
case attr::NonAllocating:
return getDerived().TraverseNonAllocatingAttr(cast<NonAllocatingAttr>(A));
case attr::NonBlocking:
return getDerived().TraverseNonBlockingAttr(cast<NonBlockingAttr>(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::OMPAssume:
return getDerived().TraverseOMPAssumeAttr(cast<OMPAssumeAttr>(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::PreferredType:
return getDerived().TraversePreferredTypeAttr(cast<PreferredTypeAttr>(A));
case attr::PreserveAll:
return getDerived().TraversePreserveAllAttr(cast<PreserveAllAttr>(A));
case attr::PreserveMost:
return getDerived().TraversePreserveMostAttr(cast<PreserveMostAttr>(A));
case attr::PreserveNone:
return getDerived().TraversePreserveNoneAttr(cast<PreserveNoneAttr>(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::RISCVVectorCC:
return getDerived().TraverseRISCVVectorCCAttr(cast<RISCVVectorCCAttr>(A));
case attr::RandomizeLayout:
return getDerived().TraverseRandomizeLayoutAttr(cast<RandomizeLayoutAttr>(A));
case attr::ReadOnlyPlacement:
return getDerived().TraverseReadOnlyPlacementAttr(cast<ReadOnlyPlacementAttr>(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::SYCLSpecialClass:
return getDerived().TraverseSYCLSpecialClassAttr(cast<SYCLSpecialClassAttr>(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::SizedBy:
return getDerived().TraverseSizedByAttr(cast<SizedByAttr>(A));
case attr::SizedByOrNull:
return getDerived().TraverseSizedByOrNullAttr(cast<SizedByOrNullAttr>(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::StrictGuardStackCheck:
return getDerived().TraverseStrictGuardStackCheckAttr(cast<StrictGuardStackCheckAttr>(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::SwiftImportAsNonGeneric:
return getDerived().TraverseSwiftImportAsNonGenericAttr(cast<SwiftImportAsNonGenericAttr>(A));
case attr::SwiftImportPropertyAsAccessors:
return getDerived().TraverseSwiftImportPropertyAsAccessorsAttr(cast<SwiftImportPropertyAsAccessorsAttr>(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::SwiftVersionedAddition:
return getDerived().TraverseSwiftVersionedAdditionAttr(cast<SwiftVersionedAdditionAttr>(A));
case attr::SwiftVersionedRemoval:
return getDerived().TraverseSwiftVersionedRemovalAttr(cast<SwiftVersionedRemovalAttr>(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::TargetClones:
return getDerived().TraverseTargetClonesAttr(cast<TargetClonesAttr>(A));
case attr::TargetVersion:
return getDerived().TraverseTargetVersionAttr(cast<TargetVersionAttr>(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::UnsafeBufferUsage:
return getDerived().TraverseUnsafeBufferUsageAttr(cast<UnsafeBufferUsageAttr>(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::VTablePointerAuthentication:
return getDerived().TraverseVTablePointerAuthenticationAttr(cast<VTablePointerAuthenticationAttr>(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::WebAssemblyFuncref:
return getDerived().TraverseWebAssemblyFuncrefAttr(cast<WebAssemblyFuncrefAttr>(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));
case attr::ZeroCallUsedRegs:
return getDerived().TraverseZeroCallUsedRegsAttr(cast<ZeroCallUsedRegsAttr>(A));
}
llvm_unreachable("bad attribute kind");
}
#endif // ATTR_VISITOR_DECLS_ONLY
Reference in New Issue View Git Blame Copy Permalink