blob: 08311b95c469ec6d8c713be8f7920e31ba7cb626 [file] [log] [blame]
/*===- 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(