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

#ifdef ATTR_VISITOR_DECLS_ONLY

  bool TraverseAMDGPUFlatWorkGroupSizeAttr(AMDGPUFlatWorkGroupSizeAttr *A);
  bool VisitAMDGPUFlatWorkGroupSizeAttr(AMDGPUFlatWorkGroupSizeAttr *A) {
    return true; 
  }
  bool TraverseAMDGPUNumSGPRAttr(AMDGPUNumSGPRAttr *A);
  bool VisitAMDGPUNumSGPRAttr(AMDGPUNumSGPRAttr *A) {
    return true; 
  }
  bool TraverseAMDGPUNumVGPRAttr(AMDGPUNumVGPRAttr *A);
  bool VisitAMDGPUNumVGPRAttr(AMDGPUNumVGPRAttr *A) {
    return true; 
  }
  bool TraverseAMDGPUWavesPerEUAttr(AMDGPUWavesPerEUAttr *A);
  bool VisitAMDGPUWavesPerEUAttr(AMDGPUWavesPerEUAttr *A) {
    return true; 
  }
  bool TraverseARMInterruptAttr(ARMInterruptAttr *A);
  bool VisitARMInterruptAttr(ARMInterruptAttr *A) {
    return true; 
  }
  bool TraverseAVRInterruptAttr(AVRInterruptAttr *A);
  bool VisitAVRInterruptAttr(AVRInterruptAttr *A) {
    return true; 
  }
  bool TraverseAVRSignalAttr(AVRSignalAttr *A);
  bool VisitAVRSignalAttr(AVRSignalAttr *A) {
    return true; 
  }
  bool TraverseAbiTagAttr(AbiTagAttr *A);
  bool VisitAbiTagAttr(AbiTagAttr *A) {
    return true; 
  }
  bool TraverseAcquireCapabilityAttr(AcquireCapabilityAttr *A);
  bool VisitAcquireCapabilityAttr(AcquireCapabilityAttr *A) {
    return true; 
  }
  bool TraverseAcquiredAfterAttr(AcquiredAfterAttr *A);
  bool VisitAcquiredAfterAttr(AcquiredAfterAttr *A) {
    return true; 
  }
  bool TraverseAcquiredBeforeAttr(AcquiredBeforeAttr *A);
  bool VisitAcquiredBeforeAttr(AcquiredBeforeAttr *A) {
    return true; 
  }
  bool TraverseAliasAttr(AliasAttr *A);
  bool VisitAliasAttr(AliasAttr *A) {
    return true; 
  }
  bool TraverseAlignMac68kAttr(AlignMac68kAttr *A);
  bool VisitAlignMac68kAttr(AlignMac68kAttr *A) {
    return true; 
  }
  bool TraverseAlignValueAttr(AlignValueAttr *A);
  bool VisitAlignValueAttr(AlignValueAttr *A) {
    return true; 
  }
  bool TraverseAlignedAttr(AlignedAttr *A);
  bool VisitAlignedAttr(AlignedAttr *A) {
    return true; 
  }
  bool TraverseAllocAlignAttr(AllocAlignAttr *A);
  bool VisitAllocAlignAttr(AllocAlignAttr *A) {
    return true; 
  }
  bool TraverseAllocSizeAttr(AllocSizeAttr *A);
  bool VisitAllocSizeAttr(AllocSizeAttr *A) {
    return true; 
  }
  bool TraverseAlwaysInlineAttr(AlwaysInlineAttr *A);
  bool VisitAlwaysInlineAttr(AlwaysInlineAttr *A) {
    return true; 
  }
  bool TraverseAnalyzerNoReturnAttr(AnalyzerNoReturnAttr *A);
  bool VisitAnalyzerNoReturnAttr(AnalyzerNoReturnAttr *A) {
    return true; 
  }
  bool TraverseAnnotateAttr(AnnotateAttr *A);
  bool VisitAnnotateAttr(AnnotateAttr *A) {
    return true; 
  }
  bool TraverseAnyX86InterruptAttr(AnyX86InterruptAttr *A);
  bool VisitAnyX86InterruptAttr(AnyX86InterruptAttr *A) {
    return true; 
  }
  bool TraverseAnyX86NoCallerSavedRegistersAttr(AnyX86NoCallerSavedRegistersAttr *A);
  bool VisitAnyX86NoCallerSavedRegistersAttr(AnyX86NoCallerSavedRegistersAttr *A) {
    return true; 
  }
  bool TraverseArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A);
  bool VisitArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A) {
    return true; 
  }
  bool TraverseArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *A);
  bool VisitArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *A) {
    return true; 
  }
  bool TraverseAsmLabelAttr(AsmLabelAttr *A);
  bool VisitAsmLabelAttr(AsmLabelAttr *A) {
    return true; 
  }
  bool TraverseAssertCapabilityAttr(AssertCapabilityAttr *A);
  bool VisitAssertCapabilityAttr(AssertCapabilityAttr *A) {
    return true; 
  }
  bool TraverseAssertExclusiveLockAttr(AssertExclusiveLockAttr *A);
  bool VisitAssertExclusiveLockAttr(AssertExclusiveLockAttr *A) {
    return true; 
  }
  bool TraverseAssertSharedLockAttr(AssertSharedLockAttr *A);
  bool VisitAssertSharedLockAttr(AssertSharedLockAttr *A) {
    return true; 
  }
  bool TraverseAssumeAlignedAttr(AssumeAlignedAttr *A);
  bool VisitAssumeAlignedAttr(AssumeAlignedAttr *A) {
    return true; 
  }
  bool TraverseAvailabilityAttr(AvailabilityAttr *A);
  bool VisitAvailabilityAttr(AvailabilityAttr *A) {
    return true; 
  }
  bool TraverseBlocksAttr(BlocksAttr *A);
  bool VisitBlocksAttr(BlocksAttr *A) {
    return true; 
  }
  bool TraverseC11NoReturnAttr(C11NoReturnAttr *A);
  bool VisitC11NoReturnAttr(C11NoReturnAttr *A) {
    return true; 
  }
  bool TraverseCDeclAttr(CDeclAttr *A);
  bool VisitCDeclAttr(CDeclAttr *A) {
    return true; 
  }
  bool TraverseCFAuditedTransferAttr(CFAuditedTransferAttr *A);
  bool VisitCFAuditedTransferAttr(CFAuditedTransferAttr *A) {
    return true; 
  }
  bool TraverseCFConsumedAttr(CFConsumedAttr *A);
  bool VisitCFConsumedAttr(CFConsumedAttr *A) {
    return true; 
  }
  bool TraverseCFReturnsNotRetainedAttr(CFReturnsNotRetainedAttr *A);
  bool VisitCFReturnsNotRetainedAttr(CFReturnsNotRetainedAttr *A) {
    return true; 
  }
  bool TraverseCFReturnsRetainedAttr(CFReturnsRetainedAttr *A);
  bool VisitCFReturnsRetainedAttr(CFReturnsRetainedAttr *A) {
    return true; 
  }
  bool TraverseCFUnknownTransferAttr(CFUnknownTransferAttr *A);
  bool VisitCFUnknownTransferAttr(CFUnknownTransferAttr *A) {
    return true; 
  }
  bool TraverseCUDAConstantAttr(CUDAConstantAttr *A);
  bool VisitCUDAConstantAttr(CUDAConstantAttr *A) {
    return true; 
  }
  bool TraverseCUDADeviceAttr(CUDADeviceAttr *A);
  bool VisitCUDADeviceAttr(CUDADeviceAttr *A) {
    return true; 
  }
  bool TraverseCUDAGlobalAttr(CUDAGlobalAttr *A);
  bool VisitCUDAGlobalAttr(CUDAGlobalAttr *A) {
    return true; 
  }
  bool TraverseCUDAHostAttr(CUDAHostAttr *A);
  bool VisitCUDAHostAttr(CUDAHostAttr *A) {
    return true; 
  }
  bool TraverseCUDAInvalidTargetAttr(CUDAInvalidTargetAttr *A);
  bool VisitCUDAInvalidTargetAttr(CUDAInvalidTargetAttr *A) {
    return true; 
  }
  bool TraverseCUDALaunchBoundsAttr(CUDALaunchBoundsAttr *A);
  bool VisitCUDALaunchBoundsAttr(CUDALaunchBoundsAttr *A) {
    return true; 
  }
  bool TraverseCUDASharedAttr(CUDASharedAttr *A);
  bool VisitCUDASharedAttr(CUDASharedAttr *A) {
    return true; 
  }
  bool TraverseCXX11NoReturnAttr(CXX11NoReturnAttr *A);
  bool VisitCXX11NoReturnAttr(CXX11NoReturnAttr *A) {
    return true; 
  }
  bool TraverseCallableWhenAttr(CallableWhenAttr *A);
  bool VisitCallableWhenAttr(CallableWhenAttr *A) {
    return true; 
  }
  bool 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 TraverseColdAttr(ColdAttr *A);
  bool VisitColdAttr(ColdAttr *A) {
    return true; 
  }
  bool TraverseCommonAttr(CommonAttr *A);
  bool VisitCommonAttr(CommonAttr *A) {
    return true; 
  }
  bool TraverseConstAttr(ConstAttr *A);
  bool VisitConstAttr(ConstAttr *A) {
    return true; 
  }
  bool TraverseConstructorAttr(ConstructorAttr *A);
  bool VisitConstructorAttr(ConstructorAttr *A) {
    return true; 
  }
  bool TraverseConsumableAttr(ConsumableAttr *A);
  bool VisitConsumableAttr(ConsumableAttr *A) {
    return true; 
  }
  bool TraverseConsumableAutoCastAttr(ConsumableAutoCastAttr *A);
  bool VisitConsumableAutoCastAttr(ConsumableAutoCastAttr *A) {
    return true; 
  }
  bool TraverseConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A);
  bool VisitConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A) {
    return true; 
  }
  bool TraverseConvergentAttr(ConvergentAttr *A);
  bool VisitConvergentAttr(ConvergentAttr *A) {
    return true; 
  }
  bool TraverseDLLExportAttr(DLLExportAttr *A);
  bool VisitDLLExportAttr(DLLExportAttr *A) {
    return true; 
  }
  bool TraverseDLLImportAttr(DLLImportAttr *A);
  bool VisitDLLImportAttr(DLLImportAttr *A) {
    return true; 
  }
  bool TraverseDeprecatedAttr(DeprecatedAttr *A);
  bool VisitDeprecatedAttr(DeprecatedAttr *A) {
    return true; 
  }
  bool TraverseDestructorAttr(DestructorAttr *A);
  bool VisitDestructorAttr(DestructorAttr *A) {
    return true; 
  }
  bool TraverseDiagnoseIfAttr(DiagnoseIfAttr *A);
  bool VisitDiagnoseIfAttr(DiagnoseIfAttr *A) {
    return true; 
  }
  bool TraverseDisableTailCallsAttr(DisableTailCallsAttr *A);
  bool VisitDisableTailCallsAttr(DisableTailCallsAttr *A) {
    return true; 
  }
  bool TraverseEmptyBasesAttr(EmptyBasesAttr *A);
  bool VisitEmptyBasesAttr(EmptyBasesAttr *A) {
    return true; 
  }
  bool TraverseEnableIfAttr(EnableIfAttr *A);
  bool VisitEnableIfAttr(EnableIfAttr *A) {
    return true; 
  }
  bool TraverseEnumExtensibilityAttr(EnumExtensibilityAttr *A);
  bool VisitEnumExtensibilityAttr(EnumExtensibilityAttr *A) {
    return true; 
  }
  bool 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 TraverseGNUInlineAttr(GNUInlineAttr *A);
  bool VisitGNUInlineAttr(GNUInlineAttr *A) {
    return true; 
  }
  bool TraverseGuardedByAttr(GuardedByAttr *A);
  bool VisitGuardedByAttr(GuardedByAttr *A) {
    return true; 
  }
  bool TraverseGuardedVarAttr(GuardedVarAttr *A);
  bool VisitGuardedVarAttr(GuardedVarAttr *A) {
    return true; 
  }
  bool TraverseHotAttr(HotAttr *A);
  bool VisitHotAttr(HotAttr *A) {
    return true; 
  }
  bool TraverseIBActionAttr(IBActionAttr *A);
  bool VisitIBActionAttr(IBActionAttr *A) {
    return true; 
  }
  bool TraverseIBOutletAttr(IBOutletAttr *A);
  bool VisitIBOutletAttr(IBOutletAttr *A) {
    return true; 
  }
  bool TraverseIBOutletCollectionAttr(IBOutletCollectionAttr *A);
  bool VisitIBOutletCollectionAttr(IBOutletCollectionAttr *A) {
    return true; 
  }
  bool TraverseIFuncAttr(IFuncAttr *A);
  bool VisitIFuncAttr(IFuncAttr *A) {
    return true; 
  }
  bool TraverseInitPriorityAttr(InitPriorityAttr *A);
  bool VisitInitPriorityAttr(InitPriorityAttr *A) {
    return true; 
  }
  bool TraverseInitSegAttr(InitSegAttr *A);
  bool VisitInitSegAttr(InitSegAttr *A) {
    return true; 
  }
  bool TraverseIntelOclBiccAttr(IntelOclBiccAttr *A);
  bool VisitIntelOclBiccAttr(IntelOclBiccAttr *A) {
    return true; 
  }
  bool TraverseInternalLinkageAttr(InternalLinkageAttr *A);
  bool VisitInternalLinkageAttr(InternalLinkageAttr *A) {
    return true; 
  }
  bool TraverseLTOVisibilityPublicAttr(LTOVisibilityPublicAttr *A);
  bool VisitLTOVisibilityPublicAttr(LTOVisibilityPublicAttr *A) {
    return true; 
  }
  bool TraverseLayoutVersionAttr(LayoutVersionAttr *A);
  bool VisitLayoutVersionAttr(LayoutVersionAttr *A) {
    return true; 
  }
  bool TraverseLockReturnedAttr(LockReturnedAttr *A);
  bool VisitLockReturnedAttr(LockReturnedAttr *A) {
    return true; 
  }
  bool TraverseLocksExcludedAttr(LocksExcludedAttr *A);
  bool VisitLocksExcludedAttr(LocksExcludedAttr *A) {
    return true; 
  }
  bool TraverseLoopHintAttr(LoopHintAttr *A);
  bool VisitLoopHintAttr(LoopHintAttr *A) {
    return true; 
  }
  bool TraverseMSABIAttr(MSABIAttr *A);
  bool VisitMSABIAttr(MSABIAttr *A) {
    return true; 
  }
  bool TraverseMSInheritanceAttr(MSInheritanceAttr *A);
  bool VisitMSInheritanceAttr(MSInheritanceAttr *A) {
    return true; 
  }
  bool TraverseMSNoVTableAttr(MSNoVTableAttr *A);
  bool VisitMSNoVTableAttr(MSNoVTableAttr *A) {
    return true; 
  }
  bool TraverseMSP430InterruptAttr(MSP430InterruptAttr *A);
  bool VisitMSP430InterruptAttr(MSP430InterruptAttr *A) {
    return true; 
  }
  bool TraverseMSStructAttr(MSStructAttr *A);
  bool VisitMSStructAttr(MSStructAttr *A) {
    return true; 
  }
  bool TraverseMSVtorDispAttr(MSVtorDispAttr *A);
  bool VisitMSVtorDispAttr(MSVtorDispAttr *A) {
    return true; 
  }
  bool TraverseMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A);
  bool VisitMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A) {
    return true; 
  }
  bool TraverseMayAliasAttr(MayAliasAttr *A);
  bool VisitMayAliasAttr(MayAliasAttr *A) {
    return true; 
  }
  bool TraverseMicroMipsAttr(MicroMipsAttr *A);
  bool VisitMicroMipsAttr(MicroMipsAttr *A) {
    return true; 
  }
  bool TraverseMinSizeAttr(MinSizeAttr *A);
  bool VisitMinSizeAttr(MinSizeAttr *A) {
    return true; 
  }
  bool TraverseMips16Attr(Mips16Attr *A);
  bool VisitMips16Attr(Mips16Attr *A) {
    return true; 
  }
  bool TraverseMipsInterruptAttr(MipsInterruptAttr *A);
  bool VisitMipsInterruptAttr(MipsInterruptAttr *A) {
    return true; 
  }
  bool TraverseModeAttr(ModeAttr *A);
  bool VisitModeAttr(ModeAttr *A) {
    return true; 
  }
  bool TraverseNSConsumedAttr(NSConsumedAttr *A);
  bool VisitNSConsumedAttr(NSConsumedAttr *A) {
    return true; 
  }
  bool TraverseNSConsumesSelfAttr(NSConsumesSelfAttr *A);
  bool VisitNSConsumesSelfAttr(NSConsumesSelfAttr *A) {
    return true; 
  }
  bool TraverseNSReturnsAutoreleasedAttr(NSReturnsAutoreleasedAttr *A);
  bool VisitNSReturnsAutoreleasedAttr(NSReturnsAutoreleasedAttr *A) {
    return true; 
  }
  bool TraverseNSReturnsNotRetainedAttr(NSReturnsNotRetainedAttr *A);
  bool VisitNSReturnsNotRetainedAttr(NSReturnsNotRetainedAttr *A) {
    return true; 
  }
  bool TraverseNSReturnsRetainedAttr(NSReturnsRetainedAttr *A);
  bool VisitNSReturnsRetainedAttr(NSReturnsRetainedAttr *A) {
    return true; 
  }
  bool TraverseNakedAttr(NakedAttr *A);
  bool VisitNakedAttr(NakedAttr *A) {
    return true; 
  }
  bool TraverseNoAliasAttr(NoAliasAttr *A);
  bool VisitNoAliasAttr(NoAliasAttr *A) {
    return true; 
  }
  bool TraverseNoCommonAttr(NoCommonAttr *A);
  bool VisitNoCommonAttr(NoCommonAttr *A) {
    return true; 
  }
  bool TraverseNoDebugAttr(NoDebugAttr *A);
  bool VisitNoDebugAttr(NoDebugAttr *A) {
    return true; 
  }
  bool TraverseNoDuplicateAttr(NoDuplicateAttr *A);
  bool VisitNoDuplicateAttr(NoDuplicateAttr *A) {
    return true; 
  }
  bool TraverseNoInlineAttr(NoInlineAttr *A);
  bool VisitNoInlineAttr(NoInlineAttr *A) {
    return true; 
  }
  bool TraverseNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A);
  bool VisitNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A) {
    return true; 
  }
  bool TraverseNoMicroMipsAttr(NoMicroMipsAttr *A);
  bool VisitNoMicroMipsAttr(NoMicroMipsAttr *A) {
    return true; 
  }
  bool TraverseNoMips16Attr(NoMips16Attr *A);
  bool VisitNoMips16Attr(NoMips16Attr *A) {
    return true; 
  }
  bool TraverseNoReturnAttr(NoReturnAttr *A);
  bool VisitNoReturnAttr(NoReturnAttr *A) {
    return true; 
  }
  bool TraverseNoSanitizeAttr(NoSanitizeAttr *A);
  bool VisitNoSanitizeAttr(NoSanitizeAttr *A) {
    return true; 
  }
  bool TraverseNoSplitStackAttr(NoSplitStackAttr *A);
  bool VisitNoSplitStackAttr(NoSplitStackAttr *A) {
    return true; 
  }
  bool TraverseNoThreadSafetyAnalysisAttr(NoThreadSafetyAnalysisAttr *A);
  bool VisitNoThreadSafetyAnalysisAttr(NoThreadSafetyAnalysisAttr *A) {
    return true; 
  }
  bool TraverseNoThrowAttr(NoThrowAttr *A);
  bool VisitNoThrowAttr(NoThrowAttr *A) {
    return true; 
  }
  bool TraverseNonNullAttr(NonNullAttr *A);
  bool VisitNonNullAttr(NonNullAttr *A) {
    return true; 
  }
  bool TraverseNotTailCalledAttr(NotTailCalledAttr *A);
  bool VisitNotTailCalledAttr(NotTailCalledAttr *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 TraverseOMPThreadPrivateDeclAttr(OMPThreadPrivateDeclAttr *A);
  bool VisitOMPThreadPrivateDeclAttr(OMPThreadPrivateDeclAttr *A) {
    return true; 
  }
  bool TraverseObjCBoxableAttr(ObjCBoxableAttr *A);
  bool VisitObjCBoxableAttr(ObjCBoxableAttr *A) {
    return true; 
  }
  bool TraverseObjCBridgeAttr(ObjCBridgeAttr *A);
  bool VisitObjCBridgeAttr(ObjCBridgeAttr *A) {
    return true; 
  }
  bool TraverseObjCBridgeMutableAttr(ObjCBridgeMutableAttr *A);
  bool VisitObjCBridgeMutableAttr(ObjCBridgeMutableAttr *A) {
    return true; 
  }
  bool TraverseObjCBridgeRelatedAttr(ObjCBridgeRelatedAttr *A);
  bool VisitObjCBridgeRelatedAttr(ObjCBridgeRelatedAttr *A) {
    return true; 
  }
  bool TraverseObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A);
  bool VisitObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A) {
    return true; 
  }
  bool TraverseObjCExceptionAttr(ObjCExceptionAttr *A);
  bool VisitObjCExceptionAttr(ObjCExceptionAttr *A) {
    return true; 
  }
  bool TraverseObjCExplicitProtocolImplAttr(ObjCExplicitProtocolImplAttr *A);
  bool VisitObjCExplicitProtocolImplAttr(ObjCExplicitProtocolImplAttr *A) {
    return true; 
  }
  bool TraverseObjCIndependentClassAttr(ObjCIndependentClassAttr *A);
  bool VisitObjCIndependentClassAttr(ObjCIndependentClassAttr *A) {
    return true; 
  }
  bool TraverseObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A);
  bool VisitObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A) {
    return true; 
  }
  bool TraverseObjCNSObjectAttr(ObjCNSObjectAttr *A);
  bool VisitObjCNSObjectAttr(ObjCNSObjectAttr *A) {
    return true; 
  }
  bool TraverseObjCPreciseLifetimeAttr(ObjCPreciseLifetimeAttr *A);
  bool VisitObjCPreciseLifetimeAttr(ObjCPreciseLifetimeAttr *A) {
    return true; 
  }
  bool TraverseObjCRequiresPropertyDefsAttr(ObjCRequiresPropertyDefsAttr *A);
  bool VisitObjCRequiresPropertyDefsAttr(ObjCRequiresPropertyDefsAttr *A) {
    return true; 
  }
  bool TraverseObjCRequiresSuperAttr(ObjCRequiresSuperAttr *A);
  bool VisitObjCRequiresSuperAttr(ObjCRequiresSuperAttr *A) {
    return true; 
  }
  bool TraverseObjCReturnsInnerPointerAttr(ObjCReturnsInnerPointerAttr *A);
  bool VisitObjCReturnsInnerPointerAttr(ObjCReturnsInnerPointerAttr *A) {
    return true; 
  }
  bool TraverseObjCRootClassAttr(ObjCRootClassAttr *A);
  bool VisitObjCRootClassAttr(ObjCRootClassAttr *A) {
    return true; 
  }
  bool TraverseObjCRuntimeNameAttr(ObjCRuntimeNameAttr *A);
  bool VisitObjCRuntimeNameAttr(ObjCRuntimeNameAttr *A) {
    return true; 
  }
  bool 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 TraverseOpenCLIntelReqdSubGroupSizeAttr(OpenCLIntelReqdSubGroupSizeAttr *A);
  bool VisitOpenCLIntelReqdSubGroupSizeAttr(OpenCLIntelReqdSubGroupSizeAttr *A) {
    return true; 
  }
  bool TraverseOpenCLKernelAttr(OpenCLKernelAttr *A);
  bool VisitOpenCLKernelAttr(OpenCLKernelAttr *A) {
    return true; 
  }
  bool TraverseOpenCLUnrollHintAttr(OpenCLUnrollHintAttr *A);
  bool VisitOpenCLUnrollHintAttr(OpenCLUnrollHintAttr *A) {
    return true; 
  }
  bool TraverseOptimizeNoneAttr(OptimizeNoneAttr *A);
  bool VisitOptimizeNoneAttr(OptimizeNoneAttr *A) {
    return true; 
  }
  bool TraverseOverloadableAttr(OverloadableAttr *A);
  bool VisitOverloadableAttr(OverloadableAttr *A) {
    return true; 
  }
  bool TraverseOverrideAttr(OverrideAttr *A);
  bool VisitOverrideAttr(OverrideAttr *A) {
    return true; 
  }
  bool TraverseOwnershipAttr(OwnershipAttr *A);
  bool VisitOwnershipAttr(OwnershipAttr *A) {
    return true; 
  }
  bool TraversePackedAttr(PackedAttr *A);
  bool VisitPackedAttr(PackedAttr *A) {
    return true; 
  }
  bool TraverseParamTypestateAttr(ParamTypestateAttr *A);
  bool VisitParamTypestateAttr(ParamTypestateAttr *A) {
    return true; 
  }
  bool TraversePascalAttr(PascalAttr *A);
  bool VisitPascalAttr(PascalAttr *A) {
    return true; 
  }
  bool TraversePassObjectSizeAttr(PassObjectSizeAttr *A);
  bool VisitPassObjectSizeAttr(PassObjectSizeAttr *A) {
    return true; 
  }
  bool TraversePcsAttr(PcsAttr *A);
  bool VisitPcsAttr(PcsAttr *A) {
    return true; 
  }
  bool TraversePragmaClangBSSSectionAttr(PragmaClangBSSSectionAttr *A);
  bool VisitPragmaClangBSSSectionAttr(PragmaClangBSSSectionAttr *A) {
    return true; 
  }
  bool TraversePragmaClangDataSectionAttr(PragmaClangDataSectionAttr *A);
  bool VisitPragmaClangDataSectionAttr(PragmaClangDataSectionAttr *A) {
    return true; 
  }
  bool TraversePragmaClangRodataSectionAttr(PragmaClangRodataSectionAttr *A);
  bool VisitPragmaClangRodataSectionAttr(PragmaClangRodataSectionAttr *A) {
    return true; 
  }
  bool TraversePragmaClangTextSectionAttr(PragmaClangTextSectionAttr *A);
  bool VisitPragmaClangTextSectionAttr(PragmaClangTextSectionAttr *A) {
    return true; 
  }
  bool TraversePreserveAllAttr(PreserveAllAttr *A);
  bool VisitPreserveAllAttr(PreserveAllAttr *A) {
    return true; 
  }
  bool TraversePreserveMostAttr(PreserveMostAttr *A);
  bool VisitPreserveMostAttr(PreserveMostAttr *A) {
    return true; 
  }
  bool TraversePtGuardedByAttr(PtGuardedByAttr *A);
  bool VisitPtGuardedByAttr(PtGuardedByAttr *A) {
    return true; 
  }
  bool TraversePtGuardedVarAttr(PtGuardedVarAttr *A);
  bool VisitPtGuardedVarAttr(PtGuardedVarAttr *A) {
    return true; 
  }
  bool TraversePureAttr(PureAttr *A);
  bool VisitPureAttr(PureAttr *A) {
    return true; 
  }
  bool TraverseRegCallAttr(RegCallAttr *A);
  bool VisitRegCallAttr(RegCallAttr *A) {
    return true; 
  }
  bool TraverseReleaseCapabilityAttr(ReleaseCapabilityAttr *A);
  bool VisitReleaseCapabilityAttr(ReleaseCapabilityAttr *A) {
    return true; 
  }
  bool TraverseRenderScriptKernelAttr(RenderScriptKernelAttr *A);
  bool VisitRenderScriptKernelAttr(RenderScriptKernelAttr *A) {
    return true; 
  }
  bool TraverseReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A);
  bool VisitReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A) {
    return true; 
  }
  bool TraverseRequireConstantInitAttr(RequireConstantInitAttr *A);
  bool VisitRequireConstantInitAttr(RequireConstantInitAttr *A) {
    return true; 
  }
  bool TraverseRequiresCapabilityAttr(RequiresCapabilityAttr *A);
  bool VisitRequiresCapabilityAttr(RequiresCapabilityAttr *A) {
    return true; 
  }
  bool TraverseRestrictAttr(RestrictAttr *A);
  bool VisitRestrictAttr(RestrictAttr *A) {
    return true; 
  }
  bool TraverseReturnTypestateAttr(ReturnTypestateAttr *A);
  bool VisitReturnTypestateAttr(ReturnTypestateAttr *A) {
    return true; 
  }
  bool TraverseReturnsNonNullAttr(ReturnsNonNullAttr *A);
  bool VisitReturnsNonNullAttr(ReturnsNonNullAttr *A) {
    return true; 
  }
  bool TraverseReturnsTwiceAttr(ReturnsTwiceAttr *A);
  bool VisitReturnsTwiceAttr(ReturnsTwiceAttr *A) {
    return true; 
  }
  bool TraverseScopedLockableAttr(ScopedLockableAttr *A);
  bool VisitScopedLockableAttr(ScopedLockableAttr *A) {
    return true; 
  }
  bool TraverseSectionAttr(SectionAttr *A);
  bool VisitSectionAttr(SectionAttr *A) {
    return true; 
  }
  bool TraverseSelectAnyAttr(SelectAnyAttr *A);
  bool VisitSelectAnyAttr(SelectAnyAttr *A) {
    return true; 
  }
  bool TraverseSentinelAttr(SentinelAttr *A);
  bool VisitSentinelAttr(SentinelAttr *A) {
    return true; 
  }
  bool TraverseSetTypestateAttr(SetTypestateAttr *A);
  bool VisitSetTypestateAttr(SetTypestateAttr *A) {
    return true; 
  }
  bool TraverseSharedTrylockFunctionAttr(SharedTrylockFunctionAttr *A);
  bool VisitSharedTrylockFunctionAttr(SharedTrylockFunctionAttr *A) {
    return true; 
  }
  bool TraverseStdCallAttr(StdCallAttr *A);
  bool VisitStdCallAttr(StdCallAttr *A) {
    return true; 
  }
  bool TraverseSuppressAttr(SuppressAttr *A);
  bool VisitSuppressAttr(SuppressAttr *A) {
    return true; 
  }
  bool TraverseSwiftCallAttr(SwiftCallAttr *A);
  bool VisitSwiftCallAttr(SwiftCallAttr *A) {
    return true; 
  }
  bool TraverseSwiftContextAttr(SwiftContextAttr *A);
  bool VisitSwiftContextAttr(SwiftContextAttr *A) {
    return true; 
  }
  bool TraverseSwiftErrorResultAttr(SwiftErrorResultAttr *A);
  bool VisitSwiftErrorResultAttr(SwiftErrorResultAttr *A) {
    return true; 
  }
  bool TraverseSwiftIndirectResultAttr(SwiftIndirectResultAttr *A);
  bool VisitSwiftIndirectResultAttr(SwiftIndirectResultAttr *A) {
    return true; 
  }
  bool TraverseSysVABIAttr(SysVABIAttr *A);
  bool VisitSysVABIAttr(SysVABIAttr *A) {
    return true; 
  }
  bool TraverseTLSModelAttr(TLSModelAttr *A);
  bool VisitTLSModelAttr(TLSModelAttr *A) {
    return true; 
  }
  bool TraverseTargetAttr(TargetAttr *A);
  bool VisitTargetAttr(TargetAttr *A) {
    return true; 
  }
  bool TraverseTestTypestateAttr(TestTypestateAttr *A);
  bool VisitTestTypestateAttr(TestTypestateAttr *A) {
    return true; 
  }
  bool TraverseThisCallAttr(ThisCallAttr *A);
  bool VisitThisCallAttr(ThisCallAttr *A) {
    return true; 
  }
  bool TraverseThreadAttr(ThreadAttr *A);
  bool VisitThreadAttr(ThreadAttr *A) {
    return true; 
  }
  bool TraverseTransparentUnionAttr(TransparentUnionAttr *A);
  bool VisitTransparentUnionAttr(TransparentUnionAttr *A) {
    return true; 
  }
  bool TraverseTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A);
  bool VisitTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A) {
    return true; 
  }
  bool TraverseTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A);
  bool VisitTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A) {
    return true; 
  }
  bool TraverseTypeVisibilityAttr(TypeVisibilityAttr *A);
  bool VisitTypeVisibilityAttr(TypeVisibilityAttr *A) {
    return true; 
  }
  bool TraverseUnavailableAttr(UnavailableAttr *A);
  bool VisitUnavailableAttr(UnavailableAttr *A) {
    return true; 
  }
  bool TraverseUnusedAttr(UnusedAttr *A);
  bool VisitUnusedAttr(UnusedAttr *A) {
    return true; 
  }
  bool TraverseUsedAttr(UsedAttr *A);
  bool VisitUsedAttr(UsedAttr *A) {
    return true; 
  }
  bool TraverseUuidAttr(UuidAttr *A);
  bool VisitUuidAttr(UuidAttr *A) {
    return true; 
  }
  bool TraverseVecReturnAttr(VecReturnAttr *A);
  bool VisitVecReturnAttr(VecReturnAttr *A) {
    return true; 
  }
  bool TraverseVecTypeHintAttr(VecTypeHintAttr *A);
  bool VisitVecTypeHintAttr(VecTypeHintAttr *A) {
    return true; 
  }
  bool 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 TraverseWorkGroupSizeHintAttr(WorkGroupSizeHintAttr *A);
  bool VisitWorkGroupSizeHintAttr(WorkGroupSizeHintAttr *A) {
    return true; 
  }
  bool TraverseX86ForceAlignArgPointerAttr(X86ForceAlignArgPointerAttr *A);
  bool VisitX86ForceAlignArgPointerAttr(X86ForceAlignArgPointerAttr *A) {
    return true; 
  }
  bool TraverseXRayInstrumentAttr(XRayInstrumentAttr *A);
  bool VisitXRayInstrumentAttr(XRayInstrumentAttr *A) {
    return true; 
  }
  bool TraverseXRayLogArgsAttr(XRayLogArgsAttr *A);
  bool VisitXRayLogArgsAttr(XRayLogArgsAttr *A) {
    return true; 
  }

