| /*===- 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 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 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 TraverseArtificialAttr(ArtificialAttr *A); |
| bool VisitArtificialAttr(ArtificialAttr *A) { |
| return true; |
| } |
| bool TraverseAsmLabelAttr(AsmLabelAttr *A); |
| bool VisitAsmLabelAttr(AsmLabelAttr *A) { |
| return true; |
| } |
| bool TraverseAssertCapabilityAttr(AssertCapabilityAttr *A); |
| bool VisitAssertCapabilityAttr(AssertCapabilityAttr *A) { |
| return true; |
| } |
| bool TraverseAssertExclusiveLockAttr(AssertExclusiveLockAttr *A); |
| bool VisitAssertExclusiveLockAttr(AssertExclusiveLockAttr *A) { |
| return true; |
| } |
| bool TraverseAssertSharedLockAttr(AssertSharedLockAttr *A); |
| bool VisitAssertSharedLockAttr(AssertSharedLockAttr *A) { |
| return true; |
| } |
| bool TraverseAssumeAlignedAttr(AssumeAlignedAttr *A); |
| bool VisitAssumeAlignedAttr(AssumeAlignedAttr *A) { |
| return true; |
| } |
| bool TraverseAvailabilityAttr(AvailabilityAttr *A); |
| bool VisitAvailabilityAttr(AvailabilityAttr *A) { |
| return true; |
| } |
| bool TraverseBlocksAttr(BlocksAttr *A); |
| bool VisitBlocksAttr(BlocksAttr *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 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 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 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 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 TraverseConstructorAttr(ConstructorAttr *A); |
| bool VisitConstructorAttr(ConstructorAttr *A) { |
| return true; |
| } |
| bool TraverseConsumableAttr(ConsumableAttr *A); |
| bool VisitConsumableAttr(ConsumableAttr *A) { |
| return true; |
| } |
| bool TraverseConsumableAutoCastAttr(ConsumableAutoCastAttr *A); |
| bool VisitConsumableAutoCastAttr(ConsumableAutoCastAttr *A) { |
| return true; |
| } |
| bool TraverseConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A); |
| bool VisitConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A) { |
| return true; |
| } |
| bool TraverseConvergentAttr(ConvergentAttr *A); |
| bool VisitConvergentAttr(ConvergentAttr *A) { |
| return true; |
| } |
| bool TraverseDLLExportAttr(DLLExportAttr *A); |
| bool VisitDLLExportAttr(DLLExportAttr *A) { |
| return true; |
| } |
| bool TraverseDLLExportStaticLocalAttr(DLLExportStaticLocalAttr *A); |
| bool VisitDLLExportStaticLocalAttr(DLLExportStaticLocalAttr *A) { |
| return true; |
| } |
| bool TraverseDLLImportAttr(DLLImportAttr *A); |
| bool VisitDLLImportAttr(DLLImportAttr *A) { |
| return true; |
| } |
| bool TraverseDLLImportStaticLocalAttr(DLLImportStaticLocalAttr *A); |
| bool VisitDLLImportStaticLocalAttr(DLLImportStaticLocalAttr *A) { |
| return true; |
| } |
| bool TraverseDeprecatedAttr(DeprecatedAttr *A); |
| bool VisitDeprecatedAttr(DeprecatedAttr *A) { |
| return true; |
| } |
| bool TraverseDestructorAttr(DestructorAttr *A); |
| bool VisitDestructorAttr(DestructorAttr *A) { |
| return true; |
| } |
| bool TraverseDiagnoseIfAttr(DiagnoseIfAttr *A); |
| bool VisitDiagnoseIfAttr(DiagnoseIfAttr *A) { |
| return true; |
| } |
| bool TraverseDisableTailCallsAttr(DisableTailCallsAttr *A); |
| bool VisitDisableTailCallsAttr(DisableTailCallsAttr *A) { |
| return true; |
| } |
| bool TraverseEmptyBasesAttr(EmptyBasesAttr *A); |
| bool VisitEmptyBasesAttr(EmptyBasesAttr *A) { |
| return true; |
| } |
| bool TraverseEnableIfAttr(EnableIfAttr *A); |
| bool VisitEnableIfAttr(EnableIfAttr *A) { |
| return true; |
| } |
| bool TraverseEnumExtensibilityAttr(EnumExtensibilityAttr *A); |
| bool VisitEnumExtensibilityAttr(EnumExtensibilityAttr *A) { |
| return true; |
| } |
| bool TraverseExcludeFromExplicitInstantiationAttr(ExcludeFromExplicitInstantiationAttr *A); |
| bool VisitExcludeFromExplicitInstantiationAttr(ExcludeFromExplicitInstantiationAttr *A) { |
| return true; |
| } |
| bool TraverseExclusiveTrylockFunctionAttr(ExclusiveTrylockFunctionAttr *A); |
| bool VisitExclusiveTrylockFunctionAttr(ExclusiveTrylockFunctionAttr *A) { |
| return true; |
| } |
| bool TraverseExternalSourceSymbolAttr(ExternalSourceSymbolAttr *A); |
| bool VisitExternalSourceSymbolAttr(ExternalSourceSymbolAttr *A) { |
| return true; |
| } |
| bool TraverseFallThroughAttr(FallThroughAttr *A); |
| bool VisitFallThroughAttr(FallThroughAttr *A) { |
| return true; |
| } |
| bool TraverseFastCallAttr(FastCallAttr *A); |
| bool VisitFastCallAttr(FastCallAttr *A) { |
| return true; |
| } |
| bool TraverseFinalAttr(FinalAttr *A); |
| bool VisitFinalAttr(FinalAttr *A) { |
| return true; |
| } |
| bool TraverseFlagEnumAttr(FlagEnumAttr *A); |
| bool VisitFlagEnumAttr(FlagEnumAttr *A) { |
| return true; |
| } |
| bool TraverseFlattenAttr(FlattenAttr *A); |
| bool VisitFlattenAttr(FlattenAttr *A) { |
| return true; |
| } |
| bool TraverseFormatAttr(FormatAttr *A); |
| bool VisitFormatAttr(FormatAttr *A) { |
| return true; |
| } |
| bool TraverseFormatArgAttr(FormatArgAttr *A); |
| bool VisitFormatArgAttr(FormatArgAttr *A) { |
| return true; |
| } |
| bool TraverseFortifyStdLibAttr(FortifyStdLibAttr *A); |
| bool VisitFortifyStdLibAttr(FortifyStdLibAttr *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 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 TraverseLifetimeBoundAttr(LifetimeBoundAttr *A); |
| bool VisitLifetimeBoundAttr(LifetimeBoundAttr *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 TraverseMSABIAttr(MSABIAttr *A); |
| bool VisitMSABIAttr(MSABIAttr *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 TraverseNSConsumedAttr(NSConsumedAttr *A); |
| bool VisitNSConsumedAttr(NSConsumedAttr *A) { |
| return true; |
| } |
| bool TraverseNSConsumesSelfAttr(NSConsumesSelfAttr *A); |
| bool VisitNSConsumesSelfAttr(NSConsumesSelfAttr *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 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 TraverseNoMicroMipsAttr(NoMicroMipsAttr *A); |
| bool VisitNoMicroMipsAttr(NoMicroMipsAttr *A) { |
| return true; |
| } |
| bool TraverseNoMips16Attr(NoMips16Attr *A); |
| bool VisitNoMips16Attr(NoMips16Attr *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 TraverseNonNullAttr(NonNullAttr *A); |
| bool VisitNonNullAttr(NonNullAttr *A) { |
| return true; |
| } |
| bool TraverseNotTailCalledAttr(NotTailCalledAttr *A); |
| bool VisitNotTailCalledAttr(NotTailCalledAttr *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 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 TraverseObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A); |
| bool VisitObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *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 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 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 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 TraversePcsAttr(PcsAttr *A); |
| bool VisitPcsAttr(PcsAttr *A) { |
| return true; |
| } |
| bool TraversePragmaClangBSSSectionAttr(PragmaClangBSSSectionAttr *A); |
| bool VisitPragmaClangBSSSectionAttr(PragmaClangBSSSectionAttr *A) { |
| return true; |
| } |
| bool TraversePragmaClangDataSectionAttr(PragmaClangDataSectionAttr *A); |
| bool VisitPragmaClangDataSectionAttr(PragmaClangDataSectionAttr *A) { |
| return true; |
| } |
| bool TraversePragmaClangRodataSectionAttr(PragmaClangRodataSectionAttr *A); |
| bool VisitPragmaClangRodataSectionAttr(PragmaClangRodataSectionAttr *A) { |
| return true; |
| } |
| bool TraversePragmaClangTextSectionAttr(PragmaClangTextSectionAttr *A); |
| bool VisitPragmaClangTextSectionAttr(PragmaClangTextSectionAttr *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 TraverseRenderScriptKernelAttr(RenderScriptKernelAttr *A); |
| bool VisitRenderScriptKernelAttr(RenderScriptKernelAttr *A) { |
| return true; |
| } |
| bool TraverseReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A); |
| bool VisitReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A) { |
| return true; |
| } |
| bool TraverseRequireConstantInitAttr(RequireConstantInitAttr *A); |
| bool VisitRequireConstantInitAttr(RequireConstantInitAttr *A) { |
| return true; |
| } |
| bool TraverseRequiresCapabilityAttr(RequiresCapabilityAttr *A); |
| bool VisitRequiresCapabilityAttr(RequiresCapabilityAttr *A) { |
| return true; |
| } |
| bool TraverseRestrictAttr(RestrictAttr *A); |
| bool VisitRestrictAttr(RestrictAttr *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 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 TraverseStdCallAttr(StdCallAttr *A); |
| bool VisitStdCallAttr(StdCallAttr *A) { |
| return true; |
| } |
| bool TraverseSuppressAttr(SuppressAttr *A); |
| bool VisitSuppressAttr(SuppressAttr *A) { |
| return true; |
| } |
| bool TraverseSwiftCallAttr(SwiftCallAttr *A); |
| bool VisitSwiftCallAttr(SwiftCallAttr *A) { |
| return true; |
| } |
| bool TraverseSwiftContextAttr(SwiftContextAttr *A); |
| bool VisitSwiftContextAttr(SwiftContextAttr *A) { |
| return true; |
| } |
| bool TraverseSwiftErrorResultAttr(SwiftErrorResultAttr *A); |
| bool VisitSwiftErrorResultAttr(SwiftErrorResultAttr *A) { |
| return true; |
| } |
| bool TraverseSwiftIndirectResultAttr(SwiftIndirectResultAttr *A); |
| bool VisitSwiftIndirectResultAttr(SwiftIndirectResultAttr *A) { |
| return true; |
| } |
| bool TraverseSysVABIAttr(SysVABIAttr *A); |
| bool VisitSysVABIAttr(SysVABIAttr *A) { |
| return true; |
| } |
| bool TraverseTLSModelAttr(TLSModelAttr *A); |
| bool VisitTLSModelAttr(TLSModelAttr *A) { |
| return true; |
| } |
| bool TraverseTargetAttr(TargetAttr *A); |
| bool VisitTargetAttr(TargetAttr *A) { |
| return true; |
| } |
| bool TraverseTestTypestateAttr(TestTypestateAttr *A); |
| bool VisitTestTypestateAttr(TestTypestateAttr *A) { |
| return true; |
| } |
| bool TraverseThisCallAttr(ThisCallAttr *A); |
| bool VisitThisCallAttr(ThisCallAttr *A) { |
| return true; |
| } |
| bool TraverseThreadAttr(ThreadAttr *A); |
| bool VisitThreadAttr(ThreadAttr *A) { |
| return true; |
| } |
| bool TraverseTransparentUnionAttr(TransparentUnionAttr *A); |
| bool VisitTransparentUnionAttr(TransparentUnionAttr *A) { |
| return true; |
| } |
| bool TraverseTrivialABIAttr(TrivialABIAttr *A); |
| bool VisitTrivialABIAttr(TrivialABIAttr *A) { |
| return true; |
| } |
| bool TraverseTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A); |
| bool VisitTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A) { |
| return true; |
| } |
| bool TraverseTypeNonNullAttr(TypeNonNullAttr *A); |
| bool VisitTypeNonNullAttr(TypeNonNullAttr *A) { |
| return true; |
| } |
| bool TraverseTypeNullUnspecifiedAttr(TypeNullUnspecifiedAttr *A); |
| bool VisitTypeNullUnspecifiedAttr(TypeNullUnspecifiedAttr *A) { |
| return true; |
| } |
| bool TraverseTypeNullableAttr(TypeNullableAttr *A); |
| bool VisitTypeNullableAttr(TypeNullableAttr *A) { |
| return true; |
| } |
| bool 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 TraverseUnusedAttr(UnusedAttr *A); |
| bool VisitUnusedAttr(UnusedAttr *A) { |
| return true; |
| } |
| bool TraverseUsedAttr(UsedAttr *A); |
| bool VisitUsedAttr(UsedAttr *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 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; |
| } |
| |
| #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; |
| 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; |
| 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>::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>::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; |
| 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>::TraverseArtificialAttr(ArtificialAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitArtificialAttr(A)) |
| return false; |
| return true; |
| } |
| |
| template <typename Derived> |
| bool VISITORCLASS<Derived>::TraverseAsmLabelAttr(AsmLabelAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitAsmLabelAttr(A)) |
| return false; |
| return true; |
| } |
| |
| template <typename Derived> |
| bool VISITORCLASS<Derived>::TraverseAssertCapabilityAttr(AssertCapabilityAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitAssertCapabilityAttr(A)) |
| return false; |
| { |
| Expr * *I = A->args_begin(); |
| Expr * *E = A->args_end(); |
| for (; I != E; ++I) { |
| if (!getDerived().TraverseStmt(*I)) |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| template <typename Derived> |
| bool VISITORCLASS<Derived>::TraverseAssertExclusiveLockAttr(AssertExclusiveLockAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitAssertExclusiveLockAttr(A)) |
| return false; |
| { |
| Expr * *I = A->args_begin(); |
| Expr * *E = A->args_end(); |
| for (; I != E; ++I) { |
| if (!getDerived().TraverseStmt(*I)) |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| template <typename Derived> |
| bool VISITORCLASS<Derived>::TraverseAssertSharedLockAttr(AssertSharedLockAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitAssertSharedLockAttr(A)) |
| return false; |
| { |
| Expr * *I = A->args_begin(); |
| Expr * *E = A->args_end(); |
| for (; I != E; ++I) { |
| if (!getDerived().TraverseStmt(*I)) |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| template <typename Derived> |
| bool VISITORCLASS<Derived>::TraverseAssumeAlignedAttr(AssumeAlignedAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitAssumeAlignedAttr(A)) |
| return false; |
| if (!getDerived().TraverseStmt(A->getAlignment())) |
| return false; |
| if (!getDerived().TraverseStmt(A->getOffset())) |
| return false; |
| return true; |
| } |
| |
| template <typename Derived> |
| bool VISITORCLASS<Derived>::TraverseAvailabilityAttr(AvailabilityAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitAvailabilityAttr(A)) |
| return false; |
| return true; |
| } |
| |
| template <typename Derived> |
| bool VISITORCLASS<Derived>::TraverseBlocksAttr(BlocksAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitBlocksAttr(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>::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>::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>::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>::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>::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>::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>::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>::TraverseEnumExtensibilityAttr(EnumExtensibilityAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitEnumExtensibilityAttr(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>::TraverseFortifyStdLibAttr(FortifyStdLibAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitFortifyStdLibAttr(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>::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>::TraverseLifetimeBoundAttr(LifetimeBoundAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitLifetimeBoundAttr(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>::TraverseMSABIAttr(MSABIAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitMSABIAttr(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>::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>::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>::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>::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>::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>::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>::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; |
| 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( |