| /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\ |
| |* *| |
| |* Used by RecursiveASTVisitor to visit attributes. *| |
| |* *| |
| |* Automatically generated file, do not edit! *| |
| |* *| |
| \*===----------------------------------------------------------------------===*/ |
| |
| #ifdef ATTR_VISITOR_DECLS_ONLY |
| |
| bool TraverseAArch64VectorPcsAttr(AArch64VectorPcsAttr *A); |
| bool VisitAArch64VectorPcsAttr(AArch64VectorPcsAttr *A) { |
| return true; |
| } |
| bool TraverseAMDGPUFlatWorkGroupSizeAttr(AMDGPUFlatWorkGroupSizeAttr *A); |
| bool VisitAMDGPUFlatWorkGroupSizeAttr(AMDGPUFlatWorkGroupSizeAttr *A) { |
| return true; |
| } |
| bool TraverseAMDGPUNumSGPRAttr(AMDGPUNumSGPRAttr *A); |
| bool VisitAMDGPUNumSGPRAttr(AMDGPUNumSGPRAttr *A) { |
| return true; |
| } |
| bool TraverseAMDGPUNumVGPRAttr(AMDGPUNumVGPRAttr *A); |
| bool VisitAMDGPUNumVGPRAttr(AMDGPUNumVGPRAttr *A) { |
| return true; |
| } |
| bool TraverseAMDGPUWavesPerEUAttr(AMDGPUWavesPerEUAttr *A); |
| bool VisitAMDGPUWavesPerEUAttr(AMDGPUWavesPerEUAttr *A) { |
| return true; |
| } |
| bool TraverseARMInterruptAttr(ARMInterruptAttr *A); |
| bool VisitARMInterruptAttr(ARMInterruptAttr *A) { |
| return true; |
| } |
| bool TraverseAVRInterruptAttr(AVRInterruptAttr *A); |
| bool VisitAVRInterruptAttr(AVRInterruptAttr *A) { |
| return true; |
| } |
| bool TraverseAVRSignalAttr(AVRSignalAttr *A); |
| bool VisitAVRSignalAttr(AVRSignalAttr *A) { |
| return true; |
| } |
| bool TraverseAbiTagAttr(AbiTagAttr *A); |
| bool VisitAbiTagAttr(AbiTagAttr *A) { |
| return true; |
| } |
| bool TraverseAcquireCapabilityAttr(AcquireCapabilityAttr *A); |
| bool VisitAcquireCapabilityAttr(AcquireCapabilityAttr *A) { |
| return true; |
| } |
| bool TraverseAcquireHandleAttr(AcquireHandleAttr *A); |
| bool VisitAcquireHandleAttr(AcquireHandleAttr *A) { |
| return true; |
| } |
| bool TraverseAcquiredAfterAttr(AcquiredAfterAttr *A); |
| bool VisitAcquiredAfterAttr(AcquiredAfterAttr *A) { |
| return true; |
| } |
| bool TraverseAcquiredBeforeAttr(AcquiredBeforeAttr *A); |
| bool VisitAcquiredBeforeAttr(AcquiredBeforeAttr *A) { |
| return true; |
| } |
| bool TraverseAddressSpaceAttr(AddressSpaceAttr *A); |
| bool VisitAddressSpaceAttr(AddressSpaceAttr *A) { |
| return true; |
| } |
| bool TraverseAliasAttr(AliasAttr *A); |
| bool VisitAliasAttr(AliasAttr *A) { |
| return true; |
| } |
| bool TraverseAlignMac68kAttr(AlignMac68kAttr *A); |
| bool VisitAlignMac68kAttr(AlignMac68kAttr *A) { |
| return true; |
| } |
| bool TraverseAlignNaturalAttr(AlignNaturalAttr *A); |
| bool VisitAlignNaturalAttr(AlignNaturalAttr *A) { |
| return true; |
| } |
| bool TraverseAlignValueAttr(AlignValueAttr *A); |
| bool VisitAlignValueAttr(AlignValueAttr *A) { |
| return true; |
| } |
| bool TraverseAlignedAttr(AlignedAttr *A); |
| bool VisitAlignedAttr(AlignedAttr *A) { |
| return true; |
| } |
| bool TraverseAllocAlignAttr(AllocAlignAttr *A); |
| bool VisitAllocAlignAttr(AllocAlignAttr *A) { |
| return true; |
| } |
| bool TraverseAllocSizeAttr(AllocSizeAttr *A); |
| bool VisitAllocSizeAttr(AllocSizeAttr *A) { |
| return true; |
| } |
| bool TraverseAlwaysDestroyAttr(AlwaysDestroyAttr *A); |
| bool VisitAlwaysDestroyAttr(AlwaysDestroyAttr *A) { |
| return true; |
| } |
| bool TraverseAlwaysInlineAttr(AlwaysInlineAttr *A); |
| bool VisitAlwaysInlineAttr(AlwaysInlineAttr *A) { |
| return true; |
| } |
| bool TraverseAnalyzerNoReturnAttr(AnalyzerNoReturnAttr *A); |
| bool VisitAnalyzerNoReturnAttr(AnalyzerNoReturnAttr *A) { |
| return true; |
| } |
| bool TraverseAnnotateAttr(AnnotateAttr *A); |
| bool VisitAnnotateAttr(AnnotateAttr *A) { |
| return true; |
| } |
| bool TraverseAnyX86InterruptAttr(AnyX86InterruptAttr *A); |
| bool VisitAnyX86InterruptAttr(AnyX86InterruptAttr *A) { |
| return true; |
| } |
| bool TraverseAnyX86NoCallerSavedRegistersAttr(AnyX86NoCallerSavedRegistersAttr *A); |
| bool VisitAnyX86NoCallerSavedRegistersAttr(AnyX86NoCallerSavedRegistersAttr *A) { |
| return true; |
| } |
| bool TraverseAnyX86NoCfCheckAttr(AnyX86NoCfCheckAttr *A); |
| bool VisitAnyX86NoCfCheckAttr(AnyX86NoCfCheckAttr *A) { |
| return true; |
| } |
| bool TraverseArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A); |
| bool VisitArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A) { |
| return true; |
| } |
| bool TraverseArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *A); |
| bool VisitArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *A) { |
| return true; |
| } |
| bool TraverseArmBuiltinAliasAttr(ArmBuiltinAliasAttr *A); |
| bool VisitArmBuiltinAliasAttr(ArmBuiltinAliasAttr *A) { |
| return true; |
| } |
| bool TraverseArmMveStrictPolymorphismAttr(ArmMveStrictPolymorphismAttr *A); |
| bool VisitArmMveStrictPolymorphismAttr(ArmMveStrictPolymorphismAttr *A) { |
| return true; |
| } |
| bool TraverseArtificialAttr(ArtificialAttr *A); |
| bool VisitArtificialAttr(ArtificialAttr *A) { |
| return true; |
| } |
| bool TraverseAsmLabelAttr(AsmLabelAttr *A); |
| bool VisitAsmLabelAttr(AsmLabelAttr *A) { |
| return true; |
| } |
| bool TraverseAssertCapabilityAttr(AssertCapabilityAttr *A); |
| bool VisitAssertCapabilityAttr(AssertCapabilityAttr *A) { |
| return true; |
| } |
| bool TraverseAssertExclusiveLockAttr(AssertExclusiveLockAttr *A); |
| bool VisitAssertExclusiveLockAttr(AssertExclusiveLockAttr *A) { |
| return true; |
| } |
| bool TraverseAssertSharedLockAttr(AssertSharedLockAttr *A); |
| bool VisitAssertSharedLockAttr(AssertSharedLockAttr *A) { |
| return true; |
| } |
| bool TraverseAssumeAlignedAttr(AssumeAlignedAttr *A); |
| bool VisitAssumeAlignedAttr(AssumeAlignedAttr *A) { |
| return true; |
| } |
| bool TraverseAssumptionAttr(AssumptionAttr *A); |
| bool VisitAssumptionAttr(AssumptionAttr *A) { |
| return true; |
| } |
| bool TraverseAvailabilityAttr(AvailabilityAttr *A); |
| bool VisitAvailabilityAttr(AvailabilityAttr *A) { |
| return true; |
| } |
| bool TraverseBPFPreserveAccessIndexAttr(BPFPreserveAccessIndexAttr *A); |
| bool VisitBPFPreserveAccessIndexAttr(BPFPreserveAccessIndexAttr *A) { |
| return true; |
| } |
| bool TraverseBTFDeclTagAttr(BTFDeclTagAttr *A); |
| bool VisitBTFDeclTagAttr(BTFDeclTagAttr *A) { |
| return true; |
| } |
| bool TraverseBTFTypeTagAttr(BTFTypeTagAttr *A); |
| bool VisitBTFTypeTagAttr(BTFTypeTagAttr *A) { |
| return true; |
| } |
| bool TraverseBlocksAttr(BlocksAttr *A); |
| bool VisitBlocksAttr(BlocksAttr *A) { |
| return true; |
| } |
| bool TraverseBuiltinAttr(BuiltinAttr *A); |
| bool VisitBuiltinAttr(BuiltinAttr *A) { |
| return true; |
| } |
| bool TraverseBuiltinAliasAttr(BuiltinAliasAttr *A); |
| bool VisitBuiltinAliasAttr(BuiltinAliasAttr *A) { |
| return true; |
| } |
| bool TraverseC11NoReturnAttr(C11NoReturnAttr *A); |
| bool VisitC11NoReturnAttr(C11NoReturnAttr *A) { |
| return true; |
| } |
| bool TraverseCDeclAttr(CDeclAttr *A); |
| bool VisitCDeclAttr(CDeclAttr *A) { |
| return true; |
| } |
| bool TraverseCFAuditedTransferAttr(CFAuditedTransferAttr *A); |
| bool VisitCFAuditedTransferAttr(CFAuditedTransferAttr *A) { |
| return true; |
| } |
| bool TraverseCFConsumedAttr(CFConsumedAttr *A); |
| bool VisitCFConsumedAttr(CFConsumedAttr *A) { |
| return true; |
| } |
| bool TraverseCFGuardAttr(CFGuardAttr *A); |
| bool VisitCFGuardAttr(CFGuardAttr *A) { |
| return true; |
| } |
| bool TraverseCFICanonicalJumpTableAttr(CFICanonicalJumpTableAttr *A); |
| bool VisitCFICanonicalJumpTableAttr(CFICanonicalJumpTableAttr *A) { |
| return true; |
| } |
| bool TraverseCFReturnsNotRetainedAttr(CFReturnsNotRetainedAttr *A); |
| bool VisitCFReturnsNotRetainedAttr(CFReturnsNotRetainedAttr *A) { |
| return true; |
| } |
| bool TraverseCFReturnsRetainedAttr(CFReturnsRetainedAttr *A); |
| bool VisitCFReturnsRetainedAttr(CFReturnsRetainedAttr *A) { |
| return true; |
| } |
| bool TraverseCFUnknownTransferAttr(CFUnknownTransferAttr *A); |
| bool VisitCFUnknownTransferAttr(CFUnknownTransferAttr *A) { |
| return true; |
| } |
| bool TraverseCPUDispatchAttr(CPUDispatchAttr *A); |
| bool VisitCPUDispatchAttr(CPUDispatchAttr *A) { |
| return true; |
| } |
| bool TraverseCPUSpecificAttr(CPUSpecificAttr *A); |
| bool VisitCPUSpecificAttr(CPUSpecificAttr *A) { |
| return true; |
| } |
| bool TraverseCUDAConstantAttr(CUDAConstantAttr *A); |
| bool VisitCUDAConstantAttr(CUDAConstantAttr *A) { |
| return true; |
| } |
| bool TraverseCUDADeviceAttr(CUDADeviceAttr *A); |
| bool VisitCUDADeviceAttr(CUDADeviceAttr *A) { |
| return true; |
| } |
| bool TraverseCUDADeviceBuiltinSurfaceTypeAttr(CUDADeviceBuiltinSurfaceTypeAttr *A); |
| bool VisitCUDADeviceBuiltinSurfaceTypeAttr(CUDADeviceBuiltinSurfaceTypeAttr *A) { |
| return true; |
| } |
| bool TraverseCUDADeviceBuiltinTextureTypeAttr(CUDADeviceBuiltinTextureTypeAttr *A); |
| bool VisitCUDADeviceBuiltinTextureTypeAttr(CUDADeviceBuiltinTextureTypeAttr *A) { |
| return true; |
| } |
| bool TraverseCUDAGlobalAttr(CUDAGlobalAttr *A); |
| bool VisitCUDAGlobalAttr(CUDAGlobalAttr *A) { |
| return true; |
| } |
| bool TraverseCUDAHostAttr(CUDAHostAttr *A); |
| bool VisitCUDAHostAttr(CUDAHostAttr *A) { |
| return true; |
| } |
| bool TraverseCUDAInvalidTargetAttr(CUDAInvalidTargetAttr *A); |
| bool VisitCUDAInvalidTargetAttr(CUDAInvalidTargetAttr *A) { |
| return true; |
| } |
| bool TraverseCUDALaunchBoundsAttr(CUDALaunchBoundsAttr *A); |
| bool VisitCUDALaunchBoundsAttr(CUDALaunchBoundsAttr *A) { |
| return true; |
| } |
| bool TraverseCUDASharedAttr(CUDASharedAttr *A); |
| bool VisitCUDASharedAttr(CUDASharedAttr *A) { |
| return true; |
| } |
| bool TraverseCXX11NoReturnAttr(CXX11NoReturnAttr *A); |
| bool VisitCXX11NoReturnAttr(CXX11NoReturnAttr *A) { |
| return true; |
| } |
| bool TraverseCallableWhenAttr(CallableWhenAttr *A); |
| bool VisitCallableWhenAttr(CallableWhenAttr *A) { |
| return true; |
| } |
| bool TraverseCallbackAttr(CallbackAttr *A); |
| bool VisitCallbackAttr(CallbackAttr *A) { |
| return true; |
| } |
| bool TraverseCalledOnceAttr(CalledOnceAttr *A); |
| bool VisitCalledOnceAttr(CalledOnceAttr *A) { |
| return true; |
| } |
| bool TraverseCapabilityAttr(CapabilityAttr *A); |
| bool VisitCapabilityAttr(CapabilityAttr *A) { |
| return true; |
| } |
| bool TraverseCapturedRecordAttr(CapturedRecordAttr *A); |
| bool VisitCapturedRecordAttr(CapturedRecordAttr *A) { |
| return true; |
| } |
| bool TraverseCarriesDependencyAttr(CarriesDependencyAttr *A); |
| bool VisitCarriesDependencyAttr(CarriesDependencyAttr *A) { |
| return true; |
| } |
| bool TraverseCleanupAttr(CleanupAttr *A); |
| bool VisitCleanupAttr(CleanupAttr *A) { |
| return true; |
| } |
| bool TraverseCmseNSCallAttr(CmseNSCallAttr *A); |
| bool VisitCmseNSCallAttr(CmseNSCallAttr *A) { |
| return true; |
| } |
| bool TraverseCmseNSEntryAttr(CmseNSEntryAttr *A); |
| bool VisitCmseNSEntryAttr(CmseNSEntryAttr *A) { |
| return true; |
| } |
| bool TraverseCodeSegAttr(CodeSegAttr *A); |
| bool VisitCodeSegAttr(CodeSegAttr *A) { |
| return true; |
| } |
| bool TraverseColdAttr(ColdAttr *A); |
| bool VisitColdAttr(ColdAttr *A) { |
| return true; |
| } |
| bool TraverseCommonAttr(CommonAttr *A); |
| bool VisitCommonAttr(CommonAttr *A) { |
| return true; |
| } |
| bool TraverseConstAttr(ConstAttr *A); |
| bool VisitConstAttr(ConstAttr *A) { |
| return true; |
| } |
| bool TraverseConstInitAttr(ConstInitAttr *A); |
| bool VisitConstInitAttr(ConstInitAttr *A) { |
| return true; |
| } |
| bool TraverseConstructorAttr(ConstructorAttr *A); |
| bool VisitConstructorAttr(ConstructorAttr *A) { |
| return true; |
| } |
| bool TraverseConsumableAttr(ConsumableAttr *A); |
| bool VisitConsumableAttr(ConsumableAttr *A) { |
| return true; |
| } |
| bool TraverseConsumableAutoCastAttr(ConsumableAutoCastAttr *A); |
| bool VisitConsumableAutoCastAttr(ConsumableAutoCastAttr *A) { |
| return true; |
| } |
| bool TraverseConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A); |
| bool VisitConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A) { |
| return true; |
| } |
| bool TraverseConvergentAttr(ConvergentAttr *A); |
| bool VisitConvergentAttr(ConvergentAttr *A) { |
| return true; |
| } |
| bool TraverseDLLExportAttr(DLLExportAttr *A); |
| bool VisitDLLExportAttr(DLLExportAttr *A) { |
| return true; |
| } |
| bool TraverseDLLExportStaticLocalAttr(DLLExportStaticLocalAttr *A); |
| bool VisitDLLExportStaticLocalAttr(DLLExportStaticLocalAttr *A) { |
| return true; |
| } |
| bool TraverseDLLImportAttr(DLLImportAttr *A); |
| bool VisitDLLImportAttr(DLLImportAttr *A) { |
| return true; |
| } |
| bool TraverseDLLImportStaticLocalAttr(DLLImportStaticLocalAttr *A); |
| bool VisitDLLImportStaticLocalAttr(DLLImportStaticLocalAttr *A) { |
| return true; |
| } |
| bool TraverseDeprecatedAttr(DeprecatedAttr *A); |
| bool VisitDeprecatedAttr(DeprecatedAttr *A) { |
| return true; |
| } |
| bool TraverseDestructorAttr(DestructorAttr *A); |
| bool VisitDestructorAttr(DestructorAttr *A) { |
| return true; |
| } |
| bool 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 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 TraverseHLSLNumThreadsAttr(HLSLNumThreadsAttr *A); |
| bool VisitHLSLNumThreadsAttr(HLSLNumThreadsAttr *A) { |
| return true; |
| } |
| bool TraverseHotAttr(HotAttr *A); |
| bool VisitHotAttr(HotAttr *A) { |
| return true; |
| } |
| bool TraverseIBActionAttr(IBActionAttr *A); |
| bool VisitIBActionAttr(IBActionAttr *A) { |
| return true; |
| } |
| bool TraverseIBOutletAttr(IBOutletAttr *A); |
| bool VisitIBOutletAttr(IBOutletAttr *A) { |
| return true; |
| } |
| bool TraverseIBOutletCollectionAttr(IBOutletCollectionAttr *A); |
| bool VisitIBOutletCollectionAttr(IBOutletCollectionAttr *A) { |
| return true; |
| } |
| bool TraverseIFuncAttr(IFuncAttr *A); |
| bool VisitIFuncAttr(IFuncAttr *A) { |
| return true; |
| } |
| bool TraverseInitPriorityAttr(InitPriorityAttr *A); |
| bool VisitInitPriorityAttr(InitPriorityAttr *A) { |
| return true; |
| } |
| bool TraverseInitSegAttr(InitSegAttr *A); |
| bool VisitInitSegAttr(InitSegAttr *A) { |
| return true; |
| } |
| bool TraverseIntelOclBiccAttr(IntelOclBiccAttr *A); |
| bool VisitIntelOclBiccAttr(IntelOclBiccAttr *A) { |
| return true; |
| } |
| bool TraverseInternalLinkageAttr(InternalLinkageAttr *A); |
| bool VisitInternalLinkageAttr(InternalLinkageAttr *A) { |
| return true; |
| } |
| bool TraverseLTOVisibilityPublicAttr(LTOVisibilityPublicAttr *A); |
| bool VisitLTOVisibilityPublicAttr(LTOVisibilityPublicAttr *A) { |
| return true; |
| } |
| bool TraverseLayoutVersionAttr(LayoutVersionAttr *A); |
| bool VisitLayoutVersionAttr(LayoutVersionAttr *A) { |
| return true; |
| } |
| bool TraverseLeafAttr(LeafAttr *A); |
| bool VisitLeafAttr(LeafAttr *A) { |
| return true; |
| } |
| bool TraverseLifetimeBoundAttr(LifetimeBoundAttr *A); |
| bool VisitLifetimeBoundAttr(LifetimeBoundAttr *A) { |
| return true; |
| } |
| bool TraverseLikelyAttr(LikelyAttr *A); |
| bool VisitLikelyAttr(LikelyAttr *A) { |
| return true; |
| } |
| bool TraverseLoaderUninitializedAttr(LoaderUninitializedAttr *A); |
| bool VisitLoaderUninitializedAttr(LoaderUninitializedAttr *A) { |
| return true; |
| } |
| bool TraverseLockReturnedAttr(LockReturnedAttr *A); |
| bool VisitLockReturnedAttr(LockReturnedAttr *A) { |
| return true; |
| } |
| bool TraverseLocksExcludedAttr(LocksExcludedAttr *A); |
| bool VisitLocksExcludedAttr(LocksExcludedAttr *A) { |
| return true; |
| } |
| bool TraverseLoopHintAttr(LoopHintAttr *A); |
| bool VisitLoopHintAttr(LoopHintAttr *A) { |
| return true; |
| } |
| bool TraverseM68kInterruptAttr(M68kInterruptAttr *A); |
| bool VisitM68kInterruptAttr(M68kInterruptAttr *A) { |
| return true; |
| } |
| bool TraverseMIGServerRoutineAttr(MIGServerRoutineAttr *A); |
| bool VisitMIGServerRoutineAttr(MIGServerRoutineAttr *A) { |
| return true; |
| } |
| bool TraverseMSABIAttr(MSABIAttr *A); |
| bool VisitMSABIAttr(MSABIAttr *A) { |
| return true; |
| } |
| bool TraverseMSAllocatorAttr(MSAllocatorAttr *A); |
| bool VisitMSAllocatorAttr(MSAllocatorAttr *A) { |
| return true; |
| } |
| bool TraverseMSInheritanceAttr(MSInheritanceAttr *A); |
| bool VisitMSInheritanceAttr(MSInheritanceAttr *A) { |
| return true; |
| } |
| bool TraverseMSNoVTableAttr(MSNoVTableAttr *A); |
| bool VisitMSNoVTableAttr(MSNoVTableAttr *A) { |
| return true; |
| } |
| bool TraverseMSP430InterruptAttr(MSP430InterruptAttr *A); |
| bool VisitMSP430InterruptAttr(MSP430InterruptAttr *A) { |
| return true; |
| } |
| bool TraverseMSStructAttr(MSStructAttr *A); |
| bool VisitMSStructAttr(MSStructAttr *A) { |
| return true; |
| } |
| bool TraverseMSVtorDispAttr(MSVtorDispAttr *A); |
| bool VisitMSVtorDispAttr(MSVtorDispAttr *A) { |
| return true; |
| } |
| bool TraverseMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A); |
| bool VisitMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A) { |
| return true; |
| } |
| bool TraverseMayAliasAttr(MayAliasAttr *A); |
| bool VisitMayAliasAttr(MayAliasAttr *A) { |
| return true; |
| } |
| bool TraverseMicroMipsAttr(MicroMipsAttr *A); |
| bool VisitMicroMipsAttr(MicroMipsAttr *A) { |
| return true; |
| } |
| bool TraverseMinSizeAttr(MinSizeAttr *A); |
| bool VisitMinSizeAttr(MinSizeAttr *A) { |
| return true; |
| } |
| bool TraverseMinVectorWidthAttr(MinVectorWidthAttr *A); |
| bool VisitMinVectorWidthAttr(MinVectorWidthAttr *A) { |
| return true; |
| } |
| bool TraverseMips16Attr(Mips16Attr *A); |
| bool VisitMips16Attr(Mips16Attr *A) { |
| return true; |
| } |
| bool TraverseMipsInterruptAttr(MipsInterruptAttr *A); |
| bool VisitMipsInterruptAttr(MipsInterruptAttr *A) { |
| return true; |
| } |
| bool TraverseMipsLongCallAttr(MipsLongCallAttr *A); |
| bool VisitMipsLongCallAttr(MipsLongCallAttr *A) { |
| return true; |
| } |
| bool TraverseMipsShortCallAttr(MipsShortCallAttr *A); |
| bool VisitMipsShortCallAttr(MipsShortCallAttr *A) { |
| return true; |
| } |
| bool TraverseModeAttr(ModeAttr *A); |
| bool VisitModeAttr(ModeAttr *A) { |
| return true; |
| } |
| bool TraverseMustTailAttr(MustTailAttr *A); |
| bool VisitMustTailAttr(MustTailAttr *A) { |
| return true; |
| } |
| bool TraverseNSConsumedAttr(NSConsumedAttr *A); |
| bool VisitNSConsumedAttr(NSConsumedAttr *A) { |
| return true; |
| } |
| bool TraverseNSConsumesSelfAttr(NSConsumesSelfAttr *A); |
| bool VisitNSConsumesSelfAttr(NSConsumesSelfAttr *A) { |
| return true; |
| } |
| bool TraverseNSErrorDomainAttr(NSErrorDomainAttr *A); |
| bool VisitNSErrorDomainAttr(NSErrorDomainAttr *A) { |
| return true; |
| } |
| bool TraverseNSReturnsAutoreleasedAttr(NSReturnsAutoreleasedAttr *A); |
| bool VisitNSReturnsAutoreleasedAttr(NSReturnsAutoreleasedAttr *A) { |
| return true; |
| } |
| bool TraverseNSReturnsNotRetainedAttr(NSReturnsNotRetainedAttr *A); |
| bool VisitNSReturnsNotRetainedAttr(NSReturnsNotRetainedAttr *A) { |
| return true; |
| } |
| bool TraverseNSReturnsRetainedAttr(NSReturnsRetainedAttr *A); |
| bool VisitNSReturnsRetainedAttr(NSReturnsRetainedAttr *A) { |
| return true; |
| } |
| bool TraverseNakedAttr(NakedAttr *A); |
| bool VisitNakedAttr(NakedAttr *A) { |
| return true; |
| } |
| bool TraverseNoAliasAttr(NoAliasAttr *A); |
| bool VisitNoAliasAttr(NoAliasAttr *A) { |
| return true; |
| } |
| bool TraverseNoBuiltinAttr(NoBuiltinAttr *A); |
| bool VisitNoBuiltinAttr(NoBuiltinAttr *A) { |
| return true; |
| } |
| bool TraverseNoCommonAttr(NoCommonAttr *A); |
| bool VisitNoCommonAttr(NoCommonAttr *A) { |
| return true; |
| } |
| bool TraverseNoDebugAttr(NoDebugAttr *A); |
| bool VisitNoDebugAttr(NoDebugAttr *A) { |
| return true; |
| } |
| bool TraverseNoDerefAttr(NoDerefAttr *A); |
| bool VisitNoDerefAttr(NoDerefAttr *A) { |
| return true; |
| } |
| bool TraverseNoDestroyAttr(NoDestroyAttr *A); |
| bool VisitNoDestroyAttr(NoDestroyAttr *A) { |
| return true; |
| } |
| bool TraverseNoDuplicateAttr(NoDuplicateAttr *A); |
| bool VisitNoDuplicateAttr(NoDuplicateAttr *A) { |
| return true; |
| } |
| bool TraverseNoEscapeAttr(NoEscapeAttr *A); |
| bool VisitNoEscapeAttr(NoEscapeAttr *A) { |
| return true; |
| } |
| bool TraverseNoInlineAttr(NoInlineAttr *A); |
| bool VisitNoInlineAttr(NoInlineAttr *A) { |
| return true; |
| } |
| bool TraverseNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A); |
| bool VisitNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A) { |
| return true; |
| } |
| bool TraverseNoMergeAttr(NoMergeAttr *A); |
| bool VisitNoMergeAttr(NoMergeAttr *A) { |
| return true; |
| } |
| bool TraverseNoMicroMipsAttr(NoMicroMipsAttr *A); |
| bool VisitNoMicroMipsAttr(NoMicroMipsAttr *A) { |
| return true; |
| } |
| bool TraverseNoMips16Attr(NoMips16Attr *A); |
| bool VisitNoMips16Attr(NoMips16Attr *A) { |
| return true; |
| } |
| bool TraverseNoProfileFunctionAttr(NoProfileFunctionAttr *A); |
| bool VisitNoProfileFunctionAttr(NoProfileFunctionAttr *A) { |
| return true; |
| } |
| bool TraverseNoReturnAttr(NoReturnAttr *A); |
| bool VisitNoReturnAttr(NoReturnAttr *A) { |
| return true; |
| } |
| bool TraverseNoSanitizeAttr(NoSanitizeAttr *A); |
| bool VisitNoSanitizeAttr(NoSanitizeAttr *A) { |
| return true; |
| } |
| bool TraverseNoSpeculativeLoadHardeningAttr(NoSpeculativeLoadHardeningAttr *A); |
| bool VisitNoSpeculativeLoadHardeningAttr(NoSpeculativeLoadHardeningAttr *A) { |
| return true; |
| } |
| bool TraverseNoSplitStackAttr(NoSplitStackAttr *A); |
| bool VisitNoSplitStackAttr(NoSplitStackAttr *A) { |
| return true; |
| } |
| bool TraverseNoStackProtectorAttr(NoStackProtectorAttr *A); |
| bool VisitNoStackProtectorAttr(NoStackProtectorAttr *A) { |
| return true; |
| } |
| bool TraverseNoThreadSafetyAnalysisAttr(NoThreadSafetyAnalysisAttr *A); |
| bool VisitNoThreadSafetyAnalysisAttr(NoThreadSafetyAnalysisAttr *A) { |
| return true; |
| } |
| bool TraverseNoThrowAttr(NoThrowAttr *A); |
| bool VisitNoThrowAttr(NoThrowAttr *A) { |
| return true; |
| } |
| bool TraverseNoUniqueAddressAttr(NoUniqueAddressAttr *A); |
| bool VisitNoUniqueAddressAttr(NoUniqueAddressAttr *A) { |
| return true; |
| } |
| bool TraverseNonNullAttr(NonNullAttr *A); |
| bool VisitNonNullAttr(NonNullAttr *A) { |
| return true; |
| } |
| bool TraverseNotTailCalledAttr(NotTailCalledAttr *A); |
| bool VisitNotTailCalledAttr(NotTailCalledAttr *A) { |
| return true; |
| } |
| bool TraverseOMPAllocateDeclAttr(OMPAllocateDeclAttr *A); |
| bool VisitOMPAllocateDeclAttr(OMPAllocateDeclAttr *A) { |
| return true; |
| } |
| bool TraverseOMPCaptureKindAttr(OMPCaptureKindAttr *A); |
| bool VisitOMPCaptureKindAttr(OMPCaptureKindAttr *A) { |
| return true; |
| } |
| bool TraverseOMPCaptureNoInitAttr(OMPCaptureNoInitAttr *A); |
| bool VisitOMPCaptureNoInitAttr(OMPCaptureNoInitAttr *A) { |
| return true; |
| } |
| bool TraverseOMPDeclareSimdDeclAttr(OMPDeclareSimdDeclAttr *A); |
| bool VisitOMPDeclareSimdDeclAttr(OMPDeclareSimdDeclAttr *A) { |
| return true; |
| } |
| bool TraverseOMPDeclareTargetDeclAttr(OMPDeclareTargetDeclAttr *A); |
| bool VisitOMPDeclareTargetDeclAttr(OMPDeclareTargetDeclAttr *A) { |
| return true; |
| } |
| bool TraverseOMPDeclareVariantAttr(OMPDeclareVariantAttr *A); |
| bool VisitOMPDeclareVariantAttr(OMPDeclareVariantAttr *A) { |
| return true; |
| } |
| bool TraverseOMPReferencedVarAttr(OMPReferencedVarAttr *A); |
| bool VisitOMPReferencedVarAttr(OMPReferencedVarAttr *A) { |
| return true; |
| } |
| bool TraverseOMPThreadPrivateDeclAttr(OMPThreadPrivateDeclAttr *A); |
| bool VisitOMPThreadPrivateDeclAttr(OMPThreadPrivateDeclAttr *A) { |
| return true; |
| } |
| bool TraverseOSConsumedAttr(OSConsumedAttr *A); |
| bool VisitOSConsumedAttr(OSConsumedAttr *A) { |
| return true; |
| } |
| bool TraverseOSConsumesThisAttr(OSConsumesThisAttr *A); |
| bool VisitOSConsumesThisAttr(OSConsumesThisAttr *A) { |
| return true; |
| } |
| bool TraverseOSReturnsNotRetainedAttr(OSReturnsNotRetainedAttr *A); |
| bool VisitOSReturnsNotRetainedAttr(OSReturnsNotRetainedAttr *A) { |
| return true; |
| } |
| bool TraverseOSReturnsRetainedAttr(OSReturnsRetainedAttr *A); |
| bool VisitOSReturnsRetainedAttr(OSReturnsRetainedAttr *A) { |
| return true; |
| } |
| bool TraverseOSReturnsRetainedOnNonZeroAttr(OSReturnsRetainedOnNonZeroAttr *A); |
| bool VisitOSReturnsRetainedOnNonZeroAttr(OSReturnsRetainedOnNonZeroAttr *A) { |
| return true; |
| } |
| bool TraverseOSReturnsRetainedOnZeroAttr(OSReturnsRetainedOnZeroAttr *A); |
| bool VisitOSReturnsRetainedOnZeroAttr(OSReturnsRetainedOnZeroAttr *A) { |
| return true; |
| } |
| bool TraverseObjCBoxableAttr(ObjCBoxableAttr *A); |
| bool VisitObjCBoxableAttr(ObjCBoxableAttr *A) { |
| return true; |
| } |
| bool TraverseObjCBridgeAttr(ObjCBridgeAttr *A); |
| bool VisitObjCBridgeAttr(ObjCBridgeAttr *A) { |
| return true; |
| } |
| bool TraverseObjCBridgeMutableAttr(ObjCBridgeMutableAttr *A); |
| bool VisitObjCBridgeMutableAttr(ObjCBridgeMutableAttr *A) { |
| return true; |
| } |
| bool TraverseObjCBridgeRelatedAttr(ObjCBridgeRelatedAttr *A); |
| bool VisitObjCBridgeRelatedAttr(ObjCBridgeRelatedAttr *A) { |
| return true; |
| } |
| bool TraverseObjCClassStubAttr(ObjCClassStubAttr *A); |
| bool VisitObjCClassStubAttr(ObjCClassStubAttr *A) { |
| return true; |
| } |
| bool TraverseObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A); |
| bool VisitObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A) { |
| return true; |
| } |
| bool TraverseObjCDirectAttr(ObjCDirectAttr *A); |
| bool VisitObjCDirectAttr(ObjCDirectAttr *A) { |
| return true; |
| } |
| bool TraverseObjCDirectMembersAttr(ObjCDirectMembersAttr *A); |
| bool VisitObjCDirectMembersAttr(ObjCDirectMembersAttr *A) { |
| return true; |
| } |
| bool TraverseObjCExceptionAttr(ObjCExceptionAttr *A); |
| bool VisitObjCExceptionAttr(ObjCExceptionAttr *A) { |
| return true; |
| } |
| bool TraverseObjCExplicitProtocolImplAttr(ObjCExplicitProtocolImplAttr *A); |
| bool VisitObjCExplicitProtocolImplAttr(ObjCExplicitProtocolImplAttr *A) { |
| return true; |
| } |
| bool TraverseObjCExternallyRetainedAttr(ObjCExternallyRetainedAttr *A); |
| bool VisitObjCExternallyRetainedAttr(ObjCExternallyRetainedAttr *A) { |
| return true; |
| } |
| bool TraverseObjCGCAttr(ObjCGCAttr *A); |
| bool VisitObjCGCAttr(ObjCGCAttr *A) { |
| return true; |
| } |
| bool TraverseObjCIndependentClassAttr(ObjCIndependentClassAttr *A); |
| bool VisitObjCIndependentClassAttr(ObjCIndependentClassAttr *A) { |
| return true; |
| } |
| bool TraverseObjCInertUnsafeUnretainedAttr(ObjCInertUnsafeUnretainedAttr *A); |
| bool VisitObjCInertUnsafeUnretainedAttr(ObjCInertUnsafeUnretainedAttr *A) { |
| return true; |
| } |
| bool TraverseObjCKindOfAttr(ObjCKindOfAttr *A); |
| bool VisitObjCKindOfAttr(ObjCKindOfAttr *A) { |
| return true; |
| } |
| bool TraverseObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A); |
| bool VisitObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A) { |
| return true; |
| } |
| bool TraverseObjCNSObjectAttr(ObjCNSObjectAttr *A); |
| bool VisitObjCNSObjectAttr(ObjCNSObjectAttr *A) { |
| return true; |
| } |
| bool TraverseObjCNonLazyClassAttr(ObjCNonLazyClassAttr *A); |
| bool VisitObjCNonLazyClassAttr(ObjCNonLazyClassAttr *A) { |
| return true; |
| } |
| bool TraverseObjCNonRuntimeProtocolAttr(ObjCNonRuntimeProtocolAttr *A); |
| bool VisitObjCNonRuntimeProtocolAttr(ObjCNonRuntimeProtocolAttr *A) { |
| return true; |
| } |
| bool TraverseObjCOwnershipAttr(ObjCOwnershipAttr *A); |
| bool VisitObjCOwnershipAttr(ObjCOwnershipAttr *A) { |
| return true; |
| } |
| bool TraverseObjCPreciseLifetimeAttr(ObjCPreciseLifetimeAttr *A); |
| bool VisitObjCPreciseLifetimeAttr(ObjCPreciseLifetimeAttr *A) { |
| return true; |
| } |
| bool TraverseObjCRequiresPropertyDefsAttr(ObjCRequiresPropertyDefsAttr *A); |
| bool VisitObjCRequiresPropertyDefsAttr(ObjCRequiresPropertyDefsAttr *A) { |
| return true; |
| } |
| bool TraverseObjCRequiresSuperAttr(ObjCRequiresSuperAttr *A); |
| bool VisitObjCRequiresSuperAttr(ObjCRequiresSuperAttr *A) { |
| return true; |
| } |
| bool TraverseObjCReturnsInnerPointerAttr(ObjCReturnsInnerPointerAttr *A); |
| bool VisitObjCReturnsInnerPointerAttr(ObjCReturnsInnerPointerAttr *A) { |
| return true; |
| } |
| bool TraverseObjCRootClassAttr(ObjCRootClassAttr *A); |
| bool VisitObjCRootClassAttr(ObjCRootClassAttr *A) { |
| return true; |
| } |
| bool TraverseObjCRuntimeNameAttr(ObjCRuntimeNameAttr *A); |
| bool VisitObjCRuntimeNameAttr(ObjCRuntimeNameAttr *A) { |
| return true; |
| } |
| bool TraverseObjCRuntimeVisibleAttr(ObjCRuntimeVisibleAttr *A); |
| bool VisitObjCRuntimeVisibleAttr(ObjCRuntimeVisibleAttr *A) { |
| return true; |
| } |
| bool TraverseObjCSubclassingRestrictedAttr(ObjCSubclassingRestrictedAttr *A); |
| bool VisitObjCSubclassingRestrictedAttr(ObjCSubclassingRestrictedAttr *A) { |
| return true; |
| } |
| bool TraverseOpenCLAccessAttr(OpenCLAccessAttr *A); |
| bool VisitOpenCLAccessAttr(OpenCLAccessAttr *A) { |
| return true; |
| } |
| bool TraverseOpenCLConstantAddressSpaceAttr(OpenCLConstantAddressSpaceAttr *A); |
| bool VisitOpenCLConstantAddressSpaceAttr(OpenCLConstantAddressSpaceAttr *A) { |
| return true; |
| } |
| bool TraverseOpenCLGenericAddressSpaceAttr(OpenCLGenericAddressSpaceAttr *A); |
| bool VisitOpenCLGenericAddressSpaceAttr(OpenCLGenericAddressSpaceAttr *A) { |
| return true; |
| } |
| bool TraverseOpenCLGlobalAddressSpaceAttr(OpenCLGlobalAddressSpaceAttr *A); |
| bool VisitOpenCLGlobalAddressSpaceAttr(OpenCLGlobalAddressSpaceAttr *A) { |
| return true; |
| } |
| bool TraverseOpenCLGlobalDeviceAddressSpaceAttr(OpenCLGlobalDeviceAddressSpaceAttr *A); |
| bool VisitOpenCLGlobalDeviceAddressSpaceAttr(OpenCLGlobalDeviceAddressSpaceAttr *A) { |
| return true; |
| } |
| bool TraverseOpenCLGlobalHostAddressSpaceAttr(OpenCLGlobalHostAddressSpaceAttr *A); |
| bool VisitOpenCLGlobalHostAddressSpaceAttr(OpenCLGlobalHostAddressSpaceAttr *A) { |
| return true; |
| } |
| bool TraverseOpenCLIntelReqdSubGroupSizeAttr(OpenCLIntelReqdSubGroupSizeAttr *A); |
| bool VisitOpenCLIntelReqdSubGroupSizeAttr(OpenCLIntelReqdSubGroupSizeAttr *A) { |
| return true; |
| } |
| bool TraverseOpenCLKernelAttr(OpenCLKernelAttr *A); |
| bool VisitOpenCLKernelAttr(OpenCLKernelAttr *A) { |
| return true; |
| } |
| bool TraverseOpenCLLocalAddressSpaceAttr(OpenCLLocalAddressSpaceAttr *A); |
| bool VisitOpenCLLocalAddressSpaceAttr(OpenCLLocalAddressSpaceAttr *A) { |
| return true; |
| } |
| bool TraverseOpenCLPrivateAddressSpaceAttr(OpenCLPrivateAddressSpaceAttr *A); |
| bool VisitOpenCLPrivateAddressSpaceAttr(OpenCLPrivateAddressSpaceAttr *A) { |
| return true; |
| } |
| bool TraverseOpenCLUnrollHintAttr(OpenCLUnrollHintAttr *A); |
| bool VisitOpenCLUnrollHintAttr(OpenCLUnrollHintAttr *A) { |
| return true; |
| } |
| bool TraverseOptimizeNoneAttr(OptimizeNoneAttr *A); |
| bool VisitOptimizeNoneAttr(OptimizeNoneAttr *A) { |
| return true; |
| } |
| bool TraverseOverloadableAttr(OverloadableAttr *A); |
| bool VisitOverloadableAttr(OverloadableAttr *A) { |
| return true; |
| } |
| bool TraverseOverrideAttr(OverrideAttr *A); |
| bool VisitOverrideAttr(OverrideAttr *A) { |
| return true; |
| } |
| bool TraverseOwnerAttr(OwnerAttr *A); |
| bool VisitOwnerAttr(OwnerAttr *A) { |
| return true; |
| } |
| bool TraverseOwnershipAttr(OwnershipAttr *A); |
| bool VisitOwnershipAttr(OwnershipAttr *A) { |
| return true; |
| } |
| bool TraversePackedAttr(PackedAttr *A); |
| bool VisitPackedAttr(PackedAttr *A) { |
| return true; |
| } |
| bool TraverseParamTypestateAttr(ParamTypestateAttr *A); |
| bool VisitParamTypestateAttr(ParamTypestateAttr *A) { |
| return true; |
| } |
| bool TraversePascalAttr(PascalAttr *A); |
| bool VisitPascalAttr(PascalAttr *A) { |
| return true; |
| } |
| bool TraversePassObjectSizeAttr(PassObjectSizeAttr *A); |
| bool VisitPassObjectSizeAttr(PassObjectSizeAttr *A) { |
| return true; |
| } |
| bool TraversePatchableFunctionEntryAttr(PatchableFunctionEntryAttr *A); |
| bool VisitPatchableFunctionEntryAttr(PatchableFunctionEntryAttr *A) { |
| return true; |
| } |
| bool TraversePcsAttr(PcsAttr *A); |
| bool VisitPcsAttr(PcsAttr *A) { |
| return true; |
| } |
| bool TraversePointerAttr(PointerAttr *A); |
| bool VisitPointerAttr(PointerAttr *A) { |
| return true; |
| } |
| bool TraversePragmaClangBSSSectionAttr(PragmaClangBSSSectionAttr *A); |
| bool VisitPragmaClangBSSSectionAttr(PragmaClangBSSSectionAttr *A) { |
| return true; |
| } |
| bool TraversePragmaClangDataSectionAttr(PragmaClangDataSectionAttr *A); |
| bool VisitPragmaClangDataSectionAttr(PragmaClangDataSectionAttr *A) { |
| return true; |
| } |
| bool TraversePragmaClangRelroSectionAttr(PragmaClangRelroSectionAttr *A); |
| bool VisitPragmaClangRelroSectionAttr(PragmaClangRelroSectionAttr *A) { |
| return true; |
| } |
| bool TraversePragmaClangRodataSectionAttr(PragmaClangRodataSectionAttr *A); |
| bool VisitPragmaClangRodataSectionAttr(PragmaClangRodataSectionAttr *A) { |
| return true; |
| } |
| bool TraversePragmaClangTextSectionAttr(PragmaClangTextSectionAttr *A); |
| bool VisitPragmaClangTextSectionAttr(PragmaClangTextSectionAttr *A) { |
| return true; |
| } |
| bool TraversePreferredNameAttr(PreferredNameAttr *A); |
| bool VisitPreferredNameAttr(PreferredNameAttr *A) { |
| return true; |
| } |
| bool TraversePreserveAllAttr(PreserveAllAttr *A); |
| bool VisitPreserveAllAttr(PreserveAllAttr *A) { |
| return true; |
| } |
| bool TraversePreserveMostAttr(PreserveMostAttr *A); |
| bool VisitPreserveMostAttr(PreserveMostAttr *A) { |
| return true; |
| } |
| bool TraversePtGuardedByAttr(PtGuardedByAttr *A); |
| bool VisitPtGuardedByAttr(PtGuardedByAttr *A) { |
| return true; |
| } |
| bool TraversePtGuardedVarAttr(PtGuardedVarAttr *A); |
| bool VisitPtGuardedVarAttr(PtGuardedVarAttr *A) { |
| return true; |
| } |
| bool TraversePtr32Attr(Ptr32Attr *A); |
| bool VisitPtr32Attr(Ptr32Attr *A) { |
| return true; |
| } |
| bool TraversePtr64Attr(Ptr64Attr *A); |
| bool VisitPtr64Attr(Ptr64Attr *A) { |
| return true; |
| } |
| bool TraversePureAttr(PureAttr *A); |
| bool VisitPureAttr(PureAttr *A) { |
| return true; |
| } |
| bool TraverseRISCVInterruptAttr(RISCVInterruptAttr *A); |
| bool VisitRISCVInterruptAttr(RISCVInterruptAttr *A) { |
| return true; |
| } |
| bool TraverseRegCallAttr(RegCallAttr *A); |
| bool VisitRegCallAttr(RegCallAttr *A) { |
| return true; |
| } |
| bool TraverseReinitializesAttr(ReinitializesAttr *A); |
| bool VisitReinitializesAttr(ReinitializesAttr *A) { |
| return true; |
| } |
| bool TraverseReleaseCapabilityAttr(ReleaseCapabilityAttr *A); |
| bool VisitReleaseCapabilityAttr(ReleaseCapabilityAttr *A) { |
| return true; |
| } |
| bool TraverseReleaseHandleAttr(ReleaseHandleAttr *A); |
| bool VisitReleaseHandleAttr(ReleaseHandleAttr *A) { |
| return true; |
| } |
| bool TraverseRenderScriptKernelAttr(RenderScriptKernelAttr *A); |
| bool VisitRenderScriptKernelAttr(RenderScriptKernelAttr *A) { |
| return true; |
| } |
| bool TraverseReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A); |
| bool VisitReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A) { |
| return true; |
| } |
| bool TraverseRequiresCapabilityAttr(RequiresCapabilityAttr *A); |
| bool VisitRequiresCapabilityAttr(RequiresCapabilityAttr *A) { |
| return true; |
| } |
| bool TraverseRestrictAttr(RestrictAttr *A); |
| bool VisitRestrictAttr(RestrictAttr *A) { |
| return true; |
| } |
| bool TraverseRetainAttr(RetainAttr *A); |
| bool VisitRetainAttr(RetainAttr *A) { |
| return true; |
| } |
| bool TraverseReturnTypestateAttr(ReturnTypestateAttr *A); |
| bool VisitReturnTypestateAttr(ReturnTypestateAttr *A) { |
| return true; |
| } |
| bool TraverseReturnsNonNullAttr(ReturnsNonNullAttr *A); |
| bool VisitReturnsNonNullAttr(ReturnsNonNullAttr *A) { |
| return true; |
| } |
| bool TraverseReturnsTwiceAttr(ReturnsTwiceAttr *A); |
| bool VisitReturnsTwiceAttr(ReturnsTwiceAttr *A) { |
| return true; |
| } |
| bool TraverseSPtrAttr(SPtrAttr *A); |
| bool VisitSPtrAttr(SPtrAttr *A) { |
| return true; |
| } |
| bool TraverseSYCLKernelAttr(SYCLKernelAttr *A); |
| bool VisitSYCLKernelAttr(SYCLKernelAttr *A) { |
| return true; |
| } |
| bool 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 TraverseSpeculativeLoadHardeningAttr(SpeculativeLoadHardeningAttr *A); |
| bool VisitSpeculativeLoadHardeningAttr(SpeculativeLoadHardeningAttr *A) { |
| return true; |
| } |
| bool TraverseStandaloneDebugAttr(StandaloneDebugAttr *A); |
| bool VisitStandaloneDebugAttr(StandaloneDebugAttr *A) { |
| return true; |
| } |
| bool TraverseStdCallAttr(StdCallAttr *A); |
| bool VisitStdCallAttr(StdCallAttr *A) { |
| return true; |
| } |
| bool TraverseStrictFPAttr(StrictFPAttr *A); |
| bool VisitStrictFPAttr(StrictFPAttr *A) { |
| return true; |
| } |
| bool TraverseSuppressAttr(SuppressAttr *A); |
| bool VisitSuppressAttr(SuppressAttr *A) { |
| return true; |
| } |
| bool TraverseSwiftAsyncAttr(SwiftAsyncAttr *A); |
| bool VisitSwiftAsyncAttr(SwiftAsyncAttr *A) { |
| return true; |
| } |
| bool TraverseSwiftAsyncCallAttr(SwiftAsyncCallAttr *A); |
| bool VisitSwiftAsyncCallAttr(SwiftAsyncCallAttr *A) { |
| return true; |
| } |
| bool TraverseSwiftAsyncContextAttr(SwiftAsyncContextAttr *A); |
| bool VisitSwiftAsyncContextAttr(SwiftAsyncContextAttr *A) { |
| return true; |
| } |
| bool TraverseSwiftAsyncErrorAttr(SwiftAsyncErrorAttr *A); |
| bool VisitSwiftAsyncErrorAttr(SwiftAsyncErrorAttr *A) { |
| return true; |
| } |
| bool TraverseSwiftAsyncNameAttr(SwiftAsyncNameAttr *A); |
| bool VisitSwiftAsyncNameAttr(SwiftAsyncNameAttr *A) { |
| return true; |
| } |
| bool TraverseSwiftAttrAttr(SwiftAttrAttr *A); |
| bool VisitSwiftAttrAttr(SwiftAttrAttr *A) { |
| return true; |
| } |
| bool TraverseSwiftBridgeAttr(SwiftBridgeAttr *A); |
| bool VisitSwiftBridgeAttr(SwiftBridgeAttr *A) { |
| return true; |
| } |
| bool TraverseSwiftBridgedTypedefAttr(SwiftBridgedTypedefAttr *A); |
| bool VisitSwiftBridgedTypedefAttr(SwiftBridgedTypedefAttr *A) { |
| return true; |
| } |
| bool TraverseSwiftCallAttr(SwiftCallAttr *A); |
| bool VisitSwiftCallAttr(SwiftCallAttr *A) { |
| return true; |
| } |
| bool TraverseSwiftContextAttr(SwiftContextAttr *A); |
| bool VisitSwiftContextAttr(SwiftContextAttr *A) { |
| return true; |
| } |
| bool TraverseSwiftErrorAttr(SwiftErrorAttr *A); |
| bool VisitSwiftErrorAttr(SwiftErrorAttr *A) { |
| return true; |
| } |
| bool TraverseSwiftErrorResultAttr(SwiftErrorResultAttr *A); |
| bool VisitSwiftErrorResultAttr(SwiftErrorResultAttr *A) { |
| return true; |
| } |
| bool TraverseSwiftIndirectResultAttr(SwiftIndirectResultAttr *A); |
| bool VisitSwiftIndirectResultAttr(SwiftIndirectResultAttr *A) { |
| return true; |
| } |
| bool TraverseSwiftNameAttr(SwiftNameAttr *A); |
| bool VisitSwiftNameAttr(SwiftNameAttr *A) { |
| return true; |
| } |
| bool TraverseSwiftNewTypeAttr(SwiftNewTypeAttr *A); |
| bool VisitSwiftNewTypeAttr(SwiftNewTypeAttr *A) { |
| return true; |
| } |
| bool TraverseSwiftObjCMembersAttr(SwiftObjCMembersAttr *A); |
| bool VisitSwiftObjCMembersAttr(SwiftObjCMembersAttr *A) { |
| return true; |
| } |
| bool TraverseSwiftPrivateAttr(SwiftPrivateAttr *A); |
| bool VisitSwiftPrivateAttr(SwiftPrivateAttr *A) { |
| return true; |
| } |
| bool TraverseSysVABIAttr(SysVABIAttr *A); |
| bool VisitSysVABIAttr(SysVABIAttr *A) { |
| return true; |
| } |
| bool TraverseTLSModelAttr(TLSModelAttr *A); |
| bool VisitTLSModelAttr(TLSModelAttr *A) { |
| return true; |
| } |
| bool TraverseTargetAttr(TargetAttr *A); |
| bool VisitTargetAttr(TargetAttr *A) { |
| return true; |
| } |
| bool TraverseTargetClonesAttr(TargetClonesAttr *A); |
| bool VisitTargetClonesAttr(TargetClonesAttr *A) { |
| return true; |
| } |
| bool TraverseTestTypestateAttr(TestTypestateAttr *A); |
| bool VisitTestTypestateAttr(TestTypestateAttr *A) { |
| return true; |
| } |
| bool TraverseThisCallAttr(ThisCallAttr *A); |
| bool VisitThisCallAttr(ThisCallAttr *A) { |
| return true; |
| } |
| bool TraverseThreadAttr(ThreadAttr *A); |
| bool VisitThreadAttr(ThreadAttr *A) { |
| return true; |
| } |
| bool TraverseTransparentUnionAttr(TransparentUnionAttr *A); |
| bool VisitTransparentUnionAttr(TransparentUnionAttr *A) { |
| return true; |
| } |
| bool TraverseTrivialABIAttr(TrivialABIAttr *A); |
| bool VisitTrivialABIAttr(TrivialABIAttr *A) { |
| return true; |
| } |
| bool TraverseTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A); |
| bool VisitTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A) { |
| return true; |
| } |
| bool TraverseTypeNonNullAttr(TypeNonNullAttr *A); |
| bool VisitTypeNonNullAttr(TypeNonNullAttr *A) { |
| return true; |
| } |
| bool TraverseTypeNullUnspecifiedAttr(TypeNullUnspecifiedAttr *A); |
| bool VisitTypeNullUnspecifiedAttr(TypeNullUnspecifiedAttr *A) { |
| return true; |
| } |
| bool TraverseTypeNullableAttr(TypeNullableAttr *A); |
| bool VisitTypeNullableAttr(TypeNullableAttr *A) { |
| return true; |
| } |
| bool TraverseTypeNullableResultAttr(TypeNullableResultAttr *A); |
| bool VisitTypeNullableResultAttr(TypeNullableResultAttr *A) { |
| return true; |
| } |
| bool TraverseTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A); |
| bool VisitTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A) { |
| return true; |
| } |
| bool TraverseTypeVisibilityAttr(TypeVisibilityAttr *A); |
| bool VisitTypeVisibilityAttr(TypeVisibilityAttr *A) { |
| return true; |
| } |
| bool TraverseUPtrAttr(UPtrAttr *A); |
| bool VisitUPtrAttr(UPtrAttr *A) { |
| return true; |
| } |
| bool TraverseUnavailableAttr(UnavailableAttr *A); |
| bool VisitUnavailableAttr(UnavailableAttr *A) { |
| return true; |
| } |
| bool TraverseUninitializedAttr(UninitializedAttr *A); |
| bool VisitUninitializedAttr(UninitializedAttr *A) { |
| return true; |
| } |
| bool TraverseUnlikelyAttr(UnlikelyAttr *A); |
| bool VisitUnlikelyAttr(UnlikelyAttr *A) { |
| return true; |
| } |
| bool TraverseUnusedAttr(UnusedAttr *A); |
| bool VisitUnusedAttr(UnusedAttr *A) { |
| return true; |
| } |
| bool TraverseUseHandleAttr(UseHandleAttr *A); |
| bool VisitUseHandleAttr(UseHandleAttr *A) { |
| return true; |
| } |
| bool TraverseUsedAttr(UsedAttr *A); |
| bool VisitUsedAttr(UsedAttr *A) { |
| return true; |
| } |
| bool TraverseUsingIfExistsAttr(UsingIfExistsAttr *A); |
| bool VisitUsingIfExistsAttr(UsingIfExistsAttr *A) { |
| return true; |
| } |
| bool TraverseUuidAttr(UuidAttr *A); |
| bool VisitUuidAttr(UuidAttr *A) { |
| return true; |
| } |
| bool TraverseVecReturnAttr(VecReturnAttr *A); |
| bool VisitVecReturnAttr(VecReturnAttr *A) { |
| return true; |
| } |
| bool TraverseVecTypeHintAttr(VecTypeHintAttr *A); |
| bool VisitVecTypeHintAttr(VecTypeHintAttr *A) { |
| return true; |
| } |
| bool TraverseVectorCallAttr(VectorCallAttr *A); |
| bool VisitVectorCallAttr(VectorCallAttr *A) { |
| return true; |
| } |
| bool TraverseVisibilityAttr(VisibilityAttr *A); |
| bool VisitVisibilityAttr(VisibilityAttr *A) { |
| return true; |
| } |
| bool TraverseWarnUnusedAttr(WarnUnusedAttr *A); |
| bool VisitWarnUnusedAttr(WarnUnusedAttr *A) { |
| return true; |
| } |
| bool TraverseWarnUnusedResultAttr(WarnUnusedResultAttr *A); |
| bool VisitWarnUnusedResultAttr(WarnUnusedResultAttr *A) { |
| return true; |
| } |
| bool TraverseWeakAttr(WeakAttr *A); |
| bool VisitWeakAttr(WeakAttr *A) { |
| return true; |
| } |
| bool TraverseWeakImportAttr(WeakImportAttr *A); |
| bool VisitWeakImportAttr(WeakImportAttr *A) { |
| return true; |
| } |
| bool TraverseWeakRefAttr(WeakRefAttr *A); |
| bool VisitWeakRefAttr(WeakRefAttr *A) { |
| return true; |
| } |
| bool TraverseWebAssemblyExportNameAttr(WebAssemblyExportNameAttr *A); |
| bool VisitWebAssemblyExportNameAttr(WebAssemblyExportNameAttr *A) { |
| return true; |
| } |
| bool TraverseWebAssemblyImportModuleAttr(WebAssemblyImportModuleAttr *A); |
| bool VisitWebAssemblyImportModuleAttr(WebAssemblyImportModuleAttr *A) { |
| return true; |
| } |
| bool TraverseWebAssemblyImportNameAttr(WebAssemblyImportNameAttr *A); |
| bool VisitWebAssemblyImportNameAttr(WebAssemblyImportNameAttr *A) { |
| return true; |
| } |
| bool TraverseWorkGroupSizeHintAttr(WorkGroupSizeHintAttr *A); |
| bool VisitWorkGroupSizeHintAttr(WorkGroupSizeHintAttr *A) { |
| return true; |
| } |
| bool TraverseX86ForceAlignArgPointerAttr(X86ForceAlignArgPointerAttr *A); |
| bool VisitX86ForceAlignArgPointerAttr(X86ForceAlignArgPointerAttr *A) { |
| return true; |
| } |
| bool TraverseXRayInstrumentAttr(XRayInstrumentAttr *A); |
| bool VisitXRayInstrumentAttr(XRayInstrumentAttr *A) { |
| return true; |
| } |
| bool TraverseXRayLogArgsAttr(XRayLogArgsAttr *A); |
| bool VisitXRayLogArgsAttr(XRayLogArgsAttr *A) { |
| return true; |
| } |
| bool TraverseZeroCallUsedRegsAttr(ZeroCallUsedRegsAttr *A); |
| bool VisitZeroCallUsedRegsAttr(ZeroCallUsedRegsAttr *A) { |
| return true; |
| } |
| |
| #else // ATTR_VISITOR_DECLS_ONLY |
| |
| 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>::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>::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>::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>::TraverseArmMveStrictPolymorphismAttr(ArmMveStrictPolymorphismAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitArmMveStrictPolymorphismAttr(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>::TraverseAssumptionAttr(AssumptionAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitAssumptionAttr(A)) |
| 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>::TraverseBPFPreserveAccessIndexAttr(BPFPreserveAccessIndexAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitBPFPreserveAccessIndexAttr(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>::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; |
| 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>::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>::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>::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>::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>::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>::TraverseHLSLNumThreadsAttr(HLSLNumThreadsAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitHLSLNumThreadsAttr(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>::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>::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>::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>::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>::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>::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>::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>::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>::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>::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>::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>::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>::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>::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>::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>::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>::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>::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>::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>::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::AArch64VectorPcs: |
| return getDerived().TraverseAArch64VectorPcsAttr(cast<AArch64VectorPcsAttr>(A)); |
| case attr::AMDGPUFlatWorkGroupSize: |
| return getDerived().TraverseAMDGPUFlatWorkGroupSizeAttr(cast<AMDGPUFlatWorkGroupSizeAttr>(A)); |
| case attr::AMDGPUNumSGPR: |
| return getDerived().TraverseAMDGPUNumSGPRAttr(cast<AMDGPUNumSGPRAttr>(A)); |
| case attr::AMDGPUNumVGPR: |
| return getDerived().TraverseAMDGPUNumVGPRAttr(cast<AMDGPUNumVGPRAttr>(A)); |
| case attr::AMDGPUWavesPerEU: |
| return getDerived().TraverseAMDGPUWavesPerEUAttr(cast<AMDGPUWavesPerEUAttr>(A)); |
| case attr::ARMInterrupt: |
| return getDerived().TraverseARMInterruptAttr(cast<ARMInterruptAttr>(A)); |
| case attr::AVRInterrupt: |
| return getDerived().TraverseAVRInterruptAttr(cast<AVRInterruptAttr>(A)); |
| case attr::AVRSignal: |
| return getDerived().TraverseAVRSignalAttr(cast<AVRSignalAttr>(A)); |
| case attr::AbiTag: |
| return getDerived().TraverseAbiTagAttr(cast<AbiTagAttr>(A)); |
| case attr::AcquireCapability: |
| return getDerived().TraverseAcquireCapabilityAttr(cast<AcquireCapabilityAttr>(A)); |
| case attr::AcquireHandle: |
| return getDerived().TraverseAcquireHandleAttr(cast<AcquireHandleAttr>(A)); |
| case attr::AcquiredAfter: |
| return getDerived().TraverseAcquiredAfterAttr(cast<AcquiredAfterAttr>(A)); |
| case attr::AcquiredBefore: |
| return getDerived().TraverseAcquiredBeforeAttr(cast<AcquiredBeforeAttr>(A)); |
| case attr::AddressSpace: |
| return getDerived().TraverseAddressSpaceAttr(cast<AddressSpaceAttr>(A)); |
| case attr::Alias: |
| return getDerived().TraverseAliasAttr(cast<AliasAttr>(A)); |
| case attr::AlignMac68k: |
| return getDerived().TraverseAlignMac68kAttr(cast<AlignMac68kAttr>(A)); |
| case attr::AlignNatural: |
| return getDerived().TraverseAlignNaturalAttr(cast<AlignNaturalAttr>(A)); |
| case attr::AlignValue: |
| return getDerived().TraverseAlignValueAttr(cast<AlignValueAttr>(A)); |
| case attr::Aligned: |
| return getDerived().TraverseAlignedAttr(cast<AlignedAttr>(A)); |
| case attr::AllocAlign: |
| return getDerived().TraverseAllocAlignAttr(cast<AllocAlignAttr>(A)); |
| case attr::AllocSize: |
| return getDerived().TraverseAllocSizeAttr(cast<AllocSizeAttr>(A)); |
| case attr::AlwaysDestroy: |
| return getDerived().TraverseAlwaysDestroyAttr(cast<AlwaysDestroyAttr>(A)); |
| case attr::AlwaysInline: |
| return getDerived().TraverseAlwaysInlineAttr(cast<AlwaysInlineAttr>(A)); |
| case attr::AnalyzerNoReturn: |
| return getDerived().TraverseAnalyzerNoReturnAttr(cast<AnalyzerNoReturnAttr>(A)); |
| case attr::Annotate: |
| return getDerived().TraverseAnnotateAttr(cast<AnnotateAttr>(A)); |
| case attr::AnyX86Interrupt: |
| return getDerived().TraverseAnyX86InterruptAttr(cast<AnyX86InterruptAttr>(A)); |
| case attr::AnyX86NoCallerSavedRegisters: |
| return getDerived().TraverseAnyX86NoCallerSavedRegistersAttr(cast<AnyX86NoCallerSavedRegistersAttr>(A)); |
| case attr::AnyX86NoCfCheck: |
| return getDerived().TraverseAnyX86NoCfCheckAttr(cast<AnyX86NoCfCheckAttr>(A)); |
| case attr::ArcWeakrefUnavailable: |
| return getDerived().TraverseArcWeakrefUnavailableAttr(cast<ArcWeakrefUnavailableAttr>(A)); |
| case attr::ArgumentWithTypeTag: |
| return getDerived().TraverseArgumentWithTypeTagAttr(cast<ArgumentWithTypeTagAttr>(A)); |
| case attr::ArmBuiltinAlias: |
| return getDerived().TraverseArmBuiltinAliasAttr(cast<ArmBuiltinAliasAttr>(A)); |
| case attr::ArmMveStrictPolymorphism: |
| return getDerived().TraverseArmMveStrictPolymorphismAttr(cast<ArmMveStrictPolymorphismAttr>(A)); |
| case attr::Artificial: |
| return getDerived().TraverseArtificialAttr(cast<ArtificialAttr>(A)); |
| case attr::AsmLabel: |
| return getDerived().TraverseAsmLabelAttr(cast<AsmLabelAttr>(A)); |
| case attr::AssertCapability: |
| return getDerived().TraverseAssertCapabilityAttr(cast<AssertCapabilityAttr>(A)); |
| case attr::AssertExclusiveLock: |
| return getDerived().TraverseAssertExclusiveLockAttr(cast<AssertExclusiveLockAttr>(A)); |
| case attr::AssertSharedLock: |
| return getDerived().TraverseAssertSharedLockAttr(cast<AssertSharedLockAttr>(A)); |
| case attr::AssumeAligned: |
| return getDerived().TraverseAssumeAlignedAttr(cast<AssumeAlignedAttr>(A)); |
| case attr::Assumption: |
| return getDerived().TraverseAssumptionAttr(cast<AssumptionAttr>(A)); |
| case attr::Availability: |
| return getDerived().TraverseAvailabilityAttr(cast<AvailabilityAttr>(A)); |
| case attr::BPFPreserveAccessIndex: |
| return getDerived().TraverseBPFPreserveAccessIndexAttr(cast<BPFPreserveAccessIndexAttr>(A)); |
| case attr::BTFDeclTag: |
| return getDerived().TraverseBTFDeclTagAttr(cast<BTFDeclTagAttr>(A)); |
| case attr::BTFTypeTag: |
| return getDerived().TraverseBTFTypeTagAttr(cast<BTFTypeTagAttr>(A)); |
| case attr::Blocks: |
| return getDerived().TraverseBlocksAttr(cast<BlocksAttr>(A)); |
| case attr::Builtin: |
| return getDerived().TraverseBuiltinAttr(cast<BuiltinAttr>(A)); |
| case attr::BuiltinAlias: |
| return getDerived().TraverseBuiltinAliasAttr(cast<BuiltinAliasAttr>(A)); |
| case attr::C11NoReturn: |
| return getDerived().TraverseC11NoReturnAttr(cast<C11NoReturnAttr>(A)); |
| case attr::CDecl: |
| return getDerived().TraverseCDeclAttr(cast<CDeclAttr>(A)); |
| case attr::CFAuditedTransfer: |
| return getDerived().TraverseCFAuditedTransferAttr(cast<CFAuditedTransferAttr>(A)); |
| case attr::CFConsumed: |
| return getDerived().TraverseCFConsumedAttr(cast<CFConsumedAttr>(A)); |
| case attr::CFGuard: |
| return getDerived().TraverseCFGuardAttr(cast<CFGuardAttr>(A)); |
| case attr::CFICanonicalJumpTable: |
| return getDerived().TraverseCFICanonicalJumpTableAttr(cast<CFICanonicalJumpTableAttr>(A)); |
| case attr::CFReturnsNotRetained: |
| return getDerived().TraverseCFReturnsNotRetainedAttr(cast<CFReturnsNotRetainedAttr>(A)); |
| case attr::CFReturnsRetained: |
| return getDerived().TraverseCFReturnsRetainedAttr(cast<CFReturnsRetainedAttr>(A)); |
| case attr::CFUnknownTransfer: |
| return getDerived().TraverseCFUnknownTransferAttr(cast<CFUnknownTransferAttr>(A)); |
| case attr::CPUDispatch: |
| return getDerived().TraverseCPUDispatchAttr(cast<CPUDispatchAttr>(A)); |
| case attr::CPUSpecific: |
| return getDerived().TraverseCPUSpecificAttr(cast<CPUSpecificAttr>(A)); |
| case attr::CUDAConstant: |
| return getDerived().TraverseCUDAConstantAttr(cast<CUDAConstantAttr>(A)); |
| case attr::CUDADevice: |
| return getDerived().TraverseCUDADeviceAttr(cast<CUDADeviceAttr>(A)); |
| case attr::CUDADeviceBuiltinSurfaceType: |
| return getDerived().TraverseCUDADeviceBuiltinSurfaceTypeAttr(cast<CUDADeviceBuiltinSurfaceTypeAttr>(A)); |
| case attr::CUDADeviceBuiltinTextureType: |
| return getDerived().TraverseCUDADeviceBuiltinTextureTypeAttr(cast<CUDADeviceBuiltinTextureTypeAttr>(A)); |
| case attr::CUDAGlobal: |
| return getDerived().TraverseCUDAGlobalAttr(cast<CUDAGlobalAttr>(A)); |
| case attr::CUDAHost: |
| return getDerived().TraverseCUDAHostAttr(cast<CUDAHostAttr>(A)); |
| case attr::CUDAInvalidTarget: |
| return getDerived().TraverseCUDAInvalidTargetAttr(cast<CUDAInvalidTargetAttr>(A)); |
| case attr::CUDALaunchBounds: |
| return getDerived().TraverseCUDALaunchBoundsAttr(cast<CUDALaunchBoundsAttr>(A)); |
| case attr::CUDAShared: |
| return getDerived().TraverseCUDASharedAttr(cast<CUDASharedAttr>(A)); |
| case attr::CXX11NoReturn: |
| return getDerived().TraverseCXX11NoReturnAttr(cast<CXX11NoReturnAttr>(A)); |
| case attr::CallableWhen: |
| return getDerived().TraverseCallableWhenAttr(cast<CallableWhenAttr>(A)); |
| case attr::Callback: |
| return getDerived().TraverseCallbackAttr(cast<CallbackAttr>(A)); |
| case attr::CalledOnce: |
| return getDerived().TraverseCalledOnceAttr(cast<CalledOnceAttr>(A)); |
| case attr::Capability: |
| return getDerived().TraverseCapabilityAttr(cast<CapabilityAttr>(A)); |
| case attr::CapturedRecord: |
| return getDerived().TraverseCapturedRecordAttr(cast<CapturedRecordAttr>(A)); |
| case attr::CarriesDependency: |
| return getDerived().TraverseCarriesDependencyAttr(cast<CarriesDependencyAttr>(A)); |
| case attr::Cleanup: |
| return getDerived().TraverseCleanupAttr(cast<CleanupAttr>(A)); |
| case attr::CmseNSCall: |
| return getDerived().TraverseCmseNSCallAttr(cast<CmseNSCallAttr>(A)); |
| case attr::CmseNSEntry: |
| return getDerived().TraverseCmseNSEntryAttr(cast<CmseNSEntryAttr>(A)); |
| case attr::CodeSeg: |
| return getDerived().TraverseCodeSegAttr(cast<CodeSegAttr>(A)); |
| case attr::Cold: |
| return getDerived().TraverseColdAttr(cast<ColdAttr>(A)); |
| case attr::Common: |
| return getDerived().TraverseCommonAttr(cast<CommonAttr>(A)); |
| case attr::Const: |
| return getDerived().TraverseConstAttr(cast<ConstAttr>(A)); |
| case attr::ConstInit: |
| return getDerived().TraverseConstInitAttr(cast<ConstInitAttr>(A)); |
| case attr::Constructor: |
| return getDerived().TraverseConstructorAttr(cast<ConstructorAttr>(A)); |
| case attr::Consumable: |
| return getDerived().TraverseConsumableAttr(cast<ConsumableAttr>(A)); |
| case attr::ConsumableAutoCast: |
| return getDerived().TraverseConsumableAutoCastAttr(cast<ConsumableAutoCastAttr>(A)); |
| case attr::ConsumableSetOnRead: |
| return getDerived().TraverseConsumableSetOnReadAttr(cast<ConsumableSetOnReadAttr>(A)); |
| case attr::Convergent: |
| return getDerived().TraverseConvergentAttr(cast<ConvergentAttr>(A)); |
| case attr::DLLExport: |
| return getDerived().TraverseDLLExportAttr(cast<DLLExportAttr>(A)); |
| case attr::DLLExportStaticLocal: |
| return getDerived().TraverseDLLExportStaticLocalAttr(cast<DLLExportStaticLocalAttr>(A)); |
| case attr::DLLImport: |
| return getDerived().TraverseDLLImportAttr(cast<DLLImportAttr>(A)); |
| case attr::DLLImportStaticLocal: |
| return getDerived().TraverseDLLImportStaticLocalAttr(cast<DLLImportStaticLocalAttr>(A)); |
| case attr::Deprecated: |
| return getDerived().TraverseDeprecatedAttr(cast<DeprecatedAttr>(A)); |
| case attr::Destructor: |
| return getDerived().TraverseDestructorAttr(cast<DestructorAttr>(A)); |
| case attr::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::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::HLSLNumThreads: |
| return getDerived().TraverseHLSLNumThreadsAttr(cast<HLSLNumThreadsAttr>(A)); |
| case attr::Hot: |
| return getDerived().TraverseHotAttr(cast<HotAttr>(A)); |
| case attr::IBAction: |
| return getDerived().TraverseIBActionAttr(cast<IBActionAttr>(A)); |
| case attr::IBOutlet: |
| return getDerived().TraverseIBOutletAttr(cast<IBOutletAttr>(A)); |
| case attr::IBOutletCollection: |
| return getDerived().TraverseIBOutletCollectionAttr(cast<IBOutletCollectionAttr>(A)); |
| case attr::IFunc: |
| return getDerived().TraverseIFuncAttr(cast<IFuncAttr>(A)); |
| case attr::InitPriority: |
| return getDerived().TraverseInitPriorityAttr(cast<InitPriorityAttr>(A)); |
| case attr::InitSeg: |
| return getDerived().TraverseInitSegAttr(cast<InitSegAttr>(A)); |
| case attr::IntelOclBicc: |
| return getDerived().TraverseIntelOclBiccAttr(cast<IntelOclBiccAttr>(A)); |
| case attr::InternalLinkage: |
| return getDerived().TraverseInternalLinkageAttr(cast<InternalLinkageAttr>(A)); |
| case attr::LTOVisibilityPublic: |
| return getDerived().TraverseLTOVisibilityPublicAttr(cast<LTOVisibilityPublicAttr>(A)); |
| case attr::LayoutVersion: |
| return getDerived().TraverseLayoutVersionAttr(cast<LayoutVersionAttr>(A)); |
| case attr::Leaf: |
| return getDerived().TraverseLeafAttr(cast<LeafAttr>(A)); |
| case attr::LifetimeBound: |
| return getDerived().TraverseLifetimeBoundAttr(cast<LifetimeBoundAttr>(A)); |
| case attr::Likely: |
| return getDerived().TraverseLikelyAttr(cast<LikelyAttr>(A)); |
| case attr::LoaderUninitialized: |
| return getDerived().TraverseLoaderUninitializedAttr(cast<LoaderUninitializedAttr>(A)); |
| case attr::LockReturned: |
| return getDerived().TraverseLockReturnedAttr(cast<LockReturnedAttr>(A)); |
| case attr::LocksExcluded: |
| return getDerived().TraverseLocksExcludedAttr(cast<LocksExcludedAttr>(A)); |
| case attr::LoopHint: |
| return getDerived().TraverseLoopHintAttr(cast<LoopHintAttr>(A)); |
| case attr::M68kInterrupt: |
| return getDerived().TraverseM68kInterruptAttr(cast<M68kInterruptAttr>(A)); |
| case attr::MIGServerRoutine: |
| return getDerived().TraverseMIGServerRoutineAttr(cast<MIGServerRoutineAttr>(A)); |
| case attr::MSABI: |
| return getDerived().TraverseMSABIAttr(cast<MSABIAttr>(A)); |
| case attr::MSAllocator: |
| return getDerived().TraverseMSAllocatorAttr(cast<MSAllocatorAttr>(A)); |
| case attr::MSInheritance: |
| return getDerived().TraverseMSInheritanceAttr(cast<MSInheritanceAttr>(A)); |
| case attr::MSNoVTable: |
| return getDerived().TraverseMSNoVTableAttr(cast<MSNoVTableAttr>(A)); |
| case attr::MSP430Interrupt: |
| return getDerived().TraverseMSP430InterruptAttr(cast<MSP430InterruptAttr>(A)); |
| case attr::MSStruct: |
| return getDerived().TraverseMSStructAttr(cast<MSStructAttr>(A)); |
| case attr::MSVtorDisp: |
| return getDerived().TraverseMSVtorDispAttr(cast<MSVtorDispAttr>(A)); |
| case attr::MaxFieldAlignment: |
| return getDerived().TraverseMaxFieldAlignmentAttr(cast<MaxFieldAlignmentAttr>(A)); |
| case attr::MayAlias: |
| return getDerived().TraverseMayAliasAttr(cast<MayAliasAttr>(A)); |
| case attr::MicroMips: |
| return getDerived().TraverseMicroMipsAttr(cast<MicroMipsAttr>(A)); |
| case attr::MinSize: |
| return getDerived().TraverseMinSizeAttr(cast<MinSizeAttr>(A)); |
| case attr::MinVectorWidth: |
| return getDerived().TraverseMinVectorWidthAttr(cast<MinVectorWidthAttr>(A)); |
| case attr::Mips16: |
| return getDerived().TraverseMips16Attr(cast<Mips16Attr>(A)); |
| case attr::MipsInterrupt: |
| return getDerived().TraverseMipsInterruptAttr(cast<MipsInterruptAttr>(A)); |
| case attr::MipsLongCall: |
| return getDerived().TraverseMipsLongCallAttr(cast<MipsLongCallAttr>(A)); |
| case attr::MipsShortCall: |
| return getDerived().TraverseMipsShortCallAttr(cast<MipsShortCallAttr>(A)); |
| case attr::Mode: |
| return getDerived().TraverseModeAttr(cast<ModeAttr>(A)); |
| case attr::MustTail: |
| return getDerived().TraverseMustTailAttr(cast<MustTailAttr>(A)); |
| case attr::NSConsumed: |
| return getDerived().TraverseNSConsumedAttr(cast<NSConsumedAttr>(A)); |
| case attr::NSConsumesSelf: |
| return getDerived().TraverseNSConsumesSelfAttr(cast<NSConsumesSelfAttr>(A)); |
| case attr::NSErrorDomain: |
| return getDerived().TraverseNSErrorDomainAttr(cast<NSErrorDomainAttr>(A)); |
| case attr::NSReturnsAutoreleased: |
| return getDerived().TraverseNSReturnsAutoreleasedAttr(cast<NSReturnsAutoreleasedAttr>(A)); |
| case attr::NSReturnsNotRetained: |
| return getDerived().TraverseNSReturnsNotRetainedAttr(cast<NSReturnsNotRetainedAttr>(A)); |
| case attr::NSReturnsRetained: |
| return getDerived().TraverseNSReturnsRetainedAttr(cast<NSReturnsRetainedAttr>(A)); |
| case attr::Naked: |
| return getDerived().TraverseNakedAttr(cast<NakedAttr>(A)); |
| case attr::NoAlias: |
| return getDerived().TraverseNoAliasAttr(cast<NoAliasAttr>(A)); |
| case attr::NoBuiltin: |
| return getDerived().TraverseNoBuiltinAttr(cast<NoBuiltinAttr>(A)); |
| case attr::NoCommon: |
| return getDerived().TraverseNoCommonAttr(cast<NoCommonAttr>(A)); |
| case attr::NoDebug: |
| return getDerived().TraverseNoDebugAttr(cast<NoDebugAttr>(A)); |
| case attr::NoDeref: |
| return getDerived().TraverseNoDerefAttr(cast<NoDerefAttr>(A)); |
| case attr::NoDestroy: |
| return getDerived().TraverseNoDestroyAttr(cast<NoDestroyAttr>(A)); |
| case attr::NoDuplicate: |
| return getDerived().TraverseNoDuplicateAttr(cast<NoDuplicateAttr>(A)); |
| case attr::NoEscape: |
| return getDerived().TraverseNoEscapeAttr(cast<NoEscapeAttr>(A)); |
| case attr::NoInline: |
| return getDerived().TraverseNoInlineAttr(cast<NoInlineAttr>(A)); |
| case attr::NoInstrumentFunction: |
| return getDerived().TraverseNoInstrumentFunctionAttr(cast<NoInstrumentFunctionAttr>(A)); |
| case attr::NoMerge: |
| return getDerived().TraverseNoMergeAttr(cast<NoMergeAttr>(A)); |
| case attr::NoMicroMips: |
| return getDerived().TraverseNoMicroMipsAttr(cast<NoMicroMipsAttr>(A)); |
| case attr::NoMips16: |
| return getDerived().TraverseNoMips16Attr(cast<NoMips16Attr>(A)); |
| case attr::NoProfileFunction: |
| return getDerived().TraverseNoProfileFunctionAttr(cast<NoProfileFunctionAttr>(A)); |
| case attr::NoReturn: |
| return getDerived().TraverseNoReturnAttr(cast<NoReturnAttr>(A)); |
| case attr::NoSanitize: |
| return getDerived().TraverseNoSanitizeAttr(cast<NoSanitizeAttr>(A)); |
| case attr::NoSpeculativeLoadHardening: |
| return getDerived().TraverseNoSpeculativeLoadHardeningAttr(cast<NoSpeculativeLoadHardeningAttr>(A)); |
| case attr::NoSplitStack: |
| return getDerived().TraverseNoSplitStackAttr(cast<NoSplitStackAttr>(A)); |
| case attr::NoStackProtector: |
| return getDerived().TraverseNoStackProtectorAttr(cast<NoStackProtectorAttr>(A)); |
| case attr::NoThreadSafetyAnalysis: |
| return getDerived().TraverseNoThreadSafetyAnalysisAttr(cast<NoThreadSafetyAnalysisAttr>(A)); |
| case attr::NoThrow: |
| return getDerived().TraverseNoThrowAttr(cast<NoThrowAttr>(A)); |
| case attr::NoUniqueAddress: |
| return getDerived().TraverseNoUniqueAddressAttr(cast<NoUniqueAddressAttr>(A)); |
| case attr::NonNull: |
| return getDerived().TraverseNonNullAttr(cast<NonNullAttr>(A)); |
| case attr::NotTailCalled: |
| return getDerived().TraverseNotTailCalledAttr(cast<NotTailCalledAttr>(A)); |
| case attr::OMPAllocateDecl: |
| return getDerived().TraverseOMPAllocateDeclAttr(cast<OMPAllocateDeclAttr>(A)); |
| case attr::OMPCaptureKind: |
| return getDerived().TraverseOMPCaptureKindAttr(cast<OMPCaptureKindAttr>(A)); |
| case attr::OMPCaptureNoInit: |
| return getDerived().TraverseOMPCaptureNoInitAttr(cast<OMPCaptureNoInitAttr>(A)); |
| case attr::OMPDeclareSimdDecl: |
| return getDerived().TraverseOMPDeclareSimdDeclAttr(cast<OMPDeclareSimdDeclAttr>(A)); |
| case attr::OMPDeclareTargetDecl: |
| return getDerived().TraverseOMPDeclareTargetDeclAttr(cast<OMPDeclareTargetDeclAttr>(A)); |
| case attr::OMPDeclareVariant: |
| return getDerived().TraverseOMPDeclareVariantAttr(cast<OMPDeclareVariantAttr>(A)); |
| case attr::OMPReferencedVar: |
| return getDerived().TraverseOMPReferencedVarAttr(cast<OMPReferencedVarAttr>(A)); |
| case attr::OMPThreadPrivateDecl: |
| return getDerived().TraverseOMPThreadPrivateDeclAttr(cast<OMPThreadPrivateDeclAttr>(A)); |
| case attr::OSConsumed: |
| return getDerived().TraverseOSConsumedAttr(cast<OSConsumedAttr>(A)); |
| case attr::OSConsumesThis: |
| return getDerived().TraverseOSConsumesThisAttr(cast<OSConsumesThisAttr>(A)); |
| case attr::OSReturnsNotRetained: |
| return getDerived().TraverseOSReturnsNotRetainedAttr(cast<OSReturnsNotRetainedAttr>(A)); |
| case attr::OSReturnsRetained: |
| return getDerived().TraverseOSReturnsRetainedAttr(cast<OSReturnsRetainedAttr>(A)); |
| case attr::OSReturnsRetainedOnNonZero: |
| return getDerived().TraverseOSReturnsRetainedOnNonZeroAttr(cast<OSReturnsRetainedOnNonZeroAttr>(A)); |
| case attr::OSReturnsRetainedOnZero: |
| return getDerived().TraverseOSReturnsRetainedOnZeroAttr(cast<OSReturnsRetainedOnZeroAttr>(A)); |
| case attr::ObjCBoxable: |
| return getDerived().TraverseObjCBoxableAttr(cast<ObjCBoxableAttr>(A)); |
| case attr::ObjCBridge: |
| return getDerived().TraverseObjCBridgeAttr(cast<ObjCBridgeAttr>(A)); |
| case attr::ObjCBridgeMutable: |
| return getDerived().TraverseObjCBridgeMutableAttr(cast<ObjCBridgeMutableAttr>(A)); |
| case attr::ObjCBridgeRelated: |
| return getDerived().TraverseObjCBridgeRelatedAttr(cast<ObjCBridgeRelatedAttr>(A)); |
| case attr::ObjCClassStub: |
| return getDerived().TraverseObjCClassStubAttr(cast<ObjCClassStubAttr>(A)); |
| case attr::ObjCDesignatedInitializer: |
| return getDerived().TraverseObjCDesignatedInitializerAttr(cast<ObjCDesignatedInitializerAttr>(A)); |
| case attr::ObjCDirect: |
| return getDerived().TraverseObjCDirectAttr(cast<ObjCDirectAttr>(A)); |
| case attr::ObjCDirectMembers: |
| return getDerived().TraverseObjCDirectMembersAttr(cast<ObjCDirectMembersAttr>(A)); |
| case attr::ObjCException: |
| return getDerived().TraverseObjCExceptionAttr(cast<ObjCExceptionAttr>(A)); |
| case attr::ObjCExplicitProtocolImpl: |
| return getDerived().TraverseObjCExplicitProtocolImplAttr(cast<ObjCExplicitProtocolImplAttr>(A)); |
| case attr::ObjCExternallyRetained: |
| return getDerived().TraverseObjCExternallyRetainedAttr(cast<ObjCExternallyRetainedAttr>(A)); |
| case attr::ObjCGC: |
| return getDerived().TraverseObjCGCAttr(cast<ObjCGCAttr>(A)); |
| case attr::ObjCIndependentClass: |
| return getDerived().TraverseObjCIndependentClassAttr(cast<ObjCIndependentClassAttr>(A)); |
| case attr::ObjCInertUnsafeUnretained: |
| return getDerived().TraverseObjCInertUnsafeUnretainedAttr(cast<ObjCInertUnsafeUnretainedAttr>(A)); |
| case attr::ObjCKindOf: |
| return getDerived().TraverseObjCKindOfAttr(cast<ObjCKindOfAttr>(A)); |
| case attr::ObjCMethodFamily: |
| return getDerived().TraverseObjCMethodFamilyAttr(cast<ObjCMethodFamilyAttr>(A)); |
| case attr::ObjCNSObject: |
| return getDerived().TraverseObjCNSObjectAttr(cast<ObjCNSObjectAttr>(A)); |
| case attr::ObjCNonLazyClass: |
| return getDerived().TraverseObjCNonLazyClassAttr(cast<ObjCNonLazyClassAttr>(A)); |
| case attr::ObjCNonRuntimeProtocol: |
| return getDerived().TraverseObjCNonRuntimeProtocolAttr(cast<ObjCNonRuntimeProtocolAttr>(A)); |
| case attr::ObjCOwnership: |
| return getDerived().TraverseObjCOwnershipAttr(cast<ObjCOwnershipAttr>(A)); |
| case attr::ObjCPreciseLifetime: |
| return getDerived().TraverseObjCPreciseLifetimeAttr(cast<ObjCPreciseLifetimeAttr>(A)); |
| case attr::ObjCRequiresPropertyDefs: |
| return getDerived().TraverseObjCRequiresPropertyDefsAttr(cast<ObjCRequiresPropertyDefsAttr>(A)); |
| case attr::ObjCRequiresSuper: |
| return getDerived().TraverseObjCRequiresSuperAttr(cast<ObjCRequiresSuperAttr>(A)); |
| case attr::ObjCReturnsInnerPointer: |
| return getDerived().TraverseObjCReturnsInnerPointerAttr(cast<ObjCReturnsInnerPointerAttr>(A)); |
| case attr::ObjCRootClass: |
| return getDerived().TraverseObjCRootClassAttr(cast<ObjCRootClassAttr>(A)); |
| case attr::ObjCRuntimeName: |
| return getDerived().TraverseObjCRuntimeNameAttr(cast<ObjCRuntimeNameAttr>(A)); |
| case attr::ObjCRuntimeVisible: |
| return getDerived().TraverseObjCRuntimeVisibleAttr(cast<ObjCRuntimeVisibleAttr>(A)); |
| case attr::ObjCSubclassingRestricted: |
| return getDerived().TraverseObjCSubclassingRestrictedAttr(cast<ObjCSubclassingRestrictedAttr>(A)); |
| case attr::OpenCLAccess: |
| return getDerived().TraverseOpenCLAccessAttr(cast<OpenCLAccessAttr>(A)); |
| case attr::OpenCLConstantAddressSpace: |
| return getDerived().TraverseOpenCLConstantAddressSpaceAttr(cast<OpenCLConstantAddressSpaceAttr>(A)); |
| case attr::OpenCLGenericAddressSpace: |
| return getDerived().TraverseOpenCLGenericAddressSpaceAttr(cast<OpenCLGenericAddressSpaceAttr>(A)); |
| case attr::OpenCLGlobalAddressSpace: |
| return getDerived().TraverseOpenCLGlobalAddressSpaceAttr(cast<OpenCLGlobalAddressSpaceAttr>(A)); |
| case attr::OpenCLGlobalDeviceAddressSpace: |
| return getDerived().TraverseOpenCLGlobalDeviceAddressSpaceAttr(cast<OpenCLGlobalDeviceAddressSpaceAttr>(A)); |
| case attr::OpenCLGlobalHostAddressSpace: |
| return getDerived().TraverseOpenCLGlobalHostAddressSpaceAttr(cast<OpenCLGlobalHostAddressSpaceAttr>(A)); |
| case attr::OpenCLIntelReqdSubGroupSize: |
| return getDerived().TraverseOpenCLIntelReqdSubGroupSizeAttr(cast<OpenCLIntelReqdSubGroupSizeAttr>(A)); |
| case attr::OpenCLKernel: |
| return getDerived().TraverseOpenCLKernelAttr(cast<OpenCLKernelAttr>(A)); |
| case attr::OpenCLLocalAddressSpace: |
| return getDerived().TraverseOpenCLLocalAddressSpaceAttr(cast<OpenCLLocalAddressSpaceAttr>(A)); |
| case attr::OpenCLPrivateAddressSpace: |
| return getDerived().TraverseOpenCLPrivateAddressSpaceAttr(cast<OpenCLPrivateAddressSpaceAttr>(A)); |
| case attr::OpenCLUnrollHint: |
| return getDerived().TraverseOpenCLUnrollHintAttr(cast<OpenCLUnrollHintAttr>(A)); |
| case attr::OptimizeNone: |
| return getDerived().TraverseOptimizeNoneAttr(cast<OptimizeNoneAttr>(A)); |
| case attr::Overloadable: |
| return getDerived().TraverseOverloadableAttr(cast<OverloadableAttr>(A)); |
| case attr::Override: |
| return getDerived().TraverseOverrideAttr(cast<OverrideAttr>(A)); |
| case attr::Owner: |
| return getDerived().TraverseOwnerAttr(cast<OwnerAttr>(A)); |
| case attr::Ownership: |
| return getDerived().TraverseOwnershipAttr(cast<OwnershipAttr>(A)); |
| case attr::Packed: |
| return getDerived().TraversePackedAttr(cast<PackedAttr>(A)); |
| case attr::ParamTypestate: |
| return getDerived().TraverseParamTypestateAttr(cast<ParamTypestateAttr>(A)); |
| case attr::Pascal: |
| return getDerived().TraversePascalAttr(cast<PascalAttr>(A)); |
| case attr::PassObjectSize: |
| return getDerived().TraversePassObjectSizeAttr(cast<PassObjectSizeAttr>(A)); |
| case attr::PatchableFunctionEntry: |
| return getDerived().TraversePatchableFunctionEntryAttr(cast<PatchableFunctionEntryAttr>(A)); |
| case attr::Pcs: |
| return getDerived().TraversePcsAttr(cast<PcsAttr>(A)); |
| case attr::Pointer: |
| return getDerived().TraversePointerAttr(cast<PointerAttr>(A)); |
| case attr::PragmaClangBSSSection: |
| return getDerived().TraversePragmaClangBSSSectionAttr(cast<PragmaClangBSSSectionAttr>(A)); |
| case attr::PragmaClangDataSection: |
| return getDerived().TraversePragmaClangDataSectionAttr(cast<PragmaClangDataSectionAttr>(A)); |
| case attr::PragmaClangRelroSection: |
| return getDerived().TraversePragmaClangRelroSectionAttr(cast<PragmaClangRelroSectionAttr>(A)); |
| case attr::PragmaClangRodataSection: |
| return getDerived().TraversePragmaClangRodataSectionAttr(cast<PragmaClangRodataSectionAttr>(A)); |
| case attr::PragmaClangTextSection: |
| return getDerived().TraversePragmaClangTextSectionAttr(cast<PragmaClangTextSectionAttr>(A)); |
| case attr::PreferredName: |
| return getDerived().TraversePreferredNameAttr(cast<PreferredNameAttr>(A)); |
| case attr::PreserveAll: |
| return getDerived().TraversePreserveAllAttr(cast<PreserveAllAttr>(A)); |
| case attr::PreserveMost: |
| return getDerived().TraversePreserveMostAttr(cast<PreserveMostAttr>(A)); |
| case attr::PtGuardedBy: |
| return getDerived().TraversePtGuardedByAttr(cast<PtGuardedByAttr>(A)); |
| case attr::PtGuardedVar: |
| return getDerived().TraversePtGuardedVarAttr(cast<PtGuardedVarAttr>(A)); |
| case attr::Ptr32: |
| return getDerived().TraversePtr32Attr(cast<Ptr32Attr>(A)); |
| case attr::Ptr64: |
| return getDerived().TraversePtr64Attr(cast<Ptr64Attr>(A)); |
| case attr::Pure: |
| return getDerived().TraversePureAttr(cast<PureAttr>(A)); |
| case attr::RISCVInterrupt: |
| return getDerived().TraverseRISCVInterruptAttr(cast<RISCVInterruptAttr>(A)); |
| case attr::RegCall: |
| return getDerived().TraverseRegCallAttr(cast<RegCallAttr>(A)); |
| case attr::Reinitializes: |
| return getDerived().TraverseReinitializesAttr(cast<ReinitializesAttr>(A)); |
| case attr::ReleaseCapability: |
| return getDerived().TraverseReleaseCapabilityAttr(cast<ReleaseCapabilityAttr>(A)); |
| case attr::ReleaseHandle: |
| return getDerived().TraverseReleaseHandleAttr(cast<ReleaseHandleAttr>(A)); |
| case attr::RenderScriptKernel: |
| return getDerived().TraverseRenderScriptKernelAttr(cast<RenderScriptKernelAttr>(A)); |
| case attr::ReqdWorkGroupSize: |
| return getDerived().TraverseReqdWorkGroupSizeAttr(cast<ReqdWorkGroupSizeAttr>(A)); |
| case attr::RequiresCapability: |
| return getDerived().TraverseRequiresCapabilityAttr(cast<RequiresCapabilityAttr>(A)); |
| case attr::Restrict: |
| return getDerived().TraverseRestrictAttr(cast<RestrictAttr>(A)); |
| case attr::Retain: |
| return getDerived().TraverseRetainAttr(cast<RetainAttr>(A)); |
| case attr::ReturnTypestate: |
| return getDerived().TraverseReturnTypestateAttr(cast<ReturnTypestateAttr>(A)); |
| case attr::ReturnsNonNull: |
| return getDerived().TraverseReturnsNonNullAttr(cast<ReturnsNonNullAttr>(A)); |
| case attr::ReturnsTwice: |
| return getDerived().TraverseReturnsTwiceAttr(cast<ReturnsTwiceAttr>(A)); |
| case attr::SPtr: |
| return getDerived().TraverseSPtrAttr(cast<SPtrAttr>(A)); |
| case attr::SYCLKernel: |
| return getDerived().TraverseSYCLKernelAttr(cast<SYCLKernelAttr>(A)); |
| case attr::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::SpeculativeLoadHardening: |
| return getDerived().TraverseSpeculativeLoadHardeningAttr(cast<SpeculativeLoadHardeningAttr>(A)); |
| case attr::StandaloneDebug: |
| return getDerived().TraverseStandaloneDebugAttr(cast<StandaloneDebugAttr>(A)); |
| case attr::StdCall: |
| return getDerived().TraverseStdCallAttr(cast<StdCallAttr>(A)); |
| case attr::StrictFP: |
| return getDerived().TraverseStrictFPAttr(cast<StrictFPAttr>(A)); |
| case attr::Suppress: |
| return getDerived().TraverseSuppressAttr(cast<SuppressAttr>(A)); |
| case attr::SwiftAsync: |
| return getDerived().TraverseSwiftAsyncAttr(cast<SwiftAsyncAttr>(A)); |
| case attr::SwiftAsyncCall: |
| return getDerived().TraverseSwiftAsyncCallAttr(cast<SwiftAsyncCallAttr>(A)); |
| case attr::SwiftAsyncContext: |
| return getDerived().TraverseSwiftAsyncContextAttr(cast<SwiftAsyncContextAttr>(A)); |
| case attr::SwiftAsyncError: |
| return getDerived().TraverseSwiftAsyncErrorAttr(cast<SwiftAsyncErrorAttr>(A)); |
| case attr::SwiftAsyncName: |
| return getDerived().TraverseSwiftAsyncNameAttr(cast<SwiftAsyncNameAttr>(A)); |
| case attr::SwiftAttr: |
| return getDerived().TraverseSwiftAttrAttr(cast<SwiftAttrAttr>(A)); |
| case attr::SwiftBridge: |
| return getDerived().TraverseSwiftBridgeAttr(cast<SwiftBridgeAttr>(A)); |
| case attr::SwiftBridgedTypedef: |
| return getDerived().TraverseSwiftBridgedTypedefAttr(cast<SwiftBridgedTypedefAttr>(A)); |
| case attr::SwiftCall: |
| return getDerived().TraverseSwiftCallAttr(cast<SwiftCallAttr>(A)); |
| case attr::SwiftContext: |
| return getDerived().TraverseSwiftContextAttr(cast<SwiftContextAttr>(A)); |
| case attr::SwiftError: |
| return getDerived().TraverseSwiftErrorAttr(cast<SwiftErrorAttr>(A)); |
| case attr::SwiftErrorResult: |
| return getDerived().TraverseSwiftErrorResultAttr(cast<SwiftErrorResultAttr>(A)); |
| case attr::SwiftIndirectResult: |
| return getDerived().TraverseSwiftIndirectResultAttr(cast<SwiftIndirectResultAttr>(A)); |
| case attr::SwiftName: |
| return getDerived().TraverseSwiftNameAttr(cast<SwiftNameAttr>(A)); |
| case attr::SwiftNewType: |
| return getDerived().TraverseSwiftNewTypeAttr(cast<SwiftNewTypeAttr>(A)); |
| case attr::SwiftObjCMembers: |
| return getDerived().TraverseSwiftObjCMembersAttr(cast<SwiftObjCMembersAttr>(A)); |
| case attr::SwiftPrivate: |
| return getDerived().TraverseSwiftPrivateAttr(cast<SwiftPrivateAttr>(A)); |
| case attr::SysVABI: |
| return getDerived().TraverseSysVABIAttr(cast<SysVABIAttr>(A)); |
| case attr::TLSModel: |
| return getDerived().TraverseTLSModelAttr(cast<TLSModelAttr>(A)); |
| case attr::Target: |
| return getDerived().TraverseTargetAttr(cast<TargetAttr>(A)); |
| case attr::TargetClones: |
| return getDerived().TraverseTargetClonesAttr(cast<TargetClonesAttr>(A)); |
| case attr::TestTypestate: |
| return getDerived().TraverseTestTypestateAttr(cast<TestTypestateAttr>(A)); |
| case attr::ThisCall: |
| return getDerived().TraverseThisCallAttr(cast<ThisCallAttr>(A)); |
| case attr::Thread: |
| return getDerived().TraverseThreadAttr(cast<ThreadAttr>(A)); |
| case attr::TransparentUnion: |
| return getDerived().TraverseTransparentUnionAttr(cast<TransparentUnionAttr>(A)); |
| case attr::TrivialABI: |
| return getDerived().TraverseTrivialABIAttr(cast<TrivialABIAttr>(A)); |
| case attr::TryAcquireCapability: |
| return getDerived().TraverseTryAcquireCapabilityAttr(cast<TryAcquireCapabilityAttr>(A)); |
| case attr::TypeNonNull: |
| return getDerived().TraverseTypeNonNullAttr(cast<TypeNonNullAttr>(A)); |
| case attr::TypeNullUnspecified: |
| return getDerived().TraverseTypeNullUnspecifiedAttr(cast<TypeNullUnspecifiedAttr>(A)); |
| case attr::TypeNullable: |
| return getDerived().TraverseTypeNullableAttr(cast<TypeNullableAttr>(A)); |
| case attr::TypeNullableResult: |
| return getDerived().TraverseTypeNullableResultAttr(cast<TypeNullableResultAttr>(A)); |
| case attr::TypeTagForDatatype: |
| return getDerived().TraverseTypeTagForDatatypeAttr(cast<TypeTagForDatatypeAttr>(A)); |
| case attr::TypeVisibility: |
| return getDerived().TraverseTypeVisibilityAttr(cast<TypeVisibilityAttr>(A)); |
| case attr::UPtr: |
| return getDerived().TraverseUPtrAttr(cast<UPtrAttr>(A)); |
| case attr::Unavailable: |
| return getDerived().TraverseUnavailableAttr(cast<UnavailableAttr>(A)); |
| case attr::Uninitialized: |
| return getDerived().TraverseUninitializedAttr(cast<UninitializedAttr>(A)); |
| case attr::Unlikely: |
| return getDerived().TraverseUnlikelyAttr(cast<UnlikelyAttr>(A)); |
| case attr::Unused: |
| return getDerived().TraverseUnusedAttr(cast<UnusedAttr>(A)); |
| case attr::UseHandle: |
| return getDerived().TraverseUseHandleAttr(cast<UseHandleAttr>(A)); |
| case attr::Used: |
| return getDerived().TraverseUsedAttr(cast<UsedAttr>(A)); |
| case attr::UsingIfExists: |
| return getDerived().TraverseUsingIfExistsAttr(cast<UsingIfExistsAttr>(A)); |
| case attr::Uuid: |
| return getDerived().TraverseUuidAttr(cast<UuidAttr>(A)); |
| case attr::VecReturn: |
| return getDerived().TraverseVecReturnAttr(cast<VecReturnAttr>(A)); |
| case attr::VecTypeHint: |
| return getDerived().TraverseVecTypeHintAttr(cast<VecTypeHintAttr>(A)); |
| case attr::VectorCall: |
| return getDerived().TraverseVectorCallAttr(cast<VectorCallAttr>(A)); |
| case attr::Visibility: |
| return getDerived().TraverseVisibilityAttr(cast<VisibilityAttr>(A)); |
| case attr::WarnUnused: |
| return getDerived().TraverseWarnUnusedAttr(cast<WarnUnusedAttr>(A)); |
| case attr::WarnUnusedResult: |
| return getDerived().TraverseWarnUnusedResultAttr(cast<WarnUnusedResultAttr>(A)); |
| case attr::Weak: |
| return getDerived().TraverseWeakAttr(cast<WeakAttr>(A)); |
| case attr::WeakImport: |
| return getDerived().TraverseWeakImportAttr(cast<WeakImportAttr>(A)); |
| case attr::WeakRef: |
| return getDerived().TraverseWeakRefAttr(cast<WeakRefAttr>(A)); |
| case attr::WebAssemblyExportName: |
| return getDerived().TraverseWebAssemblyExportNameAttr(cast<WebAssemblyExportNameAttr>(A)); |
| case attr::WebAssemblyImportModule: |
| return getDerived().TraverseWebAssemblyImportModuleAttr(cast<WebAssemblyImportModuleAttr>(A)); |
| case attr::WebAssemblyImportName: |
| return getDerived().TraverseWebAssemblyImportNameAttr(cast<WebAssemblyImportNameAttr>(A)); |
| case attr::WorkGroupSizeHint: |
| return getDerived().TraverseWorkGroupSizeHintAttr(cast<WorkGroupSizeHintAttr>(A)); |
| case attr::X86ForceAlignArgPointer: |
| return getDerived().TraverseX86ForceAlignArgPointerAttr(cast<X86ForceAlignArgPointerAttr>(A)); |
| case attr::XRayInstrument: |
| return getDerived().TraverseXRayInstrumentAttr(cast<XRayInstrumentAttr>(A)); |
| case attr::XRayLogArgs: |
| return getDerived().TraverseXRayLogArgsAttr(cast<XRayLogArgsAttr>(A)); |
| case attr::ZeroCallUsedRegs: |
| return getDerived().TraverseZeroCallUsedRegsAttr(cast<ZeroCallUsedRegsAttr>(A)); |
| } |
| llvm_unreachable("bad attribute kind"); |
| } |
| #endif // ATTR_VISITOR_DECLS_ONLY |