#else // ATTR_VISITOR_DECLS_ONLY

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAlignedAttr(AlignedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAlignedAttr(A))
    return false;
  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>::TraverseAlwaysInlineAttr(AlwaysInlineAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAlwaysInlineAttr(A))
    return false;
  return true;
}

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

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAnnotateAttr(AnnotateAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAnnotateAttr(A))
    return false;
  return true;
}

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

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

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

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

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

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAssertCapabilityAttr(AssertCapabilityAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAssertCapabilityAttr(A))
    return false;
  if (!getDerived().TraverseStmt(A->getExpr()))
    return false;
  return true;
}

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

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

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

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseAvailabilityAttr(AvailabilityAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitAvailabilityAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseBlocksAttr(BlocksAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitBlocksAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseC11NoReturnAttr(C11NoReturnAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitC11NoReturnAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCDeclAttr(CDeclAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCDeclAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCFAuditedTransferAttr(CFAuditedTransferAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCFAuditedTransferAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseCFConsumedAttr(CFConsumedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitCFConsumedAttr(A))
    return false;
  return true;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <typename Derived>
bool VISITORCLASS<Derived>::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>::TraverseGNUInlineAttr(GNUInlineAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitGNUInlineAttr(A))
    return false;
  return true;
}

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

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseGuardedVarAttr(GuardedVarAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitGuardedVarAttr(A))
    return false;
  return true;
}

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

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

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

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseIBOutletCollectionAttr(IBOutletCollectionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitIBOutletCollectionAttr(A))
    return false;
  return true;
}

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

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

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

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseMSABIAttr(MSABIAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitMSABIAttr(A))
    return false;
  return true;
}

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

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

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

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

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

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

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

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

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

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

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNSConsumedAttr(NSConsumedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNSConsumedAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseNSConsumesSelfAttr(NSConsumesSelfAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitNSConsumesSelfAttr(A))
    return false;
  return true;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseOMPThreadPrivateDeclAttr(OMPThreadPrivateDeclAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitOMPThreadPrivateDeclAttr(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>::TraverseObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCDesignatedInitializerAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCExceptionAttr(ObjCExceptionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCExceptionAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCExplicitProtocolImplAttr(ObjCExplicitProtocolImplAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCExplicitProtocolImplAttr(A))
    return false;
  return true;
}

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

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCMethodFamilyAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCNSObjectAttr(ObjCNSObjectAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCNSObjectAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCPreciseLifetimeAttr(ObjCPreciseLifetimeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCPreciseLifetimeAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCRequiresPropertyDefsAttr(ObjCRequiresPropertyDefsAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCRequiresPropertyDefsAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCRequiresSuperAttr(ObjCRequiresSuperAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCRequiresSuperAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCReturnsInnerPointerAttr(ObjCReturnsInnerPointerAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCReturnsInnerPointerAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCRootClassAttr(ObjCRootClassAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCRootClassAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseObjCRuntimeNameAttr(ObjCRuntimeNameAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitObjCRuntimeNameAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::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>::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>::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>::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>::TraversePcsAttr(PcsAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPcsAttr(A))
    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>::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>::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>::TraversePureAttr(PureAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitPureAttr(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>::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>::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>::TraverseRequireConstantInitAttr(RequireConstantInitAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitRequireConstantInitAttr(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>::TraverseReturnTypestateAttr(ReturnTypestateAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitReturnTypestateAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseReturnsNonNullAttr(ReturnsNonNullAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitReturnsNonNullAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseReturnsTwiceAttr(ReturnsTwiceAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitReturnsTwiceAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseScopedLockableAttr(ScopedLockableAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitScopedLockableAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSectionAttr(SectionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSectionAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSelectAnyAttr(SelectAnyAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSelectAnyAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSentinelAttr(SentinelAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSentinelAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSetTypestateAttr(SetTypestateAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSetTypestateAttr(A))
    return false;
  return true;
}

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

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseStdCallAttr(StdCallAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitStdCallAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseSuppressAttr(SuppressAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitSuppressAttr(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>::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>::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>::TraverseTestTypestateAttr(TestTypestateAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitTestTypestateAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseThisCallAttr(ThisCallAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitThisCallAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseThreadAttr(ThreadAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitThreadAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseTransparentUnionAttr(TransparentUnionAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitTransparentUnionAttr(A))
    return false;
  return true;
}

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

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitTypeTagForDatatypeAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseTypeVisibilityAttr(TypeVisibilityAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitTypeVisibilityAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseUnavailableAttr(UnavailableAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitUnavailableAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseUnusedAttr(UnusedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitUnusedAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseUsedAttr(UsedAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitUsedAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseUuidAttr(UuidAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitUuidAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseVecReturnAttr(VecReturnAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitVecReturnAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::TraverseVecTypeHintAttr(VecTypeHintAttr *A) {
  if (!getDerived().VisitAttr(A))
    return false;
  if (!getDerived().VisitVecTypeHintAttr(A))
    return false;
  return true;
}

template <typename Derived>
bool VISITORCLASS<Derived>::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>::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>::TraverseAttr(Attr *A) {
  if (!A)
    return true;

  switch (A->getKind()) {
    case attr::AMDGPUFlatWorkGroupSize:
      return getDerived().TraverseAMDGPUFlatWorkGroupSizeAttr(cast<AMDGPUFlatWorkGroupSizeAttr>(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::AcquiredAfter:
      return getDerived().TraverseAcquiredAfterAttr(cast<AcquiredAfterAttr>(A));
    case attr::AcquiredBefore:
      return getDerived().TraverseAcquiredBeforeAttr(cast<AcquiredBeforeAttr>(A));
    case attr::Alias:
      return getDerived().TraverseAliasAttr(cast<AliasAttr>(A));
    case attr::AlignMac68k:
      return getDerived().TraverseAlignMac68kAttr(cast<AlignMac68kAttr>(A));
    case attr::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::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::AnyX86Interrupt:
      return getDerived().TraverseAnyX86InterruptAttr(cast<AnyX86InterruptAttr>(A));
    case attr::AnyX86NoCallerSavedRegisters:
      return getDerived().TraverseAnyX86NoCallerSavedRegistersAttr(cast<AnyX86NoCallerSavedRegistersAttr>(A));
    case attr::ArcWeakrefUnavailable:
      return getDerived().TraverseArcWeakrefUnavailableAttr(cast<ArcWeakrefUnavailableAttr>(A));
    case attr::ArgumentWithTypeTag:
      return getDerived().TraverseArgumentWithTypeTagAttr(cast<ArgumentWithTypeTagAttr>(A));
    case attr::AsmLabel:
      return getDerived().TraverseAsmLabelAttr(cast<AsmLabelAttr>(A));
    case attr::AssertCapability:
      return getDerived().TraverseAssertCapabilityAttr(cast<AssertCapabilityAttr>(A));
    case attr::AssertExclusiveLock:
      return getDerived().TraverseAssertExclusiveLockAttr(cast<AssertExclusiveLockAttr>(A));
    case attr::AssertSharedLock:
      return getDerived().TraverseAssertSharedLockAttr(cast<AssertSharedLockAttr>(A));
    case attr::AssumeAligned:
      return getDerived().TraverseAssumeAlignedAttr(cast<AssumeAlignedAttr>(A));
    case attr::Availability:
      return getDerived().TraverseAvailabilityAttr(cast<AvailabilityAttr>(A));
    case attr::Blocks:
      return getDerived().TraverseBlocksAttr(cast<BlocksAttr>(A));
    case attr::C11NoReturn:
      return getDerived().TraverseC11NoReturnAttr(cast<C11NoReturnAttr>(A));
    case attr::CDecl:
      return getDerived().TraverseCDeclAttr(cast<CDeclAttr>(A));
    case attr::CFAuditedTransfer:
      return getDerived().TraverseCFAuditedTransferAttr(cast<CFAuditedTransferAttr>(A));
    case attr::CFConsumed:
      return getDerived().TraverseCFConsumedAttr(cast<CFConsumedAttr>(A));
    case attr::CFReturnsNotRetained:
      return getDerived().TraverseCFReturnsNotRetainedAttr(cast<CFReturnsNotRetainedAttr>(A));
    case attr::CFReturnsRetained:
      return getDerived().TraverseCFReturnsRetainedAttr(cast<CFReturnsRetainedAttr>(A));
    case attr::CFUnknownTransfer:
      return getDerived().TraverseCFUnknownTransferAttr(cast<CFUnknownTransferAttr>(A));
    case attr::CUDAConstant:
      return getDerived().TraverseCUDAConstantAttr(cast<CUDAConstantAttr>(A));
    case attr::CUDADevice:
      return getDerived().TraverseCUDADeviceAttr(cast<CUDADeviceAttr>(A));
    case attr::CUDAGlobal:
      return getDerived().TraverseCUDAGlobalAttr(cast<CUDAGlobalAttr>(A));
    case attr::CUDAHost:
      return getDerived().TraverseCUDAHostAttr(cast<CUDAHostAttr>(A));
    case attr::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::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::Cold:
      return getDerived().TraverseColdAttr(cast<ColdAttr>(A));
    case attr::Common:
      return getDerived().TraverseCommonAttr(cast<CommonAttr>(A));
    case attr::Const:
      return getDerived().TraverseConstAttr(cast<ConstAttr>(A));
    case attr::Constructor:
      return getDerived().TraverseConstructorAttr(cast<ConstructorAttr>(A));
    case attr::Consumable:
      return getDerived().TraverseConsumableAttr(cast<ConsumableAttr>(A));
    case attr::ConsumableAutoCast:
      return getDerived().TraverseConsumableAutoCastAttr(cast<ConsumableAutoCastAttr>(A));
    case attr::ConsumableSetOnRead:
      return getDerived().TraverseConsumableSetOnReadAttr(cast<ConsumableSetOnReadAttr>(A));
    case attr::Convergent:
      return getDerived().TraverseConvergentAttr(cast<ConvergentAttr>(A));
    case attr::DLLExport:
      return getDerived().TraverseDLLExportAttr(cast<DLLExportAttr>(A));
    case attr::DLLImport:
      return getDerived().TraverseDLLImportAttr(cast<DLLImportAttr>(A));
    case attr::Deprecated:
      return getDerived().TraverseDeprecatedAttr(cast<DeprecatedAttr>(A));
    case attr::Destructor:
      return getDerived().TraverseDestructorAttr(cast<DestructorAttr>(A));
    case attr::DiagnoseIf:
      return getDerived().TraverseDiagnoseIfAttr(cast<DiagnoseIfAttr>(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::EnumExtensibility:
      return getDerived().TraverseEnumExtensibilityAttr(cast<EnumExtensibilityAttr>(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::GNUInline:
      return getDerived().TraverseGNUInlineAttr(cast<GNUInlineAttr>(A));
    case attr::GuardedBy:
      return getDerived().TraverseGuardedByAttr(cast<GuardedByAttr>(A));
    case attr::GuardedVar:
      return getDerived().TraverseGuardedVarAttr(cast<GuardedVarAttr>(A));
    case attr::Hot:
      return getDerived().TraverseHotAttr(cast<HotAttr>(A));
    case attr::IBAction:
      return getDerived().TraverseIBActionAttr(cast<IBActionAttr>(A));
    case attr::IBOutlet:
      return getDerived().TraverseIBOutletAttr(cast<IBOutletAttr>(A));
    case attr::IBOutletCollection:
      return getDerived().TraverseIBOutletCollectionAttr(cast<IBOutletCollectionAttr>(A));
    case attr::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::LockReturned:
      return getDerived().TraverseLockReturnedAttr(cast<LockReturnedAttr>(A));
    case attr::LocksExcluded:
      return getDerived().TraverseLocksExcludedAttr(cast<LocksExcludedAttr>(A));
    case attr::LoopHint:
      return getDerived().TraverseLoopHintAttr(cast<LoopHintAttr>(A));
    case attr::MSABI:
      return getDerived().TraverseMSABIAttr(cast<MSABIAttr>(A));
    case attr::MSInheritance:
      return getDerived().TraverseMSInheritanceAttr(cast<MSInheritanceAttr>(A));
    case attr::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::Mips16:
      return getDerived().TraverseMips16Attr(cast<Mips16Attr>(A));
    case attr::MipsInterrupt:
      return getDerived().TraverseMipsInterruptAttr(cast<MipsInterruptAttr>(A));
    case attr::Mode:
      return getDerived().TraverseModeAttr(cast<ModeAttr>(A));
    case attr::NSConsumed:
      return getDerived().TraverseNSConsumedAttr(cast<NSConsumedAttr>(A));
    case attr::NSConsumesSelf:
      return getDerived().TraverseNSConsumesSelfAttr(cast<NSConsumesSelfAttr>(A));
    case attr::NSReturnsAutoreleased:
      return getDerived().TraverseNSReturnsAutoreleasedAttr(cast<NSReturnsAutoreleasedAttr>(A));
    case attr::NSReturnsNotRetained:
      return getDerived().TraverseNSReturnsNotRetainedAttr(cast<NSReturnsNotRetainedAttr>(A));
    case attr::NSReturnsRetained:
      return getDerived().TraverseNSReturnsRetainedAttr(cast<NSReturnsRetainedAttr>(A));
    case attr::Naked:
      return getDerived().TraverseNakedAttr(cast<NakedAttr>(A));
    case attr::NoAlias:
      return getDerived().TraverseNoAliasAttr(cast<NoAliasAttr>(A));
    case attr::NoCommon:
      return getDerived().TraverseNoCommonAttr(cast<NoCommonAttr>(A));
    case attr::NoDebug:
      return getDerived().TraverseNoDebugAttr(cast<NoDebugAttr>(A));
    case attr::NoDuplicate:
      return getDerived().TraverseNoDuplicateAttr(cast<NoDuplicateAttr>(A));
    case attr::NoInline:
      return getDerived().TraverseNoInlineAttr(cast<NoInlineAttr>(A));
    case attr::NoInstrumentFunction:
      return getDerived().TraverseNoInstrumentFunctionAttr(cast<NoInstrumentFunctionAttr>(A));
    case attr::NoMicroMips:
      return getDerived().TraverseNoMicroMipsAttr(cast<NoMicroMipsAttr>(A));
    case attr::NoMips16:
      return getDerived().TraverseNoMips16Attr(cast<NoMips16Attr>(A));
    case attr::NoReturn:
      return getDerived().TraverseNoReturnAttr(cast<NoReturnAttr>(A));
    case attr::NoSanitize:
      return getDerived().TraverseNoSanitizeAttr(cast<NoSanitizeAttr>(A));
    case attr::NoSplitStack:
      return getDerived().TraverseNoSplitStackAttr(cast<NoSplitStackAttr>(A));
    case attr::NoThreadSafetyAnalysis:
      return getDerived().TraverseNoThreadSafetyAnalysisAttr(cast<NoThreadSafetyAnalysisAttr>(A));
    case attr::NoThrow:
      return getDerived().TraverseNoThrowAttr(cast<NoThrowAttr>(A));
    case attr::NonNull:
      return getDerived().TraverseNonNullAttr(cast<NonNullAttr>(A));
    case attr::NotTailCalled:
      return getDerived().TraverseNotTailCalledAttr(cast<NotTailCalledAttr>(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::OMPThreadPrivateDecl:
      return getDerived().TraverseOMPThreadPrivateDeclAttr(cast<OMPThreadPrivateDeclAttr>(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::ObjCDesignatedInitializer:
      return getDerived().TraverseObjCDesignatedInitializerAttr(cast<ObjCDesignatedInitializerAttr>(A));
    case attr::ObjCException:
      return getDerived().TraverseObjCExceptionAttr(cast<ObjCExceptionAttr>(A));
    case attr::ObjCExplicitProtocolImpl:
      return getDerived().TraverseObjCExplicitProtocolImplAttr(cast<ObjCExplicitProtocolImplAttr>(A));
    case attr::ObjCIndependentClass:
      return getDerived().TraverseObjCIndependentClassAttr(cast<ObjCIndependentClassAttr>(A));
    case attr::ObjCMethodFamily:
      return getDerived().TraverseObjCMethodFamilyAttr(cast<ObjCMethodFamilyAttr>(A));
    case attr::ObjCNSObject:
      return getDerived().TraverseObjCNSObjectAttr(cast<ObjCNSObjectAttr>(A));
    case attr::ObjCPreciseLifetime:
      return getDerived().TraverseObjCPreciseLifetimeAttr(cast<ObjCPreciseLifetimeAttr>(A));
    case attr::ObjCRequiresPropertyDefs:
      return getDerived().TraverseObjCRequiresPropertyDefsAttr(cast<ObjCRequiresPropertyDefsAttr>(A));
    case attr::ObjCRequiresSuper:
      return getDerived().TraverseObjCRequiresSuperAttr(cast<ObjCRequiresSuperAttr>(A));
    case attr::ObjCReturnsInnerPointer:
      return getDerived().TraverseObjCReturnsInnerPointerAttr(cast<ObjCReturnsInnerPointerAttr>(A));
    case attr::ObjCRootClass:
      return getDerived().TraverseObjCRootClassAttr(cast<ObjCRootClassAttr>(A));
    case attr::ObjCRuntimeName:
      return getDerived().TraverseObjCRuntimeNameAttr(cast<ObjCRuntimeNameAttr>(A));
    case attr::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::OpenCLIntelReqdSubGroupSize:
      return getDerived().TraverseOpenCLIntelReqdSubGroupSizeAttr(cast<OpenCLIntelReqdSubGroupSizeAttr>(A));
    case attr::OpenCLKernel:
      return getDerived().TraverseOpenCLKernelAttr(cast<OpenCLKernelAttr>(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::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::Pcs:
      return getDerived().TraversePcsAttr(cast<PcsAttr>(A));
    case attr::PragmaClangBSSSection:
      return getDerived().TraversePragmaClangBSSSectionAttr(cast<PragmaClangBSSSectionAttr>(A));
    case attr::PragmaClangDataSection:
      return getDerived().TraversePragmaClangDataSectionAttr(cast<PragmaClangDataSectionAttr>(A));
    case attr::PragmaClangRodataSection:
      return getDerived().TraversePragmaClangRodataSectionAttr(cast<PragmaClangRodataSectionAttr>(A));
    case attr::PragmaClangTextSection:
      return getDerived().TraversePragmaClangTextSectionAttr(cast<PragmaClangTextSectionAttr>(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::Pure:
      return getDerived().TraversePureAttr(cast<PureAttr>(A));
    case attr::RegCall:
      return getDerived().TraverseRegCallAttr(cast<RegCallAttr>(A));
    case attr::ReleaseCapability:
      return getDerived().TraverseReleaseCapabilityAttr(cast<ReleaseCapabilityAttr>(A));
    case attr::RenderScriptKernel:
      return getDerived().TraverseRenderScriptKernelAttr(cast<RenderScriptKernelAttr>(A));
    case attr::ReqdWorkGroupSize:
      return getDerived().TraverseReqdWorkGroupSizeAttr(cast<ReqdWorkGroupSizeAttr>(A));
    case attr::RequireConstantInit:
      return getDerived().TraverseRequireConstantInitAttr(cast<RequireConstantInitAttr>(A));
    case attr::RequiresCapability:
      return getDerived().TraverseRequiresCapabilityAttr(cast<RequiresCapabilityAttr>(A));
    case attr::Restrict:
      return getDerived().TraverseRestrictAttr(cast<RestrictAttr>(A));
    case attr::ReturnTypestate:
      return getDerived().TraverseReturnTypestateAttr(cast<ReturnTypestateAttr>(A));
    case attr::ReturnsNonNull:
      return getDerived().TraverseReturnsNonNullAttr(cast<ReturnsNonNullAttr>(A));
    case attr::ReturnsTwice:
      return getDerived().TraverseReturnsTwiceAttr(cast<ReturnsTwiceAttr>(A));
    case attr::ScopedLockable:
      return getDerived().TraverseScopedLockableAttr(cast<ScopedLockableAttr>(A));
    case attr::Section:
      return getDerived().TraverseSectionAttr(cast<SectionAttr>(A));
    case attr::SelectAny:
      return getDerived().TraverseSelectAnyAttr(cast<SelectAnyAttr>(A));
    case attr::Sentinel:
      return getDerived().TraverseSentinelAttr(cast<SentinelAttr>(A));
    case attr::SetTypestate:
      return getDerived().TraverseSetTypestateAttr(cast<SetTypestateAttr>(A));
    case attr::SharedTrylockFunction:
      return getDerived().TraverseSharedTrylockFunctionAttr(cast<SharedTrylockFunctionAttr>(A));
    case attr::StdCall:
      return getDerived().TraverseStdCallAttr(cast<StdCallAttr>(A));
    case attr::Suppress:
      return getDerived().TraverseSuppressAttr(cast<SuppressAttr>(A));
    case attr::SwiftCall:
      return getDerived().TraverseSwiftCallAttr(cast<SwiftCallAttr>(A));
    case attr::SwiftContext:
      return getDerived().TraverseSwiftContextAttr(cast<SwiftContextAttr>(A));
    case attr::SwiftErrorResult:
      return getDerived().TraverseSwiftErrorResultAttr(cast<SwiftErrorResultAttr>(A));
    case attr::SwiftIndirectResult:
      return getDerived().TraverseSwiftIndirectResultAttr(cast<SwiftIndirectResultAttr>(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::TestTypestate:
      return getDerived().TraverseTestTypestateAttr(cast<TestTypestateAttr>(A));
    case attr::ThisCall:
      return getDerived().TraverseThisCallAttr(cast<ThisCallAttr>(A));
    case attr::Thread:
      return getDerived().TraverseThreadAttr(cast<ThreadAttr>(A));
    case attr::TransparentUnion:
      return getDerived().TraverseTransparentUnionAttr(cast<TransparentUnionAttr>(A));
    case attr::TryAcquireCapability:
      return getDerived().TraverseTryAcquireCapabilityAttr(cast<TryAcquireCapabilityAttr>(A));
    case attr::TypeTagForDatatype:
      return getDerived().TraverseTypeTagForDatatypeAttr(cast<TypeTagForDatatypeAttr>(A));
    case attr::TypeVisibility:
      return getDerived().TraverseTypeVisibilityAttr(cast<TypeVisibilityAttr>(A));
    case attr::Unavailable:
      return getDerived().TraverseUnavailableAttr(cast<UnavailableAttr>(A));
    case attr::Unused:
      return getDerived().TraverseUnusedAttr(cast<UnusedAttr>(A));
    case attr::Used:
      return getDerived().TraverseUsedAttr(cast<UsedAttr>(A));
    case attr::Uuid:
      return getDerived().TraverseUuidAttr(cast<UuidAttr>(A));
    case attr::VecReturn:
      return getDerived().TraverseVecReturnAttr(cast<VecReturnAttr>(A));
    case attr::VecTypeHint:
      return getDerived().TraverseVecTypeHintAttr(cast<VecTypeHintAttr>(A));
    case attr::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::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));
  }
  llvm_unreachable("bad attribute kind");
}
#endif  // ATTR_VISITOR_DECLS_ONLY
