llvm/tools/clang/include/clang/AST/AttrVisitor.inc

/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* Used by RecursiveASTVisitor to visit attributes.                           *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|* From: Attr.td                                                              *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/

#ifdef ATTR_VISITOR_DECLS_ONLY

  bool TraverseAArch64SVEPcsAttr(AArch64SVEPcsAttr *A);
  bool VisitAArch64SVEPcsAttr(AArch64SVEPcsAttr *A) {}
  bool TraverseAArch64VectorPcsAttr(AArch64VectorPcsAttr *A);
  bool VisitAArch64VectorPcsAttr(AArch64VectorPcsAttr *A) {}
  bool TraverseAMDGPUFlatWorkGroupSizeAttr(AMDGPUFlatWorkGroupSizeAttr *A);
  bool VisitAMDGPUFlatWorkGroupSizeAttr(AMDGPUFlatWorkGroupSizeAttr *A) {}
  bool TraverseAMDGPUKernelCallAttr(AMDGPUKernelCallAttr *A);
  bool VisitAMDGPUKernelCallAttr(AMDGPUKernelCallAttr *A) {}
  bool TraverseAMDGPUMaxNumWorkGroupsAttr(AMDGPUMaxNumWorkGroupsAttr *A);
  bool VisitAMDGPUMaxNumWorkGroupsAttr(AMDGPUMaxNumWorkGroupsAttr *A) {}
  bool TraverseAMDGPUNumSGPRAttr(AMDGPUNumSGPRAttr *A);
  bool VisitAMDGPUNumSGPRAttr(AMDGPUNumSGPRAttr *A) {}
  bool TraverseAMDGPUNumVGPRAttr(AMDGPUNumVGPRAttr *A);
  bool VisitAMDGPUNumVGPRAttr(AMDGPUNumVGPRAttr *A) {}
  bool TraverseAMDGPUWavesPerEUAttr(AMDGPUWavesPerEUAttr *A);
  bool VisitAMDGPUWavesPerEUAttr(AMDGPUWavesPerEUAttr *A) {}
  bool TraverseARMInterruptAttr(ARMInterruptAttr *A);
  bool VisitARMInterruptAttr(ARMInterruptAttr *A) {}
  bool TraverseAVRInterruptAttr(AVRInterruptAttr *A);
  bool VisitAVRInterruptAttr(AVRInterruptAttr *A) {}
  bool TraverseAVRSignalAttr(AVRSignalAttr *A);
  bool VisitAVRSignalAttr(AVRSignalAttr *A) {}
  bool TraverseAbiTagAttr(AbiTagAttr *A);
  bool VisitAbiTagAttr(AbiTagAttr *A) {}
  bool TraverseAcquireCapabilityAttr(AcquireCapabilityAttr *A);
  bool VisitAcquireCapabilityAttr(AcquireCapabilityAttr *A) {}
  bool TraverseAcquireHandleAttr(AcquireHandleAttr *A);
  bool VisitAcquireHandleAttr(AcquireHandleAttr *A) {}
  bool TraverseAcquiredAfterAttr(AcquiredAfterAttr *A);
  bool VisitAcquiredAfterAttr(AcquiredAfterAttr *A) {}
  bool TraverseAcquiredBeforeAttr(AcquiredBeforeAttr *A);
  bool VisitAcquiredBeforeAttr(AcquiredBeforeAttr *A) {}
  bool TraverseAddressSpaceAttr(AddressSpaceAttr *A);
  bool VisitAddressSpaceAttr(AddressSpaceAttr *A) {}
  bool TraverseAliasAttr(AliasAttr *A);
  bool VisitAliasAttr(AliasAttr *A) {}
  bool TraverseAlignMac68kAttr(AlignMac68kAttr *A);
  bool VisitAlignMac68kAttr(AlignMac68kAttr *A) {}
  bool TraverseAlignNaturalAttr(AlignNaturalAttr *A);
  bool VisitAlignNaturalAttr(AlignNaturalAttr *A) {}
  bool TraverseAlignValueAttr(AlignValueAttr *A);
  bool VisitAlignValueAttr(AlignValueAttr *A) {}
  bool TraverseAlignedAttr(AlignedAttr *A);
  bool VisitAlignedAttr(AlignedAttr *A) {}
  bool TraverseAllocAlignAttr(AllocAlignAttr *A);
  bool VisitAllocAlignAttr(AllocAlignAttr *A) {}
  bool TraverseAllocSizeAttr(AllocSizeAttr *A);
  bool VisitAllocSizeAttr(AllocSizeAttr *A) {}
  bool TraverseAllocatingAttr(AllocatingAttr *A);
  bool VisitAllocatingAttr(AllocatingAttr *A) {}
  bool TraverseAlwaysDestroyAttr(AlwaysDestroyAttr *A);
  bool VisitAlwaysDestroyAttr(AlwaysDestroyAttr *A) {}
  bool TraverseAlwaysInlineAttr(AlwaysInlineAttr *A);
  bool VisitAlwaysInlineAttr(AlwaysInlineAttr *A) {}
  bool TraverseAnalyzerNoReturnAttr(AnalyzerNoReturnAttr *A);
  bool VisitAnalyzerNoReturnAttr(AnalyzerNoReturnAttr *A) {}
  bool TraverseAnnotateAttr(AnnotateAttr *A);
  bool VisitAnnotateAttr(AnnotateAttr *A) {}
  bool TraverseAnnotateTypeAttr(AnnotateTypeAttr *A);
  bool VisitAnnotateTypeAttr(AnnotateTypeAttr *A) {}
  bool TraverseAnyX86InterruptAttr(AnyX86InterruptAttr *A);
  bool VisitAnyX86InterruptAttr(AnyX86InterruptAttr *A) {}
  bool TraverseAnyX86NoCallerSavedRegistersAttr(AnyX86NoCallerSavedRegistersAttr *A);
  bool VisitAnyX86NoCallerSavedRegistersAttr(AnyX86NoCallerSavedRegistersAttr *A) {}
  bool TraverseAnyX86NoCfCheckAttr(AnyX86NoCfCheckAttr *A);
  bool VisitAnyX86NoCfCheckAttr(AnyX86NoCfCheckAttr *A) {}
  bool TraverseArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A);
  bool VisitArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A) {}
  bool TraverseArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *A);
  bool VisitArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *A) {}
  bool TraverseArmBuiltinAliasAttr(ArmBuiltinAliasAttr *A);
  bool VisitArmBuiltinAliasAttr(ArmBuiltinAliasAttr *A) {}
  bool TraverseArmInAttr(ArmInAttr *A);
  bool VisitArmInAttr(ArmInAttr *A) {}
  bool TraverseArmInOutAttr(ArmInOutAttr *A);
  bool VisitArmInOutAttr(ArmInOutAttr *A) {}
  bool TraverseArmLocallyStreamingAttr(ArmLocallyStreamingAttr *A);
  bool VisitArmLocallyStreamingAttr(ArmLocallyStreamingAttr *A) {}
  bool TraverseArmMveStrictPolymorphismAttr(ArmMveStrictPolymorphismAttr *A);
  bool VisitArmMveStrictPolymorphismAttr(ArmMveStrictPolymorphismAttr *A) {}
  bool TraverseArmNewAttr(ArmNewAttr *A);
  bool VisitArmNewAttr(ArmNewAttr *A) {}
  bool TraverseArmOutAttr(ArmOutAttr *A);
  bool VisitArmOutAttr(ArmOutAttr *A) {}
  bool TraverseArmPreservesAttr(ArmPreservesAttr *A);
  bool VisitArmPreservesAttr(ArmPreservesAttr *A) {}
  bool TraverseArmStreamingAttr(ArmStreamingAttr *A);
  bool VisitArmStreamingAttr(ArmStreamingAttr *A) {}
  bool TraverseArmStreamingCompatibleAttr(ArmStreamingCompatibleAttr *A);
  bool VisitArmStreamingCompatibleAttr(ArmStreamingCompatibleAttr *A) {}
  bool TraverseArtificialAttr(ArtificialAttr *A);
  bool VisitArtificialAttr(ArtificialAttr *A) {}
  bool TraverseAsmLabelAttr(AsmLabelAttr *A);
  bool VisitAsmLabelAttr(AsmLabelAttr *A) {}
  bool TraverseAssertCapabilityAttr(AssertCapabilityAttr *A);
  bool VisitAssertCapabilityAttr(AssertCapabilityAttr *A) {}
  bool TraverseAssertExclusiveLockAttr(AssertExclusiveLockAttr *A);
  bool VisitAssertExclusiveLockAttr(AssertExclusiveLockAttr *A) {}
  bool TraverseAssertSharedLockAttr(AssertSharedLockAttr *A);
  bool VisitAssertSharedLockAttr(AssertSharedLockAttr *A) {}
  bool TraverseAssumeAlignedAttr(AssumeAlignedAttr *A);
  bool VisitAssumeAlignedAttr(AssumeAlignedAttr *A) {}
  bool TraverseAvailabilityAttr(AvailabilityAttr *A);
  bool VisitAvailabilityAttr(AvailabilityAttr *A) {}
  bool TraverseAvailableOnlyInDefaultEvalMethodAttr(AvailableOnlyInDefaultEvalMethodAttr *A);
  bool VisitAvailableOnlyInDefaultEvalMethodAttr(AvailableOnlyInDefaultEvalMethodAttr *A) {}
  bool TraverseBPFFastCallAttr(BPFFastCallAttr *A);
  bool VisitBPFFastCallAttr(BPFFastCallAttr *A) {}
  bool TraverseBPFPreserveAccessIndexAttr(BPFPreserveAccessIndexAttr *A);
  bool VisitBPFPreserveAccessIndexAttr(BPFPreserveAccessIndexAttr *A) {}
  bool TraverseBPFPreserveStaticOffsetAttr(BPFPreserveStaticOffsetAttr *A);
  bool VisitBPFPreserveStaticOffsetAttr(BPFPreserveStaticOffsetAttr *A) {}
  bool TraverseBTFDeclTagAttr(BTFDeclTagAttr *A);
  bool VisitBTFDeclTagAttr(BTFDeclTagAttr *A) {}
  bool TraverseBTFTypeTagAttr(BTFTypeTagAttr *A);
  bool VisitBTFTypeTagAttr(BTFTypeTagAttr *A) {}
  bool TraverseBlockingAttr(BlockingAttr *A);
  bool VisitBlockingAttr(BlockingAttr *A) {}
  bool TraverseBlocksAttr(BlocksAttr *A);
  bool VisitBlocksAttr(BlocksAttr *A) {}
  bool TraverseBuiltinAttr(BuiltinAttr *A);
  bool VisitBuiltinAttr(BuiltinAttr *A) {}
  bool TraverseBuiltinAliasAttr(BuiltinAliasAttr *A);
  bool VisitBuiltinAliasAttr(BuiltinAliasAttr *A) {}
  bool TraverseC11NoReturnAttr(C11NoReturnAttr *A);
  bool VisitC11NoReturnAttr(C11NoReturnAttr *A) {}
  bool TraverseCDeclAttr(CDeclAttr *A);
  bool VisitCDeclAttr(CDeclAttr *A) {}
  bool TraverseCFAuditedTransferAttr(CFAuditedTransferAttr *A);
  bool VisitCFAuditedTransferAttr(CFAuditedTransferAttr *A) {}
  bool TraverseCFConsumedAttr(CFConsumedAttr *A);
  bool VisitCFConsumedAttr(CFConsumedAttr *A) {}
  bool TraverseCFGuardAttr(CFGuardAttr *A);
  bool VisitCFGuardAttr(CFGuardAttr *A) {}
  bool TraverseCFICanonicalJumpTableAttr(CFICanonicalJumpTableAttr *A);
  bool VisitCFICanonicalJumpTableAttr(CFICanonicalJumpTableAttr *A) {}
  bool TraverseCFReturnsNotRetainedAttr(CFReturnsNotRetainedAttr *A);
  bool VisitCFReturnsNotRetainedAttr(CFReturnsNotRetainedAttr *A) {}
  bool TraverseCFReturnsRetainedAttr(CFReturnsRetainedAttr *A);
  bool VisitCFReturnsRetainedAttr(CFReturnsRetainedAttr *A) {}
  bool TraverseCFUnknownTransferAttr(CFUnknownTransferAttr *A);
  bool VisitCFUnknownTransferAttr(CFUnknownTransferAttr *A) {}
  bool TraverseCPUDispatchAttr(CPUDispatchAttr *A);
  bool VisitCPUDispatchAttr(CPUDispatchAttr *A) {}
  bool TraverseCPUSpecificAttr(CPUSpecificAttr *A);
  bool VisitCPUSpecificAttr(CPUSpecificAttr *A) {}
  bool TraverseCUDAConstantAttr(CUDAConstantAttr *A);
  bool VisitCUDAConstantAttr(CUDAConstantAttr *A) {}
  bool TraverseCUDADeviceAttr(CUDADeviceAttr *A);
  bool VisitCUDADeviceAttr(CUDADeviceAttr *A) {}
  bool TraverseCUDADeviceBuiltinSurfaceTypeAttr(CUDADeviceBuiltinSurfaceTypeAttr *A);
  bool VisitCUDADeviceBuiltinSurfaceTypeAttr(CUDADeviceBuiltinSurfaceTypeAttr *A) {}
  bool TraverseCUDADeviceBuiltinTextureTypeAttr(CUDADeviceBuiltinTextureTypeAttr *A);
  bool VisitCUDADeviceBuiltinTextureTypeAttr(CUDADeviceBuiltinTextureTypeAttr *A) {}
  bool TraverseCUDAGlobalAttr(CUDAGlobalAttr *A);
  bool VisitCUDAGlobalAttr(CUDAGlobalAttr *A) {}
  bool TraverseCUDAHostAttr(CUDAHostAttr *A);
  bool VisitCUDAHostAttr(CUDAHostAttr *A) {}
  bool TraverseCUDAInvalidTargetAttr(CUDAInvalidTargetAttr *A);
  bool VisitCUDAInvalidTargetAttr(CUDAInvalidTargetAttr *A) {}
  bool TraverseCUDALaunchBoundsAttr(CUDALaunchBoundsAttr *A);
  bool VisitCUDALaunchBoundsAttr(CUDALaunchBoundsAttr *A) {}
  bool TraverseCUDASharedAttr(CUDASharedAttr *A);
  bool VisitCUDASharedAttr(CUDASharedAttr *A) {}
  bool TraverseCXX11NoReturnAttr(CXX11NoReturnAttr *A);
  bool VisitCXX11NoReturnAttr(CXX11NoReturnAttr *A) {}
  bool TraverseCXXAssumeAttr(CXXAssumeAttr *A);
  bool VisitCXXAssumeAttr(CXXAssumeAttr *A) {}
  bool TraverseCallableWhenAttr(CallableWhenAttr *A);
  bool VisitCallableWhenAttr(CallableWhenAttr *A) {}
  bool TraverseCallbackAttr(CallbackAttr *A);
  bool VisitCallbackAttr(CallbackAttr *A) {}
  bool TraverseCalledOnceAttr(CalledOnceAttr *A);
  bool VisitCalledOnceAttr(CalledOnceAttr *A) {}
  bool TraverseCapabilityAttr(CapabilityAttr *A);
  bool VisitCapabilityAttr(CapabilityAttr *A) {}
  bool TraverseCapturedRecordAttr(CapturedRecordAttr *A);
  bool VisitCapturedRecordAttr(CapturedRecordAttr *A) {}
  bool TraverseCarriesDependencyAttr(CarriesDependencyAttr *A);
  bool VisitCarriesDependencyAttr(CarriesDependencyAttr *A) {}
  bool TraverseCleanupAttr(CleanupAttr *A);
  bool VisitCleanupAttr(CleanupAttr *A) {}
  bool TraverseClspvLibclcBuiltinAttr(ClspvLibclcBuiltinAttr *A);
  bool VisitClspvLibclcBuiltinAttr(ClspvLibclcBuiltinAttr *A) {}
  bool TraverseCmseNSCallAttr(CmseNSCallAttr *A);
  bool VisitCmseNSCallAttr(CmseNSCallAttr *A) {}
  bool TraverseCmseNSEntryAttr(CmseNSEntryAttr *A);
  bool VisitCmseNSEntryAttr(CmseNSEntryAttr *A) {}
  bool TraverseCodeAlignAttr(CodeAlignAttr *A);
  bool VisitCodeAlignAttr(CodeAlignAttr *A) {}
  bool TraverseCodeModelAttr(CodeModelAttr *A);
  bool VisitCodeModelAttr(CodeModelAttr *A) {}
  bool TraverseCodeSegAttr(CodeSegAttr *A);
  bool VisitCodeSegAttr(CodeSegAttr *A) {}
  bool TraverseColdAttr(ColdAttr *A);
  bool VisitColdAttr(ColdAttr *A) {}
  bool TraverseCommonAttr(CommonAttr *A);
  bool VisitCommonAttr(CommonAttr *A) {}
  bool TraverseConstAttr(ConstAttr *A);
  bool VisitConstAttr(ConstAttr *A) {}
  bool TraverseConstInitAttr(ConstInitAttr *A);
  bool VisitConstInitAttr(ConstInitAttr *A) {}
  bool TraverseConstructorAttr(ConstructorAttr *A);
  bool VisitConstructorAttr(ConstructorAttr *A) {}
  bool TraverseConsumableAttr(ConsumableAttr *A);
  bool VisitConsumableAttr(ConsumableAttr *A) {}
  bool TraverseConsumableAutoCastAttr(ConsumableAutoCastAttr *A);
  bool VisitConsumableAutoCastAttr(ConsumableAutoCastAttr *A) {}
  bool TraverseConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A);
  bool VisitConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A) {}
  bool TraverseConvergentAttr(ConvergentAttr *A);
  bool VisitConvergentAttr(ConvergentAttr *A) {}
  bool TraverseCoroAwaitElidableAttr(CoroAwaitElidableAttr *A);
  bool VisitCoroAwaitElidableAttr(CoroAwaitElidableAttr *A) {}
  bool TraverseCoroDisableLifetimeBoundAttr(CoroDisableLifetimeBoundAttr *A);
  bool VisitCoroDisableLifetimeBoundAttr(CoroDisableLifetimeBoundAttr *A) {}
  bool TraverseCoroLifetimeBoundAttr(CoroLifetimeBoundAttr *A);
  bool VisitCoroLifetimeBoundAttr(CoroLifetimeBoundAttr *A) {}
  bool TraverseCoroOnlyDestroyWhenCompleteAttr(CoroOnlyDestroyWhenCompleteAttr *A);
  bool VisitCoroOnlyDestroyWhenCompleteAttr(CoroOnlyDestroyWhenCompleteAttr *A) {}
  bool TraverseCoroReturnTypeAttr(CoroReturnTypeAttr *A);
  bool VisitCoroReturnTypeAttr(CoroReturnTypeAttr *A) {}
  bool TraverseCoroWrapperAttr(CoroWrapperAttr *A);
  bool VisitCoroWrapperAttr(CoroWrapperAttr *A) {}
  bool TraverseCountedByAttr(CountedByAttr *A);
  bool VisitCountedByAttr(CountedByAttr *A) {}
  bool TraverseCountedByOrNullAttr(CountedByOrNullAttr *A);
  bool VisitCountedByOrNullAttr(CountedByOrNullAttr *A) {}
  bool TraverseDLLExportAttr(DLLExportAttr *A);
  bool VisitDLLExportAttr(DLLExportAttr *A) {}
  bool TraverseDLLExportStaticLocalAttr(DLLExportStaticLocalAttr *A);
  bool VisitDLLExportStaticLocalAttr(DLLExportStaticLocalAttr *A) {}
  bool TraverseDLLImportAttr(DLLImportAttr *A);
  bool VisitDLLImportAttr(DLLImportAttr *A) {}
  bool TraverseDLLImportStaticLocalAttr(DLLImportStaticLocalAttr *A);
  bool VisitDLLImportStaticLocalAttr(DLLImportStaticLocalAttr *A) {}
  bool TraverseDeprecatedAttr(DeprecatedAttr *A);
  bool VisitDeprecatedAttr(DeprecatedAttr *A) {}
  bool TraverseDestructorAttr(DestructorAttr *A);
  bool VisitDestructorAttr(DestructorAttr *A) {}
  bool TraverseDiagnoseAsBuiltinAttr(DiagnoseAsBuiltinAttr *A);
  bool VisitDiagnoseAsBuiltinAttr(DiagnoseAsBuiltinAttr *A) {}
  bool TraverseDiagnoseIfAttr(DiagnoseIfAttr *A);
  bool VisitDiagnoseIfAttr(DiagnoseIfAttr *A) {}
  bool TraverseDisableSanitizerInstrumentationAttr(DisableSanitizerInstrumentationAttr *A);
  bool VisitDisableSanitizerInstrumentationAttr(DisableSanitizerInstrumentationAttr *A) {}
  bool TraverseDisableTailCallsAttr(DisableTailCallsAttr *A);
  bool VisitDisableTailCallsAttr(DisableTailCallsAttr *A) {}
  bool TraverseEmptyBasesAttr(EmptyBasesAttr *A);
  bool VisitEmptyBasesAttr(EmptyBasesAttr *A) {}
  bool TraverseEnableIfAttr(EnableIfAttr *A);
  bool VisitEnableIfAttr(EnableIfAttr *A) {}
  bool TraverseEnforceTCBAttr(EnforceTCBAttr *A);
  bool VisitEnforceTCBAttr(EnforceTCBAttr *A) {}
  bool TraverseEnforceTCBLeafAttr(EnforceTCBLeafAttr *A);
  bool VisitEnforceTCBLeafAttr(EnforceTCBLeafAttr *A) {}
  bool TraverseEnumExtensibilityAttr(EnumExtensibilityAttr *A);
  bool VisitEnumExtensibilityAttr(EnumExtensibilityAttr *A) {}
  bool TraverseErrorAttr(ErrorAttr *A);
  bool VisitErrorAttr(ErrorAttr *A) {}
  bool TraverseExcludeFromExplicitInstantiationAttr(ExcludeFromExplicitInstantiationAttr *A);
  bool VisitExcludeFromExplicitInstantiationAttr(ExcludeFromExplicitInstantiationAttr *A) {}
  bool TraverseExclusiveTrylockFunctionAttr(ExclusiveTrylockFunctionAttr *A);
  bool VisitExclusiveTrylockFunctionAttr(ExclusiveTrylockFunctionAttr *A) {}
  bool TraverseExternalSourceSymbolAttr(ExternalSourceSymbolAttr *A);
  bool VisitExternalSourceSymbolAttr(ExternalSourceSymbolAttr *A) {}
  bool TraverseFallThroughAttr(FallThroughAttr *A);
  bool VisitFallThroughAttr(FallThroughAttr *A) {}
  bool TraverseFastCallAttr(FastCallAttr *A);
  bool VisitFastCallAttr(FastCallAttr *A) {}
  bool TraverseFinalAttr(FinalAttr *A);
  bool VisitFinalAttr(FinalAttr *A) {}
  bool TraverseFlagEnumAttr(FlagEnumAttr *A);
  bool VisitFlagEnumAttr(FlagEnumAttr *A) {}
  bool TraverseFlattenAttr(FlattenAttr *A);
  bool VisitFlattenAttr(FlattenAttr *A) {}
  bool TraverseFormatAttr(FormatAttr *A);
  bool VisitFormatAttr(FormatAttr *A) {}
  bool TraverseFormatArgAttr(FormatArgAttr *A);
  bool VisitFormatArgAttr(FormatArgAttr *A) {}
  bool TraverseFunctionReturnThunksAttr(FunctionReturnThunksAttr *A);
  bool VisitFunctionReturnThunksAttr(FunctionReturnThunksAttr *A) {}
  bool TraverseGNUInlineAttr(GNUInlineAttr *A);
  bool VisitGNUInlineAttr(GNUInlineAttr *A) {}
  bool TraverseGuardedByAttr(GuardedByAttr *A);
  bool VisitGuardedByAttr(GuardedByAttr *A) {}
  bool TraverseGuardedVarAttr(GuardedVarAttr *A);
  bool VisitGuardedVarAttr(GuardedVarAttr *A) {}
  bool TraverseHIPManagedAttr(HIPManagedAttr *A);
  bool VisitHIPManagedAttr(HIPManagedAttr *A) {}
  bool TraverseHLSLContainedTypeAttr(HLSLContainedTypeAttr *A);
  bool VisitHLSLContainedTypeAttr(HLSLContainedTypeAttr *A) {}
  bool TraverseHLSLGroupSharedAddressSpaceAttr(HLSLGroupSharedAddressSpaceAttr *A);
  bool VisitHLSLGroupSharedAddressSpaceAttr(HLSLGroupSharedAddressSpaceAttr *A) {}
  bool TraverseHLSLLoopHintAttr(HLSLLoopHintAttr *A);
  bool VisitHLSLLoopHintAttr(HLSLLoopHintAttr *A) {}
  bool TraverseHLSLNumThreadsAttr(HLSLNumThreadsAttr *A);
  bool VisitHLSLNumThreadsAttr(HLSLNumThreadsAttr *A) {}
  bool TraverseHLSLPackOffsetAttr(HLSLPackOffsetAttr *A);
  bool VisitHLSLPackOffsetAttr(HLSLPackOffsetAttr *A) {}
  bool TraverseHLSLParamModifierAttr(HLSLParamModifierAttr *A);
  bool VisitHLSLParamModifierAttr(HLSLParamModifierAttr *A) {}
  bool TraverseHLSLROVAttr(HLSLROVAttr *A);
  bool VisitHLSLROVAttr(HLSLROVAttr *A) {}
  bool TraverseHLSLRawBufferAttr(HLSLRawBufferAttr *A);
  bool VisitHLSLRawBufferAttr(HLSLRawBufferAttr *A) {}
  bool TraverseHLSLResourceAttr(HLSLResourceAttr *A);
  bool VisitHLSLResourceAttr(HLSLResourceAttr *A) {}
  bool TraverseHLSLResourceBindingAttr(HLSLResourceBindingAttr *A);
  bool VisitHLSLResourceBindingAttr(HLSLResourceBindingAttr *A) {}
  bool TraverseHLSLResourceClassAttr(HLSLResourceClassAttr *A);
  bool VisitHLSLResourceClassAttr(HLSLResourceClassAttr *A) {}
  bool TraverseHLSLSV_DispatchThreadIDAttr(HLSLSV_DispatchThreadIDAttr *A);
  bool VisitHLSLSV_DispatchThreadIDAttr(HLSLSV_DispatchThreadIDAttr *A) {}
  bool TraverseHLSLSV_GroupIndexAttr(HLSLSV_GroupIndexAttr *A);
  bool VisitHLSLSV_GroupIndexAttr(HLSLSV_GroupIndexAttr *A) {}
  bool TraverseHLSLShaderAttr(HLSLShaderAttr *A);
  bool VisitHLSLShaderAttr(HLSLShaderAttr *A) {}
  bool TraverseHLSLWaveSizeAttr(HLSLWaveSizeAttr *A);
  bool VisitHLSLWaveSizeAttr(HLSLWaveSizeAttr *A) {}
  bool TraverseHotAttr(HotAttr *A);
  bool VisitHotAttr(HotAttr *A) {}
  bool TraverseHybridPatchableAttr(HybridPatchableAttr *A);
  bool VisitHybridPatchableAttr(HybridPatchableAttr *A) {}
  bool TraverseIBActionAttr(IBActionAttr *A);
  bool VisitIBActionAttr(IBActionAttr *A) {}
  bool TraverseIBOutletAttr(IBOutletAttr *A);
  bool VisitIBOutletAttr(IBOutletAttr *A) {}
  bool TraverseIBOutletCollectionAttr(IBOutletCollectionAttr *A);
  bool VisitIBOutletCollectionAttr(IBOutletCollectionAttr *A) {}
  bool TraverseIFuncAttr(IFuncAttr *A);
  bool VisitIFuncAttr(IFuncAttr *A) {}
  bool TraverseInitPriorityAttr(InitPriorityAttr *A);
  bool VisitInitPriorityAttr(InitPriorityAttr *A) {}
  bool TraverseInitSegAttr(InitSegAttr *A);
  bool VisitInitSegAttr(InitSegAttr *A) {}
  bool TraverseIntelOclBiccAttr(IntelOclBiccAttr *A);
  bool VisitIntelOclBiccAttr(IntelOclBiccAttr *A) {}
  bool TraverseInternalLinkageAttr(InternalLinkageAttr *A);
  bool VisitInternalLinkageAttr(InternalLinkageAttr *A) {}
  bool TraverseLTOVisibilityPublicAttr(LTOVisibilityPublicAttr *A);
  bool VisitLTOVisibilityPublicAttr(LTOVisibilityPublicAttr *A) {}
  bool TraverseLayoutVersionAttr(LayoutVersionAttr *A);
  bool VisitLayoutVersionAttr(LayoutVersionAttr *A) {}
  bool TraverseLeafAttr(LeafAttr *A);
  bool VisitLeafAttr(LeafAttr *A) {}
  bool TraverseLifetimeBoundAttr(LifetimeBoundAttr *A);
  bool VisitLifetimeBoundAttr(LifetimeBoundAttr *A) {}
  bool TraverseLikelyAttr(LikelyAttr *A);
  bool VisitLikelyAttr(LikelyAttr *A) {}
  bool TraverseLoaderUninitializedAttr(LoaderUninitializedAttr *A);
  bool VisitLoaderUninitializedAttr(LoaderUninitializedAttr *A) {}
  bool TraverseLockReturnedAttr(LockReturnedAttr *A);
  bool VisitLockReturnedAttr(LockReturnedAttr *A) {}
  bool TraverseLocksExcludedAttr(LocksExcludedAttr *A);
  bool VisitLocksExcludedAttr(LocksExcludedAttr *A) {}
  bool TraverseLoopHintAttr(LoopHintAttr *A);
  bool VisitLoopHintAttr(LoopHintAttr *A) {}
  bool TraverseM68kInterruptAttr(M68kInterruptAttr *A);
  bool VisitM68kInterruptAttr(M68kInterruptAttr *A) {}
  bool TraverseM68kRTDAttr(M68kRTDAttr *A);
  bool VisitM68kRTDAttr(M68kRTDAttr *A) {}
  bool TraverseMIGServerRoutineAttr(MIGServerRoutineAttr *A);
  bool VisitMIGServerRoutineAttr(MIGServerRoutineAttr *A) {}
  bool TraverseMSABIAttr(MSABIAttr *A);
  bool VisitMSABIAttr(MSABIAttr *A) {}
  bool TraverseMSAllocatorAttr(MSAllocatorAttr *A);
  bool VisitMSAllocatorAttr(MSAllocatorAttr *A) {}
  bool TraverseMSConstexprAttr(MSConstexprAttr *A);
  bool VisitMSConstexprAttr(MSConstexprAttr *A) {}
  bool TraverseMSInheritanceAttr(MSInheritanceAttr *A);
  bool VisitMSInheritanceAttr(MSInheritanceAttr *A) {}
  bool TraverseMSNoVTableAttr(MSNoVTableAttr *A);
  bool VisitMSNoVTableAttr(MSNoVTableAttr *A) {}
  bool TraverseMSP430InterruptAttr(MSP430InterruptAttr *A);
  bool VisitMSP430InterruptAttr(MSP430InterruptAttr *A) {}
  bool TraverseMSStructAttr(MSStructAttr *A);
  bool VisitMSStructAttr(MSStructAttr *A) {}
  bool TraverseMSVtorDispAttr(MSVtorDispAttr *A);
  bool VisitMSVtorDispAttr(MSVtorDispAttr *A) {}
  bool TraverseMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A);
  bool VisitMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A) {}
  bool TraverseMayAliasAttr(MayAliasAttr *A);
  bool VisitMayAliasAttr(MayAliasAttr *A) {}
  bool TraverseMaybeUndefAttr(MaybeUndefAttr *A);
  bool VisitMaybeUndefAttr(MaybeUndefAttr *A) {}
  bool TraverseMicroMipsAttr(MicroMipsAttr *A);
  bool VisitMicroMipsAttr(MicroMipsAttr *A) {}
  bool TraverseMinSizeAttr(MinSizeAttr *A);
  bool VisitMinSizeAttr(MinSizeAttr *A) {}
  bool TraverseMinVectorWidthAttr(MinVectorWidthAttr *A);
  bool VisitMinVectorWidthAttr(MinVectorWidthAttr *A) {}
  bool TraverseMips16Attr(Mips16Attr *A);
  bool VisitMips16Attr(Mips16Attr *A) {}
  bool TraverseMipsInterruptAttr(MipsInterruptAttr *A);
  bool VisitMipsInterruptAttr(MipsInterruptAttr *A) {}
  bool TraverseMipsLongCallAttr(MipsLongCallAttr *A);
  bool VisitMipsLongCallAttr(MipsLongCallAttr *A) {}
  bool TraverseMipsShortCallAttr(MipsShortCallAttr *A);
  bool VisitMipsShortCallAttr(MipsShortCallAttr *A) {}
  bool TraverseModeAttr(ModeAttr *A);
  bool VisitModeAttr(ModeAttr *A) {}
  bool TraverseMustTailAttr(MustTailAttr *A);
  bool VisitMustTailAttr(MustTailAttr *A) {}
  bool TraverseNSConsumedAttr(NSConsumedAttr *A);
  bool VisitNSConsumedAttr(NSConsumedAttr *A) {}
  bool TraverseNSConsumesSelfAttr(NSConsumesSelfAttr *A);
  bool VisitNSConsumesSelfAttr(NSConsumesSelfAttr *A) {}
  bool TraverseNSErrorDomainAttr(NSErrorDomainAttr *A);
  bool VisitNSErrorDomainAttr(NSErrorDomainAttr *A) {}
  bool TraverseNSReturnsAutoreleasedAttr(NSReturnsAutoreleasedAttr *A);
  bool VisitNSReturnsAutoreleasedAttr(NSReturnsAutoreleasedAttr *A) {}
  bool TraverseNSReturnsNotRetainedAttr(NSReturnsNotRetainedAttr *A);
  bool VisitNSReturnsNotRetainedAttr(NSReturnsNotRetainedAttr *A) {}
  bool TraverseNSReturnsRetainedAttr(NSReturnsRetainedAttr *A);
  bool VisitNSReturnsRetainedAttr(NSReturnsRetainedAttr *A) {}
  bool TraverseNVPTXKernelAttr(NVPTXKernelAttr *A);
  bool VisitNVPTXKernelAttr(NVPTXKernelAttr *A) {}
  bool TraverseNakedAttr(NakedAttr *A);
  bool VisitNakedAttr(NakedAttr *A) {}
  bool TraverseNoAliasAttr(NoAliasAttr *A);
  bool VisitNoAliasAttr(NoAliasAttr *A) {}
  bool TraverseNoBuiltinAttr(NoBuiltinAttr *A);
  bool VisitNoBuiltinAttr(NoBuiltinAttr *A) {}
  bool TraverseNoCommonAttr(NoCommonAttr *A);
  bool VisitNoCommonAttr(NoCommonAttr *A) {}
  bool TraverseNoConvergentAttr(NoConvergentAttr *A);
  bool VisitNoConvergentAttr(NoConvergentAttr *A) {}
  bool TraverseNoDebugAttr(NoDebugAttr *A);
  bool VisitNoDebugAttr(NoDebugAttr *A) {}
  bool TraverseNoDerefAttr(NoDerefAttr *A);
  bool VisitNoDerefAttr(NoDerefAttr *A) {}
  bool TraverseNoDestroyAttr(NoDestroyAttr *A);
  bool VisitNoDestroyAttr(NoDestroyAttr *A) {}
  bool TraverseNoDuplicateAttr(NoDuplicateAttr *A);
  bool VisitNoDuplicateAttr(NoDuplicateAttr *A) {}
  bool TraverseNoEscapeAttr(NoEscapeAttr *A);
  bool VisitNoEscapeAttr(NoEscapeAttr *A) {}
  bool TraverseNoInlineAttr(NoInlineAttr *A);
  bool VisitNoInlineAttr(NoInlineAttr *A) {}
  bool TraverseNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A);
  bool VisitNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A) {}
  bool TraverseNoMergeAttr(NoMergeAttr *A);
  bool VisitNoMergeAttr(NoMergeAttr *A) {}
  bool TraverseNoMicroMipsAttr(NoMicroMipsAttr *A);
  bool VisitNoMicroMipsAttr(NoMicroMipsAttr *A) {}
  bool TraverseNoMips16Attr(NoMips16Attr *A);
  bool VisitNoMips16Attr(NoMips16Attr *A) {}
  bool TraverseNoProfileFunctionAttr(NoProfileFunctionAttr *A);
  bool VisitNoProfileFunctionAttr(NoProfileFunctionAttr *A) {}
  bool TraverseNoRandomizeLayoutAttr(NoRandomizeLayoutAttr *A);
  bool VisitNoRandomizeLayoutAttr(NoRandomizeLayoutAttr *A) {}
  bool TraverseNoReturnAttr(NoReturnAttr *A);
  bool VisitNoReturnAttr(NoReturnAttr *A) {}
  bool TraverseNoSanitizeAttr(NoSanitizeAttr *A);
  bool VisitNoSanitizeAttr(NoSanitizeAttr *A) {}
  bool TraverseNoSpeculativeLoadHardeningAttr(NoSpeculativeLoadHardeningAttr *A);
  bool VisitNoSpeculativeLoadHardeningAttr(NoSpeculativeLoadHardeningAttr *A) {}
  bool TraverseNoSplitStackAttr(NoSplitStackAttr *A);
  bool VisitNoSplitStackAttr(NoSplitStackAttr *A) {}
  bool TraverseNoStackProtectorAttr(NoStackProtectorAttr *A);
  bool VisitNoStackProtectorAttr(NoStackProtectorAttr *A) {}
  bool TraverseNoThreadSafetyAnalysisAttr(NoThreadSafetyAnalysisAttr *A);
  bool VisitNoThreadSafetyAnalysisAttr(NoThreadSafetyAnalysisAttr *A) {}
  bool TraverseNoThrowAttr(NoThrowAttr *A);
  bool VisitNoThrowAttr(NoThrowAttr *A) {}
  bool TraverseNoUniqueAddressAttr(NoUniqueAddressAttr *A);
  bool VisitNoUniqueAddressAttr(NoUniqueAddressAttr *A) {}
  bool TraverseNoUwtableAttr(NoUwtableAttr *A);
  bool VisitNoUwtableAttr(NoUwtableAttr *A) {}
  bool TraverseNonAllocatingAttr(NonAllocatingAttr *A);
  bool VisitNonAllocatingAttr(NonAllocatingAttr *A) {}
  bool TraverseNonBlockingAttr(NonBlockingAttr *A);
  bool VisitNonBlockingAttr(NonBlockingAttr *A) {}
  bool TraverseNonNullAttr(NonNullAttr *A);
  bool VisitNonNullAttr(NonNullAttr *A) {}
  bool TraverseNotTailCalledAttr(NotTailCalledAttr *A);
  bool VisitNotTailCalledAttr(NotTailCalledAttr *A) {}
  bool TraverseOMPAllocateDeclAttr(OMPAllocateDeclAttr *A);
  bool VisitOMPAllocateDeclAttr(OMPAllocateDeclAttr *A) {}
  bool TraverseOMPAssumeAttr(OMPAssumeAttr *A);
  bool VisitOMPAssumeAttr(OMPAssumeAttr *A) {}
  bool TraverseOMPCaptureKindAttr(OMPCaptureKindAttr *A);
  bool VisitOMPCaptureKindAttr(OMPCaptureKindAttr *A) {}
  bool TraverseOMPCaptureNoInitAttr(OMPCaptureNoInitAttr *A);
  bool VisitOMPCaptureNoInitAttr(OMPCaptureNoInitAttr *A) {}
  bool TraverseOMPDeclareSimdDeclAttr(OMPDeclareSimdDeclAttr *A);
  bool VisitOMPDeclareSimdDeclAttr(OMPDeclareSimdDeclAttr *A) {}
  bool TraverseOMPDeclareTargetDeclAttr(OMPDeclareTargetDeclAttr *A);
  bool VisitOMPDeclareTargetDeclAttr(OMPDeclareTargetDeclAttr *A) {}
  bool TraverseOMPDeclareVariantAttr(OMPDeclareVariantAttr *A);
  bool VisitOMPDeclareVariantAttr(OMPDeclareVariantAttr *A) {}
  bool TraverseOMPReferencedVarAttr(OMPReferencedVarAttr *A);
  bool VisitOMPReferencedVarAttr(OMPReferencedVarAttr *A) {}
  bool TraverseOMPThreadPrivateDeclAttr(OMPThreadPrivateDeclAttr *A);
  bool VisitOMPThreadPrivateDeclAttr(OMPThreadPrivateDeclAttr *A) {}
  bool TraverseOSConsumedAttr(OSConsumedAttr *A);
  bool VisitOSConsumedAttr(OSConsumedAttr *A) {}
  bool TraverseOSConsumesThisAttr(OSConsumesThisAttr *A);
  bool VisitOSConsumesThisAttr(OSConsumesThisAttr *A) {}
  bool TraverseOSReturnsNotRetainedAttr(OSReturnsNotRetainedAttr *A);
  bool VisitOSReturnsNotRetainedAttr(OSReturnsNotRetainedAttr *A) {}
  bool TraverseOSReturnsRetainedAttr(OSReturnsRetainedAttr *A);
  bool VisitOSReturnsRetainedAttr(OSReturnsRetainedAttr *A) {}
  bool TraverseOSReturnsRetainedOnNonZeroAttr(OSReturnsRetainedOnNonZeroAttr *A);
  bool VisitOSReturnsRetainedOnNonZeroAttr(OSReturnsRetainedOnNonZeroAttr *A) {}
  bool TraverseOSReturnsRetainedOnZeroAttr(OSReturnsRetainedOnZeroAttr *A);
  bool VisitOSReturnsRetainedOnZeroAttr(OSReturnsRetainedOnZeroAttr *A) {}
  bool TraverseObjCBoxableAttr(ObjCBoxableAttr *A);
  bool VisitObjCBoxableAttr(ObjCBoxableAttr *A) {}
  bool TraverseObjCBridgeAttr(ObjCBridgeAttr *A);
  bool VisitObjCBridgeAttr(ObjCBridgeAttr *A) {}
  bool TraverseObjCBridgeMutableAttr(ObjCBridgeMutableAttr *A);
  bool VisitObjCBridgeMutableAttr(ObjCBridgeMutableAttr *A) {}
  bool TraverseObjCBridgeRelatedAttr(ObjCBridgeRelatedAttr *A);
  bool VisitObjCBridgeRelatedAttr(ObjCBridgeRelatedAttr *A) {}
  bool TraverseObjCClassStubAttr(ObjCClassStubAttr *A);
  bool VisitObjCClassStubAttr(ObjCClassStubAttr *A) {}
  bool TraverseObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A);
  bool VisitObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A) {}
  bool TraverseObjCDirectAttr(ObjCDirectAttr *A);
  bool VisitObjCDirectAttr(ObjCDirectAttr *A) {}
  bool TraverseObjCDirectMembersAttr(ObjCDirectMembersAttr *A);
  bool VisitObjCDirectMembersAttr(ObjCDirectMembersAttr *A) {}
  bool TraverseObjCExceptionAttr(ObjCExceptionAttr *A);
  bool VisitObjCExceptionAttr(ObjCExceptionAttr *A) {}
  bool TraverseObjCExplicitProtocolImplAttr(ObjCExplicitProtocolImplAttr *A);
  bool VisitObjCExplicitProtocolImplAttr(ObjCExplicitProtocolImplAttr *A) {}
  bool TraverseObjCExternallyRetainedAttr(ObjCExternallyRetainedAttr *A);
  bool VisitObjCExternallyRetainedAttr(ObjCExternallyRetainedAttr *A) {}
  bool TraverseObjCGCAttr(ObjCGCAttr *A);
  bool VisitObjCGCAttr(ObjCGCAttr *A) {}
  bool TraverseObjCIndependentClassAttr(ObjCIndependentClassAttr *A);
  bool VisitObjCIndependentClassAttr(ObjCIndependentClassAttr *A) {}
  bool TraverseObjCInertUnsafeUnretainedAttr(ObjCInertUnsafeUnretainedAttr *A);
  bool VisitObjCInertUnsafeUnretainedAttr(ObjCInertUnsafeUnretainedAttr *A) {}
  bool TraverseObjCKindOfAttr(ObjCKindOfAttr *A);
  bool VisitObjCKindOfAttr(ObjCKindOfAttr *A) {}
  bool TraverseObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A);
  bool VisitObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A) {}
  bool TraverseObjCNSObjectAttr(ObjCNSObjectAttr *A);
  bool VisitObjCNSObjectAttr(ObjCNSObjectAttr *A) {}
  bool TraverseObjCNonLazyClassAttr(ObjCNonLazyClassAttr *A);
  bool VisitObjCNonLazyClassAttr(ObjCNonLazyClassAttr *A) {}
  bool TraverseObjCNonRuntimeProtocolAttr(ObjCNonRuntimeProtocolAttr *A);
  bool VisitObjCNonRuntimeProtocolAttr(ObjCNonRuntimeProtocolAttr *A) {}
  bool TraverseObjCOwnershipAttr(ObjCOwnershipAttr *A);
  bool VisitObjCOwnershipAttr(ObjCOwnershipAttr *A) {}
  bool TraverseObjCPreciseLifetimeAttr(ObjCPreciseLifetimeAttr *A);
  bool VisitObjCPreciseLifetimeAttr(ObjCPreciseLifetimeAttr *A) {}
  bool TraverseObjCRequiresPropertyDefsAttr(ObjCRequiresPropertyDefsAttr *A);
  bool VisitObjCRequiresPropertyDefsAttr(ObjCRequiresPropertyDefsAttr *A) {}
  bool TraverseObjCRequiresSuperAttr(ObjCRequiresSuperAttr *A);
  bool VisitObjCRequiresSuperAttr(ObjCRequiresSuperAttr *A) {}
  bool TraverseObjCReturnsInnerPointerAttr(ObjCReturnsInnerPointerAttr *A);
  bool VisitObjCReturnsInnerPointerAttr(ObjCReturnsInnerPointerAttr *A) {}
  bool TraverseObjCRootClassAttr(ObjCRootClassAttr *A);
  bool VisitObjCRootClassAttr(ObjCRootClassAttr *A) {}
  bool TraverseObjCRuntimeNameAttr(ObjCRuntimeNameAttr *A);
  bool VisitObjCRuntimeNameAttr(ObjCRuntimeNameAttr *A) {}
  bool TraverseObjCRuntimeVisibleAttr(ObjCRuntimeVisibleAttr *A);
  bool VisitObjCRuntimeVisibleAttr(ObjCRuntimeVisibleAttr *A) {}
  bool TraverseObjCSubclassingRestrictedAttr(ObjCSubclassingRestrictedAttr *A);
  bool VisitObjCSubclassingRestrictedAttr(ObjCSubclassingRestrictedAttr *A) {}
  bool TraverseOpenCLAccessAttr(OpenCLAccessAttr *A);
  bool VisitOpenCLAccessAttr(OpenCLAccessAttr *A) {}
  bool TraverseOpenCLConstantAddressSpaceAttr(OpenCLConstantAddressSpaceAttr *A);
  bool VisitOpenCLConstantAddressSpaceAttr(OpenCLConstantAddressSpaceAttr *A) {}
  bool TraverseOpenCLGenericAddressSpaceAttr(OpenCLGenericAddressSpaceAttr *A);
  bool VisitOpenCLGenericAddressSpaceAttr(OpenCLGenericAddressSpaceAttr *A) {}
  bool TraverseOpenCLGlobalAddressSpaceAttr(OpenCLGlobalAddressSpaceAttr *A);
  bool VisitOpenCLGlobalAddressSpaceAttr(OpenCLGlobalAddressSpaceAttr *A) {}
  bool TraverseOpenCLGlobalDeviceAddressSpaceAttr(OpenCLGlobalDeviceAddressSpaceAttr *A);
  bool VisitOpenCLGlobalDeviceAddressSpaceAttr(OpenCLGlobalDeviceAddressSpaceAttr *A) {}
  bool TraverseOpenCLGlobalHostAddressSpaceAttr(OpenCLGlobalHostAddressSpaceAttr *A);
  bool VisitOpenCLGlobalHostAddressSpaceAttr(OpenCLGlobalHostAddressSpaceAttr *A) {}
  bool TraverseOpenCLIntelReqdSubGroupSizeAttr(OpenCLIntelReqdSubGroupSizeAttr *A);
  bool VisitOpenCLIntelReqdSubGroupSizeAttr(OpenCLIntelReqdSubGroupSizeAttr *A) {}
  bool TraverseOpenCLKernelAttr(OpenCLKernelAttr *A);
  bool VisitOpenCLKernelAttr(OpenCLKernelAttr *A) {}
  bool TraverseOpenCLLocalAddressSpaceAttr(OpenCLLocalAddressSpaceAttr *A);
  bool VisitOpenCLLocalAddressSpaceAttr(OpenCLLocalAddressSpaceAttr *A) {}
  bool TraverseOpenCLPrivateAddressSpaceAttr(OpenCLPrivateAddressSpaceAttr *A);
  bool VisitOpenCLPrivateAddressSpaceAttr(OpenCLPrivateAddressSpaceAttr *A) {}
  bool TraverseOpenCLUnrollHintAttr(OpenCLUnrollHintAttr *A);
  bool VisitOpenCLUnrollHintAttr(OpenCLUnrollHintAttr *A) {}
  bool TraverseOptimizeNoneAttr(OptimizeNoneAttr *A);
  bool VisitOptimizeNoneAttr(OptimizeNoneAttr *A) {}
  bool TraverseOverloadableAttr(OverloadableAttr *A);
  bool VisitOverloadableAttr(OverloadableAttr *A) {}
  bool TraverseOverrideAttr(OverrideAttr *A);
  bool VisitOverrideAttr(OverrideAttr *A) {}
  bool TraverseOwnerAttr(OwnerAttr *A);
  bool VisitOwnerAttr(OwnerAttr *A) {}
  bool TraverseOwnershipAttr(OwnershipAttr *A);
  bool VisitOwnershipAttr(OwnershipAttr *A) {}
  bool TraversePackedAttr(PackedAttr *A);
  bool VisitPackedAttr(PackedAttr *A) {}
  bool TraverseParamTypestateAttr(ParamTypestateAttr *A);
  bool VisitParamTypestateAttr(ParamTypestateAttr *A) {}
  bool TraversePascalAttr(PascalAttr *A);
  bool VisitPascalAttr(PascalAttr *A) {}
  bool TraversePassObjectSizeAttr(PassObjectSizeAttr *A);
  bool VisitPassObjectSizeAttr(PassObjectSizeAttr *A) {}
  bool TraversePatchableFunctionEntryAttr(PatchableFunctionEntryAttr *A);
  bool VisitPatchableFunctionEntryAttr(PatchableFunctionEntryAttr *A) {}
  bool TraversePcsAttr(PcsAttr *A);
  bool VisitPcsAttr(PcsAttr *A) {}
  bool TraversePointerAttr(PointerAttr *A);
  bool VisitPointerAttr(PointerAttr *A) {}
  bool TraversePragmaClangBSSSectionAttr(PragmaClangBSSSectionAttr *A);
  bool VisitPragmaClangBSSSectionAttr(PragmaClangBSSSectionAttr *A) {}
  bool TraversePragmaClangDataSectionAttr(PragmaClangDataSectionAttr *A);
  bool VisitPragmaClangDataSectionAttr(PragmaClangDataSectionAttr *A) {}
  bool TraversePragmaClangRelroSectionAttr(PragmaClangRelroSectionAttr *A);
  bool VisitPragmaClangRelroSectionAttr(PragmaClangRelroSectionAttr *A) {}
  bool TraversePragmaClangRodataSectionAttr(PragmaClangRodataSectionAttr *A);
  bool VisitPragmaClangRodataSectionAttr(PragmaClangRodataSectionAttr *A) {}
  bool TraversePragmaClangTextSectionAttr(PragmaClangTextSectionAttr *A);
  bool VisitPragmaClangTextSectionAttr(PragmaClangTextSectionAttr *A) {}
  bool TraversePreferredNameAttr(PreferredNameAttr *A);
  bool VisitPreferredNameAttr(PreferredNameAttr *A) {}
  bool TraversePreferredTypeAttr(PreferredTypeAttr *A);
  bool VisitPreferredTypeAttr(PreferredTypeAttr *A) {}
  bool TraversePreserveAllAttr(PreserveAllAttr *A);
  bool VisitPreserveAllAttr(PreserveAllAttr *A) {}
  bool TraversePreserveMostAttr(PreserveMostAttr *A);
  bool VisitPreserveMostAttr(PreserveMostAttr *A) {}
  bool TraversePreserveNoneAttr(PreserveNoneAttr *A);
  bool VisitPreserveNoneAttr(PreserveNoneAttr *A) {}
  bool TraversePtGuardedByAttr(PtGuardedByAttr *A);
  bool VisitPtGuardedByAttr(PtGuardedByAttr *A) {}
  bool TraversePtGuardedVarAttr(PtGuardedVarAttr *A);
  bool VisitPtGuardedVarAttr(PtGuardedVarAttr *A) {}
  bool TraversePtr32Attr(Ptr32Attr *A);
  bool VisitPtr32Attr(Ptr32Attr *A) {}
  bool TraversePtr64Attr(Ptr64Attr *A);
  bool VisitPtr64Attr(Ptr64Attr *A) {}
  bool TraversePureAttr(PureAttr *A);
  bool VisitPureAttr(PureAttr *A) {}
  bool TraverseRISCVInterruptAttr(RISCVInterruptAttr *A);
  bool VisitRISCVInterruptAttr(RISCVInterruptAttr *A) {}
  bool TraverseRISCVVectorCCAttr(RISCVVectorCCAttr *A);
  bool VisitRISCVVectorCCAttr(RISCVVectorCCAttr *A) {}
  bool TraverseRandomizeLayoutAttr(RandomizeLayoutAttr *A);
  bool VisitRandomizeLayoutAttr(RandomizeLayoutAttr *A) {}
  bool TraverseReadOnlyPlacementAttr(ReadOnlyPlacementAttr *A);
  bool VisitReadOnlyPlacementAttr(ReadOnlyPlacementAttr *A) {}
  bool TraverseRegCallAttr(RegCallAttr *A);
  bool VisitRegCallAttr(RegCallAttr *A) {}
  bool TraverseReinitializesAttr(ReinitializesAttr *A);
  bool VisitReinitializesAttr(ReinitializesAttr *A) {}
  bool TraverseReleaseCapabilityAttr(ReleaseCapabilityAttr *A);
  bool VisitReleaseCapabilityAttr(ReleaseCapabilityAttr *A) {}
  bool TraverseReleaseHandleAttr(ReleaseHandleAttr *A);
  bool VisitReleaseHandleAttr(ReleaseHandleAttr *A) {}
  bool TraverseRenderScriptKernelAttr(RenderScriptKernelAttr *A);
  bool VisitRenderScriptKernelAttr(RenderScriptKernelAttr *A) {}
  bool TraverseReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A);
  bool VisitReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A) {}
  bool TraverseRequiresCapabilityAttr(RequiresCapabilityAttr *A);
  bool VisitRequiresCapabilityAttr(RequiresCapabilityAttr *A) {}
  bool TraverseRestrictAttr(RestrictAttr *A);
  bool VisitRestrictAttr(RestrictAttr *A) {}
  bool TraverseRetainAttr(RetainAttr *A);
  bool VisitRetainAttr(RetainAttr *A) {}
  bool TraverseReturnTypestateAttr(ReturnTypestateAttr *A);
  bool VisitReturnTypestateAttr(ReturnTypestateAttr *A) {}
  bool TraverseReturnsNonNullAttr(ReturnsNonNullAttr *A);
  bool VisitReturnsNonNullAttr(ReturnsNonNullAttr *A) {}
  bool TraverseReturnsTwiceAttr(ReturnsTwiceAttr *A);
  bool VisitReturnsTwiceAttr(ReturnsTwiceAttr *A) {}
  bool TraverseSPtrAttr(SPtrAttr *A);
  bool VisitSPtrAttr(SPtrAttr *A) {}
  bool TraverseSYCLKernelAttr(SYCLKernelAttr *A);
  bool VisitSYCLKernelAttr(SYCLKernelAttr *A) {}
  bool TraverseSYCLSpecialClassAttr(SYCLSpecialClassAttr *A);
  bool VisitSYCLSpecialClassAttr(SYCLSpecialClassAttr *A) {}
  bool TraverseScopedLockableAttr(ScopedLockableAttr *A);
  bool VisitScopedLockableAttr(ScopedLockableAttr *A) {}
  bool TraverseSectionAttr(SectionAttr *A);
  bool VisitSectionAttr(SectionAttr *A) {}
  bool TraverseSelectAnyAttr(SelectAnyAttr *A);
  bool VisitSelectAnyAttr(SelectAnyAttr *A) {}
  bool TraverseSentinelAttr(SentinelAttr *A);
  bool VisitSentinelAttr(SentinelAttr *A) {}
  bool TraverseSetTypestateAttr(SetTypestateAttr *A);
  bool VisitSetTypestateAttr(SetTypestateAttr *A) {}
  bool TraverseSharedTrylockFunctionAttr(SharedTrylockFunctionAttr *A);
  bool VisitSharedTrylockFunctionAttr(SharedTrylockFunctionAttr *A) {}
  bool TraverseSizedByAttr(SizedByAttr *A);
  bool VisitSizedByAttr(SizedByAttr *A) {}
  bool TraverseSizedByOrNullAttr(SizedByOrNullAttr *A);
  bool VisitSizedByOrNullAttr(SizedByOrNullAttr *A) {}
  bool TraverseSpeculativeLoadHardeningAttr(SpeculativeLoadHardeningAttr *A);
  bool VisitSpeculativeLoadHardeningAttr(SpeculativeLoadHardeningAttr *A) {}
  bool TraverseStandaloneDebugAttr(StandaloneDebugAttr *A);
  bool VisitStandaloneDebugAttr(StandaloneDebugAttr *A) {}
  bool TraverseStdCallAttr(StdCallAttr *A);
  bool VisitStdCallAttr(StdCallAttr *A) {}
  bool TraverseStrictFPAttr(StrictFPAttr *A);
  bool VisitStrictFPAttr(StrictFPAttr *A) {}
  bool TraverseStrictGuardStackCheckAttr(StrictGuardStackCheckAttr *A);
  bool VisitStrictGuardStackCheckAttr(StrictGuardStackCheckAttr *A) {}
  bool TraverseSuppressAttr(SuppressAttr *A);
  bool VisitSuppressAttr(SuppressAttr *A) {}
  bool TraverseSwiftAsyncAttr(SwiftAsyncAttr *A);
  bool VisitSwiftAsyncAttr(SwiftAsyncAttr *A) {}
  bool TraverseSwiftAsyncCallAttr(SwiftAsyncCallAttr *A);
  bool VisitSwiftAsyncCallAttr(SwiftAsyncCallAttr *A) {}
  bool TraverseSwiftAsyncContextAttr(SwiftAsyncContextAttr *A);
  bool VisitSwiftAsyncContextAttr(SwiftAsyncContextAttr *A) {}
  bool TraverseSwiftAsyncErrorAttr(SwiftAsyncErrorAttr *A);
  bool VisitSwiftAsyncErrorAttr(SwiftAsyncErrorAttr *A) {}
  bool TraverseSwiftAsyncNameAttr(SwiftAsyncNameAttr *A);
  bool VisitSwiftAsyncNameAttr(SwiftAsyncNameAttr *A) {}
  bool TraverseSwiftAttrAttr(SwiftAttrAttr *A);
  bool VisitSwiftAttrAttr(SwiftAttrAttr *A) {}
  bool TraverseSwiftBridgeAttr(SwiftBridgeAttr *A);
  bool VisitSwiftBridgeAttr(SwiftBridgeAttr *A) {}
  bool TraverseSwiftBridgedTypedefAttr(SwiftBridgedTypedefAttr *A);
  bool VisitSwiftBridgedTypedefAttr(SwiftBridgedTypedefAttr *A) {}
  bool TraverseSwiftCallAttr(SwiftCallAttr *A);
  bool VisitSwiftCallAttr(SwiftCallAttr *A) {}
  bool TraverseSwiftContextAttr(SwiftContextAttr *A);
  bool VisitSwiftContextAttr(SwiftContextAttr *A) {}
  bool TraverseSwiftErrorAttr(SwiftErrorAttr *A);
  bool VisitSwiftErrorAttr(SwiftErrorAttr *A) {}
  bool TraverseSwiftErrorResultAttr(SwiftErrorResultAttr *A);
  bool VisitSwiftErrorResultAttr(SwiftErrorResultAttr *A) {}
  bool TraverseSwiftImportAsNonGenericAttr(SwiftImportAsNonGenericAttr *A);
  bool VisitSwiftImportAsNonGenericAttr(SwiftImportAsNonGenericAttr *A) {}
  bool TraverseSwiftImportPropertyAsAccessorsAttr(SwiftImportPropertyAsAccessorsAttr *A);
  bool VisitSwiftImportPropertyAsAccessorsAttr(SwiftImportPropertyAsAccessorsAttr *A) {}
  bool TraverseSwiftIndirectResultAttr(SwiftIndirectResultAttr *A);
  bool VisitSwiftIndirectResultAttr(SwiftIndirectResultAttr *A) {}
  bool TraverseSwiftNameAttr(SwiftNameAttr *A);
  bool VisitSwiftNameAttr(SwiftNameAttr *A) {}
  bool TraverseSwiftNewTypeAttr(SwiftNewTypeAttr *A);
  bool VisitSwiftNewTypeAttr(SwiftNewTypeAttr *A) {}
  bool TraverseSwiftObjCMembersAttr(SwiftObjCMembersAttr *A);
  bool VisitSwiftObjCMembersAttr(SwiftObjCMembersAttr *A) {}
  bool TraverseSwiftPrivateAttr(SwiftPrivateAttr *A);
  bool VisitSwiftPrivateAttr(SwiftPrivateAttr *A) {}
  bool TraverseSwiftVersionedAdditionAttr(SwiftVersionedAdditionAttr *A);
  bool VisitSwiftVersionedAdditionAttr(SwiftVersionedAdditionAttr *A) {}
  bool TraverseSwiftVersionedRemovalAttr(SwiftVersionedRemovalAttr *A);
  bool VisitSwiftVersionedRemovalAttr(SwiftVersionedRemovalAttr *A) {}
  bool TraverseSysVABIAttr(SysVABIAttr *A);
  bool VisitSysVABIAttr(SysVABIAttr *A) {}
  bool TraverseTLSModelAttr(TLSModelAttr *A);
  bool VisitTLSModelAttr(TLSModelAttr *A) {}
  bool TraverseTargetAttr(TargetAttr *A);
  bool VisitTargetAttr(TargetAttr *A) {}
  bool TraverseTargetClonesAttr(TargetClonesAttr *A);
  bool VisitTargetClonesAttr(TargetClonesAttr *A) {}
  bool TraverseTargetVersionAttr(TargetVersionAttr *A);
  bool VisitTargetVersionAttr(TargetVersionAttr *A) {}
  bool TraverseTestTypestateAttr(TestTypestateAttr *A);
  bool VisitTestTypestateAttr(TestTypestateAttr *A) {}
  bool TraverseThisCallAttr(ThisCallAttr *A);
  bool VisitThisCallAttr(ThisCallAttr *A) {}
  bool TraverseThreadAttr(ThreadAttr *A);
  bool VisitThreadAttr(ThreadAttr *A) {}
  bool TraverseTransparentUnionAttr(TransparentUnionAttr *A);
  bool VisitTransparentUnionAttr(TransparentUnionAttr *A) {}
  bool TraverseTrivialABIAttr(TrivialABIAttr *A);
  bool VisitTrivialABIAttr(TrivialABIAttr *A) {}
  bool TraverseTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A);
  bool VisitTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A) {}
  bool TraverseTypeNonNullAttr(TypeNonNullAttr *A);
  bool VisitTypeNonNullAttr(TypeNonNullAttr *A) {}
  bool TraverseTypeNullUnspecifiedAttr(TypeNullUnspecifiedAttr *A);
  bool VisitTypeNullUnspecifiedAttr(TypeNullUnspecifiedAttr *A) {}
  bool TraverseTypeNullableAttr(TypeNullableAttr *A);
  bool VisitTypeNullableAttr(TypeNullableAttr *A) {}
  bool TraverseTypeNullableResultAttr(TypeNullableResultAttr *A);
  bool VisitTypeNullableResultAttr(TypeNullableResultAttr *A) {}
  bool TraverseTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A);
  bool VisitTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A) {}
  bool TraverseTypeVisibilityAttr(TypeVisibilityAttr *A);
  bool VisitTypeVisibilityAttr(TypeVisibilityAttr *A) {}
  bool TraverseUPtrAttr(UPtrAttr *A);
  bool VisitUPtrAttr(UPtrAttr *A) {}
  bool TraverseUnavailableAttr(UnavailableAttr *A);
  bool VisitUnavailableAttr(UnavailableAttr *A) {}
  bool TraverseUninitializedAttr(UninitializedAttr *A);
  bool VisitUninitializedAttr(UninitializedAttr *A) {}
  bool TraverseUnlikelyAttr(UnlikelyAttr *A);
  bool VisitUnlikelyAttr(UnlikelyAttr *A) {}
  bool TraverseUnsafeBufferUsageAttr(UnsafeBufferUsageAttr *A);
  bool VisitUnsafeBufferUsageAttr(UnsafeBufferUsageAttr *A) {}
  bool TraverseUnusedAttr(UnusedAttr *A);
  bool VisitUnusedAttr(UnusedAttr *A) {}
  bool TraverseUseHandleAttr(UseHandleAttr *A);
  bool VisitUseHandleAttr(UseHandleAttr *A) {}
  bool TraverseUsedAttr(UsedAttr *A);
  bool VisitUsedAttr(UsedAttr *A) {}
  bool TraverseUsingIfExistsAttr(UsingIfExistsAttr *A);
  bool VisitUsingIfExistsAttr(UsingIfExistsAttr *A) {}
  bool TraverseUuidAttr(UuidAttr *A);
  bool VisitUuidAttr(UuidAttr *A) {}
  bool TraverseVTablePointerAuthenticationAttr(VTablePointerAuthenticationAttr *A);
  bool VisitVTablePointerAuthenticationAttr(VTablePointerAuthenticationAttr *A) {}
  bool TraverseVecReturnAttr(VecReturnAttr *A);
  bool VisitVecReturnAttr(VecReturnAttr *A) {}
  bool TraverseVecTypeHintAttr(VecTypeHintAttr *A);
  bool VisitVecTypeHintAttr(VecTypeHintAttr *A) {}
  bool TraverseVectorCallAttr(VectorCallAttr *A);
  bool VisitVectorCallAttr(VectorCallAttr *A) {}
  bool TraverseVisibilityAttr(VisibilityAttr *A);
  bool VisitVisibilityAttr(VisibilityAttr *A) {}
  bool TraverseWarnUnusedAttr(WarnUnusedAttr *A);
  bool VisitWarnUnusedAttr(WarnUnusedAttr *A) {}
  bool TraverseWarnUnusedResultAttr(WarnUnusedResultAttr *A);
  bool VisitWarnUnusedResultAttr(WarnUnusedResultAttr *A) {}
  bool TraverseWeakAttr(WeakAttr *A);
  bool VisitWeakAttr(WeakAttr *A) {}
  bool TraverseWeakImportAttr(WeakImportAttr *A);
  bool VisitWeakImportAttr(WeakImportAttr *A) {}
  bool TraverseWeakRefAttr(WeakRefAttr *A);
  bool VisitWeakRefAttr(WeakRefAttr *A) {}
  bool TraverseWebAssemblyExportNameAttr(WebAssemblyExportNameAttr *A);
  bool VisitWebAssemblyExportNameAttr(WebAssemblyExportNameAttr *A) {}
  bool TraverseWebAssemblyFuncrefAttr(WebAssemblyFuncrefAttr *A);
  bool VisitWebAssemblyFuncrefAttr(WebAssemblyFuncrefAttr *A) {}
  bool TraverseWebAssemblyImportModuleAttr(WebAssemblyImportModuleAttr *A);
  bool VisitWebAssemblyImportModuleAttr(WebAssemblyImportModuleAttr *A) {}
  bool TraverseWebAssemblyImportNameAttr(WebAssemblyImportNameAttr *A);
  bool VisitWebAssemblyImportNameAttr(WebAssemblyImportNameAttr *A) {}
  bool TraverseWorkGroupSizeHintAttr(WorkGroupSizeHintAttr *A);
  bool VisitWorkGroupSizeHintAttr(WorkGroupSizeHintAttr *A) {}
  bool TraverseX86ForceAlignArgPointerAttr(X86ForceAlignArgPointerAttr *A);
  bool VisitX86ForceAlignArgPointerAttr(X86ForceAlignArgPointerAttr *A) {}
  bool TraverseXRayInstrumentAttr(XRayInstrumentAttr *A);
  bool VisitXRayInstrumentAttr(XRayInstrumentAttr *A) {}
  bool TraverseXRayLogArgsAttr(XRayLogArgsAttr *A);
  bool VisitXRayLogArgsAttr(XRayLogArgsAttr *A) {}
  bool TraverseZeroCallUsedRegsAttr(ZeroCallUsedRegsAttr *A);
  bool VisitZeroCallUsedRegsAttr(ZeroCallUsedRegsAttr *A) {}

