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

#ifdef ATTR_VISITOR_DECLS_ONLY

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

#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>::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 = 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>::TraverseAcquireHandleAttr(AcquireHandleAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAcquireHandleAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAcquiredAfterAttr(AcquiredAfterAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAcquiredAfterAttr(A))
    return false;
  {
    Expr * *I = A->args_begin();
    Expr * *E = A->args_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAcquiredBeforeAttr(AcquiredBeforeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAcquiredBeforeAttr(A))
    return false;
  {
    Expr * *I = A->args_begin();
    Expr * *E = A->args_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAddressSpaceAttr(AddressSpaceAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAddressSpaceAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAliasAttr(AliasAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAliasAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAlignMac68kAttr(AlignMac68kAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAlignMac68kAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAlignNaturalAttr(AlignNaturalAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAlignNaturalAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAlignValueAttr(AlignValueAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAlignValueAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getAlignment()))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAlignedAttr(AlignedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAlignedAttr(A))
    return false;
  if (A->isAlignmentExpr()) {
    if (!getDerived().TraverseStmt(A->getAlignmentExpr()))
      return false;
  } else if (auto *TSI = A->getAlignmentType()) {
    if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
      return false;
  }
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAllocAlignAttr(AllocAlignAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAllocAlignAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAllocSizeAttr(AllocSizeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAllocSizeAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAlwaysDestroyAttr(AlwaysDestroyAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAlwaysDestroyAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAlwaysInlineAttr(AlwaysInlineAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAlwaysInlineAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAnalyzerNoReturnAttr(AnalyzerNoReturnAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAnalyzerNoReturnAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAnnotateAttr(AnnotateAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAnnotateAttr(A))
    return false;
  {
    Expr * *I = A->args_begin();
    Expr * *E = A->args_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  {
    Expr * *I = A->delayedArgs_begin();
    Expr * *E = A->delayedArgs_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAnnotateTypeAttr(AnnotateTypeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAnnotateTypeAttr(A))
    return false;
  {
    Expr * *I = A->args_begin();
    Expr * *E = A->args_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  {
    Expr * *I = A->delayedArgs_begin();
    Expr * *E = A->delayedArgs_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAnyX86InterruptAttr(AnyX86InterruptAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAnyX86InterruptAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAnyX86NoCallerSavedRegistersAttr(AnyX86NoCallerSavedRegistersAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAnyX86NoCallerSavedRegistersAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAnyX86NoCfCheckAttr(AnyX86NoCfCheckAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAnyX86NoCfCheckAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitArcWeakrefUnavailableAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitArgumentWithTypeTagAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseArmBuiltinAliasAttr(ArmBuiltinAliasAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitArmBuiltinAliasAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseArmMveStrictPolymorphismAttr(ArmMveStrictPolymorphismAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitArmMveStrictPolymorphismAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseArtificialAttr(ArtificialAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitArtificialAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAsmLabelAttr(AsmLabelAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAsmLabelAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAssertCapabilityAttr(AssertCapabilityAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAssertCapabilityAttr(A))
    return false;
  {
    Expr * *I = A->args_begin();
    Expr * *E = A->args_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAssertExclusiveLockAttr(AssertExclusiveLockAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAssertExclusiveLockAttr(A))
    return false;
  {
    Expr * *I = A->args_begin();
    Expr * *E = A->args_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAssertSharedLockAttr(AssertSharedLockAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAssertSharedLockAttr(A))
    return false;
  {
    Expr * *I = A->args_begin();
    Expr * *E = A->args_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAssumeAlignedAttr(AssumeAlignedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAssumeAlignedAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getAlignment()))
    return false;
  if (!getDerived().TraverseStmt(A->getOffset()))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAssumptionAttr(AssumptionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAssumptionAttr(A))
    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>::TraverseBPFPreserveAccessIndexAttr(BPFPreserveAccessIndexAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitBPFPreserveAccessIndexAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseBTFDeclTagAttr(BTFDeclTagAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitBTFDeclTagAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseBTFTypeTagAttr(BTFTypeTagAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitBTFTypeTagAttr(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>::TraverseBuiltinAttr(BuiltinAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitBuiltinAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseBuiltinAliasAttr(BuiltinAliasAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitBuiltinAliasAttr(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>::TraverseCFGuardAttr(CFGuardAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCFGuardAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCFICanonicalJumpTableAttr(CFICanonicalJumpTableAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCFICanonicalJumpTableAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCFReturnsNotRetainedAttr(CFReturnsNotRetainedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCFReturnsNotRetainedAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCFReturnsRetainedAttr(CFReturnsRetainedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCFReturnsRetainedAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCFUnknownTransferAttr(CFUnknownTransferAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCFUnknownTransferAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCPUDispatchAttr(CPUDispatchAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCPUDispatchAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCPUSpecificAttr(CPUSpecificAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCPUSpecificAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCUDAConstantAttr(CUDAConstantAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCUDAConstantAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCUDADeviceAttr(CUDADeviceAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCUDADeviceAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCUDADeviceBuiltinSurfaceTypeAttr(CUDADeviceBuiltinSurfaceTypeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCUDADeviceBuiltinSurfaceTypeAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCUDADeviceBuiltinTextureTypeAttr(CUDADeviceBuiltinTextureTypeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCUDADeviceBuiltinTextureTypeAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCUDAGlobalAttr(CUDAGlobalAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCUDAGlobalAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCUDAHostAttr(CUDAHostAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCUDAHostAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCUDAInvalidTargetAttr(CUDAInvalidTargetAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCUDAInvalidTargetAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCUDALaunchBoundsAttr(CUDALaunchBoundsAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCUDALaunchBoundsAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getMaxThreads()))
    return false;
  if (!getDerived().TraverseStmt(A->getMinBlocks()))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCUDASharedAttr(CUDASharedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCUDASharedAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCXX11NoReturnAttr(CXX11NoReturnAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCXX11NoReturnAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCallableWhenAttr(CallableWhenAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCallableWhenAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCallbackAttr(CallbackAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCallbackAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCalledOnceAttr(CalledOnceAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCalledOnceAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCapabilityAttr(CapabilityAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCapabilityAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCapturedRecordAttr(CapturedRecordAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCapturedRecordAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCarriesDependencyAttr(CarriesDependencyAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCarriesDependencyAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCleanupAttr(CleanupAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCleanupAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCmseNSCallAttr(CmseNSCallAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCmseNSCallAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCmseNSEntryAttr(CmseNSEntryAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCmseNSEntryAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCodeSegAttr(CodeSegAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCodeSegAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseColdAttr(ColdAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitColdAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCommonAttr(CommonAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCommonAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseConstAttr(ConstAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitConstAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseConstInitAttr(ConstInitAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitConstInitAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseConstructorAttr(ConstructorAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitConstructorAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseConsumableAttr(ConsumableAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitConsumableAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseConsumableAutoCastAttr(ConsumableAutoCastAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitConsumableAutoCastAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitConsumableSetOnReadAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseConvergentAttr(ConvergentAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitConvergentAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseDLLExportAttr(DLLExportAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitDLLExportAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseDLLExportStaticLocalAttr(DLLExportStaticLocalAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitDLLExportStaticLocalAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseDLLImportAttr(DLLImportAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitDLLImportAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseDLLImportStaticLocalAttr(DLLImportStaticLocalAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitDLLImportStaticLocalAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseDeprecatedAttr(DeprecatedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitDeprecatedAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseDestructorAttr(DestructorAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitDestructorAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseDiagnoseAsBuiltinAttr(DiagnoseAsBuiltinAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitDiagnoseAsBuiltinAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseDiagnoseIfAttr(DiagnoseIfAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitDiagnoseIfAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getCond()))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseDisableSanitizerInstrumentationAttr(DisableSanitizerInstrumentationAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitDisableSanitizerInstrumentationAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseDisableTailCallsAttr(DisableTailCallsAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitDisableTailCallsAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseEmptyBasesAttr(EmptyBasesAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitEmptyBasesAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseEnableIfAttr(EnableIfAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitEnableIfAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getCond()))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseEnforceTCBAttr(EnforceTCBAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitEnforceTCBAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseEnforceTCBLeafAttr(EnforceTCBLeafAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitEnforceTCBLeafAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseEnumExtensibilityAttr(EnumExtensibilityAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitEnumExtensibilityAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseErrorAttr(ErrorAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitErrorAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseExcludeFromExplicitInstantiationAttr(ExcludeFromExplicitInstantiationAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitExcludeFromExplicitInstantiationAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseExclusiveTrylockFunctionAttr(ExclusiveTrylockFunctionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitExclusiveTrylockFunctionAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getSuccessValue()))
    return false;
  {
    Expr * *I = A->args_begin();
    Expr * *E = A->args_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseExternalSourceSymbolAttr(ExternalSourceSymbolAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitExternalSourceSymbolAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseFallThroughAttr(FallThroughAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitFallThroughAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseFastCallAttr(FastCallAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitFastCallAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseFinalAttr(FinalAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitFinalAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseFlagEnumAttr(FlagEnumAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitFlagEnumAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseFlattenAttr(FlattenAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitFlattenAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseFormatAttr(FormatAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitFormatAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseFormatArgAttr(FormatArgAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitFormatArgAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseFunctionReturnThunksAttr(FunctionReturnThunksAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitFunctionReturnThunksAttr(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>::TraverseHIPManagedAttr(HIPManagedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitHIPManagedAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseHLSLNumThreadsAttr(HLSLNumThreadsAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitHLSLNumThreadsAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseHLSLSV_GroupIndexAttr(HLSLSV_GroupIndexAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitHLSLSV_GroupIndexAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseHLSLShaderAttr(HLSLShaderAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitHLSLShaderAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseHotAttr(HotAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitHotAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseIBActionAttr(IBActionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitIBActionAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseIBOutletAttr(IBOutletAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitIBOutletAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseIBOutletCollectionAttr(IBOutletCollectionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitIBOutletCollectionAttr(A))
    return false;
  if (auto *TSI = A->getInterfaceLoc())
    if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
      return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseIFuncAttr(IFuncAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitIFuncAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseInitPriorityAttr(InitPriorityAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitInitPriorityAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseInitSegAttr(InitSegAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitInitSegAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseIntelOclBiccAttr(IntelOclBiccAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitIntelOclBiccAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseInternalLinkageAttr(InternalLinkageAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitInternalLinkageAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseLTOVisibilityPublicAttr(LTOVisibilityPublicAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitLTOVisibilityPublicAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseLayoutVersionAttr(LayoutVersionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitLayoutVersionAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseLeafAttr(LeafAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitLeafAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseLifetimeBoundAttr(LifetimeBoundAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitLifetimeBoundAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseLikelyAttr(LikelyAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitLikelyAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseLoaderUninitializedAttr(LoaderUninitializedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitLoaderUninitializedAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseLockReturnedAttr(LockReturnedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitLockReturnedAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getArg()))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseLocksExcludedAttr(LocksExcludedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitLocksExcludedAttr(A))
    return false;
  {
    Expr * *I = A->args_begin();
    Expr * *E = A->args_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseLoopHintAttr(LoopHintAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitLoopHintAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getValue()))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseM68kInterruptAttr(M68kInterruptAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitM68kInterruptAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMIGServerRoutineAttr(MIGServerRoutineAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMIGServerRoutineAttr(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>::TraverseMSAllocatorAttr(MSAllocatorAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMSAllocatorAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMSInheritanceAttr(MSInheritanceAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMSInheritanceAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMSNoVTableAttr(MSNoVTableAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMSNoVTableAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMSP430InterruptAttr(MSP430InterruptAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMSP430InterruptAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMSStructAttr(MSStructAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMSStructAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMSVtorDispAttr(MSVtorDispAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMSVtorDispAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMaxFieldAlignmentAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMayAliasAttr(MayAliasAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMayAliasAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMicroMipsAttr(MicroMipsAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMicroMipsAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMinSizeAttr(MinSizeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMinSizeAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMinVectorWidthAttr(MinVectorWidthAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMinVectorWidthAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMips16Attr(Mips16Attr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMips16Attr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMipsInterruptAttr(MipsInterruptAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMipsInterruptAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMipsLongCallAttr(MipsLongCallAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMipsLongCallAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMipsShortCallAttr(MipsShortCallAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMipsShortCallAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseModeAttr(ModeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitModeAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMustTailAttr(MustTailAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMustTailAttr(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>::TraverseNSErrorDomainAttr(NSErrorDomainAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNSErrorDomainAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNSReturnsAutoreleasedAttr(NSReturnsAutoreleasedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNSReturnsAutoreleasedAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNSReturnsNotRetainedAttr(NSReturnsNotRetainedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNSReturnsNotRetainedAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNSReturnsRetainedAttr(NSReturnsRetainedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNSReturnsRetainedAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNakedAttr(NakedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNakedAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoAliasAttr(NoAliasAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoAliasAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoBuiltinAttr(NoBuiltinAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoBuiltinAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoCommonAttr(NoCommonAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoCommonAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoDebugAttr(NoDebugAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoDebugAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoDerefAttr(NoDerefAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoDerefAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoDestroyAttr(NoDestroyAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoDestroyAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoDuplicateAttr(NoDuplicateAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoDuplicateAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoEscapeAttr(NoEscapeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoEscapeAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoInlineAttr(NoInlineAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoInlineAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoInstrumentFunctionAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoMergeAttr(NoMergeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoMergeAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoMicroMipsAttr(NoMicroMipsAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoMicroMipsAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoMips16Attr(NoMips16Attr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoMips16Attr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoProfileFunctionAttr(NoProfileFunctionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoProfileFunctionAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoRandomizeLayoutAttr(NoRandomizeLayoutAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoRandomizeLayoutAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoReturnAttr(NoReturnAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoReturnAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoSanitizeAttr(NoSanitizeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoSanitizeAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoSpeculativeLoadHardeningAttr(NoSpeculativeLoadHardeningAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoSpeculativeLoadHardeningAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoSplitStackAttr(NoSplitStackAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoSplitStackAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoStackProtectorAttr(NoStackProtectorAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoStackProtectorAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoThreadSafetyAnalysisAttr(NoThreadSafetyAnalysisAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoThreadSafetyAnalysisAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoThrowAttr(NoThrowAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoThrowAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNoUniqueAddressAttr(NoUniqueAddressAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNoUniqueAddressAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNonNullAttr(NonNullAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNonNullAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNotTailCalledAttr(NotTailCalledAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNotTailCalledAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOMPAllocateDeclAttr(OMPAllocateDeclAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOMPAllocateDeclAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getAllocator()))
    return false;
  if (!getDerived().TraverseStmt(A->getAlignment()))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOMPCaptureKindAttr(OMPCaptureKindAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOMPCaptureKindAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOMPCaptureNoInitAttr(OMPCaptureNoInitAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOMPCaptureNoInitAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOMPDeclareSimdDeclAttr(OMPDeclareSimdDeclAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOMPDeclareSimdDeclAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getSimdlen()))
    return false;
  {
    Expr * *I = A->uniforms_begin();
    Expr * *E = A->uniforms_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  {
    Expr * *I = A->aligneds_begin();
    Expr * *E = A->aligneds_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  {
    Expr * *I = A->alignments_begin();
    Expr * *E = A->alignments_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  {
    Expr * *I = A->linears_begin();
    Expr * *E = A->linears_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  {
    Expr * *I = A->steps_begin();
    Expr * *E = A->steps_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOMPDeclareTargetDeclAttr(OMPDeclareTargetDeclAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOMPDeclareTargetDeclAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getIndirectExpr()))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOMPDeclareVariantAttr(OMPDeclareVariantAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOMPDeclareVariantAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getVariantFuncRef()))
    return false;
  {
    Expr * *I = A->adjustArgsNothing_begin();
    Expr * *E = A->adjustArgsNothing_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  {
    Expr * *I = A->adjustArgsNeedDevicePtr_begin();
    Expr * *E = A->adjustArgsNeedDevicePtr_end();
    for (; I != E; ++I) {
      if (!getDerived().TraverseStmt(*I))
        return false;
    }
  }
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOMPReferencedVarAttr(OMPReferencedVarAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOMPReferencedVarAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getRef()))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOMPThreadPrivateDeclAttr(OMPThreadPrivateDeclAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOMPThreadPrivateDeclAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOSConsumedAttr(OSConsumedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOSConsumedAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOSConsumesThisAttr(OSConsumesThisAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOSConsumesThisAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOSReturnsNotRetainedAttr(OSReturnsNotRetainedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOSReturnsNotRetainedAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOSReturnsRetainedAttr(OSReturnsRetainedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOSReturnsRetainedAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOSReturnsRetainedOnNonZeroAttr(OSReturnsRetainedOnNonZeroAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOSReturnsRetainedOnNonZeroAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOSReturnsRetainedOnZeroAttr(OSReturnsRetainedOnZeroAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOSReturnsRetainedOnZeroAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCBoxableAttr(ObjCBoxableAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCBoxableAttr(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>::TraverseObjCClassStubAttr(ObjCClassStubAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCClassStubAttr(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>::TraverseObjCDirectAttr(ObjCDirectAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCDirectAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCDirectMembersAttr(ObjCDirectMembersAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCDirectMembersAttr(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>::TraverseObjCExternallyRetainedAttr(ObjCExternallyRetainedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCExternallyRetainedAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCGCAttr(ObjCGCAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCGCAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCIndependentClassAttr(ObjCIndependentClassAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCIndependentClassAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCInertUnsafeUnretainedAttr(ObjCInertUnsafeUnretainedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCInertUnsafeUnretainedAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCKindOfAttr(ObjCKindOfAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCKindOfAttr(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>::TraverseObjCNonLazyClassAttr(ObjCNonLazyClassAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCNonLazyClassAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCNonRuntimeProtocolAttr(ObjCNonRuntimeProtocolAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCNonRuntimeProtocolAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCOwnershipAttr(ObjCOwnershipAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCOwnershipAttr(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>::TraverseObjCRuntimeVisibleAttr(ObjCRuntimeVisibleAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCRuntimeVisibleAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCSubclassingRestrictedAttr(ObjCSubclassingRestrictedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCSubclassingRestrictedAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOpenCLAccessAttr(OpenCLAccessAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOpenCLAccessAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOpenCLConstantAddressSpaceAttr(OpenCLConstantAddressSpaceAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOpenCLConstantAddressSpaceAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOpenCLGenericAddressSpaceAttr(OpenCLGenericAddressSpaceAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOpenCLGenericAddressSpaceAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOpenCLGlobalAddressSpaceAttr(OpenCLGlobalAddressSpaceAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOpenCLGlobalAddressSpaceAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOpenCLGlobalDeviceAddressSpaceAttr(OpenCLGlobalDeviceAddressSpaceAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOpenCLGlobalDeviceAddressSpaceAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOpenCLGlobalHostAddressSpaceAttr(OpenCLGlobalHostAddressSpaceAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOpenCLGlobalHostAddressSpaceAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOpenCLIntelReqdSubGroupSizeAttr(OpenCLIntelReqdSubGroupSizeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOpenCLIntelReqdSubGroupSizeAttr(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>::TraverseOpenCLLocalAddressSpaceAttr(OpenCLLocalAddressSpaceAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOpenCLLocalAddressSpaceAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOpenCLPrivateAddressSpaceAttr(OpenCLPrivateAddressSpaceAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOpenCLPrivateAddressSpaceAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOpenCLUnrollHintAttr(OpenCLUnrollHintAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOpenCLUnrollHintAttr(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>::TraverseOwnerAttr(OwnerAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOwnerAttr(A))
    return false;
  if (auto *TSI = A->getDerefTypeLoc())
    if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
      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>::TraversePassObjectSizeAttr(PassObjectSizeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPassObjectSizeAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraversePatchableFunctionEntryAttr(PatchableFunctionEntryAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPatchableFunctionEntryAttr(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>::TraversePointerAttr(PointerAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPointerAttr(A))
    return false;
  if (auto *TSI = A->getDerefTypeLoc())
    if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
      return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraversePragmaClangBSSSectionAttr(PragmaClangBSSSectionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPragmaClangBSSSectionAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraversePragmaClangDataSectionAttr(PragmaClangDataSectionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPragmaClangDataSectionAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraversePragmaClangRelroSectionAttr(PragmaClangRelroSectionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPragmaClangRelroSectionAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraversePragmaClangRodataSectionAttr(PragmaClangRodataSectionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPragmaClangRodataSectionAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraversePragmaClangTextSectionAttr(PragmaClangTextSectionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPragmaClangTextSectionAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraversePreferredNameAttr(PreferredNameAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPreferredNameAttr(A))
    return false;
  if (auto *TSI = A->getTypedefTypeLoc())
    if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
      return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraversePreserveAllAttr(PreserveAllAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPreserveAllAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraversePreserveMostAttr(PreserveMostAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPreserveMostAttr(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>::TraversePtr32Attr(Ptr32Attr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPtr32Attr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraversePtr64Attr(Ptr64Attr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPtr64Attr(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>::TraverseRISCVInterruptAttr(RISCVInterruptAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitRISCVInterruptAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseRandomizeLayoutAttr(RandomizeLayoutAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitRandomizeLayoutAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseRegCallAttr(RegCallAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitRegCallAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseReinitializesAttr(ReinitializesAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitReinitializesAttr(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>::TraverseReleaseHandleAttr(ReleaseHandleAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitReleaseHandleAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseRenderScriptKernelAttr(RenderScriptKernelAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitRenderScriptKernelAttr(A))
    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>::TraverseRestrictAttr(RestrictAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitRestrictAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseRetainAttr(RetainAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitRetainAttr(A))
    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>::TraverseSPtrAttr(SPtrAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSPtrAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSYCLKernelAttr(SYCLKernelAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSYCLKernelAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSYCLSpecialClassAttr(SYCLSpecialClassAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSYCLSpecialClassAttr(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>::TraverseSpeculativeLoadHardeningAttr(SpeculativeLoadHardeningAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSpeculativeLoadHardeningAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseStandaloneDebugAttr(StandaloneDebugAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitStandaloneDebugAttr(A))
    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>::TraverseStrictFPAttr(StrictFPAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitStrictFPAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSuppressAttr(SuppressAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSuppressAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftAsyncAttr(SwiftAsyncAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftAsyncAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftAsyncCallAttr(SwiftAsyncCallAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftAsyncCallAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftAsyncContextAttr(SwiftAsyncContextAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftAsyncContextAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftAsyncErrorAttr(SwiftAsyncErrorAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftAsyncErrorAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftAsyncNameAttr(SwiftAsyncNameAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftAsyncNameAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftAttrAttr(SwiftAttrAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftAttrAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftBridgeAttr(SwiftBridgeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftBridgeAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftBridgedTypedefAttr(SwiftBridgedTypedefAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftBridgedTypedefAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftCallAttr(SwiftCallAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftCallAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftContextAttr(SwiftContextAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftContextAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftErrorAttr(SwiftErrorAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftErrorAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftErrorResultAttr(SwiftErrorResultAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftErrorResultAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftIndirectResultAttr(SwiftIndirectResultAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftIndirectResultAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftNameAttr(SwiftNameAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftNameAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftNewTypeAttr(SwiftNewTypeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftNewTypeAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftObjCMembersAttr(SwiftObjCMembersAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftObjCMembersAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSwiftPrivateAttr(SwiftPrivateAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSwiftPrivateAttr(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>::TraverseTargetAttr(TargetAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitTargetAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseTargetClonesAttr(TargetClonesAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitTargetClonesAttr(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>::TraverseTrivialABIAttr(TrivialABIAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitTrivialABIAttr(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>::TraverseTypeNonNullAttr(TypeNonNullAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitTypeNonNullAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseTypeNullUnspecifiedAttr(TypeNullUnspecifiedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitTypeNullUnspecifiedAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseTypeNullableAttr(TypeNullableAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitTypeNullableAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseTypeNullableResultAttr(TypeNullableResultAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitTypeNullableResultAttr(A))
    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;
  if (auto *TSI = A->getMatchingCTypeLoc())
    if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
      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>::TraverseUPtrAttr(UPtrAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitUPtrAttr(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>::TraverseUninitializedAttr(UninitializedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitUninitializedAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseUnlikelyAttr(UnlikelyAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitUnlikelyAttr(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>::TraverseUseHandleAttr(UseHandleAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitUseHandleAttr(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>::TraverseUsingIfExistsAttr(UsingIfExistsAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitUsingIfExistsAttr(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;
  if (auto *TSI = A->getTypeHintLoc())
    if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
      return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseVectorCallAttr(VectorCallAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitVectorCallAttr(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>::TraverseWebAssemblyExportNameAttr(WebAssemblyExportNameAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitWebAssemblyExportNameAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseWebAssemblyImportModuleAttr(WebAssemblyImportModuleAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitWebAssemblyImportModuleAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseWebAssemblyImportNameAttr(WebAssemblyImportNameAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitWebAssemblyImportNameAttr(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>::TraverseXRayInstrumentAttr(XRayInstrumentAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitXRayInstrumentAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseXRayLogArgsAttr(XRayLogArgsAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitXRayLogArgsAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseZeroCallUsedRegsAttr(ZeroCallUsedRegsAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitZeroCallUsedRegsAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAttr(Attr *A) {
  if (!A)
    return true;

  switch (A->getKind()) {
    case attr::AArch64SVEPcs:
      return getDerived().TraverseAArch64SVEPcsAttr(cast<AArch64SVEPcsAttr>(A));
    case attr::AArch64VectorPcs:
      return getDerived().TraverseAArch64VectorPcsAttr(cast<AArch64VectorPcsAttr>(A));
    case attr::AMDGPUFlatWorkGroupSize:
      return getDerived().TraverseAMDGPUFlatWorkGroupSizeAttr(cast<AMDGPUFlatWorkGroupSizeAttr>(A));
    case attr::AMDGPUKernelCall:
      return getDerived().TraverseAMDGPUKernelCallAttr(cast<AMDGPUKernelCallAttr>(A));
    case attr::AMDGPUNumSGPR:
      return getDerived().TraverseAMDGPUNumSGPRAttr(cast<AMDGPUNumSGPRAttr>(A));
    case attr::AMDGPUNumVGPR:
      return getDerived().TraverseAMDGPUNumVGPRAttr(cast<AMDGPUNumVGPRAttr>(A));
    case attr::AMDGPUWavesPerEU:
      return getDerived().TraverseAMDGPUWavesPerEUAttr(cast<AMDGPUWavesPerEUAttr>(A));
    case attr::ARMInterrupt:
      return getDerived().TraverseARMInterruptAttr(cast<ARMInterruptAttr>(A));
    case attr::AVRInterrupt:
      return getDerived().TraverseAVRInterruptAttr(cast<AVRInterruptAttr>(A));
    case attr::AVRSignal:
      return getDerived().TraverseAVRSignalAttr(cast<AVRSignalAttr>(A));
    case attr::AbiTag:
      return getDerived().TraverseAbiTagAttr(cast<AbiTagAttr>(A));
    case attr::AcquireCapability:
      return getDerived().TraverseAcquireCapabilityAttr(cast<AcquireCapabilityAttr>(A));
    case attr::AcquireHandle:
      return getDerived().TraverseAcquireHandleAttr(cast<AcquireHandleAttr>(A));
    case attr::AcquiredAfter:
      return getDerived().TraverseAcquiredAfterAttr(cast<AcquiredAfterAttr>(A));
    case attr::AcquiredBefore:
      return getDerived().TraverseAcquiredBeforeAttr(cast<AcquiredBeforeAttr>(A));
    case attr::AddressSpace:
      return getDerived().TraverseAddressSpaceAttr(cast<AddressSpaceAttr>(A));
    case attr::Alias:
      return getDerived().TraverseAliasAttr(cast<AliasAttr>(A));
    case attr::AlignMac68k:
      return getDerived().TraverseAlignMac68kAttr(cast<AlignMac68kAttr>(A));
    case attr::AlignNatural:
      return getDerived().TraverseAlignNaturalAttr(cast<AlignNaturalAttr>(A));
    case attr::AlignValue:
      return getDerived().TraverseAlignValueAttr(cast<AlignValueAttr>(A));
    case attr::Aligned:
      return getDerived().TraverseAlignedAttr(cast<AlignedAttr>(A));
    case attr::AllocAlign:
      return getDerived().TraverseAllocAlignAttr(cast<AllocAlignAttr>(A));
    case attr::AllocSize:
      return getDerived().TraverseAllocSizeAttr(cast<AllocSizeAttr>(A));
    case attr::AlwaysDestroy:
      return getDerived().TraverseAlwaysDestroyAttr(cast<AlwaysDestroyAttr>(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::AnnotateType:
      return getDerived().TraverseAnnotateTypeAttr(cast<AnnotateTypeAttr>(A));
    case attr::AnyX86Interrupt:
      return getDerived().TraverseAnyX86InterruptAttr(cast<AnyX86InterruptAttr>(A));
    case attr::AnyX86NoCallerSavedRegisters:
      return getDerived().TraverseAnyX86NoCallerSavedRegistersAttr(cast<AnyX86NoCallerSavedRegistersAttr>(A));
    case attr::AnyX86NoCfCheck:
      return getDerived().TraverseAnyX86NoCfCheckAttr(cast<AnyX86NoCfCheckAttr>(A));
    case attr::ArcWeakrefUnavailable:
      return getDerived().TraverseArcWeakrefUnavailableAttr(cast<ArcWeakrefUnavailableAttr>(A));
    case attr::ArgumentWithTypeTag:
      return getDerived().TraverseArgumentWithTypeTagAttr(cast<ArgumentWithTypeTagAttr>(A));
    case attr::ArmBuiltinAlias:
      return getDerived().TraverseArmBuiltinAliasAttr(cast<ArmBuiltinAliasAttr>(A));
    case attr::ArmMveStrictPolymorphism:
      return getDerived().TraverseArmMveStrictPolymorphismAttr(cast<ArmMveStrictPolymorphismAttr>(A));
    case attr::Artificial:
      return getDerived().TraverseArtificialAttr(cast<ArtificialAttr>(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::AssumeAligned:
      return getDerived().TraverseAssumeAlignedAttr(cast<AssumeAlignedAttr>(A));
    case attr::Assumption:
      return getDerived().TraverseAssumptionAttr(cast<AssumptionAttr>(A));
    case attr::Availability:
      return getDerived().TraverseAvailabilityAttr(cast<AvailabilityAttr>(A));
    case attr::BPFPreserveAccessIndex:
      return getDerived().TraverseBPFPreserveAccessIndexAttr(cast<BPFPreserveAccessIndexAttr>(A));
    case attr::BTFDeclTag:
      return getDerived().TraverseBTFDeclTagAttr(cast<BTFDeclTagAttr>(A));
    case attr::BTFTypeTag:
      return getDerived().TraverseBTFTypeTagAttr(cast<BTFTypeTagAttr>(A));
    case attr::Blocks:
      return getDerived().TraverseBlocksAttr(cast<BlocksAttr>(A));
    case attr::Builtin:
      return getDerived().TraverseBuiltinAttr(cast<BuiltinAttr>(A));
    case attr::BuiltinAlias:
      return getDerived().TraverseBuiltinAliasAttr(cast<BuiltinAliasAttr>(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::CFGuard:
      return getDerived().TraverseCFGuardAttr(cast<CFGuardAttr>(A));
    case attr::CFICanonicalJumpTable:
      return getDerived().TraverseCFICanonicalJumpTableAttr(cast<CFICanonicalJumpTableAttr>(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::CPUDispatch:
      return getDerived().TraverseCPUDispatchAttr(cast<CPUDispatchAttr>(A));
    case attr::CPUSpecific:
      return getDerived().TraverseCPUSpecificAttr(cast<CPUSpecificAttr>(A));
    case attr::CUDAConstant:
      return getDerived().TraverseCUDAConstantAttr(cast<CUDAConstantAttr>(A));
    case attr::CUDADevice:
      return getDerived().TraverseCUDADeviceAttr(cast<CUDADeviceAttr>(A));
    case attr::CUDADeviceBuiltinSurfaceType:
      return getDerived().TraverseCUDADeviceBuiltinSurfaceTypeAttr(cast<CUDADeviceBuiltinSurfaceTypeAttr>(A));
    case attr::CUDADeviceBuiltinTextureType:
      return getDerived().TraverseCUDADeviceBuiltinTextureTypeAttr(cast<CUDADeviceBuiltinTextureTypeAttr>(A));
    case attr::CUDAGlobal:
      return getDerived().TraverseCUDAGlobalAttr(cast<CUDAGlobalAttr>(A));
    case attr::CUDAHost:
      return getDerived().TraverseCUDAHostAttr(cast<CUDAHostAttr>(A));
    case attr::CUDAInvalidTarget:
      return getDerived().TraverseCUDAInvalidTargetAttr(cast<CUDAInvalidTargetAttr>(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::Callback:
      return getDerived().TraverseCallbackAttr(cast<CallbackAttr>(A));
    case attr::CalledOnce:
      return getDerived().TraverseCalledOnceAttr(cast<CalledOnceAttr>(A));
    case attr::Capability:
      return getDerived().TraverseCapabilityAttr(cast<CapabilityAttr>(A));
    case attr::CapturedRecord:
      return getDerived().TraverseCapturedRecordAttr(cast<CapturedRecordAttr>(A));
    case attr::CarriesDependency:
      return getDerived().TraverseCarriesDependencyAttr(cast<CarriesDependencyAttr>(A));
    case attr::Cleanup:
      return getDerived().TraverseCleanupAttr(cast<CleanupAttr>(A));
    case attr::CmseNSCall:
      return getDerived().TraverseCmseNSCallAttr(cast<CmseNSCallAttr>(A));
    case attr::CmseNSEntry:
      return getDerived().TraverseCmseNSEntryAttr(cast<CmseNSEntryAttr>(A));
    case attr::CodeSeg:
      return getDerived().TraverseCodeSegAttr(cast<CodeSegAttr>(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::ConstInit:
      return getDerived().TraverseConstInitAttr(cast<ConstInitAttr>(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::Convergent:
      return getDerived().TraverseConvergentAttr(cast<ConvergentAttr>(A));
    case attr::DLLExport:
      return getDerived().TraverseDLLExportAttr(cast<DLLExportAttr>(A));
    case attr::DLLExportStaticLocal:
      return getDerived().TraverseDLLExportStaticLocalAttr(cast<DLLExportStaticLocalAttr>(A));
    case attr::DLLImport:
      return getDerived().TraverseDLLImportAttr(cast<DLLImportAttr>(A));
    case attr::DLLImportStaticLocal:
      return getDerived().TraverseDLLImportStaticLocalAttr(cast<DLLImportStaticLocalAttr>(A));
    case attr::Deprecated:
      return getDerived().TraverseDeprecatedAttr(cast<DeprecatedAttr>(A));
    case attr::Destructor:
      return getDerived().TraverseDestructorAttr(cast<DestructorAttr>(A));
    case attr::DiagnoseAsBuiltin:
      return getDerived().TraverseDiagnoseAsBuiltinAttr(cast<DiagnoseAsBuiltinAttr>(A));
    case attr::DiagnoseIf:
      return getDerived().TraverseDiagnoseIfAttr(cast<DiagnoseIfAttr>(A));
    case attr::DisableSanitizerInstrumentation:
      return getDerived().TraverseDisableSanitizerInstrumentationAttr(cast<DisableSanitizerInstrumentationAttr>(A));
    case attr::DisableTailCalls:
      return getDerived().TraverseDisableTailCallsAttr(cast<DisableTailCallsAttr>(A));
    case attr::EmptyBases:
      return getDerived().TraverseEmptyBasesAttr(cast<EmptyBasesAttr>(A));
    case attr::EnableIf:
      return getDerived().TraverseEnableIfAttr(cast<EnableIfAttr>(A));
    case attr::EnforceTCB:
      return getDerived().TraverseEnforceTCBAttr(cast<EnforceTCBAttr>(A));
    case attr::EnforceTCBLeaf:
      return getDerived().TraverseEnforceTCBLeafAttr(cast<EnforceTCBLeafAttr>(A));
    case attr::EnumExtensibility:
      return getDerived().TraverseEnumExtensibilityAttr(cast<EnumExtensibilityAttr>(A));
    case attr::Error:
      return getDerived().TraverseErrorAttr(cast<ErrorAttr>(A));
    case attr::ExcludeFromExplicitInstantiation:
      return getDerived().TraverseExcludeFromExplicitInstantiationAttr(cast<ExcludeFromExplicitInstantiationAttr>(A));
    case attr::ExclusiveTrylockFunction:
      return getDerived().TraverseExclusiveTrylockFunctionAttr(cast<ExclusiveTrylockFunctionAttr>(A));
    case attr::ExternalSourceSymbol:
      return getDerived().TraverseExternalSourceSymbolAttr(cast<ExternalSourceSymbolAttr>(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::FlagEnum:
      return getDerived().TraverseFlagEnumAttr(cast<FlagEnumAttr>(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::FunctionReturnThunks:
      return getDerived().TraverseFunctionReturnThunksAttr(cast<FunctionReturnThunksAttr>(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::HIPManaged:
      return getDerived().TraverseHIPManagedAttr(cast<HIPManagedAttr>(A));
    case attr::HLSLNumThreads:
      return getDerived().TraverseHLSLNumThreadsAttr(cast<HLSLNumThreadsAttr>(A));
    case attr::HLSLSV_GroupIndex:
      return getDerived().TraverseHLSLSV_GroupIndexAttr(cast<HLSLSV_GroupIndexAttr>(A));
    case attr::HLSLShader:
      return getDerived().TraverseHLSLShaderAttr(cast<HLSLShaderAttr>(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::IFunc:
      return getDerived().TraverseIFuncAttr(cast<IFuncAttr>(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::InternalLinkage:
      return getDerived().TraverseInternalLinkageAttr(cast<InternalLinkageAttr>(A));
    case attr::LTOVisibilityPublic:
      return getDerived().TraverseLTOVisibilityPublicAttr(cast<LTOVisibilityPublicAttr>(A));
    case attr::LayoutVersion:
      return getDerived().TraverseLayoutVersionAttr(cast<LayoutVersionAttr>(A));
    case attr::Leaf:
      return getDerived().TraverseLeafAttr(cast<LeafAttr>(A));
    case attr::LifetimeBound:
      return getDerived().TraverseLifetimeBoundAttr(cast<LifetimeBoundAttr>(A));
    case attr::Likely:
      return getDerived().TraverseLikelyAttr(cast<LikelyAttr>(A));
    case attr::LoaderUninitialized:
      return getDerived().TraverseLoaderUninitializedAttr(cast<LoaderUninitializedAttr>(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::M68kInterrupt:
      return getDerived().TraverseM68kInterruptAttr(cast<M68kInterruptAttr>(A));
    case attr::MIGServerRoutine:
      return getDerived().TraverseMIGServerRoutineAttr(cast<MIGServerRoutineAttr>(A));
    case attr::MSABI:
      return getDerived().TraverseMSABIAttr(cast<MSABIAttr>(A));
    case attr::MSAllocator:
      return getDerived().TraverseMSAllocatorAttr(cast<MSAllocatorAttr>(A));
    case attr::MSInheritance:
      return getDerived().TraverseMSInheritanceAttr(cast<MSInheritanceAttr>(A));
    case attr::MSNoVTable:
      return getDerived().TraverseMSNoVTableAttr(cast<MSNoVTableAttr>(A));
    case attr::MSP430Interrupt:
      return getDerived().TraverseMSP430InterruptAttr(cast<MSP430InterruptAttr>(A));
    case attr::MSStruct:
      return getDerived().TraverseMSStructAttr(cast<MSStructAttr>(A));
    case attr::MSVtorDisp:
      return getDerived().TraverseMSVtorDispAttr(cast<MSVtorDispAttr>(A));
    case attr::MaxFieldAlignment:
      return getDerived().TraverseMaxFieldAlignmentAttr(cast<MaxFieldAlignmentAttr>(A));
    case attr::MayAlias:
      return getDerived().TraverseMayAliasAttr(cast<MayAliasAttr>(A));
    case attr::MicroMips:
      return getDerived().TraverseMicroMipsAttr(cast<MicroMipsAttr>(A));
    case attr::MinSize:
      return getDerived().TraverseMinSizeAttr(cast<MinSizeAttr>(A));
    case attr::MinVectorWidth:
      return getDerived().TraverseMinVectorWidthAttr(cast<MinVectorWidthAttr>(A));
    case attr::Mips16:
      return getDerived().TraverseMips16Attr(cast<Mips16Attr>(A));
    case attr::MipsInterrupt:
      return getDerived().TraverseMipsInterruptAttr(cast<MipsInterruptAttr>(A));
    case attr::MipsLongCall:
      return getDerived().TraverseMipsLongCallAttr(cast<MipsLongCallAttr>(A));
    case attr::MipsShortCall:
      return getDerived().TraverseMipsShortCallAttr(cast<MipsShortCallAttr>(A));
    case attr::Mode:
      return getDerived().TraverseModeAttr(cast<ModeAttr>(A));
    case attr::MustTail:
      return getDerived().TraverseMustTailAttr(cast<MustTailAttr>(A));
    case attr::NSConsumed:
      return getDerived().TraverseNSConsumedAttr(cast<NSConsumedAttr>(A));
    case attr::NSConsumesSelf:
      return getDerived().TraverseNSConsumesSelfAttr(cast<NSConsumesSelfAttr>(A));
    case attr::NSErrorDomain:
      return getDerived().TraverseNSErrorDomainAttr(cast<NSErrorDomainAttr>(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::NoAlias:
      return getDerived().TraverseNoAliasAttr(cast<NoAliasAttr>(A));
    case attr::NoBuiltin:
      return getDerived().TraverseNoBuiltinAttr(cast<NoBuiltinAttr>(A));
    case attr::NoCommon:
      return getDerived().TraverseNoCommonAttr(cast<NoCommonAttr>(A));
    case attr::NoDebug:
      return getDerived().TraverseNoDebugAttr(cast<NoDebugAttr>(A));
    case attr::NoDeref:
      return getDerived().TraverseNoDerefAttr(cast<NoDerefAttr>(A));
    case attr::NoDestroy:
      return getDerived().TraverseNoDestroyAttr(cast<NoDestroyAttr>(A));
    case attr::NoDuplicate:
      return getDerived().TraverseNoDuplicateAttr(cast<NoDuplicateAttr>(A));
    case attr::NoEscape:
      return getDerived().TraverseNoEscapeAttr(cast<NoEscapeAttr>(A));
    case attr::NoInline:
      return getDerived().TraverseNoInlineAttr(cast<NoInlineAttr>(A));
    case attr::NoInstrumentFunction:
      return getDerived().TraverseNoInstrumentFunctionAttr(cast<NoInstrumentFunctionAttr>(A));
    case attr::NoMerge:
      return getDerived().TraverseNoMergeAttr(cast<NoMergeAttr>(A));
    case attr::NoMicroMips:
      return getDerived().TraverseNoMicroMipsAttr(cast<NoMicroMipsAttr>(A));
    case attr::NoMips16:
      return getDerived().TraverseNoMips16Attr(cast<NoMips16Attr>(A));
    case attr::NoProfileFunction:
      return getDerived().TraverseNoProfileFunctionAttr(cast<NoProfileFunctionAttr>(A));
    case attr::NoRandomizeLayout:
      return getDerived().TraverseNoRandomizeLayoutAttr(cast<NoRandomizeLayoutAttr>(A));
    case attr::NoReturn:
      return getDerived().TraverseNoReturnAttr(cast<NoReturnAttr>(A));
    case attr::NoSanitize:
      return getDerived().TraverseNoSanitizeAttr(cast<NoSanitizeAttr>(A));
    case attr::NoSpeculativeLoadHardening:
      return getDerived().TraverseNoSpeculativeLoadHardeningAttr(cast<NoSpeculativeLoadHardeningAttr>(A));
    case attr::NoSplitStack:
      return getDerived().TraverseNoSplitStackAttr(cast<NoSplitStackAttr>(A));
    case attr::NoStackProtector:
      return getDerived().TraverseNoStackProtectorAttr(cast<NoStackProtectorAttr>(A));
    case attr::NoThreadSafetyAnalysis:
      return getDerived().TraverseNoThreadSafetyAnalysisAttr(cast<NoThreadSafetyAnalysisAttr>(A));
    case attr::NoThrow:
      return getDerived().TraverseNoThrowAttr(cast<NoThrowAttr>(A));
    case attr::NoUniqueAddress:
      return getDerived().TraverseNoUniqueAddressAttr(cast<NoUniqueAddressAttr>(A));
    case attr::NonNull:
      return getDerived().TraverseNonNullAttr(cast<NonNullAttr>(A));
    case attr::NotTailCalled:
      return getDerived().TraverseNotTailCalledAttr(cast<NotTailCalledAttr>(A));
    case attr::OMPAllocateDecl:
      return getDerived().TraverseOMPAllocateDeclAttr(cast<OMPAllocateDeclAttr>(A));
    case attr::OMPCaptureKind:
      return getDerived().TraverseOMPCaptureKindAttr(cast<OMPCaptureKindAttr>(A));
    case attr::OMPCaptureNoInit:
      return getDerived().TraverseOMPCaptureNoInitAttr(cast<OMPCaptureNoInitAttr>(A));
    case attr::OMPDeclareSimdDecl:
      return getDerived().TraverseOMPDeclareSimdDeclAttr(cast<OMPDeclareSimdDeclAttr>(A));
    case attr::OMPDeclareTargetDecl:
      return getDerived().TraverseOMPDeclareTargetDeclAttr(cast<OMPDeclareTargetDeclAttr>(A));
    case attr::OMPDeclareVariant:
      return getDerived().TraverseOMPDeclareVariantAttr(cast<OMPDeclareVariantAttr>(A));
    case attr::OMPReferencedVar:
      return getDerived().TraverseOMPReferencedVarAttr(cast<OMPReferencedVarAttr>(A));
    case attr::OMPThreadPrivateDecl:
      return getDerived().TraverseOMPThreadPrivateDeclAttr(cast<OMPThreadPrivateDeclAttr>(A));
    case attr::OSConsumed:
      return getDerived().TraverseOSConsumedAttr(cast<OSConsumedAttr>(A));
    case attr::OSConsumesThis:
      return getDerived().TraverseOSConsumesThisAttr(cast<OSConsumesThisAttr>(A));
    case attr::OSReturnsNotRetained:
      return getDerived().TraverseOSReturnsNotRetainedAttr(cast<OSReturnsNotRetainedAttr>(A));
    case attr::OSReturnsRetained:
      return getDerived().TraverseOSReturnsRetainedAttr(cast<OSReturnsRetainedAttr>(A));
    case attr::OSReturnsRetainedOnNonZero:
      return getDerived().TraverseOSReturnsRetainedOnNonZeroAttr(cast<OSReturnsRetainedOnNonZeroAttr>(A));
    case attr::OSReturnsRetainedOnZero:
      return getDerived().TraverseOSReturnsRetainedOnZeroAttr(cast<OSReturnsRetainedOnZeroAttr>(A));
    case attr::ObjCBoxable:
      return getDerived().TraverseObjCBoxableAttr(cast<ObjCBoxableAttr>(A));
    case attr::ObjCBridge:
      return getDerived().TraverseObjCBridgeAttr(cast<ObjCBridgeAttr>(A));
    case attr::ObjCBridgeMutable:
      return getDerived().TraverseObjCBridgeMutableAttr(cast<ObjCBridgeMutableAttr>(A));
    case attr::ObjCBridgeRelated:
      return getDerived().TraverseObjCBridgeRelatedAttr(cast<ObjCBridgeRelatedAttr>(A));
    case attr::ObjCClassStub:
      return getDerived().TraverseObjCClassStubAttr(cast<ObjCClassStubAttr>(A));
    case attr::ObjCDesignatedInitializer:
      return getDerived().TraverseObjCDesignatedInitializerAttr(cast<ObjCDesignatedInitializerAttr>(A));
    case attr::ObjCDirect:
      return getDerived().TraverseObjCDirectAttr(cast<ObjCDirectAttr>(A));
    case attr::ObjCDirectMembers:
      return getDerived().TraverseObjCDirectMembersAttr(cast<ObjCDirectMembersAttr>(A));
    case attr::ObjCException:
      return getDerived().TraverseObjCExceptionAttr(cast<ObjCExceptionAttr>(A));
    case attr::ObjCExplicitProtocolImpl:
      return getDerived().TraverseObjCExplicitProtocolImplAttr(cast<ObjCExplicitProtocolImplAttr>(A));
    case attr::ObjCExternallyRetained:
      return getDerived().TraverseObjCExternallyRetainedAttr(cast<ObjCExternallyRetainedAttr>(A));
    case attr::ObjCGC:
      return getDerived().TraverseObjCGCAttr(cast<ObjCGCAttr>(A));
    case attr::ObjCIndependentClass:
      return getDerived().TraverseObjCIndependentClassAttr(cast<ObjCIndependentClassAttr>(A));
    case attr::ObjCInertUnsafeUnretained:
      return getDerived().TraverseObjCInertUnsafeUnretainedAttr(cast<ObjCInertUnsafeUnretainedAttr>(A));
    case attr::ObjCKindOf:
      return getDerived().TraverseObjCKindOfAttr(cast<ObjCKindOfAttr>(A));
    case attr::ObjCMethodFamily:
      return getDerived().TraverseObjCMethodFamilyAttr(cast<ObjCMethodFamilyAttr>(A));
    case attr::ObjCNSObject:
      return getDerived().TraverseObjCNSObjectAttr(cast<ObjCNSObjectAttr>(A));
    case attr::ObjCNonLazyClass:
      return getDerived().TraverseObjCNonLazyClassAttr(cast<ObjCNonLazyClassAttr>(A));
    case attr::ObjCNonRuntimeProtocol:
      return getDerived().TraverseObjCNonRuntimeProtocolAttr(cast<ObjCNonRuntimeProtocolAttr>(A));
    case attr::ObjCOwnership:
      return getDerived().TraverseObjCOwnershipAttr(cast<ObjCOwnershipAttr>(A));
    case attr::ObjCPreciseLifetime:
      return getDerived().TraverseObjCPreciseLifetimeAttr(cast<ObjCPreciseLifetimeAttr>(A));
    case attr::ObjCRequiresPropertyDefs:
      return getDerived().TraverseObjCRequiresPropertyDefsAttr(cast<ObjCRequiresPropertyDefsAttr>(A));
    case attr::ObjCRequiresSuper:
      return getDerived().TraverseObjCRequiresSuperAttr(cast<ObjCRequiresSuperAttr>(A));
    case attr::ObjCReturnsInnerPointer:
      return getDerived().TraverseObjCReturnsInnerPointerAttr(cast<ObjCReturnsInnerPointerAttr>(A));
    case attr::ObjCRootClass:
      return getDerived().TraverseObjCRootClassAttr(cast<ObjCRootClassAttr>(A));
    case attr::ObjCRuntimeName:
      return getDerived().TraverseObjCRuntimeNameAttr(cast<ObjCRuntimeNameAttr>(A));
    case attr::ObjCRuntimeVisible:
      return getDerived().TraverseObjCRuntimeVisibleAttr(cast<ObjCRuntimeVisibleAttr>(A));
    case attr::ObjCSubclassingRestricted:
      return getDerived().TraverseObjCSubclassingRestrictedAttr(cast<ObjCSubclassingRestrictedAttr>(A));
    case attr::OpenCLAccess:
      return getDerived().TraverseOpenCLAccessAttr(cast<OpenCLAccessAttr>(A));
    case attr::OpenCLConstantAddressSpace:
      return getDerived().TraverseOpenCLConstantAddressSpaceAttr(cast<OpenCLConstantAddressSpaceAttr>(A));
    case attr::OpenCLGenericAddressSpace:
      return getDerived().TraverseOpenCLGenericAddressSpaceAttr(cast<OpenCLGenericAddressSpaceAttr>(A));
    case attr::OpenCLGlobalAddressSpace:
      return getDerived().TraverseOpenCLGlobalAddressSpaceAttr(cast<OpenCLGlobalAddressSpaceAttr>(A));
    case attr::OpenCLGlobalDeviceAddressSpace:
      return getDerived().TraverseOpenCLGlobalDeviceAddressSpaceAttr(cast<OpenCLGlobalDeviceAddressSpaceAttr>(A));
    case attr::OpenCLGlobalHostAddressSpace:
      return getDerived().TraverseOpenCLGlobalHostAddressSpaceAttr(cast<OpenCLGlobalHostAddressSpaceAttr>(A));
    case attr::OpenCLIntelReqdSubGroupSize:
      return getDerived().TraverseOpenCLIntelReqdSubGroupSizeAttr(cast<OpenCLIntelReqdSubGroupSizeAttr>(A));
    case attr::OpenCLKernel:
      return getDerived().TraverseOpenCLKernelAttr(cast<OpenCLKernelAttr>(A));
    case attr::OpenCLLocalAddressSpace:
      return getDerived().TraverseOpenCLLocalAddressSpaceAttr(cast<OpenCLLocalAddressSpaceAttr>(A));
    case attr::OpenCLPrivateAddressSpace:
      return getDerived().TraverseOpenCLPrivateAddressSpaceAttr(cast<OpenCLPrivateAddressSpaceAttr>(A));
    case attr::OpenCLUnrollHint:
      return getDerived().TraverseOpenCLUnrollHintAttr(cast<OpenCLUnrollHintAttr>(A));
    case attr::OptimizeNone:
      return getDerived().TraverseOptimizeNoneAttr(cast<OptimizeNoneAttr>(A));
    case attr::Overloadable:
      return getDerived().TraverseOverloadableAttr(cast<OverloadableAttr>(A));
    case attr::Override:
      return getDerived().TraverseOverrideAttr(cast<OverrideAttr>(A));
    case attr::Owner:
      return getDerived().TraverseOwnerAttr(cast<OwnerAttr>(A));
    case attr::Ownership:
      return getDerived().TraverseOwnershipAttr(cast<OwnershipAttr>(A));
    case attr::Packed:
      return getDerived().TraversePackedAttr(cast<PackedAttr>(A));
    case attr::ParamTypestate:
      return getDerived().TraverseParamTypestateAttr(cast<ParamTypestateAttr>(A));
    case attr::Pascal:
      return getDerived().TraversePascalAttr(cast<PascalAttr>(A));
    case attr::PassObjectSize:
      return getDerived().TraversePassObjectSizeAttr(cast<PassObjectSizeAttr>(A));
    case attr::PatchableFunctionEntry:
      return getDerived().TraversePatchableFunctionEntryAttr(cast<PatchableFunctionEntryAttr>(A));
    case attr::Pcs:
      return getDerived().TraversePcsAttr(cast<PcsAttr>(A));
    case attr::Pointer:
      return getDerived().TraversePointerAttr(cast<PointerAttr>(A));
    case attr::PragmaClangBSSSection:
      return getDerived().TraversePragmaClangBSSSectionAttr(cast<PragmaClangBSSSectionAttr>(A));
    case attr::PragmaClangDataSection:
      return getDerived().TraversePragmaClangDataSectionAttr(cast<PragmaClangDataSectionAttr>(A));
    case attr::PragmaClangRelroSection:
      return getDerived().TraversePragmaClangRelroSectionAttr(cast<PragmaClangRelroSectionAttr>(A));
    case attr::PragmaClangRodataSection:
      return getDerived().TraversePragmaClangRodataSectionAttr(cast<PragmaClangRodataSectionAttr>(A));
    case attr::PragmaClangTextSection:
      return getDerived().TraversePragmaClangTextSectionAttr(cast<PragmaClangTextSectionAttr>(A));
    case attr::PreferredName:
      return getDerived().TraversePreferredNameAttr(cast<PreferredNameAttr>(A));
    case attr::PreserveAll:
      return getDerived().TraversePreserveAllAttr(cast<PreserveAllAttr>(A));
    case attr::PreserveMost:
      return getDerived().TraversePreserveMostAttr(cast<PreserveMostAttr>(A));
    case attr::PtGuardedBy:
      return getDerived().TraversePtGuardedByAttr(cast<PtGuardedByAttr>(A));
    case attr::PtGuardedVar:
      return getDerived().TraversePtGuardedVarAttr(cast<PtGuardedVarAttr>(A));
    case attr::Ptr32:
      return getDerived().TraversePtr32Attr(cast<Ptr32Attr>(A));
    case attr::Ptr64:
      return getDerived().TraversePtr64Attr(cast<Ptr64Attr>(A));
    case attr::Pure:
      return getDerived().TraversePureAttr(cast<PureAttr>(A));
    case attr::RISCVInterrupt:
      return getDerived().TraverseRISCVInterruptAttr(cast<RISCVInterruptAttr>(A));
    case attr::RandomizeLayout:
      return getDerived().TraverseRandomizeLayoutAttr(cast<RandomizeLayoutAttr>(A));
    case attr::RegCall:
      return getDerived().TraverseRegCallAttr(cast<RegCallAttr>(A));
    case attr::Reinitializes:
      return getDerived().TraverseReinitializesAttr(cast<ReinitializesAttr>(A));
    case attr::ReleaseCapability:
      return getDerived().TraverseReleaseCapabilityAttr(cast<ReleaseCapabilityAttr>(A));
    case attr::ReleaseHandle:
      return getDerived().TraverseReleaseHandleAttr(cast<ReleaseHandleAttr>(A));
    case attr::RenderScriptKernel:
      return getDerived().TraverseRenderScriptKernelAttr(cast<RenderScriptKernelAttr>(A));
    case attr::ReqdWorkGroupSize:
      return getDerived().TraverseReqdWorkGroupSizeAttr(cast<ReqdWorkGroupSizeAttr>(A));
    case attr::RequiresCapability:
      return getDerived().TraverseRequiresCapabilityAttr(cast<RequiresCapabilityAttr>(A));
    case attr::Restrict:
      return getDerived().TraverseRestrictAttr(cast<RestrictAttr>(A));
    case attr::Retain:
      return getDerived().TraverseRetainAttr(cast<RetainAttr>(A));
    case attr::ReturnTypestate:
      return getDerived().TraverseReturnTypestateAttr(cast<ReturnTypestateAttr>(A));
    case attr::ReturnsNonNull:
      return getDerived().TraverseReturnsNonNullAttr(cast<ReturnsNonNullAttr>(A));
    case attr::ReturnsTwice:
      return getDerived().TraverseReturnsTwiceAttr(cast<ReturnsTwiceAttr>(A));
    case attr::SPtr:
      return getDerived().TraverseSPtrAttr(cast<SPtrAttr>(A));
    case attr::SYCLKernel:
      return getDerived().TraverseSYCLKernelAttr(cast<SYCLKernelAttr>(A));
    case attr::SYCLSpecialClass:
      return getDerived().TraverseSYCLSpecialClassAttr(cast<SYCLSpecialClassAttr>(A));
    case attr::ScopedLockable:
      return getDerived().TraverseScopedLockableAttr(cast<ScopedLockableAttr>(A));
    case attr::Section:
      return getDerived().TraverseSectionAttr(cast<SectionAttr>(A));
    case attr::SelectAny:
      return getDerived().TraverseSelectAnyAttr(cast<SelectAnyAttr>(A));
    case attr::Sentinel:
      return getDerived().TraverseSentinelAttr(cast<SentinelAttr>(A));
    case attr::SetTypestate:
      return getDerived().TraverseSetTypestateAttr(cast<SetTypestateAttr>(A));
    case attr::SharedTrylockFunction:
      return getDerived().TraverseSharedTrylockFunctionAttr(cast<SharedTrylockFunctionAttr>(A));
    case attr::SpeculativeLoadHardening:
      return getDerived().TraverseSpeculativeLoadHardeningAttr(cast<SpeculativeLoadHardeningAttr>(A));
    case attr::StandaloneDebug:
      return getDerived().TraverseStandaloneDebugAttr(cast<StandaloneDebugAttr>(A));
    case attr::StdCall:
      return getDerived().TraverseStdCallAttr(cast<StdCallAttr>(A));
    case attr::StrictFP:
      return getDerived().TraverseStrictFPAttr(cast<StrictFPAttr>(A));
    case attr::Suppress:
      return getDerived().TraverseSuppressAttr(cast<SuppressAttr>(A));
    case attr::SwiftAsync:
      return getDerived().TraverseSwiftAsyncAttr(cast<SwiftAsyncAttr>(A));
    case attr::SwiftAsyncCall:
      return getDerived().TraverseSwiftAsyncCallAttr(cast<SwiftAsyncCallAttr>(A));
    case attr::SwiftAsyncContext:
      return getDerived().TraverseSwiftAsyncContextAttr(cast<SwiftAsyncContextAttr>(A));
    case attr::SwiftAsyncError:
      return getDerived().TraverseSwiftAsyncErrorAttr(cast<SwiftAsyncErrorAttr>(A));
    case attr::SwiftAsyncName:
      return getDerived().TraverseSwiftAsyncNameAttr(cast<SwiftAsyncNameAttr>(A));
    case attr::SwiftAttr:
      return getDerived().TraverseSwiftAttrAttr(cast<SwiftAttrAttr>(A));
    case attr::SwiftBridge:
      return getDerived().TraverseSwiftBridgeAttr(cast<SwiftBridgeAttr>(A));
    case attr::SwiftBridgedTypedef:
      return getDerived().TraverseSwiftBridgedTypedefAttr(cast<SwiftBridgedTypedefAttr>(A));
    case attr::SwiftCall:
      return getDerived().TraverseSwiftCallAttr(cast<SwiftCallAttr>(A));
    case attr::SwiftContext:
      return getDerived().TraverseSwiftContextAttr(cast<SwiftContextAttr>(A));
    case attr::SwiftError:
      return getDerived().TraverseSwiftErrorAttr(cast<SwiftErrorAttr>(A));
    case attr::SwiftErrorResult:
      return getDerived().TraverseSwiftErrorResultAttr(cast<SwiftErrorResultAttr>(A));
    case attr::SwiftIndirectResult:
      return getDerived().TraverseSwiftIndirectResultAttr(cast<SwiftIndirectResultAttr>(A));
    case attr::SwiftName:
      return getDerived().TraverseSwiftNameAttr(cast<SwiftNameAttr>(A));
    case attr::SwiftNewType:
      return getDerived().TraverseSwiftNewTypeAttr(cast<SwiftNewTypeAttr>(A));
    case attr::SwiftObjCMembers:
      return getDerived().TraverseSwiftObjCMembersAttr(cast<SwiftObjCMembersAttr>(A));
    case attr::SwiftPrivate:
      return getDerived().TraverseSwiftPrivateAttr(cast<SwiftPrivateAttr>(A));
    case attr::SysVABI:
      return getDerived().TraverseSysVABIAttr(cast<SysVABIAttr>(A));
    case attr::TLSModel:
      return getDerived().TraverseTLSModelAttr(cast<TLSModelAttr>(A));
    case attr::Target:
      return getDerived().TraverseTargetAttr(cast<TargetAttr>(A));
    case attr::TargetClones:
      return getDerived().TraverseTargetClonesAttr(cast<TargetClonesAttr>(A));
    case attr::TestTypestate:
      return getDerived().TraverseTestTypestateAttr(cast<TestTypestateAttr>(A));
    case attr::ThisCall:
      return getDerived().TraverseThisCallAttr(cast<ThisCallAttr>(A));
    case attr::Thread:
      return getDerived().TraverseThreadAttr(cast<ThreadAttr>(A));
    case attr::TransparentUnion:
      return getDerived().TraverseTransparentUnionAttr(cast<TransparentUnionAttr>(A));
    case attr::TrivialABI:
      return getDerived().TraverseTrivialABIAttr(cast<TrivialABIAttr>(A));
    case attr::TryAcquireCapability:
      return getDerived().TraverseTryAcquireCapabilityAttr(cast<TryAcquireCapabilityAttr>(A));
    case attr::TypeNonNull:
      return getDerived().TraverseTypeNonNullAttr(cast<TypeNonNullAttr>(A));
    case attr::TypeNullUnspecified:
      return getDerived().TraverseTypeNullUnspecifiedAttr(cast<TypeNullUnspecifiedAttr>(A));
    case attr::TypeNullable:
      return getDerived().TraverseTypeNullableAttr(cast<TypeNullableAttr>(A));
    case attr::TypeNullableResult:
      return getDerived().TraverseTypeNullableResultAttr(cast<TypeNullableResultAttr>(A));
    case attr::TypeTagForDatatype:
      return getDerived().TraverseTypeTagForDatatypeAttr(cast<TypeTagForDatatypeAttr>(A));
    case attr::TypeVisibility:
      return getDerived().TraverseTypeVisibilityAttr(cast<TypeVisibilityAttr>(A));
    case attr::UPtr:
      return getDerived().TraverseUPtrAttr(cast<UPtrAttr>(A));
    case attr::Unavailable:
      return getDerived().TraverseUnavailableAttr(cast<UnavailableAttr>(A));
    case attr::Uninitialized:
      return getDerived().TraverseUninitializedAttr(cast<UninitializedAttr>(A));
    case attr::Unlikely:
      return getDerived().TraverseUnlikelyAttr(cast<UnlikelyAttr>(A));
    case attr::Unused:
      return getDerived().TraverseUnusedAttr(cast<UnusedAttr>(A));
    case attr::UseHandle:
      return getDerived().TraverseUseHandleAttr(cast<UseHandleAttr>(A));
    case attr::Used:
      return getDerived().TraverseUsedAttr(cast<UsedAttr>(A));
    case attr::UsingIfExists:
      return getDerived().TraverseUsingIfExistsAttr(cast<UsingIfExistsAttr>(A));
    case attr::Uuid:
      return getDerived().TraverseUuidAttr(cast<UuidAttr>(A));
    case attr::VecReturn:
      return getDerived().TraverseVecReturnAttr(cast<VecReturnAttr>(A));
    case attr::VecTypeHint:
      return getDerived().TraverseVecTypeHintAttr(cast<VecTypeHintAttr>(A));
    case attr::VectorCall:
      return getDerived().TraverseVectorCallAttr(cast<VectorCallAttr>(A));
    case attr::Visibility:
      return getDerived().TraverseVisibilityAttr(cast<VisibilityAttr>(A));
    case attr::WarnUnused:
      return getDerived().TraverseWarnUnusedAttr(cast<WarnUnusedAttr>(A));
    case attr::WarnUnusedResult:
      return getDerived().TraverseWarnUnusedResultAttr(cast<WarnUnusedResultAttr>(A));
    case attr::Weak:
      return getDerived().TraverseWeakAttr(cast<WeakAttr>(A));
    case attr::WeakImport:
      return getDerived().TraverseWeakImportAttr(cast<WeakImportAttr>(A));
    case attr::WeakRef:
      return getDerived().TraverseWeakRefAttr(cast<WeakRefAttr>(A));
    case attr::WebAssemblyExportName:
      return getDerived().TraverseWebAssemblyExportNameAttr(cast<WebAssemblyExportNameAttr>(A));
    case attr::WebAssemblyImportModule:
      return getDerived().TraverseWebAssemblyImportModuleAttr(cast<WebAssemblyImportModuleAttr>(A));
    case attr::WebAssemblyImportName:
      return getDerived().TraverseWebAssemblyImportNameAttr(cast<WebAssemblyImportNameAttr>(A));
    case attr::WorkGroupSizeHint:
      return getDerived().TraverseWorkGroupSizeHintAttr(cast<WorkGroupSizeHintAttr>(A));
    case attr::X86ForceAlignArgPointer:
      return getDerived().TraverseX86ForceAlignArgPointerAttr(cast<X86ForceAlignArgPointerAttr>(A));
    case attr::XRayInstrument:
      return getDerived().TraverseXRayInstrumentAttr(cast<XRayInstrumentAttr>(A));
    case attr::XRayLogArgs:
      return getDerived().TraverseXRayLogArgsAttr(cast<XRayLogArgsAttr>(A));
    case attr::ZeroCallUsedRegs:
      return getDerived().TraverseZeroCallUsedRegsAttr(cast<ZeroCallUsedRegsAttr>(A));
  }
  llvm_unreachable("bad attribute kind");
}
#endif  // ATTR_VISITOR_DECLS_ONLY
