blob: 35f1f8299f49cfa561eb479fb067e03cbc606684 [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 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: