| /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\ |
| |* *| |
| |*Used by RecursiveASTVisitor to visit attributes. *| |
| |* *| |
| |* Automatically generated file, do not edit! *| |
| |* *| |
| \*===----------------------------------------------------------------------===*/ |
| |
| #ifdef ATTR_VISITOR_DECLS_ONLY |
| |
| bool TraverseARMInterruptAttr(ARMInterruptAttr *A); |
| bool VisitARMInterruptAttr(ARMInterruptAttr *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 TraverseAliasAttr(AliasAttr *A); |
| bool VisitAliasAttr(AliasAttr *A) { |
| return true; |
| }; |
| bool TraverseAlignMac68kAttr(AlignMac68kAttr *A); |
| bool VisitAlignMac68kAttr(AlignMac68kAttr *A) { |
| return true; |
| }; |
| bool TraverseAlignedAttr(AlignedAttr *A); |
| bool VisitAlignedAttr(AlignedAttr *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 TraverseArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A); |
| bool VisitArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A) { |
| return true; |
| }; |
| bool TraverseArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *A); |
| bool VisitArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *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 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 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 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 TraverseCapabilityAttr(CapabilityAttr *A); |
| bool VisitCapabilityAttr(CapabilityAttr *A) { |
| return true; |
| }; |
| bool TraverseCarriesDependencyAttr(CarriesDependencyAttr *A); |
| bool VisitCarriesDependencyAttr(CarriesDependencyAttr *A) { |
| return true; |
| }; |
| bool TraverseCleanupAttr(CleanupAttr *A); |
| bool VisitCleanupAttr(CleanupAttr *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 TraverseDLLExportAttr(DLLExportAttr *A); |
| bool VisitDLLExportAttr(DLLExportAttr *A) { |
| return true; |
| }; |
| bool TraverseDLLImportAttr(DLLImportAttr *A); |
| bool VisitDLLImportAttr(DLLImportAttr *A) { |
| return true; |
| }; |
| bool TraverseDeprecatedAttr(DeprecatedAttr *A); |
| bool VisitDeprecatedAttr(DeprecatedAttr *A) { |
| return true; |
| }; |
| bool TraverseDestructorAttr(DestructorAttr *A); |
| bool VisitDestructorAttr(DestructorAttr *A) { |
| return true; |
| }; |
| bool TraverseEnableIfAttr(EnableIfAttr *A); |
| bool VisitEnableIfAttr(EnableIfAttr *A) { |
| return true; |
| }; |
| bool TraverseExclusiveTrylockFunctionAttr(ExclusiveTrylockFunctionAttr *A); |
| bool VisitExclusiveTrylockFunctionAttr(ExclusiveTrylockFunctionAttr *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 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 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 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 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 TraverseMSP430InterruptAttr(MSP430InterruptAttr *A); |
| bool VisitMSP430InterruptAttr(MSP430InterruptAttr *A) { |
| return true; |
| }; |
| bool TraverseMSVtorDispAttr(MSVtorDispAttr *A); |
| bool VisitMSVtorDispAttr(MSVtorDispAttr *A) { |
| return true; |
| }; |
| bool TraverseMallocAttr(MallocAttr *A); |
| bool VisitMallocAttr(MallocAttr *A) { |
| return true; |
| }; |
| bool TraverseMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A); |
| bool VisitMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A) { |
| return true; |
| }; |
| bool TraverseMayAliasAttr(MayAliasAttr *A); |
| bool VisitMayAliasAttr(MayAliasAttr *A) { |
| return true; |
| }; |
| bool TraverseMinSizeAttr(MinSizeAttr *A); |
| bool VisitMinSizeAttr(MinSizeAttr *A) { |
| return true; |
| }; |
| bool TraverseMips16Attr(Mips16Attr *A); |
| bool VisitMips16Attr(Mips16Attr *A) { |
| return true; |
| }; |
| bool TraverseModeAttr(ModeAttr *A); |
| bool VisitModeAttr(ModeAttr *A) { |
| return true; |
| }; |
| bool TraverseMsStructAttr(MsStructAttr *A); |
| bool VisitMsStructAttr(MsStructAttr *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 TraverseNoCommonAttr(NoCommonAttr *A); |
| bool VisitNoCommonAttr(NoCommonAttr *A) { |
| return true; |
| }; |
| bool TraverseNoDebugAttr(NoDebugAttr *A); |
| bool VisitNoDebugAttr(NoDebugAttr *A) { |
| return true; |
| }; |
| bool TraverseNoDuplicateAttr(NoDuplicateAttr *A); |
| bool VisitNoDuplicateAttr(NoDuplicateAttr *A) { |
| return true; |
| }; |
| bool TraverseNoInlineAttr(NoInlineAttr *A); |
| bool VisitNoInlineAttr(NoInlineAttr *A) { |
| return true; |
| }; |
| bool TraverseNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A); |
| bool VisitNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A) { |
| return true; |
| }; |
| bool TraverseNoMips16Attr(NoMips16Attr *A); |
| bool VisitNoMips16Attr(NoMips16Attr *A) { |
| return true; |
| }; |
| bool TraverseNoReturnAttr(NoReturnAttr *A); |
| bool VisitNoReturnAttr(NoReturnAttr *A) { |
| return true; |
| }; |
| bool TraverseNoSanitizeAddressAttr(NoSanitizeAddressAttr *A); |
| bool VisitNoSanitizeAddressAttr(NoSanitizeAddressAttr *A) { |
| return true; |
| }; |
| bool TraverseNoSanitizeMemoryAttr(NoSanitizeMemoryAttr *A); |
| bool VisitNoSanitizeMemoryAttr(NoSanitizeMemoryAttr *A) { |
| return true; |
| }; |
| bool TraverseNoSanitizeThreadAttr(NoSanitizeThreadAttr *A); |
| bool VisitNoSanitizeThreadAttr(NoSanitizeThreadAttr *A) { |
| return true; |
| }; |
| bool TraverseNoSplitStackAttr(NoSplitStackAttr *A); |
| bool VisitNoSplitStackAttr(NoSplitStackAttr *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 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 TraverseObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A); |
| bool VisitObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A) { |
| return true; |
| }; |
| bool TraverseObjCNSObjectAttr(ObjCNSObjectAttr *A); |
| bool VisitObjCNSObjectAttr(ObjCNSObjectAttr *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 TraverseOpenCLImageAccessAttr(OpenCLImageAccessAttr *A); |
| bool VisitOpenCLImageAccessAttr(OpenCLImageAccessAttr *A) { |
| return true; |
| }; |
| bool TraverseOpenCLKernelAttr(OpenCLKernelAttr *A); |
| bool VisitOpenCLKernelAttr(OpenCLKernelAttr *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 TraversePcsAttr(PcsAttr *A); |
| bool VisitPcsAttr(PcsAttr *A) { |
| return true; |
| }; |
| bool TraversePnaclCallAttr(PnaclCallAttr *A); |
| bool VisitPnaclCallAttr(PnaclCallAttr *A) { |
| return true; |
| }; |
| bool TraversePtGuardedByAttr(PtGuardedByAttr *A); |
| bool VisitPtGuardedByAttr(PtGuardedByAttr *A) { |
| return true; |
| }; |
| bool TraversePtGuardedVarAttr(PtGuardedVarAttr *A); |
| bool VisitPtGuardedVarAttr(PtGuardedVarAttr *A) { |
| return true; |
| }; |
| bool TraversePureAttr(PureAttr *A); |
| bool VisitPureAttr(PureAttr *A) { |
| return true; |
| }; |
| bool TraverseReleaseCapabilityAttr(ReleaseCapabilityAttr *A); |
| bool VisitReleaseCapabilityAttr(ReleaseCapabilityAttr *A) { |
| return true; |
| }; |
| bool TraverseReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A); |
| bool VisitReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A) { |
| return true; |
| }; |
| bool TraverseRequiresCapabilityAttr(RequiresCapabilityAttr *A); |
| bool VisitRequiresCapabilityAttr(RequiresCapabilityAttr *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 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 TraverseStdCallAttr(StdCallAttr *A); |
| bool VisitStdCallAttr(StdCallAttr *A) { |
| return true; |
| }; |
| bool TraverseSysVABIAttr(SysVABIAttr *A); |
| bool VisitSysVABIAttr(SysVABIAttr *A) { |
| return true; |
| }; |
| bool TraverseTLSModelAttr(TLSModelAttr *A); |
| bool VisitTLSModelAttr(TLSModelAttr *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 TraverseTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A); |
| bool VisitTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A) { |
| return true; |
| }; |
| bool TraverseTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A); |
| bool VisitTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A) { |
| return true; |
| }; |
| bool TraverseTypeVisibilityAttr(TypeVisibilityAttr *A); |
| bool VisitTypeVisibilityAttr(TypeVisibilityAttr *A) { |
| return true; |
| }; |
| bool TraverseUnavailableAttr(UnavailableAttr *A); |
| bool VisitUnavailableAttr(UnavailableAttr *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 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 TraverseWorkGroupSizeHintAttr(WorkGroupSizeHintAttr *A); |
| bool VisitWorkGroupSizeHintAttr(WorkGroupSizeHintAttr *A) { |
| return true; |
| }; |
| bool TraverseX86ForceAlignArgPointerAttr(X86ForceAlignArgPointerAttr *A); |
| bool VisitX86ForceAlignArgPointerAttr(X86ForceAlignArgPointerAttr *A) { |
| return true; |
| }; |
| |
| #else // ATTR_VISITOR_DECLS_ONLY |
| |
| 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>::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>::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>::TraverseAlignedAttr(AlignedAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitAlignedAttr(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>::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>::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; |
| if (!getDerived().TraverseStmt(A->getExpr())) |
| 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>::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>::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>::TraverseCUDALaunchBoundsAttr(CUDALaunchBoundsAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitCUDALaunchBoundsAttr(A)) |
| 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>::TraverseCapabilityAttr(CapabilityAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitCapabilityAttr(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>::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>::TraverseDLLExportAttr(DLLExportAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitDLLExportAttr(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>::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>::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>::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>::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>::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>::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; |
| 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>::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; |
| 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>::TraverseMSP430InterruptAttr(MSP430InterruptAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitMSP430InterruptAttr(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>::TraverseMallocAttr(MallocAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitMallocAttr(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>::TraverseMinSizeAttr(MinSizeAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitMinSizeAttr(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>::TraverseModeAttr(ModeAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitModeAttr(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>::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>::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>::TraverseNoDuplicateAttr(NoDuplicateAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitNoDuplicateAttr(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>::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>::TraverseNoSanitizeAddressAttr(NoSanitizeAddressAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitNoSanitizeAddressAttr(A)) |
| return false; |
| return true; |
| } |
| |
| template <typename Derived> |
| bool VISITORCLASS<Derived>::TraverseNoSanitizeMemoryAttr(NoSanitizeMemoryAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitNoSanitizeMemoryAttr(A)) |
| return false; |
| return true; |
| } |
| |
| template <typename Derived> |
| bool VISITORCLASS<Derived>::TraverseNoSanitizeThreadAttr(NoSanitizeThreadAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitNoSanitizeThreadAttr(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>::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>::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>::TraverseObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitObjCDesignatedInitializerAttr(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>::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>::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>::TraverseOpenCLImageAccessAttr(OpenCLImageAccessAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitOpenCLImageAccessAttr(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>::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>::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>::TraversePcsAttr(PcsAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitPcsAttr(A)) |
| return false; |
| return true; |
| } |
| |
| template <typename Derived> |
| bool VISITORCLASS<Derived>::TraversePnaclCallAttr(PnaclCallAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitPnaclCallAttr(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>::TraversePureAttr(PureAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitPureAttr(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>::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>::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>::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>::TraverseStdCallAttr(StdCallAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitStdCallAttr(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>::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>::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>::TraverseTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitTypeTagForDatatypeAttr(A)) |
| 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>::TraverseUnavailableAttr(UnavailableAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitUnavailableAttr(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>::TraverseUsedAttr(UsedAttr *A) { |
| if (!getDerived().VisitAttr(A)) |
| return false; |
| if (!getDerived().VisitUsedAttr(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; |
| 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>::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>::TraverseAttr(Attr *A) { |
| if (!A) |
| return true; |
| |
| switch (A->getKind()) { |
| default: |
| return true; |
| case attr::ARMInterrupt: |
| return getDerived().TraverseARMInterruptAttr(cast<ARMInterruptAttr>(A)); |
| case attr::AcquireCapability: |
| return getDerived().TraverseAcquireCapabilityAttr(cast<AcquireCapabilityAttr>(A)); |
| case attr::AcquiredAfter: |
| return getDerived().TraverseAcquiredAfterAttr(cast<AcquiredAfterAttr>(A)); |
| case attr::AcquiredBefore: |
| return getDerived().TraverseAcquiredBeforeAttr(cast<AcquiredBeforeAttr>(A)); |
| case attr::Alias: |
| return getDerived().TraverseAliasAttr(cast<AliasAttr>(A)); |
| case attr::AlignMac68k: |
| return getDerived().TraverseAlignMac68kAttr(cast<AlignMac68kAttr>(A)); |
| case attr::Aligned: |
| return getDerived().TraverseAlignedAttr(cast<AlignedAttr>(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::ArcWeakrefUnavailable: |
| return getDerived().TraverseArcWeakrefUnavailableAttr(cast<ArcWeakrefUnavailableAttr>(A)); |
| case attr::ArgumentWithTypeTag: |
| return getDerived().TraverseArgumentWithTypeTagAttr(cast<ArgumentWithTypeTagAttr>(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::Availability: |
| return getDerived().TraverseAvailabilityAttr(cast<AvailabilityAttr>(A)); |
| case attr::Blocks: |
| return getDerived().TraverseBlocksAttr(cast<BlocksAttr>(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::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::CUDAConstant: |
| return getDerived().TraverseCUDAConstantAttr(cast<CUDAConstantAttr>(A)); |
| case attr::CUDADevice: |
| return getDerived().TraverseCUDADeviceAttr(cast<CUDADeviceAttr>(A)); |
| case attr::CUDAGlobal: |
| return getDerived().TraverseCUDAGlobalAttr(cast<CUDAGlobalAttr>(A)); |
| case attr::CUDAHost: |
| return getDerived().TraverseCUDAHostAttr(cast<CUDAHostAttr>(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::Capability: |
| return getDerived().TraverseCapabilityAttr(cast<CapabilityAttr>(A)); |
| case attr::CarriesDependency: |
| return getDerived().TraverseCarriesDependencyAttr(cast<CarriesDependencyAttr>(A)); |
| case attr::Cleanup: |
| return getDerived().TraverseCleanupAttr(cast<CleanupAttr>(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::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::DLLExport: |
| return getDerived().TraverseDLLExportAttr(cast<DLLExportAttr>(A)); |
| case attr::DLLImport: |
| return getDerived().TraverseDLLImportAttr(cast<DLLImportAttr>(A)); |
| case attr::Deprecated: |
| return getDerived().TraverseDeprecatedAttr(cast<DeprecatedAttr>(A)); |
| case attr::Destructor: |
| return getDerived().TraverseDestructorAttr(cast<DestructorAttr>(A)); |
| case attr::EnableIf: |
| return getDerived().TraverseEnableIfAttr(cast<EnableIfAttr>(A)); |
| case attr::ExclusiveTrylockFunction: |
| return getDerived().TraverseExclusiveTrylockFunctionAttr(cast<ExclusiveTrylockFunctionAttr>(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::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::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::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::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::MSABI: |
| return getDerived().TraverseMSABIAttr(cast<MSABIAttr>(A)); |
| case attr::MSInheritance: |
| return getDerived().TraverseMSInheritanceAttr(cast<MSInheritanceAttr>(A)); |
| case attr::MSP430Interrupt: |
| return getDerived().TraverseMSP430InterruptAttr(cast<MSP430InterruptAttr>(A)); |
| case attr::MSVtorDisp: |
| return getDerived().TraverseMSVtorDispAttr(cast<MSVtorDispAttr>(A)); |
| case attr::Malloc: |
| return getDerived().TraverseMallocAttr(cast<MallocAttr>(A)); |
| case attr::MaxFieldAlignment: |
| return getDerived().TraverseMaxFieldAlignmentAttr(cast<MaxFieldAlignmentAttr>(A)); |
| case attr::MayAlias: |
| return getDerived().TraverseMayAliasAttr(cast<MayAliasAttr>(A)); |
| case attr::MinSize: |
| return getDerived().TraverseMinSizeAttr(cast<MinSizeAttr>(A)); |
| case attr::Mips16: |
| return getDerived().TraverseMips16Attr(cast<Mips16Attr>(A)); |
| case attr::Mode: |
| return getDerived().TraverseModeAttr(cast<ModeAttr>(A)); |
| case attr::MsStruct: |
| return getDerived().TraverseMsStructAttr(cast<MsStructAttr>(A)); |
| case attr::NSConsumed: |
| return getDerived().TraverseNSConsumedAttr(cast<NSConsumedAttr>(A)); |
| case attr::NSConsumesSelf: |
| return getDerived().TraverseNSConsumesSelfAttr(cast<NSConsumesSelfAttr>(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::NoCommon: |
| return getDerived().TraverseNoCommonAttr(cast<NoCommonAttr>(A)); |
| case attr::NoDebug: |
| return getDerived().TraverseNoDebugAttr(cast<NoDebugAttr>(A)); |
| case attr::NoDuplicate: |
| return getDerived().TraverseNoDuplicateAttr(cast<NoDuplicateAttr>(A)); |
| case attr::NoInline: |
| return getDerived().TraverseNoInlineAttr(cast<NoInlineAttr>(A)); |
| case attr::NoInstrumentFunction: |
| return getDerived().TraverseNoInstrumentFunctionAttr(cast<NoInstrumentFunctionAttr>(A)); |
| case attr::NoMips16: |
| return getDerived().TraverseNoMips16Attr(cast<NoMips16Attr>(A)); |
| case attr::NoReturn: |
| return getDerived().TraverseNoReturnAttr(cast<NoReturnAttr>(A)); |
| case attr::NoSanitizeAddress: |
| return getDerived().TraverseNoSanitizeAddressAttr(cast<NoSanitizeAddressAttr>(A)); |
| case attr::NoSanitizeMemory: |
| return getDerived().TraverseNoSanitizeMemoryAttr(cast<NoSanitizeMemoryAttr>(A)); |
| case attr::NoSanitizeThread: |
| return getDerived().TraverseNoSanitizeThreadAttr(cast<NoSanitizeThreadAttr>(A)); |
| case attr::NoSplitStack: |
| return getDerived().TraverseNoSplitStackAttr(cast<NoSplitStackAttr>(A)); |
| case attr::NoThreadSafetyAnalysis: |
| return getDerived().TraverseNoThreadSafetyAnalysisAttr(cast<NoThreadSafetyAnalysisAttr>(A)); |
| case attr::NoThrow: |
| return getDerived().TraverseNoThrowAttr(cast<NoThrowAttr>(A)); |
| case attr::NonNull: |
| return getDerived().TraverseNonNullAttr(cast<NonNullAttr>(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::ObjCDesignatedInitializer: |
| return getDerived().TraverseObjCDesignatedInitializerAttr(cast<ObjCDesignatedInitializerAttr>(A)); |
| case attr::ObjCException: |
| return getDerived().TraverseObjCExceptionAttr(cast<ObjCExceptionAttr>(A)); |
| case attr::ObjCExplicitProtocolImpl: |
| return getDerived().TraverseObjCExplicitProtocolImplAttr(cast<ObjCExplicitProtocolImplAttr>(A)); |
| case attr::ObjCMethodFamily: |
| return getDerived().TraverseObjCMethodFamilyAttr(cast<ObjCMethodFamilyAttr>(A)); |
| case attr::ObjCNSObject: |
| return getDerived().TraverseObjCNSObjectAttr(cast<ObjCNSObjectAttr>(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::OpenCLImageAccess: |
| return getDerived().TraverseOpenCLImageAccessAttr(cast<OpenCLImageAccessAttr>(A)); |
| case attr::OpenCLKernel: |
| return getDerived().TraverseOpenCLKernelAttr(cast<OpenCLKernelAttr>(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::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::Pcs: |
| return getDerived().TraversePcsAttr(cast<PcsAttr>(A)); |
| case attr::PnaclCall: |
| return getDerived().TraversePnaclCallAttr(cast<PnaclCallAttr>(A)); |
| case attr::PtGuardedBy: |
| return getDerived().TraversePtGuardedByAttr(cast<PtGuardedByAttr>(A)); |
| case attr::PtGuardedVar: |
| return getDerived().TraversePtGuardedVarAttr(cast<PtGuardedVarAttr>(A)); |
| case attr::Pure: |
| return getDerived().TraversePureAttr(cast<PureAttr>(A)); |
| case attr::ReleaseCapability: |
| return getDerived().TraverseReleaseCapabilityAttr(cast<ReleaseCapabilityAttr>(A)); |
| case attr::ReqdWorkGroupSize: |
| return getDerived().TraverseReqdWorkGroupSizeAttr(cast<ReqdWorkGroupSizeAttr>(A)); |
| case attr::RequiresCapability: |
| return getDerived().TraverseRequiresCapabilityAttr(cast<RequiresCapabilityAttr>(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::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::StdCall: |
| return getDerived().TraverseStdCallAttr(cast<StdCallAttr>(A)); |
| case attr::SysVABI: |
| return getDerived().TraverseSysVABIAttr(cast<SysVABIAttr>(A)); |
| case attr::TLSModel: |
| return getDerived().TraverseTLSModelAttr(cast<TLSModelAttr>(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::TryAcquireCapability: |
| return getDerived().TraverseTryAcquireCapabilityAttr(cast<TryAcquireCapabilityAttr>(A)); |
| case attr::TypeTagForDatatype: |
| return getDerived().TraverseTypeTagForDatatypeAttr(cast<TypeTagForDatatypeAttr>(A)); |
| case attr::TypeVisibility: |
| return getDerived().TraverseTypeVisibilityAttr(cast<TypeVisibilityAttr>(A)); |
| case attr::Unavailable: |
| return getDerived().TraverseUnavailableAttr(cast<UnavailableAttr>(A)); |
| case attr::Unused: |
| return getDerived().TraverseUnusedAttr(cast<UnusedAttr>(A)); |
| case attr::Used: |
| return getDerived().TraverseUsedAttr(cast<UsedAttr>(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::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::WorkGroupSizeHint: |
| return getDerived().TraverseWorkGroupSizeHintAttr(cast<WorkGroupSizeHintAttr>(A)); |
| case attr::X86ForceAlignArgPointer: |
| return getDerived().TraverseX86ForceAlignArgPointerAttr(cast<X86ForceAlignArgPointerAttr>(A)); |
| } |
| } |
| #endif // ATTR_VISITOR_DECLS_ONLY |