#else // ATTR_VISITOR_DECLS_ONLY

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAArch64SVEPcsAttr(AArch64SVEPcsAttr *A) {}
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAArch64SVEPcsAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAArch64VectorPcsAttr(AArch64VectorPcsAttr *A) {}
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAArch64VectorPcsAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAMDGPUFlatWorkGroupSizeAttr(AMDGPUFlatWorkGroupSizeAttr *A) {}
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAMDGPUFlatWorkGroupSizeAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getMin()))
    return false;
  if (!getDerived().TraverseStmt(A->getMax()))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAMDGPUKernelCallAttr(AMDGPUKernelCallAttr *A) {}
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAMDGPUKernelCallAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAMDGPUMaxNumWorkGroupsAttr(AMDGPUMaxNumWorkGroupsAttr *A) {}
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAMDGPUMaxNumWorkGroupsAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getMaxNumWorkGroupsX()))
    return false;
  if (!getDerived().TraverseStmt(A->getMaxNumWorkGroupsY()))
    return false;
  if (!getDerived().TraverseStmt(A->getMaxNumWorkGroupsZ()))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAMDGPUNumSGPRAttr(AMDGPUNumSGPRAttr *A) {}
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAMDGPUNumSGPRAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAMDGPUNumVGPRAttr(AMDGPUNumVGPRAttr *A) {}
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAMDGPUNumVGPRAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAMDGPUWavesPerEUAttr(AMDGPUWavesPerEUAttr *A) {}
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAMDGPUWavesPerEUAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getMin()))
    return false;
  if (!getDerived().TraverseStmt(A->getMax()))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseARMInterruptAttr(ARMInterruptAttr *A) {}
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitARMInterruptAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAVRInterruptAttr(AVRInterruptAttr *A) {}
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAVRInterruptAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAVRSignalAttr(AVRSignalAttr *A) {}
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAVRSignalAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAbiTagAttr(AbiTagAttr *A) {}
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAbiTagAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAcquireCapabilityAttr(AcquireCapabilityAttr *A) {}
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAcquireCapabilityAttr(A))
    return false;
  {}
    Expr * *I =