LCOV - code coverage report
Current view: top level - build-llvm/tools/clang/include/clang/AST - AttrVisitor.inc (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 17 366 4.6 %
Date: 2018-07-13 00:08:38 Functions: 53 2421 2.2 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
       2             : |*                                                                            *|
       3             : |* Used by RecursiveASTVisitor to visit attributes.                           *|
       4             : |*                                                                            *|
       5             : |* Automatically generated file, do not edit!                                 *|
       6             : |*                                                                            *|
       7             : \*===----------------------------------------------------------------------===*/
       8             : 
       9             : #ifdef ATTR_VISITOR_DECLS_ONLY
      10             : 
      11             :   bool TraverseAMDGPUFlatWorkGroupSizeAttr(AMDGPUFlatWorkGroupSizeAttr *A);
      12             :   bool VisitAMDGPUFlatWorkGroupSizeAttr(AMDGPUFlatWorkGroupSizeAttr *A) {
      13             :     return true; 
      14             :   }
      15             :   bool TraverseAMDGPUNumSGPRAttr(AMDGPUNumSGPRAttr *A);
      16             :   bool VisitAMDGPUNumSGPRAttr(AMDGPUNumSGPRAttr *A) {
      17             :     return true; 
      18             :   }
      19             :   bool TraverseAMDGPUNumVGPRAttr(AMDGPUNumVGPRAttr *A);
      20             :   bool VisitAMDGPUNumVGPRAttr(AMDGPUNumVGPRAttr *A) {
      21             :     return true; 
      22             :   }
      23             :   bool TraverseAMDGPUWavesPerEUAttr(AMDGPUWavesPerEUAttr *A);
      24             :   bool VisitAMDGPUWavesPerEUAttr(AMDGPUWavesPerEUAttr *A) {
      25             :     return true; 
      26             :   }
      27             :   bool TraverseARMInterruptAttr(ARMInterruptAttr *A);
      28             :   bool VisitARMInterruptAttr(ARMInterruptAttr *A) {
      29             :     return true; 
      30             :   }
      31             :   bool TraverseAVRInterruptAttr(AVRInterruptAttr *A);
      32             :   bool VisitAVRInterruptAttr(AVRInterruptAttr *A) {
      33             :     return true; 
      34             :   }
      35             :   bool TraverseAVRSignalAttr(AVRSignalAttr *A);
      36             :   bool VisitAVRSignalAttr(AVRSignalAttr *A) {
      37             :     return true; 
      38             :   }
      39             :   bool TraverseAbiTagAttr(AbiTagAttr *A);
      40             :   bool VisitAbiTagAttr(AbiTagAttr *A) {
      41             :     return true; 
      42             :   }
      43             :   bool TraverseAcquireCapabilityAttr(AcquireCapabilityAttr *A);
      44             :   bool VisitAcquireCapabilityAttr(AcquireCapabilityAttr *A) {
      45             :     return true; 
      46             :   }
      47             :   bool TraverseAcquiredAfterAttr(AcquiredAfterAttr *A);
      48             :   bool VisitAcquiredAfterAttr(AcquiredAfterAttr *A) {
      49             :     return true; 
      50             :   }
      51             :   bool TraverseAcquiredBeforeAttr(AcquiredBeforeAttr *A);
      52             :   bool VisitAcquiredBeforeAttr(AcquiredBeforeAttr *A) {
      53             :     return true; 
      54             :   }
      55             :   bool TraverseAliasAttr(AliasAttr *A);
      56             :   bool VisitAliasAttr(AliasAttr *A) {
      57             :     return true; 
      58             :   }
      59             :   bool TraverseAlignMac68kAttr(AlignMac68kAttr *A);
      60             :   bool VisitAlignMac68kAttr(AlignMac68kAttr *A) {
      61             :     return true; 
      62             :   }
      63             :   bool TraverseAlignValueAttr(AlignValueAttr *A);
      64             :   bool VisitAlignValueAttr(AlignValueAttr *A) {
      65             :     return true; 
      66             :   }
      67             :   bool TraverseAlignedAttr(AlignedAttr *A);
      68             :   bool VisitAlignedAttr(AlignedAttr *A) {
      69             :     return true; 
      70             :   }
      71             :   bool TraverseAllocAlignAttr(AllocAlignAttr *A);
      72             :   bool VisitAllocAlignAttr(AllocAlignAttr *A) {
      73             :     return true; 
      74             :   }
      75             :   bool TraverseAllocSizeAttr(AllocSizeAttr *A);
      76             :   bool VisitAllocSizeAttr(AllocSizeAttr *A) {
      77             :     return true; 
      78             :   }
      79             :   bool TraverseAlwaysInlineAttr(AlwaysInlineAttr *A);
      80             :   bool VisitAlwaysInlineAttr(AlwaysInlineAttr *A) {
      81             :     return true; 
      82             :   }
      83             :   bool TraverseAnalyzerNoReturnAttr(AnalyzerNoReturnAttr *A);
      84             :   bool VisitAnalyzerNoReturnAttr(AnalyzerNoReturnAttr *A) {
      85             :     return true; 
      86             :   }
      87             :   bool TraverseAnnotateAttr(AnnotateAttr *A);
      88             :   bool VisitAnnotateAttr(AnnotateAttr *A) {
      89             :     return true; 
      90             :   }
      91             :   bool TraverseAnyX86InterruptAttr(AnyX86InterruptAttr *A);
      92             :   bool VisitAnyX86InterruptAttr(AnyX86InterruptAttr *A) {
      93             :     return true; 
      94             :   }
      95             :   bool TraverseAnyX86NoCallerSavedRegistersAttr(AnyX86NoCallerSavedRegistersAttr *A);
      96             :   bool VisitAnyX86NoCallerSavedRegistersAttr(AnyX86NoCallerSavedRegistersAttr *A) {
      97             :     return true; 
      98             :   }
      99             :   bool TraverseAnyX86NoCfCheckAttr(AnyX86NoCfCheckAttr *A);
     100             :   bool VisitAnyX86NoCfCheckAttr(AnyX86NoCfCheckAttr *A) {
     101             :     return true; 
     102             :   }
     103             :   bool TraverseArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A);
     104             :   bool VisitArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A) {
     105             :     return true; 
     106             :   }
     107             :   bool TraverseArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *A);
     108             :   bool VisitArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *A) {
     109             :     return true; 
     110             :   }
     111             :   bool TraverseArtificialAttr(ArtificialAttr *A);
     112             :   bool VisitArtificialAttr(ArtificialAttr *A) {
     113             :     return true; 
     114             :   }
     115             :   bool TraverseAsmLabelAttr(AsmLabelAttr *A);
     116             :   bool VisitAsmLabelAttr(AsmLabelAttr *A) {
     117             :     return true; 
     118             :   }
     119             :   bool TraverseAssertCapabilityAttr(AssertCapabilityAttr *A);
     120             :   bool VisitAssertCapabilityAttr(AssertCapabilityAttr *A) {
     121             :     return true; 
     122             :   }
     123             :   bool TraverseAssertExclusiveLockAttr(AssertExclusiveLockAttr *A);
     124             :   bool VisitAssertExclusiveLockAttr(AssertExclusiveLockAttr *A) {
     125             :     return true; 
     126             :   }
     127             :   bool TraverseAssertSharedLockAttr(AssertSharedLockAttr *A);
     128             :   bool VisitAssertSharedLockAttr(AssertSharedLockAttr *A) {
     129             :     return true; 
     130             :   }
     131             :   bool TraverseAssumeAlignedAttr(AssumeAlignedAttr *A);
     132             :   bool VisitAssumeAlignedAttr(AssumeAlignedAttr *A) {
     133             :     return true; 
     134             :   }
     135             :   bool TraverseAvailabilityAttr(AvailabilityAttr *A);
     136             :   bool VisitAvailabilityAttr(AvailabilityAttr *A) {
     137             :     return true; 
     138             :   }
     139             :   bool TraverseBlocksAttr(BlocksAttr *A);
     140             :   bool VisitBlocksAttr(BlocksAttr *A) {
     141             :     return true; 
     142             :   }
     143             :   bool TraverseC11NoReturnAttr(C11NoReturnAttr *A);
     144             :   bool VisitC11NoReturnAttr(C11NoReturnAttr *A) {
     145             :     return true; 
     146             :   }
     147             :   bool TraverseCDeclAttr(CDeclAttr *A);
     148             :   bool VisitCDeclAttr(CDeclAttr *A) {
     149             :     return true; 
     150             :   }
     151             :   bool TraverseCFAuditedTransferAttr(CFAuditedTransferAttr *A);
     152             :   bool VisitCFAuditedTransferAttr(CFAuditedTransferAttr *A) {
     153             :     return true; 
     154             :   }
     155             :   bool TraverseCFConsumedAttr(CFConsumedAttr *A);
     156             :   bool VisitCFConsumedAttr(CFConsumedAttr *A) {
     157             :     return true; 
     158             :   }
     159             :   bool TraverseCFReturnsNotRetainedAttr(CFReturnsNotRetainedAttr *A);
     160             :   bool VisitCFReturnsNotRetainedAttr(CFReturnsNotRetainedAttr *A) {
     161             :     return true; 
     162             :   }
     163             :   bool TraverseCFReturnsRetainedAttr(CFReturnsRetainedAttr *A);
     164             :   bool VisitCFReturnsRetainedAttr(CFReturnsRetainedAttr *A) {
     165             :     return true; 
     166             :   }
     167             :   bool TraverseCFUnknownTransferAttr(CFUnknownTransferAttr *A);
     168             :   bool VisitCFUnknownTransferAttr(CFUnknownTransferAttr *A) {
     169             :     return true; 
     170             :   }
     171             :   bool TraverseCUDAConstantAttr(CUDAConstantAttr *A);
     172             :   bool VisitCUDAConstantAttr(CUDAConstantAttr *A) {
     173             :     return true; 
     174             :   }
     175             :   bool TraverseCUDADeviceAttr(CUDADeviceAttr *A);
     176             :   bool VisitCUDADeviceAttr(CUDADeviceAttr *A) {
     177             :     return true; 
     178             :   }
     179             :   bool TraverseCUDAGlobalAttr(CUDAGlobalAttr *A);
     180             :   bool VisitCUDAGlobalAttr(CUDAGlobalAttr *A) {
     181             :     return true; 
     182             :   }
     183             :   bool TraverseCUDAHostAttr(CUDAHostAttr *A);
     184             :   bool VisitCUDAHostAttr(CUDAHostAttr *A) {
     185             :     return true; 
     186             :   }
     187             :   bool TraverseCUDAInvalidTargetAttr(CUDAInvalidTargetAttr *A);
     188             :   bool VisitCUDAInvalidTargetAttr(CUDAInvalidTargetAttr *A) {
     189             :     return true; 
     190             :   }
     191             :   bool TraverseCUDALaunchBoundsAttr(CUDALaunchBoundsAttr *A);
     192             :   bool VisitCUDALaunchBoundsAttr(CUDALaunchBoundsAttr *A) {
     193             :     return true; 
     194             :   }
     195             :   bool TraverseCUDASharedAttr(CUDASharedAttr *A);
     196             :   bool VisitCUDASharedAttr(CUDASharedAttr *A) {
     197             :     return true; 
     198             :   }
     199             :   bool TraverseCXX11NoReturnAttr(CXX11NoReturnAttr *A);
     200             :   bool VisitCXX11NoReturnAttr(CXX11NoReturnAttr *A) {
     201             :     return true; 
     202             :   }
     203             :   bool TraverseCallableWhenAttr(CallableWhenAttr *A);
     204             :   bool VisitCallableWhenAttr(CallableWhenAttr *A) {
     205             :     return true; 
     206             :   }
     207             :   bool TraverseCapabilityAttr(CapabilityAttr *A);
     208             :   bool VisitCapabilityAttr(CapabilityAttr *A) {
     209             :     return true; 
     210             :   }
     211             :   bool TraverseCapturedRecordAttr(CapturedRecordAttr *A);
     212             :   bool VisitCapturedRecordAttr(CapturedRecordAttr *A) {
     213             :     return true; 
     214             :   }
     215             :   bool TraverseCarriesDependencyAttr(CarriesDependencyAttr *A);
     216             :   bool VisitCarriesDependencyAttr(CarriesDependencyAttr *A) {
     217             :     return true; 
     218             :   }
     219             :   bool TraverseCleanupAttr(CleanupAttr *A);
     220             :   bool VisitCleanupAttr(CleanupAttr *A) {
     221             :     return true; 
     222             :   }
     223             :   bool TraverseColdAttr(ColdAttr *A);
     224             :   bool VisitColdAttr(ColdAttr *A) {
     225             :     return true; 
     226             :   }
     227             :   bool TraverseCommonAttr(CommonAttr *A);
     228             :   bool VisitCommonAttr(CommonAttr *A) {
     229             :     return true; 
     230             :   }
     231             :   bool TraverseConstAttr(ConstAttr *A);
     232             :   bool VisitConstAttr(ConstAttr *A) {
     233             :     return true; 
     234             :   }
     235             :   bool TraverseConstructorAttr(ConstructorAttr *A);
     236             :   bool VisitConstructorAttr(ConstructorAttr *A) {
     237             :     return true; 
     238             :   }
     239             :   bool TraverseConsumableAttr(ConsumableAttr *A);
     240             :   bool VisitConsumableAttr(ConsumableAttr *A) {
     241             :     return true; 
     242             :   }
     243             :   bool TraverseConsumableAutoCastAttr(ConsumableAutoCastAttr *A);
     244             :   bool VisitConsumableAutoCastAttr(ConsumableAutoCastAttr *A) {
     245             :     return true; 
     246             :   }
     247             :   bool TraverseConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A);
     248             :   bool VisitConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A) {
     249             :     return true; 
     250             :   }
     251             :   bool TraverseConvergentAttr(ConvergentAttr *A);
     252             :   bool VisitConvergentAttr(ConvergentAttr *A) {
     253             :     return true; 
     254             :   }
     255             :   bool TraverseDLLExportAttr(DLLExportAttr *A);
     256             :   bool VisitDLLExportAttr(DLLExportAttr *A) {
     257             :     return true; 
     258             :   }
     259             :   bool TraverseDLLImportAttr(DLLImportAttr *A);
     260             :   bool VisitDLLImportAttr(DLLImportAttr *A) {
     261             :     return true; 
     262             :   }
     263             :   bool TraverseDeprecatedAttr(DeprecatedAttr *A);
     264             :   bool VisitDeprecatedAttr(DeprecatedAttr *A) {
     265             :     return true; 
     266             :   }
     267             :   bool TraverseDestructorAttr(DestructorAttr *A);
     268             :   bool VisitDestructorAttr(DestructorAttr *A) {
     269             :     return true; 
     270             :   }
     271             :   bool TraverseDiagnoseIfAttr(DiagnoseIfAttr *A);
     272             :   bool VisitDiagnoseIfAttr(DiagnoseIfAttr *A) {
     273             :     return true; 
     274             :   }
     275             :   bool TraverseDisableTailCallsAttr(DisableTailCallsAttr *A);
     276             :   bool VisitDisableTailCallsAttr(DisableTailCallsAttr *A) {
     277             :     return true; 
     278             :   }
     279             :   bool TraverseEmptyBasesAttr(EmptyBasesAttr *A);
     280             :   bool VisitEmptyBasesAttr(EmptyBasesAttr *A) {
     281             :     return true; 
     282             :   }
     283             :   bool TraverseEnableIfAttr(EnableIfAttr *A);
     284             :   bool VisitEnableIfAttr(EnableIfAttr *A) {
     285             :     return true; 
     286             :   }
     287             :   bool TraverseEnumExtensibilityAttr(EnumExtensibilityAttr *A);
     288             :   bool VisitEnumExtensibilityAttr(EnumExtensibilityAttr *A) {
     289             :     return true; 
     290             :   }
     291             :   bool TraverseExclusiveTrylockFunctionAttr(ExclusiveTrylockFunctionAttr *A);
     292             :   bool VisitExclusiveTrylockFunctionAttr(ExclusiveTrylockFunctionAttr *A) {
     293             :     return true; 
     294             :   }
     295             :   bool TraverseExternalSourceSymbolAttr(ExternalSourceSymbolAttr *A);
     296             :   bool VisitExternalSourceSymbolAttr(ExternalSourceSymbolAttr *A) {
     297             :     return true; 
     298             :   }
     299             :   bool TraverseFallThroughAttr(FallThroughAttr *A);
     300             :   bool VisitFallThroughAttr(FallThroughAttr *A) {
     301             :     return true; 
     302             :   }
     303             :   bool TraverseFastCallAttr(FastCallAttr *A);
     304             :   bool VisitFastCallAttr(FastCallAttr *A) {
     305             :     return true; 
     306             :   }
     307             :   bool TraverseFinalAttr(FinalAttr *A);
     308             :   bool VisitFinalAttr(FinalAttr *A) {
     309             :     return true; 
     310             :   }
     311             :   bool TraverseFlagEnumAttr(FlagEnumAttr *A);
     312             :   bool VisitFlagEnumAttr(FlagEnumAttr *A) {
     313             :     return true; 
     314             :   }
     315             :   bool TraverseFlattenAttr(FlattenAttr *A);
     316             :   bool VisitFlattenAttr(FlattenAttr *A) {
     317             :     return true; 
     318             :   }
     319             :   bool TraverseFormatAttr(FormatAttr *A);
     320             :   bool VisitFormatAttr(FormatAttr *A) {
     321             :     return true; 
     322             :   }
     323             :   bool TraverseFormatArgAttr(FormatArgAttr *A);
     324             :   bool VisitFormatArgAttr(FormatArgAttr *A) {
     325             :     return true; 
     326             :   }
     327             :   bool TraverseGNUInlineAttr(GNUInlineAttr *A);
     328             :   bool VisitGNUInlineAttr(GNUInlineAttr *A) {
     329             :     return true; 
     330             :   }
     331             :   bool TraverseGuardedByAttr(GuardedByAttr *A);
     332             :   bool VisitGuardedByAttr(GuardedByAttr *A) {
     333             :     return true; 
     334             :   }
     335             :   bool TraverseGuardedVarAttr(GuardedVarAttr *A);
     336             :   bool VisitGuardedVarAttr(GuardedVarAttr *A) {
     337             :     return true; 
     338             :   }
     339             :   bool TraverseHotAttr(HotAttr *A);
     340             :   bool VisitHotAttr(HotAttr *A) {
     341             :     return true; 
     342             :   }
     343             :   bool TraverseIBActionAttr(IBActionAttr *A);
     344             :   bool VisitIBActionAttr(IBActionAttr *A) {
     345             :     return true; 
     346             :   }
     347             :   bool TraverseIBOutletAttr(IBOutletAttr *A);
     348             :   bool VisitIBOutletAttr(IBOutletAttr *A) {
     349             :     return true; 
     350             :   }
     351             :   bool TraverseIBOutletCollectionAttr(IBOutletCollectionAttr *A);
     352             :   bool VisitIBOutletCollectionAttr(IBOutletCollectionAttr *A) {
     353             :     return true; 
     354             :   }
     355             :   bool TraverseIFuncAttr(IFuncAttr *A);
     356             :   bool VisitIFuncAttr(IFuncAttr *A) {
     357             :     return true; 
     358             :   }
     359             :   bool TraverseInitPriorityAttr(InitPriorityAttr *A);
     360             :   bool VisitInitPriorityAttr(InitPriorityAttr *A) {
     361             :     return true; 
     362             :   }
     363             :   bool TraverseInitSegAttr(InitSegAttr *A);
     364             :   bool VisitInitSegAttr(InitSegAttr *A) {
     365             :     return true; 
     366             :   }
     367             :   bool TraverseIntelOclBiccAttr(IntelOclBiccAttr *A);
     368             :   bool VisitIntelOclBiccAttr(IntelOclBiccAttr *A) {
     369             :     return true; 
     370             :   }
     371             :   bool TraverseInternalLinkageAttr(InternalLinkageAttr *A);
     372             :   bool VisitInternalLinkageAttr(InternalLinkageAttr *A) {
     373             :     return true; 
     374             :   }
     375             :   bool TraverseLTOVisibilityPublicAttr(LTOVisibilityPublicAttr *A);
     376             :   bool VisitLTOVisibilityPublicAttr(LTOVisibilityPublicAttr *A) {
     377             :     return true; 
     378             :   }
     379             :   bool TraverseLayoutVersionAttr(LayoutVersionAttr *A);
     380             :   bool VisitLayoutVersionAttr(LayoutVersionAttr *A) {
     381             :     return true; 
     382             :   }
     383             :   bool TraverseLockReturnedAttr(LockReturnedAttr *A);
     384             :   bool VisitLockReturnedAttr(LockReturnedAttr *A) {
     385             :     return true; 
     386             :   }
     387             :   bool TraverseLocksExcludedAttr(LocksExcludedAttr *A);
     388             :   bool VisitLocksExcludedAttr(LocksExcludedAttr *A) {
     389             :     return true; 
     390             :   }
     391             :   bool TraverseLoopHintAttr(LoopHintAttr *A);
     392             :   bool VisitLoopHintAttr(LoopHintAttr *A) {
     393             :     return true; 
     394             :   }
     395             :   bool TraverseMSABIAttr(MSABIAttr *A);
     396             :   bool VisitMSABIAttr(MSABIAttr *A) {
     397             :     return true; 
     398             :   }
     399             :   bool TraverseMSInheritanceAttr(MSInheritanceAttr *A);
     400             :   bool VisitMSInheritanceAttr(MSInheritanceAttr *A) {
     401             :     return true; 
     402             :   }
     403             :   bool TraverseMSNoVTableAttr(MSNoVTableAttr *A);
     404             :   bool VisitMSNoVTableAttr(MSNoVTableAttr *A) {
     405             :     return true; 
     406             :   }
     407             :   bool TraverseMSP430InterruptAttr(MSP430InterruptAttr *A);
     408             :   bool VisitMSP430InterruptAttr(MSP430InterruptAttr *A) {
     409             :     return true; 
     410             :   }
     411             :   bool TraverseMSStructAttr(MSStructAttr *A);
     412             :   bool VisitMSStructAttr(MSStructAttr *A) {
     413             :     return true; 
     414             :   }
     415             :   bool TraverseMSVtorDispAttr(MSVtorDispAttr *A);
     416             :   bool VisitMSVtorDispAttr(MSVtorDispAttr *A) {
     417             :     return true; 
     418             :   }
     419             :   bool TraverseMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A);
     420             :   bool VisitMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A) {
     421             :     return true; 
     422             :   }
     423             :   bool TraverseMayAliasAttr(MayAliasAttr *A);
     424             :   bool VisitMayAliasAttr(MayAliasAttr *A) {
     425             :     return true; 
     426             :   }
     427             :   bool TraverseMicroMipsAttr(MicroMipsAttr *A);
     428             :   bool VisitMicroMipsAttr(MicroMipsAttr *A) {
     429             :     return true; 
     430             :   }
     431             :   bool TraverseMinSizeAttr(MinSizeAttr *A);
     432             :   bool VisitMinSizeAttr(MinSizeAttr *A) {
     433             :     return true; 
     434             :   }
     435             :   bool TraverseMinVectorWidthAttr(MinVectorWidthAttr *A);
     436             :   bool VisitMinVectorWidthAttr(MinVectorWidthAttr *A) {
     437             :     return true; 
     438             :   }
     439             :   bool TraverseMips16Attr(Mips16Attr *A);
     440             :   bool VisitMips16Attr(Mips16Attr *A) {
     441             :     return true; 
     442             :   }
     443             :   bool TraverseMipsInterruptAttr(MipsInterruptAttr *A);
     444             :   bool VisitMipsInterruptAttr(MipsInterruptAttr *A) {
     445             :     return true; 
     446             :   }
     447             :   bool TraverseMipsLongCallAttr(MipsLongCallAttr *A);
     448             :   bool VisitMipsLongCallAttr(MipsLongCallAttr *A) {
     449             :     return true; 
     450             :   }
     451             :   bool TraverseMipsShortCallAttr(MipsShortCallAttr *A);
     452             :   bool VisitMipsShortCallAttr(MipsShortCallAttr *A) {
     453             :     return true; 
     454             :   }
     455             :   bool TraverseModeAttr(ModeAttr *A);
     456             :   bool VisitModeAttr(ModeAttr *A) {
     457             :     return true; 
     458             :   }
     459             :   bool TraverseNSConsumedAttr(NSConsumedAttr *A);
     460             :   bool VisitNSConsumedAttr(NSConsumedAttr *A) {
     461             :     return true; 
     462             :   }
     463             :   bool TraverseNSConsumesSelfAttr(NSConsumesSelfAttr *A);
     464             :   bool VisitNSConsumesSelfAttr(NSConsumesSelfAttr *A) {
     465             :     return true; 
     466             :   }
     467             :   bool TraverseNSReturnsAutoreleasedAttr(NSReturnsAutoreleasedAttr *A);
     468             :   bool VisitNSReturnsAutoreleasedAttr(NSReturnsAutoreleasedAttr *A) {
     469             :     return true; 
     470             :   }
     471             :   bool TraverseNSReturnsNotRetainedAttr(NSReturnsNotRetainedAttr *A);
     472             :   bool VisitNSReturnsNotRetainedAttr(NSReturnsNotRetainedAttr *A) {
     473             :     return true; 
     474             :   }
     475             :   bool TraverseNSReturnsRetainedAttr(NSReturnsRetainedAttr *A);
     476             :   bool VisitNSReturnsRetainedAttr(NSReturnsRetainedAttr *A) {
     477             :     return true; 
     478             :   }
     479             :   bool TraverseNakedAttr(NakedAttr *A);
     480             :   bool VisitNakedAttr(NakedAttr *A) {
     481             :     return true; 
     482             :   }
     483             :   bool TraverseNoAliasAttr(NoAliasAttr *A);
     484             :   bool VisitNoAliasAttr(NoAliasAttr *A) {
     485             :     return true; 
     486             :   }
     487             :   bool TraverseNoCommonAttr(NoCommonAttr *A);
     488             :   bool VisitNoCommonAttr(NoCommonAttr *A) {
     489             :     return true; 
     490             :   }
     491             :   bool TraverseNoDebugAttr(NoDebugAttr *A);
     492             :   bool VisitNoDebugAttr(NoDebugAttr *A) {
     493             :     return true; 
     494             :   }
     495             :   bool TraverseNoDuplicateAttr(NoDuplicateAttr *A);
     496             :   bool VisitNoDuplicateAttr(NoDuplicateAttr *A) {
     497             :     return true; 
     498             :   }
     499             :   bool TraverseNoEscapeAttr(NoEscapeAttr *A);
     500             :   bool VisitNoEscapeAttr(NoEscapeAttr *A) {
     501             :     return true; 
     502             :   }
     503             :   bool TraverseNoInlineAttr(NoInlineAttr *A);
     504             :   bool VisitNoInlineAttr(NoInlineAttr *A) {
     505             :     return true; 
     506             :   }
     507             :   bool TraverseNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A);
     508             :   bool VisitNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A) {
     509             :     return true; 
     510             :   }
     511             :   bool TraverseNoMicroMipsAttr(NoMicroMipsAttr *A);
     512             :   bool VisitNoMicroMipsAttr(NoMicroMipsAttr *A) {
     513             :     return true; 
     514             :   }
     515             :   bool TraverseNoMips16Attr(NoMips16Attr *A);
     516             :   bool VisitNoMips16Attr(NoMips16Attr *A) {
     517             :     return true; 
     518             :   }
     519             :   bool TraverseNoReturnAttr(NoReturnAttr *A);
     520             :   bool VisitNoReturnAttr(NoReturnAttr *A) {
     521             :     return true; 
     522             :   }
     523             :   bool TraverseNoSanitizeAttr(NoSanitizeAttr *A);
     524             :   bool VisitNoSanitizeAttr(NoSanitizeAttr *A) {
     525             :     return true; 
     526             :   }
     527             :   bool TraverseNoSplitStackAttr(NoSplitStackAttr *A);
     528             :   bool VisitNoSplitStackAttr(NoSplitStackAttr *A) {
     529             :     return true; 
     530             :   }
     531             :   bool TraverseNoStackProtectorAttr(NoStackProtectorAttr *A);
     532             :   bool VisitNoStackProtectorAttr(NoStackProtectorAttr *A) {
     533             :     return true; 
     534             :   }
     535             :   bool TraverseNoThreadSafetyAnalysisAttr(NoThreadSafetyAnalysisAttr *A);
     536             :   bool VisitNoThreadSafetyAnalysisAttr(NoThreadSafetyAnalysisAttr *A) {
     537             :     return true; 
     538             :   }
     539             :   bool TraverseNoThrowAttr(NoThrowAttr *A);
     540             :   bool VisitNoThrowAttr(NoThrowAttr *A) {
     541             :     return true; 
     542             :   }
     543             :   bool TraverseNonNullAttr(NonNullAttr *A);
     544             :   bool VisitNonNullAttr(NonNullAttr *A) {
     545             :     return true; 
     546             :   }
     547             :   bool TraverseNotTailCalledAttr(NotTailCalledAttr *A);
     548             :   bool VisitNotTailCalledAttr(NotTailCalledAttr *A) {
     549             :     return true; 
     550             :   }
     551             :   bool TraverseOMPCaptureKindAttr(OMPCaptureKindAttr *A);
     552             :   bool VisitOMPCaptureKindAttr(OMPCaptureKindAttr *A) {
     553             :     return true; 
     554             :   }
     555             :   bool TraverseOMPCaptureNoInitAttr(OMPCaptureNoInitAttr *A);
     556             :   bool VisitOMPCaptureNoInitAttr(OMPCaptureNoInitAttr *A) {
     557             :     return true; 
     558             :   }
     559             :   bool TraverseOMPDeclareSimdDeclAttr(OMPDeclareSimdDeclAttr *A);
     560             :   bool VisitOMPDeclareSimdDeclAttr(OMPDeclareSimdDeclAttr *A) {
     561             :     return true; 
     562             :   }
     563             :   bool TraverseOMPDeclareTargetDeclAttr(OMPDeclareTargetDeclAttr *A);
     564             :   bool VisitOMPDeclareTargetDeclAttr(OMPDeclareTargetDeclAttr *A) {
     565             :     return true; 
     566             :   }
     567             :   bool TraverseOMPReferencedVarAttr(OMPReferencedVarAttr *A);
     568             :   bool VisitOMPReferencedVarAttr(OMPReferencedVarAttr *A) {
     569             :     return true; 
     570             :   }
     571             :   bool TraverseOMPThreadPrivateDeclAttr(OMPThreadPrivateDeclAttr *A);
     572             :   bool VisitOMPThreadPrivateDeclAttr(OMPThreadPrivateDeclAttr *A) {
     573             :     return true; 
     574             :   }
     575             :   bool TraverseObjCBoxableAttr(ObjCBoxableAttr *A);
     576             :   bool VisitObjCBoxableAttr(ObjCBoxableAttr *A) {
     577             :     return true; 
     578             :   }
     579             :   bool TraverseObjCBridgeAttr(ObjCBridgeAttr *A);
     580             :   bool VisitObjCBridgeAttr(ObjCBridgeAttr *A) {
     581             :     return true; 
     582             :   }
     583             :   bool TraverseObjCBridgeMutableAttr(ObjCBridgeMutableAttr *A);
     584             :   bool VisitObjCBridgeMutableAttr(ObjCBridgeMutableAttr *A) {
     585             :     return true; 
     586             :   }
     587             :   bool TraverseObjCBridgeRelatedAttr(ObjCBridgeRelatedAttr *A);
     588             :   bool VisitObjCBridgeRelatedAttr(ObjCBridgeRelatedAttr *A) {
     589             :     return true; 
     590             :   }
     591             :   bool TraverseObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A);
     592             :   bool VisitObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A) {
     593             :     return true; 
     594             :   }
     595             :   bool TraverseObjCExceptionAttr(ObjCExceptionAttr *A);
     596             :   bool VisitObjCExceptionAttr(ObjCExceptionAttr *A) {
     597             :     return true; 
     598             :   }
     599             :   bool TraverseObjCExplicitProtocolImplAttr(ObjCExplicitProtocolImplAttr *A);
     600             :   bool VisitObjCExplicitProtocolImplAttr(ObjCExplicitProtocolImplAttr *A) {
     601             :     return true; 
     602             :   }
     603             :   bool TraverseObjCIndependentClassAttr(ObjCIndependentClassAttr *A);
     604             :   bool VisitObjCIndependentClassAttr(ObjCIndependentClassAttr *A) {
     605             :     return true; 
     606             :   }
     607             :   bool TraverseObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A);
     608             :   bool VisitObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A) {
     609             :     return true; 
     610             :   }
     611             :   bool TraverseObjCNSObjectAttr(ObjCNSObjectAttr *A);
     612             :   bool VisitObjCNSObjectAttr(ObjCNSObjectAttr *A) {
     613             :     return true; 
     614             :   }
     615             :   bool TraverseObjCPreciseLifetimeAttr(ObjCPreciseLifetimeAttr *A);
     616             :   bool VisitObjCPreciseLifetimeAttr(ObjCPreciseLifetimeAttr *A) {
     617             :     return true; 
     618             :   }
     619             :   bool TraverseObjCRequiresPropertyDefsAttr(ObjCRequiresPropertyDefsAttr *A);
     620             :   bool VisitObjCRequiresPropertyDefsAttr(ObjCRequiresPropertyDefsAttr *A) {
     621             :     return true; 
     622             :   }
     623             :   bool TraverseObjCRequiresSuperAttr(ObjCRequiresSuperAttr *A);
     624             :   bool VisitObjCRequiresSuperAttr(ObjCRequiresSuperAttr *A) {
     625             :     return true; 
     626             :   }
     627             :   bool TraverseObjCReturnsInnerPointerAttr(ObjCReturnsInnerPointerAttr *A);
     628             :   bool VisitObjCReturnsInnerPointerAttr(ObjCReturnsInnerPointerAttr *A) {
     629             :     return true; 
     630             :   }
     631             :   bool TraverseObjCRootClassAttr(ObjCRootClassAttr *A);
     632             :   bool VisitObjCRootClassAttr(ObjCRootClassAttr *A) {
     633             :     return true; 
     634             :   }
     635             :   bool TraverseObjCRuntimeNameAttr(ObjCRuntimeNameAttr *A);
     636             :   bool VisitObjCRuntimeNameAttr(ObjCRuntimeNameAttr *A) {
     637             :     return true; 
     638             :   }
     639             :   bool TraverseObjCRuntimeVisibleAttr(ObjCRuntimeVisibleAttr *A);
     640             :   bool VisitObjCRuntimeVisibleAttr(ObjCRuntimeVisibleAttr *A) {
     641             :     return true; 
     642             :   }
     643             :   bool TraverseObjCSubclassingRestrictedAttr(ObjCSubclassingRestrictedAttr *A);
     644             :   bool VisitObjCSubclassingRestrictedAttr(ObjCSubclassingRestrictedAttr *A) {
     645             :     return true; 
     646             :   }
     647             :   bool TraverseOpenCLAccessAttr(OpenCLAccessAttr *A);
     648             :   bool VisitOpenCLAccessAttr(OpenCLAccessAttr *A) {
     649             :     return true; 
     650             :   }
     651             :   bool TraverseOpenCLIntelReqdSubGroupSizeAttr(OpenCLIntelReqdSubGroupSizeAttr *A);
     652             :   bool VisitOpenCLIntelReqdSubGroupSizeAttr(OpenCLIntelReqdSubGroupSizeAttr *A) {
     653             :     return true; 
     654             :   }
     655             :   bool TraverseOpenCLKernelAttr(OpenCLKernelAttr *A);
     656             :   bool VisitOpenCLKernelAttr(OpenCLKernelAttr *A) {
     657             :     return true; 
     658             :   }
     659             :   bool TraverseOpenCLUnrollHintAttr(OpenCLUnrollHintAttr *A);
     660             :   bool VisitOpenCLUnrollHintAttr(OpenCLUnrollHintAttr *A) {
     661             :     return true; 
     662             :   }
     663             :   bool TraverseOptimizeNoneAttr(OptimizeNoneAttr *A);
     664             :   bool VisitOptimizeNoneAttr(OptimizeNoneAttr *A) {
     665             :     return true; 
     666             :   }
     667             :   bool TraverseOverloadableAttr(OverloadableAttr *A);
     668             :   bool VisitOverloadableAttr(OverloadableAttr *A) {
     669             :     return true; 
     670             :   }
     671             :   bool TraverseOverrideAttr(OverrideAttr *A);
     672             :   bool VisitOverrideAttr(OverrideAttr *A) {
     673             :     return true; 
     674             :   }
     675             :   bool TraverseOwnershipAttr(OwnershipAttr *A);
     676             :   bool VisitOwnershipAttr(OwnershipAttr *A) {
     677             :     return true; 
     678             :   }
     679             :   bool TraversePackedAttr(PackedAttr *A);
     680             :   bool VisitPackedAttr(PackedAttr *A) {
     681             :     return true; 
     682             :   }
     683             :   bool TraverseParamTypestateAttr(ParamTypestateAttr *A);
     684             :   bool VisitParamTypestateAttr(ParamTypestateAttr *A) {
     685             :     return true; 
     686             :   }
     687             :   bool TraversePascalAttr(PascalAttr *A);
     688             :   bool VisitPascalAttr(PascalAttr *A) {
     689             :     return true; 
     690             :   }
     691             :   bool TraversePassObjectSizeAttr(PassObjectSizeAttr *A);
     692             :   bool VisitPassObjectSizeAttr(PassObjectSizeAttr *A) {
     693             :     return true; 
     694             :   }
     695             :   bool TraversePcsAttr(PcsAttr *A);
     696             :   bool VisitPcsAttr(PcsAttr *A) {
     697             :     return true; 
     698             :   }
     699             :   bool TraversePragmaClangBSSSectionAttr(PragmaClangBSSSectionAttr *A);
     700             :   bool VisitPragmaClangBSSSectionAttr(PragmaClangBSSSectionAttr *A) {
     701             :     return true; 
     702             :   }
     703             :   bool TraversePragmaClangDataSectionAttr(PragmaClangDataSectionAttr *A);
     704             :   bool VisitPragmaClangDataSectionAttr(PragmaClangDataSectionAttr *A) {
     705             :     return true; 
     706             :   }
     707             :   bool TraversePragmaClangRodataSectionAttr(PragmaClangRodataSectionAttr *A);
     708             :   bool VisitPragmaClangRodataSectionAttr(PragmaClangRodataSectionAttr *A) {
     709             :     return true; 
     710             :   }
     711             :   bool TraversePragmaClangTextSectionAttr(PragmaClangTextSectionAttr *A);
     712             :   bool VisitPragmaClangTextSectionAttr(PragmaClangTextSectionAttr *A) {
     713             :     return true; 
     714             :   }
     715             :   bool TraversePreserveAllAttr(PreserveAllAttr *A);
     716             :   bool VisitPreserveAllAttr(PreserveAllAttr *A) {
     717             :     return true; 
     718             :   }
     719             :   bool TraversePreserveMostAttr(PreserveMostAttr *A);
     720             :   bool VisitPreserveMostAttr(PreserveMostAttr *A) {
     721             :     return true; 
     722             :   }
     723             :   bool TraversePtGuardedByAttr(PtGuardedByAttr *A);
     724             :   bool VisitPtGuardedByAttr(PtGuardedByAttr *A) {
     725             :     return true; 
     726             :   }
     727             :   bool TraversePtGuardedVarAttr(PtGuardedVarAttr *A);
     728             :   bool VisitPtGuardedVarAttr(PtGuardedVarAttr *A) {
     729             :     return true; 
     730             :   }
     731             :   bool TraversePureAttr(PureAttr *A);
     732             :   bool VisitPureAttr(PureAttr *A) {
     733             :     return true; 
     734             :   }
     735             :   bool TraverseRegCallAttr(RegCallAttr *A);
     736             :   bool VisitRegCallAttr(RegCallAttr *A) {
     737             :     return true; 
     738             :   }
     739             :   bool TraverseReleaseCapabilityAttr(ReleaseCapabilityAttr *A);
     740             :   bool VisitReleaseCapabilityAttr(ReleaseCapabilityAttr *A) {
     741             :     return true; 
     742             :   }
     743             :   bool TraverseRenderScriptKernelAttr(RenderScriptKernelAttr *A);
     744             :   bool VisitRenderScriptKernelAttr(RenderScriptKernelAttr *A) {
     745             :     return true; 
     746             :   }
     747             :   bool TraverseReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A);
     748             :   bool VisitReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A) {
     749             :     return true; 
     750             :   }
     751             :   bool TraverseRequireConstantInitAttr(RequireConstantInitAttr *A);
     752             :   bool VisitRequireConstantInitAttr(RequireConstantInitAttr *A) {
     753             :     return true; 
     754             :   }
     755             :   bool TraverseRequiresCapabilityAttr(RequiresCapabilityAttr *A);
     756             :   bool VisitRequiresCapabilityAttr(RequiresCapabilityAttr *A) {
     757             :     return true; 
     758             :   }
     759             :   bool TraverseRestrictAttr(RestrictAttr *A);
     760             :   bool VisitRestrictAttr(RestrictAttr *A) {
     761             :     return true; 
     762             :   }
     763             :   bool TraverseReturnTypestateAttr(ReturnTypestateAttr *A);
     764             :   bool VisitReturnTypestateAttr(ReturnTypestateAttr *A) {
     765             :     return true; 
     766             :   }
     767             :   bool TraverseReturnsNonNullAttr(ReturnsNonNullAttr *A);
     768             :   bool VisitReturnsNonNullAttr(ReturnsNonNullAttr *A) {
     769             :     return true; 
     770             :   }
     771             :   bool TraverseReturnsTwiceAttr(ReturnsTwiceAttr *A);
     772             :   bool VisitReturnsTwiceAttr(ReturnsTwiceAttr *A) {
     773             :     return true; 
     774             :   }
     775             :   bool TraverseScopedLockableAttr(ScopedLockableAttr *A);
     776             :   bool VisitScopedLockableAttr(ScopedLockableAttr *A) {
     777             :     return true; 
     778             :   }
     779             :   bool TraverseSectionAttr(SectionAttr *A);
     780             :   bool VisitSectionAttr(SectionAttr *A) {
     781             :     return true; 
     782             :   }
     783             :   bool TraverseSelectAnyAttr(SelectAnyAttr *A);
     784             :   bool VisitSelectAnyAttr(SelectAnyAttr *A) {
     785             :     return true; 
     786             :   }
     787             :   bool TraverseSentinelAttr(SentinelAttr *A);
     788             :   bool VisitSentinelAttr(SentinelAttr *A) {
     789             :     return true; 
     790             :   }
     791             :   bool TraverseSetTypestateAttr(SetTypestateAttr *A);
     792             :   bool VisitSetTypestateAttr(SetTypestateAttr *A) {
     793             :     return true; 
     794             :   }
     795             :   bool TraverseSharedTrylockFunctionAttr(SharedTrylockFunctionAttr *A);
     796             :   bool VisitSharedTrylockFunctionAttr(SharedTrylockFunctionAttr *A) {
     797             :     return true; 
     798             :   }
     799             :   bool TraverseStdCallAttr(StdCallAttr *A);
     800             :   bool VisitStdCallAttr(StdCallAttr *A) {
     801             :     return true; 
     802             :   }
     803             :   bool TraverseSuppressAttr(SuppressAttr *A);
     804             :   bool VisitSuppressAttr(SuppressAttr *A) {
     805             :     return true; 
     806             :   }
     807             :   bool TraverseSwiftCallAttr(SwiftCallAttr *A);
     808             :   bool VisitSwiftCallAttr(SwiftCallAttr *A) {
     809             :     return true; 
     810             :   }
     811             :   bool TraverseSwiftContextAttr(SwiftContextAttr *A);
     812             :   bool VisitSwiftContextAttr(SwiftContextAttr *A) {
     813             :     return true; 
     814             :   }
     815             :   bool TraverseSwiftErrorResultAttr(SwiftErrorResultAttr *A);
     816             :   bool VisitSwiftErrorResultAttr(SwiftErrorResultAttr *A) {
     817             :     return true; 
     818             :   }
     819             :   bool TraverseSwiftIndirectResultAttr(SwiftIndirectResultAttr *A);
     820             :   bool VisitSwiftIndirectResultAttr(SwiftIndirectResultAttr *A) {
     821             :     return true; 
     822             :   }
     823             :   bool TraverseSysVABIAttr(SysVABIAttr *A);
     824             :   bool VisitSysVABIAttr(SysVABIAttr *A) {
     825             :     return true; 
     826             :   }
     827             :   bool TraverseTLSModelAttr(TLSModelAttr *A);
     828             :   bool VisitTLSModelAttr(TLSModelAttr *A) {
     829             :     return true; 
     830             :   }
     831             :   bool TraverseTargetAttr(TargetAttr *A);
     832             :   bool VisitTargetAttr(TargetAttr *A) {
     833             :     return true; 
     834             :   }
     835             :   bool TraverseTestTypestateAttr(TestTypestateAttr *A);
     836             :   bool VisitTestTypestateAttr(TestTypestateAttr *A) {
     837             :     return true; 
     838             :   }
     839             :   bool TraverseThisCallAttr(ThisCallAttr *A);
     840             :   bool VisitThisCallAttr(ThisCallAttr *A) {
     841             :     return true; 
     842             :   }
     843             :   bool TraverseThreadAttr(ThreadAttr *A);
     844             :   bool VisitThreadAttr(ThreadAttr *A) {
     845             :     return true; 
     846             :   }
     847             :   bool TraverseTransparentUnionAttr(TransparentUnionAttr *A);
     848             :   bool VisitTransparentUnionAttr(TransparentUnionAttr *A) {
     849             :     return true; 
     850             :   }
     851             :   bool TraverseTrivialABIAttr(TrivialABIAttr *A);
     852             :   bool VisitTrivialABIAttr(TrivialABIAttr *A) {
     853             :     return true; 
     854             :   }
     855             :   bool TraverseTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A);
     856             :   bool VisitTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A) {
     857             :     return true; 
     858             :   }
     859             :   bool TraverseTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A);
     860             :   bool VisitTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A) {
     861             :     return true; 
     862             :   }
     863             :   bool TraverseTypeVisibilityAttr(TypeVisibilityAttr *A);
     864             :   bool VisitTypeVisibilityAttr(TypeVisibilityAttr *A) {
     865             :     return true; 
     866             :   }
     867             :   bool TraverseUnavailableAttr(UnavailableAttr *A);
     868             :   bool VisitUnavailableAttr(UnavailableAttr *A) {
     869             :     return true; 
     870             :   }
     871             :   bool TraverseUnusedAttr(UnusedAttr *A);
     872             :   bool VisitUnusedAttr(UnusedAttr *A) {
     873             :     return true; 
     874             :   }
     875             :   bool TraverseUsedAttr(UsedAttr *A);
     876             :   bool VisitUsedAttr(UsedAttr *A) {
     877             :     return true; 
     878             :   }
     879             :   bool TraverseUuidAttr(UuidAttr *A);
     880             :   bool VisitUuidAttr(UuidAttr *A) {
     881             :     return true; 
     882             :   }
     883             :   bool TraverseVecReturnAttr(VecReturnAttr *A);
     884             :   bool VisitVecReturnAttr(VecReturnAttr *A) {
     885             :     return true; 
     886             :   }
     887             :   bool TraverseVecTypeHintAttr(VecTypeHintAttr *A);
     888             :   bool VisitVecTypeHintAttr(VecTypeHintAttr *A) {
     889             :     return true; 
     890             :   }
     891             :   bool TraverseVectorCallAttr(VectorCallAttr *A);
     892             :   bool VisitVectorCallAttr(VectorCallAttr *A) {
     893             :     return true; 
     894             :   }
     895             :   bool TraverseVisibilityAttr(VisibilityAttr *A);
     896             :   bool VisitVisibilityAttr(VisibilityAttr *A) {
     897             :     return true; 
     898             :   }
     899             :   bool TraverseWarnUnusedAttr(WarnUnusedAttr *A);
     900             :   bool VisitWarnUnusedAttr(WarnUnusedAttr *A) {
     901             :     return true; 
     902             :   }
     903             :   bool TraverseWarnUnusedResultAttr(WarnUnusedResultAttr *A);
     904             :   bool VisitWarnUnusedResultAttr(WarnUnusedResultAttr *A) {
     905             :     return true; 
     906             :   }
     907             :   bool TraverseWeakAttr(WeakAttr *A);
     908             :   bool VisitWeakAttr(WeakAttr *A) {
     909             :     return true; 
     910             :   }
     911             :   bool TraverseWeakImportAttr(WeakImportAttr *A);
     912             :   bool VisitWeakImportAttr(WeakImportAttr *A) {
     913             :     return true; 
     914             :   }
     915             :   bool TraverseWeakRefAttr(WeakRefAttr *A);
     916             :   bool VisitWeakRefAttr(WeakRefAttr *A) {
     917             :     return true; 
     918             :   }
     919             :   bool TraverseWorkGroupSizeHintAttr(WorkGroupSizeHintAttr *A);
     920             :   bool VisitWorkGroupSizeHintAttr(WorkGroupSizeHintAttr *A) {
     921             :     return true; 
     922             :   }
     923             :   bool TraverseX86ForceAlignArgPointerAttr(X86ForceAlignArgPointerAttr *A);
     924             :   bool VisitX86ForceAlignArgPointerAttr(X86ForceAlignArgPointerAttr *A) {
     925             :     return true; 
     926             :   }
     927             :   bool TraverseXRayInstrumentAttr(XRayInstrumentAttr *A);
     928             :   bool VisitXRayInstrumentAttr(XRayInstrumentAttr *A) {
     929             :     return true; 
     930             :   }
     931             :   bool TraverseXRayLogArgsAttr(XRayLogArgsAttr *A);
     932             :   bool VisitXRayLogArgsAttr(XRayLogArgsAttr *A) {
     933             :     return true; 
     934             :   }
     935             : 
     936             : #else // ATTR_VISITOR_DECLS_ONLY
     937             : 
     938             : template <typename Derived>
     939             : bool VISITORCLASS<Derived>::TraverseAMDGPUFlatWorkGroupSizeAttr(AMDGPUFlatWorkGroupSizeAttr *A) {
     940             :   if (!getDerived().VisitAttr(A))
     941             :     return false;
     942             :   if (!getDerived().VisitAMDGPUFlatWorkGroupSizeAttr(A))
     943             :     return false;
     944             :   return true;
     945             : }
     946             : 
     947             : template <typename Derived>
     948             : bool VISITORCLASS<Derived>::TraverseAMDGPUNumSGPRAttr(AMDGPUNumSGPRAttr *A) {
     949             :   if (!getDerived().VisitAttr(A))
     950             :     return false;
     951             :   if (!getDerived().VisitAMDGPUNumSGPRAttr(A))
     952             :     return false;
     953             :   return true;
     954             : }
     955             : 
     956             : template <typename Derived>
     957             : bool VISITORCLASS<Derived>::TraverseAMDGPUNumVGPRAttr(AMDGPUNumVGPRAttr *A) {
     958             :   if (!getDerived().VisitAttr(A))
     959             :     return false;
     960             :   if (!getDerived().VisitAMDGPUNumVGPRAttr(A))
     961             :     return false;
     962             :   return true;
     963             : }
     964             : 
     965             : template <typename Derived>
     966             : bool VISITORCLASS<Derived>::TraverseAMDGPUWavesPerEUAttr(AMDGPUWavesPerEUAttr *A) {
     967             :   if (!getDerived().VisitAttr(A))
     968             :     return false;
     969             :   if (!getDerived().VisitAMDGPUWavesPerEUAttr(A))
     970             :     return false;
     971             :   return true;
     972             : }
     973             : 
     974             : template <typename Derived>
     975             : bool VISITORCLASS<Derived>::TraverseARMInterruptAttr(ARMInterruptAttr *A) {
     976             :   if (!getDerived().VisitAttr(A))
     977             :     return false;
     978             :   if (!getDerived().VisitARMInterruptAttr(A))
     979             :     return false;
     980             :   return true;
     981             : }
     982             : 
     983             : template <typename Derived>
     984             : bool VISITORCLASS<Derived>::TraverseAVRInterruptAttr(AVRInterruptAttr *A) {
     985             :   if (!getDerived().VisitAttr(A))
     986             :     return false;
     987             :   if (!getDerived().VisitAVRInterruptAttr(A))
     988             :     return false;
     989             :   return true;
     990             : }
     991             : 
     992             : template <typename Derived>
     993             : bool VISITORCLASS<Derived>::TraverseAVRSignalAttr(AVRSignalAttr *A) {
     994             :   if (!getDerived().VisitAttr(A))
     995             :     return false;
     996             :   if (!getDerived().VisitAVRSignalAttr(A))
     997             :     return false;
     998             :   return true;
     999             : }
    1000             : 
    1001             : template <typename Derived>
    1002             : bool VISITORCLASS<Derived>::TraverseAbiTagAttr(AbiTagAttr *A) {
    1003             :   if (!getDerived().VisitAttr(A))
    1004             :     return false;
    1005             :   if (!getDerived().VisitAbiTagAttr(A))
    1006             :     return false;
    1007             :   return true;
    1008             : }
    1009             : 
    1010             : template <typename Derived>
    1011           0 : bool VISITORCLASS<Derived>::TraverseAcquireCapabilityAttr(AcquireCapabilityAttr *A) {
    1012             :   if (!getDerived().VisitAttr(A))
    1013             :     return false;
    1014             :   if (!getDerived().VisitAcquireCapabilityAttr(A))
    1015             :     return false;
    1016             :   {
    1017           0 :     Expr * *I = A->args_begin();
    1018           0 :     Expr * *E = A->args_end();
    1019           0 :     for (; I != E; ++I) {
    1020           0 :       if (!getDerived().TraverseStmt(*I))
    1021             :         return false;
    1022             :     }
    1023             :   }
    1024             :   return true;
    1025             : }
    1026             : 
    1027             : template <typename Derived>
    1028           0 : bool VISITORCLASS<Derived>::TraverseAcquiredAfterAttr(AcquiredAfterAttr *A) {
    1029             :   if (!getDerived().VisitAttr(A))
    1030             :     return false;
    1031             :   if (!getDerived().VisitAcquiredAfterAttr(A))
    1032             :     return false;
    1033             :   {
    1034           0 :     Expr * *I = A->args_begin();
    1035           0 :     Expr * *E = A->args_end();
    1036           0 :     for (; I != E; ++I) {
    1037           0 :       if (!getDerived().TraverseStmt(*I))
    1038             :         return false;
    1039             :     }
    1040             :   }
    1041             :   return true;
    1042             : }
    1043             : 
    1044             : template <typename Derived>
    1045           0 : bool VISITORCLASS<Derived>::TraverseAcquiredBeforeAttr(AcquiredBeforeAttr *A) {
    1046             :   if (!getDerived().VisitAttr(A))
    1047             :     return false;
    1048             :   if (!getDerived().VisitAcquiredBeforeAttr(A))
    1049             :     return false;
    1050             :   {
    1051           0 :     Expr * *I = A->args_begin();
    1052           0 :     Expr * *E = A->args_end();
    1053           0 :     for (; I != E; ++I) {
    1054           0 :       if (!getDerived().TraverseStmt(*I))
    1055             :         return false;
    1056             :     }
    1057             :   }
    1058             :   return true;
    1059             : }
    1060             : 
    1061             : template <typename Derived>
    1062             : bool VISITORCLASS<Derived>::TraverseAliasAttr(AliasAttr *A) {
    1063             :   if (!getDerived().VisitAttr(A))
    1064             :     return false;
    1065             :   if (!getDerived().VisitAliasAttr(A))
    1066             :     return false;
    1067             :   return true;
    1068             : }
    1069             : 
    1070             : template <typename Derived>
    1071             : bool VISITORCLASS<Derived>::TraverseAlignMac68kAttr(AlignMac68kAttr *A) {
    1072             :   if (!getDerived().VisitAttr(A))
    1073             :     return false;
    1074             :   if (!getDerived().VisitAlignMac68kAttr(A))
    1075             :     return false;
    1076             :   return true;
    1077             : }
    1078             : 
    1079             : template <typename Derived>
    1080           0 : bool VISITORCLASS<Derived>::TraverseAlignValueAttr(AlignValueAttr *A) {
    1081             :   if (!getDerived().VisitAttr(A))
    1082             :     return false;
    1083             :   if (!getDerived().VisitAlignValueAttr(A))
    1084             :     return false;
    1085           0 :   if (!getDerived().TraverseStmt(A->getAlignment()))
    1086             :     return false;
    1087           0 :   return true;
    1088             : }
    1089             : 
    1090             : template <typename Derived>
    1091          74 : bool VISITORCLASS<Derived>::TraverseAlignedAttr(AlignedAttr *A) {
    1092             :   if (!getDerived().VisitAttr(A))
    1093             :     return false;
    1094             :   if (!getDerived().VisitAlignedAttr(A))
    1095             :     return false;
    1096          74 :   if (A->isAlignmentExpr()) {
    1097          54 :     if (!getDerived().TraverseStmt(A->getAlignmentExpr()))
    1098             :       return false;
    1099           0 :   } else if (auto *TSI = A->getAlignmentType()) {
    1100           0 :     if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
    1101             :       return false;
    1102             :   }
    1103             :   return true;
    1104             : }
    1105             : 
    1106             : template <typename Derived>
    1107             : bool VISITORCLASS<Derived>::TraverseAllocAlignAttr(AllocAlignAttr *A) {
    1108             :   if (!getDerived().VisitAttr(A))
    1109             :     return false;
    1110             :   if (!getDerived().VisitAllocAlignAttr(A))
    1111             :     return false;
    1112             :   return true;
    1113             : }
    1114             : 
    1115             : template <typename Derived>
    1116             : bool VISITORCLASS<Derived>::TraverseAllocSizeAttr(AllocSizeAttr *A) {
    1117             :   if (!getDerived().VisitAttr(A))
    1118             :     return false;
    1119             :   if (!getDerived().VisitAllocSizeAttr(A))
    1120             :     return false;
    1121             :   return true;
    1122             : }
    1123             : 
    1124             : template <typename Derived>
    1125             : bool VISITORCLASS<Derived>::TraverseAlwaysInlineAttr(AlwaysInlineAttr *A) {
    1126             :   if (!getDerived().VisitAttr(A))
    1127             :     return false;
    1128             :   if (!getDerived().VisitAlwaysInlineAttr(A))
    1129             :     return false;
    1130             :   return true;
    1131             : }
    1132             : 
    1133             : template <typename Derived>
    1134             : bool VISITORCLASS<Derived>::TraverseAnalyzerNoReturnAttr(AnalyzerNoReturnAttr *A) {
    1135             :   if (!getDerived().VisitAttr(A))
    1136             :     return false;
    1137             :   if (!getDerived().VisitAnalyzerNoReturnAttr(A))
    1138             :     return false;
    1139             :   return true;
    1140             : }
    1141             : 
    1142             : template <typename Derived>
    1143             : bool VISITORCLASS<Derived>::TraverseAnnotateAttr(AnnotateAttr *A) {
    1144             :   if (!getDerived().VisitAttr(A))
    1145             :     return false;
    1146             :   if (!getDerived().VisitAnnotateAttr(A))
    1147             :     return false;
    1148             :   return true;
    1149             : }
    1150             : 
    1151             : template <typename Derived>
    1152             : bool VISITORCLASS<Derived>::TraverseAnyX86InterruptAttr(AnyX86InterruptAttr *A) {
    1153             :   if (!getDerived().VisitAttr(A))
    1154             :     return false;
    1155             :   if (!getDerived().VisitAnyX86InterruptAttr(A))
    1156             :     return false;
    1157             :   return true;
    1158             : }
    1159             : 
    1160             : template <typename Derived>
    1161             : bool VISITORCLASS<Derived>::TraverseAnyX86NoCallerSavedRegistersAttr(AnyX86NoCallerSavedRegistersAttr *A) {
    1162             :   if (!getDerived().VisitAttr(A))
    1163             :     return false;
    1164             :   if (!getDerived().VisitAnyX86NoCallerSavedRegistersAttr(A))
    1165             :     return false;
    1166             :   return true;
    1167             : }
    1168             : 
    1169             : template <typename Derived>
    1170             : bool VISITORCLASS<Derived>::TraverseAnyX86NoCfCheckAttr(AnyX86NoCfCheckAttr *A) {
    1171             :   if (!getDerived().VisitAttr(A))
    1172             :     return false;
    1173             :   if (!getDerived().VisitAnyX86NoCfCheckAttr(A))
    1174             :     return false;
    1175             :   return true;
    1176             : }
    1177             : 
    1178             : template <typename Derived>
    1179             : bool VISITORCLASS<Derived>::TraverseArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A) {
    1180             :   if (!getDerived().VisitAttr(A))
    1181             :     return false;
    1182             :   if (!getDerived().VisitArcWeakrefUnavailableAttr(A))
    1183             :     return false;
    1184             :   return true;
    1185             : }
    1186             : 
    1187             : template <typename Derived>
    1188             : bool VISITORCLASS<Derived>::TraverseArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *A) {
    1189             :   if (!getDerived().VisitAttr(A))
    1190             :     return false;
    1191             :   if (!getDerived().VisitArgumentWithTypeTagAttr(A))
    1192             :     return false;
    1193             :   return true;
    1194             : }
    1195             : 
    1196             : template <typename Derived>
    1197             : bool VISITORCLASS<Derived>::TraverseArtificialAttr(ArtificialAttr *A) {
    1198             :   if (!getDerived().VisitAttr(A))
    1199             :     return false;
    1200             :   if (!getDerived().VisitArtificialAttr(A))
    1201             :     return false;
    1202             :   return true;
    1203             : }
    1204             : 
    1205             : template <typename Derived>
    1206             : bool VISITORCLASS<Derived>::TraverseAsmLabelAttr(AsmLabelAttr *A) {
    1207             :   if (!getDerived().VisitAttr(A))
    1208             :     return false;
    1209             :   if (!getDerived().VisitAsmLabelAttr(A))
    1210             :     return false;
    1211             :   return true;
    1212             : }
    1213             : 
    1214             : template <typename Derived>
    1215           0 : bool VISITORCLASS<Derived>::TraverseAssertCapabilityAttr(AssertCapabilityAttr *A) {
    1216             :   if (!getDerived().VisitAttr(A))
    1217             :     return false;
    1218             :   if (!getDerived().VisitAssertCapabilityAttr(A))
    1219             :     return false;
    1220             :   {
    1221           0 :     Expr * *I = A->args_begin();
    1222           0 :     Expr * *E = A->args_end();
    1223           0 :     for (; I != E; ++I) {
    1224           0 :       if (!getDerived().TraverseStmt(*I))
    1225             :         return false;
    1226             :     }
    1227             :   }
    1228             :   return true;
    1229             : }
    1230             : 
    1231             : template <typename Derived>
    1232           0 : bool VISITORCLASS<Derived>::TraverseAssertExclusiveLockAttr(AssertExclusiveLockAttr *A) {
    1233             :   if (!getDerived().VisitAttr(A))
    1234             :     return false;
    1235             :   if (!getDerived().VisitAssertExclusiveLockAttr(A))
    1236             :     return false;
    1237             :   {
    1238           0 :     Expr * *I = A->args_begin();
    1239           0 :     Expr * *E = A->args_end();
    1240           0 :     for (; I != E; ++I) {
    1241           0 :       if (!getDerived().TraverseStmt(*I))
    1242             :         return false;
    1243             :     }
    1244             :   }
    1245             :   return true;
    1246             : }
    1247             : 
    1248             : template <typename Derived>
    1249           0 : bool VISITORCLASS<Derived>::TraverseAssertSharedLockAttr(AssertSharedLockAttr *A) {
    1250             :   if (!getDerived().VisitAttr(A))
    1251             :     return false;
    1252             :   if (!getDerived().VisitAssertSharedLockAttr(A))
    1253             :     return false;
    1254             :   {
    1255           0 :     Expr * *I = A->args_begin();
    1256           0 :     Expr * *E = A->args_end();
    1257           0 :     for (; I != E; ++I) {
    1258           0 :       if (!getDerived().TraverseStmt(*I))
    1259             :         return false;
    1260             :     }
    1261             :   }
    1262             :   return true;
    1263             : }
    1264             : 
    1265             : template <typename Derived>
    1266           0 : bool VISITORCLASS<Derived>::TraverseAssumeAlignedAttr(AssumeAlignedAttr *A) {
    1267             :   if (!getDerived().VisitAttr(A))
    1268             :     return false;
    1269             :   if (!getDerived().VisitAssumeAlignedAttr(A))
    1270             :     return false;
    1271           0 :   if (!getDerived().TraverseStmt(A->getAlignment()))
    1272             :     return false;
    1273           0 :   if (!getDerived().TraverseStmt(A->getOffset()))
    1274             :     return false;
    1275           0 :   return true;
    1276             : }
    1277             : 
    1278             : template <typename Derived>
    1279             : bool VISITORCLASS<Derived>::TraverseAvailabilityAttr(AvailabilityAttr *A) {
    1280             :   if (!getDerived().VisitAttr(A))
    1281             :     return false;
    1282             :   if (!getDerived().VisitAvailabilityAttr(A))
    1283             :     return false;
    1284             :   return true;
    1285             : }
    1286             : 
    1287             : template <typename Derived>
    1288             : bool VISITORCLASS<Derived>::TraverseBlocksAttr(BlocksAttr *A) {
    1289             :   if (!getDerived().VisitAttr(A))
    1290             :     return false;
    1291             :   if (!getDerived().VisitBlocksAttr(A))
    1292             :     return false;
    1293             :   return true;
    1294             : }
    1295             : 
    1296             : template <typename Derived>
    1297             : bool VISITORCLASS<Derived>::TraverseC11NoReturnAttr(C11NoReturnAttr *A) {
    1298             :   if (!getDerived().VisitAttr(A))
    1299             :     return false;
    1300             :   if (!getDerived().VisitC11NoReturnAttr(A))
    1301             :     return false;
    1302             :   return true;
    1303             : }
    1304             : 
    1305             : template <typename Derived>
    1306             : bool VISITORCLASS<Derived>::TraverseCDeclAttr(CDeclAttr *A) {
    1307             :   if (!getDerived().VisitAttr(A))
    1308             :     return false;
    1309             :   if (!getDerived().VisitCDeclAttr(A))
    1310             :     return false;
    1311             :   return true;
    1312             : }
    1313             : 
    1314             : template <typename Derived>
    1315             : bool VISITORCLASS<Derived>::TraverseCFAuditedTransferAttr(CFAuditedTransferAttr *A) {
    1316             :   if (!getDerived().VisitAttr(A))
    1317             :     return false;
    1318             :   if (!getDerived().VisitCFAuditedTransferAttr(A))
    1319             :     return false;
    1320             :   return true;
    1321             : }
    1322             : 
    1323             : template <typename Derived>
    1324             : bool VISITORCLASS<Derived>::TraverseCFConsumedAttr(CFConsumedAttr *A) {
    1325             :   if (!getDerived().VisitAttr(A))
    1326             :     return false;
    1327             :   if (!getDerived().VisitCFConsumedAttr(A))
    1328             :     return false;
    1329             :   return true;
    1330             : }
    1331             : 
    1332             : template <typename Derived>
    1333             : bool VISITORCLASS<Derived>::TraverseCFReturnsNotRetainedAttr(CFReturnsNotRetainedAttr *A) {
    1334             :   if (!getDerived().VisitAttr(A))
    1335             :     return false;
    1336             :   if (!getDerived().VisitCFReturnsNotRetainedAttr(A))
    1337             :     return false;
    1338             :   return true;
    1339             : }
    1340             : 
    1341             : template <typename Derived>
    1342             : bool VISITORCLASS<Derived>::TraverseCFReturnsRetainedAttr(CFReturnsRetainedAttr *A) {
    1343             :   if (!getDerived().VisitAttr(A))
    1344             :     return false;
    1345             :   if (!getDerived().VisitCFReturnsRetainedAttr(A))
    1346             :     return false;
    1347             :   return true;
    1348             : }
    1349             : 
    1350             : template <typename Derived>
    1351             : bool VISITORCLASS<Derived>::TraverseCFUnknownTransferAttr(CFUnknownTransferAttr *A) {
    1352             :   if (!getDerived().VisitAttr(A))
    1353             :     return false;
    1354             :   if (!getDerived().VisitCFUnknownTransferAttr(A))
    1355             :     return false;
    1356             :   return true;
    1357             : }
    1358             : 
    1359             : template <typename Derived>
    1360             : bool VISITORCLASS<Derived>::TraverseCUDAConstantAttr(CUDAConstantAttr *A) {
    1361             :   if (!getDerived().VisitAttr(A))
    1362             :     return false;
    1363             :   if (!getDerived().VisitCUDAConstantAttr(A))
    1364             :     return false;
    1365             :   return true;
    1366             : }
    1367             : 
    1368             : template <typename Derived>
    1369             : bool VISITORCLASS<Derived>::TraverseCUDADeviceAttr(CUDADeviceAttr *A) {
    1370             :   if (!getDerived().VisitAttr(A))
    1371             :     return false;
    1372             :   if (!getDerived().VisitCUDADeviceAttr(A))
    1373             :     return false;
    1374             :   return true;
    1375             : }
    1376             : 
    1377             : template <typename Derived>
    1378             : bool VISITORCLASS<Derived>::TraverseCUDAGlobalAttr(CUDAGlobalAttr *A) {
    1379             :   if (!getDerived().VisitAttr(A))
    1380             :     return false;
    1381             :   if (!getDerived().VisitCUDAGlobalAttr(A))
    1382             :     return false;
    1383             :   return true;
    1384             : }
    1385             : 
    1386             : template <typename Derived>
    1387             : bool VISITORCLASS<Derived>::TraverseCUDAHostAttr(CUDAHostAttr *A) {
    1388             :   if (!getDerived().VisitAttr(A))
    1389             :     return false;
    1390             :   if (!getDerived().VisitCUDAHostAttr(A))
    1391             :     return false;
    1392             :   return true;
    1393             : }
    1394             : 
    1395             : template <typename Derived>
    1396             : bool VISITORCLASS<Derived>::TraverseCUDAInvalidTargetAttr(CUDAInvalidTargetAttr *A) {
    1397             :   if (!getDerived().VisitAttr(A))
    1398             :     return false;
    1399             :   if (!getDerived().VisitCUDAInvalidTargetAttr(A))
    1400             :     return false;
    1401             :   return true;
    1402             : }
    1403             : 
    1404             : template <typename Derived>
    1405           0 : bool VISITORCLASS<Derived>::TraverseCUDALaunchBoundsAttr(CUDALaunchBoundsAttr *A) {
    1406             :   if (!getDerived().VisitAttr(A))
    1407             :     return false;
    1408             :   if (!getDerived().VisitCUDALaunchBoundsAttr(A))
    1409             :     return false;
    1410           0 :   if (!getDerived().TraverseStmt(A->getMaxThreads()))
    1411             :     return false;
    1412           0 :   if (!getDerived().TraverseStmt(A->getMinBlocks()))
    1413             :     return false;
    1414           0 :   return true;
    1415             : }
    1416             : 
    1417             : template <typename Derived>
    1418             : bool VISITORCLASS<Derived>::TraverseCUDASharedAttr(CUDASharedAttr *A) {
    1419             :   if (!getDerived().VisitAttr(A))
    1420             :     return false;
    1421             :   if (!getDerived().VisitCUDASharedAttr(A))
    1422             :     return false;
    1423             :   return true;
    1424             : }
    1425             : 
    1426             : template <typename Derived>
    1427             : bool VISITORCLASS<Derived>::TraverseCXX11NoReturnAttr(CXX11NoReturnAttr *A) {
    1428             :   if (!getDerived().VisitAttr(A))
    1429             :     return false;
    1430             :   if (!getDerived().VisitCXX11NoReturnAttr(A))
    1431             :     return false;
    1432             :   return true;
    1433             : }
    1434             : 
    1435             : template <typename Derived>
    1436             : bool VISITORCLASS<Derived>::TraverseCallableWhenAttr(CallableWhenAttr *A) {
    1437             :   if (!getDerived().VisitAttr(A))
    1438             :     return false;
    1439             :   if (!getDerived().VisitCallableWhenAttr(A))
    1440             :     return false;
    1441             :   return true;
    1442             : }
    1443             : 
    1444             : template <typename Derived>
    1445             : bool VISITORCLASS<Derived>::TraverseCapabilityAttr(CapabilityAttr *A) {
    1446             :   if (!getDerived().VisitAttr(A))
    1447             :     return false;
    1448             :   if (!getDerived().VisitCapabilityAttr(A))
    1449             :     return false;
    1450             :   return true;
    1451             : }
    1452             : 
    1453             : template <typename Derived>
    1454             : bool VISITORCLASS<Derived>::TraverseCapturedRecordAttr(CapturedRecordAttr *A) {
    1455             :   if (!getDerived().VisitAttr(A))
    1456             :     return false;
    1457             :   if (!getDerived().VisitCapturedRecordAttr(A))
    1458             :     return false;
    1459             :   return true;
    1460             : }
    1461             : 
    1462             : template <typename Derived>
    1463             : bool VISITORCLASS<Derived>::TraverseCarriesDependencyAttr(CarriesDependencyAttr *A) {
    1464             :   if (!getDerived().VisitAttr(A))
    1465             :     return false;
    1466             :   if (!getDerived().VisitCarriesDependencyAttr(A))
    1467             :     return false;
    1468             :   return true;
    1469             : }
    1470             : 
    1471             : template <typename Derived>
    1472             : bool VISITORCLASS<Derived>::TraverseCleanupAttr(CleanupAttr *A) {
    1473             :   if (!getDerived().VisitAttr(A))
    1474             :     return false;
    1475             :   if (!getDerived().VisitCleanupAttr(A))
    1476             :     return false;
    1477             :   return true;
    1478             : }
    1479             : 
    1480             : template <typename Derived>
    1481             : bool VISITORCLASS<Derived>::TraverseColdAttr(ColdAttr *A) {
    1482             :   if (!getDerived().VisitAttr(A))
    1483             :     return false;
    1484             :   if (!getDerived().VisitColdAttr(A))
    1485             :     return false;
    1486             :   return true;
    1487             : }
    1488             : 
    1489             : template <typename Derived>
    1490             : bool VISITORCLASS<Derived>::TraverseCommonAttr(CommonAttr *A) {
    1491             :   if (!getDerived().VisitAttr(A))
    1492             :     return false;
    1493             :   if (!getDerived().VisitCommonAttr(A))
    1494             :     return false;
    1495             :   return true;
    1496             : }
    1497             : 
    1498             : template <typename Derived>
    1499             : bool VISITORCLASS<Derived>::TraverseConstAttr(ConstAttr *A) {
    1500             :   if (!getDerived().VisitAttr(A))
    1501             :     return false;
    1502             :   if (!getDerived().VisitConstAttr(A))
    1503             :     return false;
    1504             :   return true;
    1505             : }
    1506             : 
    1507             : template <typename Derived>
    1508             : bool VISITORCLASS<Derived>::TraverseConstructorAttr(ConstructorAttr *A) {
    1509             :   if (!getDerived().VisitAttr(A))
    1510             :     return false;
    1511             :   if (!getDerived().VisitConstructorAttr(A))
    1512             :     return false;
    1513             :   return true;
    1514             : }
    1515             : 
    1516             : template <typename Derived>
    1517             : bool VISITORCLASS<Derived>::TraverseConsumableAttr(ConsumableAttr *A) {
    1518             :   if (!getDerived().VisitAttr(A))
    1519             :     return false;
    1520             :   if (!getDerived().VisitConsumableAttr(A))
    1521             :     return false;
    1522             :   return true;
    1523             : }
    1524             : 
    1525             : template <typename Derived>
    1526             : bool VISITORCLASS<Derived>::TraverseConsumableAutoCastAttr(ConsumableAutoCastAttr *A) {
    1527             :   if (!getDerived().VisitAttr(A))
    1528             :     return false;
    1529             :   if (!getDerived().VisitConsumableAutoCastAttr(A))
    1530             :     return false;
    1531             :   return true;
    1532             : }
    1533             : 
    1534             : template <typename Derived>
    1535             : bool VISITORCLASS<Derived>::TraverseConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A) {
    1536             :   if (!getDerived().VisitAttr(A))
    1537             :     return false;
    1538             :   if (!getDerived().VisitConsumableSetOnReadAttr(A))
    1539             :     return false;
    1540             :   return true;
    1541             : }
    1542             : 
    1543             : template <typename Derived>
    1544             : bool VISITORCLASS<Derived>::TraverseConvergentAttr(ConvergentAttr *A) {
    1545             :   if (!getDerived().VisitAttr(A))
    1546             :     return false;
    1547             :   if (!getDerived().VisitConvergentAttr(A))
    1548             :     return false;
    1549             :   return true;
    1550             : }
    1551             : 
    1552             : template <typename Derived>
    1553             : bool VISITORCLASS<Derived>::TraverseDLLExportAttr(DLLExportAttr *A) {
    1554             :   if (!getDerived().VisitAttr(A))
    1555             :     return false;
    1556             :   if (!getDerived().VisitDLLExportAttr(A))
    1557             :     return false;
    1558             :   return true;
    1559             : }
    1560             : 
    1561             : template <typename Derived>
    1562             : bool VISITORCLASS<Derived>::TraverseDLLImportAttr(DLLImportAttr *A) {
    1563             :   if (!getDerived().VisitAttr(A))
    1564             :     return false;
    1565             :   if (!getDerived().VisitDLLImportAttr(A))
    1566             :     return false;
    1567             :   return true;
    1568             : }
    1569             : 
    1570             : template <typename Derived>
    1571             : bool VISITORCLASS<Derived>::TraverseDeprecatedAttr(DeprecatedAttr *A) {
    1572             :   if (!getDerived().VisitAttr(A))
    1573             :     return false;
    1574             :   if (!getDerived().VisitDeprecatedAttr(A))
    1575             :     return false;
    1576             :   return true;
    1577             : }
    1578             : 
    1579             : template <typename Derived>
    1580             : bool VISITORCLASS<Derived>::TraverseDestructorAttr(DestructorAttr *A) {
    1581             :   if (!getDerived().VisitAttr(A))
    1582             :     return false;
    1583             :   if (!getDerived().VisitDestructorAttr(A))
    1584             :     return false;
    1585             :   return true;
    1586             : }
    1587             : 
    1588             : template <typename Derived>
    1589           0 : bool VISITORCLASS<Derived>::TraverseDiagnoseIfAttr(DiagnoseIfAttr *A) {
    1590             :   if (!getDerived().VisitAttr(A))
    1591             :     return false;
    1592             :   if (!getDerived().VisitDiagnoseIfAttr(A))
    1593             :     return false;
    1594           0 :   if (!getDerived().TraverseStmt(A->getCond()))
    1595             :     return false;
    1596           0 :   return true;
    1597             : }
    1598             : 
    1599             : template <typename Derived>
    1600             : bool VISITORCLASS<Derived>::TraverseDisableTailCallsAttr(DisableTailCallsAttr *A) {
    1601             :   if (!getDerived().VisitAttr(A))
    1602             :     return false;
    1603             :   if (!getDerived().VisitDisableTailCallsAttr(A))
    1604             :     return false;
    1605             :   return true;
    1606             : }
    1607             : 
    1608             : template <typename Derived>
    1609             : bool VISITORCLASS<Derived>::TraverseEmptyBasesAttr(EmptyBasesAttr *A) {
    1610             :   if (!getDerived().VisitAttr(A))
    1611             :     return false;
    1612             :   if (!getDerived().VisitEmptyBasesAttr(A))
    1613             :     return false;
    1614             :   return true;
    1615             : }
    1616             : 
    1617             : template <typename Derived>
    1618           0 : bool VISITORCLASS<Derived>::TraverseEnableIfAttr(EnableIfAttr *A) {
    1619             :   if (!getDerived().VisitAttr(A))
    1620             :     return false;
    1621             :   if (!getDerived().VisitEnableIfAttr(A))
    1622             :     return false;
    1623           0 :   if (!getDerived().TraverseStmt(A->getCond()))
    1624             :     return false;
    1625           0 :   return true;
    1626             : }
    1627             : 
    1628             : template <typename Derived>
    1629             : bool VISITORCLASS<Derived>::TraverseEnumExtensibilityAttr(EnumExtensibilityAttr *A) {
    1630             :   if (!getDerived().VisitAttr(A))
    1631             :     return false;
    1632             :   if (!getDerived().VisitEnumExtensibilityAttr(A))
    1633             :     return false;
    1634             :   return true;
    1635             : }
    1636             : 
    1637             : template <typename Derived>
    1638           0 : bool VISITORCLASS<Derived>::TraverseExclusiveTrylockFunctionAttr(ExclusiveTrylockFunctionAttr *A) {
    1639             :   if (!getDerived().VisitAttr(A))
    1640             :     return false;
    1641             :   if (!getDerived().VisitExclusiveTrylockFunctionAttr(A))
    1642             :     return false;
    1643           0 :   if (!getDerived().TraverseStmt(A->getSuccessValue()))
    1644             :     return false;
    1645             :   {
    1646           0 :     Expr * *I = A->args_begin();
    1647           0 :     Expr * *E = A->args_end();
    1648           0 :     for (; I != E; ++I) {
    1649           0 :       if (!getDerived().TraverseStmt(*I))
    1650             :         return false;
    1651             :     }
    1652             :   }
    1653             :   return true;
    1654             : }
    1655             : 
    1656             : template <typename Derived>
    1657             : bool VISITORCLASS<Derived>::TraverseExternalSourceSymbolAttr(ExternalSourceSymbolAttr *A) {
    1658             :   if (!getDerived().VisitAttr(A))
    1659             :     return false;
    1660             :   if (!getDerived().VisitExternalSourceSymbolAttr(A))
    1661             :     return false;
    1662             :   return true;
    1663             : }
    1664             : 
    1665             : template <typename Derived>
    1666             : bool VISITORCLASS<Derived>::TraverseFallThroughAttr(FallThroughAttr *A) {
    1667             :   if (!getDerived().VisitAttr(A))
    1668             :     return false;
    1669             :   if (!getDerived().VisitFallThroughAttr(A))
    1670             :     return false;
    1671             :   return true;
    1672             : }
    1673             : 
    1674             : template <typename Derived>
    1675             : bool VISITORCLASS<Derived>::TraverseFastCallAttr(FastCallAttr *A) {
    1676             :   if (!getDerived().VisitAttr(A))
    1677             :     return false;
    1678             :   if (!getDerived().VisitFastCallAttr(A))
    1679             :     return false;
    1680             :   return true;
    1681             : }
    1682             : 
    1683             : template <typename Derived>
    1684             : bool VISITORCLASS<Derived>::TraverseFinalAttr(FinalAttr *A) {
    1685             :   if (!getDerived().VisitAttr(A))
    1686             :     return false;
    1687             :   if (!getDerived().VisitFinalAttr(A))
    1688             :     return false;
    1689             :   return true;
    1690             : }
    1691             : 
    1692             : template <typename Derived>
    1693             : bool VISITORCLASS<Derived>::TraverseFlagEnumAttr(FlagEnumAttr *A) {
    1694             :   if (!getDerived().VisitAttr(A))
    1695             :     return false;
    1696             :   if (!getDerived().VisitFlagEnumAttr(A))
    1697             :     return false;
    1698             :   return true;
    1699             : }
    1700             : 
    1701             : template <typename Derived>
    1702             : bool VISITORCLASS<Derived>::TraverseFlattenAttr(FlattenAttr *A) {
    1703             :   if (!getDerived().VisitAttr(A))
    1704             :     return false;
    1705             :   if (!getDerived().VisitFlattenAttr(A))
    1706             :     return false;
    1707             :   return true;
    1708             : }
    1709             : 
    1710             : template <typename Derived>
    1711             : bool VISITORCLASS<Derived>::TraverseFormatAttr(FormatAttr *A) {
    1712             :   if (!getDerived().VisitAttr(A))
    1713             :     return false;
    1714             :   if (!getDerived().VisitFormatAttr(A))
    1715             :     return false;
    1716             :   return true;
    1717             : }
    1718             : 
    1719             : template <typename Derived>
    1720             : bool VISITORCLASS<Derived>::TraverseFormatArgAttr(FormatArgAttr *A) {
    1721             :   if (!getDerived().VisitAttr(A))
    1722             :     return false;
    1723             :   if (!getDerived().VisitFormatArgAttr(A))
    1724             :     return false;
    1725             :   return true;
    1726             : }
    1727             : 
    1728             : template <typename Derived>
    1729             : bool VISITORCLASS<Derived>::TraverseGNUInlineAttr(GNUInlineAttr *A) {
    1730             :   if (!getDerived().VisitAttr(A))
    1731             :     return false;
    1732             :   if (!getDerived().VisitGNUInlineAttr(A))
    1733             :     return false;
    1734             :   return true;
    1735             : }
    1736             : 
    1737             : template <typename Derived>
    1738           1 : bool VISITORCLASS<Derived>::TraverseGuardedByAttr(GuardedByAttr *A) {
    1739             :   if (!getDerived().VisitAttr(A))
    1740             :     return false;
    1741             :   if (!getDerived().VisitGuardedByAttr(A))
    1742             :     return false;
    1743           1 :   if (!getDerived().TraverseStmt(A->getArg()))
    1744             :     return false;
    1745           1 :   return true;
    1746             : }
    1747             : 
    1748             : template <typename Derived>
    1749             : bool VISITORCLASS<Derived>::TraverseGuardedVarAttr(GuardedVarAttr *A) {
    1750             :   if (!getDerived().VisitAttr(A))
    1751             :     return false;
    1752             :   if (!getDerived().VisitGuardedVarAttr(A))
    1753             :     return false;
    1754             :   return true;
    1755             : }
    1756             : 
    1757             : template <typename Derived>
    1758             : bool VISITORCLASS<Derived>::TraverseHotAttr(HotAttr *A) {
    1759             :   if (!getDerived().VisitAttr(A))
    1760             :     return false;
    1761             :   if (!getDerived().VisitHotAttr(A))
    1762             :     return false;
    1763             :   return true;
    1764             : }
    1765             : 
    1766             : template <typename Derived>
    1767             : bool VISITORCLASS<Derived>::TraverseIBActionAttr(IBActionAttr *A) {
    1768             :   if (!getDerived().VisitAttr(A))
    1769             :     return false;
    1770             :   if (!getDerived().VisitIBActionAttr(A))
    1771             :     return false;
    1772             :   return true;
    1773             : }
    1774             : 
    1775             : template <typename Derived>
    1776             : bool VISITORCLASS<Derived>::TraverseIBOutletAttr(IBOutletAttr *A) {
    1777             :   if (!getDerived().VisitAttr(A))
    1778             :     return false;
    1779             :   if (!getDerived().VisitIBOutletAttr(A))
    1780             :     return false;
    1781             :   return true;
    1782             : }
    1783             : 
    1784             : template <typename Derived>
    1785           0 : bool VISITORCLASS<Derived>::TraverseIBOutletCollectionAttr(IBOutletCollectionAttr *A) {
    1786             :   if (!getDerived().VisitAttr(A))
    1787             :     return false;
    1788             :   if (!getDerived().VisitIBOutletCollectionAttr(A))
    1789             :     return false;
    1790           0 :   if (auto *TSI = A->getInterfaceLoc())
    1791           0 :     if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
    1792             :       return false;
    1793             :   return true;
    1794             : }
    1795             : 
    1796             : template <typename Derived>
    1797             : bool VISITORCLASS<Derived>::TraverseIFuncAttr(IFuncAttr *A) {
    1798             :   if (!getDerived().VisitAttr(A))
    1799             :     return false;
    1800             :   if (!getDerived().VisitIFuncAttr(A))
    1801             :     return false;
    1802             :   return true;
    1803             : }
    1804             : 
    1805             : template <typename Derived>
    1806             : bool VISITORCLASS<Derived>::TraverseInitPriorityAttr(InitPriorityAttr *A) {
    1807             :   if (!getDerived().VisitAttr(A))
    1808             :     return false;
    1809             :   if (!getDerived().VisitInitPriorityAttr(A))
    1810             :     return false;
    1811             :   return true;
    1812             : }
    1813             : 
    1814             : template <typename Derived>
    1815             : bool VISITORCLASS<Derived>::TraverseInitSegAttr(InitSegAttr *A) {
    1816             :   if (!getDerived().VisitAttr(A))
    1817             :     return false;
    1818             :   if (!getDerived().VisitInitSegAttr(A))
    1819             :     return false;
    1820             :   return true;
    1821             : }
    1822             : 
    1823             : template <typename Derived>
    1824             : bool VISITORCLASS<Derived>::TraverseIntelOclBiccAttr(IntelOclBiccAttr *A) {
    1825             :   if (!getDerived().VisitAttr(A))
    1826             :     return false;
    1827             :   if (!getDerived().VisitIntelOclBiccAttr(A))
    1828             :     return false;
    1829             :   return true;
    1830             : }
    1831             : 
    1832             : template <typename Derived>
    1833             : bool VISITORCLASS<Derived>::TraverseInternalLinkageAttr(InternalLinkageAttr *A) {
    1834             :   if (!getDerived().VisitAttr(A))
    1835             :     return false;
    1836             :   if (!getDerived().VisitInternalLinkageAttr(A))
    1837             :     return false;
    1838             :   return true;
    1839             : }
    1840             : 
    1841             : template <typename Derived>
    1842             : bool VISITORCLASS<Derived>::TraverseLTOVisibilityPublicAttr(LTOVisibilityPublicAttr *A) {
    1843             :   if (!getDerived().VisitAttr(A))
    1844             :     return false;
    1845             :   if (!getDerived().VisitLTOVisibilityPublicAttr(A))
    1846             :     return false;
    1847             :   return true;
    1848             : }
    1849             : 
    1850             : template <typename Derived>
    1851             : bool VISITORCLASS<Derived>::TraverseLayoutVersionAttr(LayoutVersionAttr *A) {
    1852             :   if (!getDerived().VisitAttr(A))
    1853             :     return false;
    1854             :   if (!getDerived().VisitLayoutVersionAttr(A))
    1855             :     return false;
    1856             :   return true;
    1857             : }
    1858             : 
    1859             : template <typename Derived>
    1860           0 : bool VISITORCLASS<Derived>::TraverseLockReturnedAttr(LockReturnedAttr *A) {
    1861             :   if (!getDerived().VisitAttr(A))
    1862             :     return false;
    1863             :   if (!getDerived().VisitLockReturnedAttr(A))
    1864             :     return false;
    1865           0 :   if (!getDerived().TraverseStmt(A->getArg()))
    1866             :     return false;
    1867           0 :   return true;
    1868             : }
    1869             : 
    1870             : template <typename Derived>
    1871           0 : bool VISITORCLASS<Derived>::TraverseLocksExcludedAttr(LocksExcludedAttr *A) {
    1872             :   if (!getDerived().VisitAttr(A))
    1873             :     return false;
    1874             :   if (!getDerived().VisitLocksExcludedAttr(A))
    1875             :     return false;
    1876             :   {
    1877           0 :     Expr * *I = A->args_begin();
    1878           0 :     Expr * *E = A->args_end();
    1879           0 :     for (; I != E; ++I) {
    1880           0 :       if (!getDerived().TraverseStmt(*I))
    1881             :         return false;
    1882             :     }
    1883             :   }
    1884             :   return true;
    1885             : }
    1886             : 
    1887             : template <typename Derived>
    1888           0 : bool VISITORCLASS<Derived>::TraverseLoopHintAttr(LoopHintAttr *A) {
    1889             :   if (!getDerived().VisitAttr(A))
    1890             :     return false;
    1891             :   if (!getDerived().VisitLoopHintAttr(A))
    1892             :     return false;
    1893           0 :   if (!getDerived().TraverseStmt(A->getValue()))
    1894             :     return false;
    1895           0 :   return true;
    1896             : }
    1897             : 
    1898             : template <typename Derived>
    1899             : bool VISITORCLASS<Derived>::TraverseMSABIAttr(MSABIAttr *A) {
    1900             :   if (!getDerived().VisitAttr(A))
    1901             :     return false;
    1902             :   if (!getDerived().VisitMSABIAttr(A))
    1903             :     return false;
    1904             :   return true;
    1905             : }
    1906             : 
    1907             : template <typename Derived>
    1908             : bool VISITORCLASS<Derived>::TraverseMSInheritanceAttr(MSInheritanceAttr *A) {
    1909             :   if (!getDerived().VisitAttr(A))
    1910             :     return false;
    1911             :   if (!getDerived().VisitMSInheritanceAttr(A))
    1912             :     return false;
    1913             :   return true;
    1914             : }
    1915             : 
    1916             : template <typename Derived>
    1917             : bool VISITORCLASS<Derived>::TraverseMSNoVTableAttr(MSNoVTableAttr *A) {
    1918             :   if (!getDerived().VisitAttr(A))
    1919             :     return false;
    1920             :   if (!getDerived().VisitMSNoVTableAttr(A))
    1921             :     return false;
    1922             :   return true;
    1923             : }
    1924             : 
    1925             : template <typename Derived>
    1926             : bool VISITORCLASS<Derived>::TraverseMSP430InterruptAttr(MSP430InterruptAttr *A) {
    1927             :   if (!getDerived().VisitAttr(A))
    1928             :     return false;
    1929             :   if (!getDerived().VisitMSP430InterruptAttr(A))
    1930             :     return false;
    1931             :   return true;
    1932             : }
    1933             : 
    1934             : template <typename Derived>
    1935             : bool VISITORCLASS<Derived>::TraverseMSStructAttr(MSStructAttr *A) {
    1936             :   if (!getDerived().VisitAttr(A))
    1937             :     return false;
    1938             :   if (!getDerived().VisitMSStructAttr(A))
    1939             :     return false;
    1940             :   return true;
    1941             : }
    1942             : 
    1943             : template <typename Derived>
    1944             : bool VISITORCLASS<Derived>::TraverseMSVtorDispAttr(MSVtorDispAttr *A) {
    1945             :   if (!getDerived().VisitAttr(A))
    1946             :     return false;
    1947             :   if (!getDerived().VisitMSVtorDispAttr(A))
    1948             :     return false;
    1949             :   return true;
    1950             : }
    1951             : 
    1952             : template <typename Derived>
    1953             : bool VISITORCLASS<Derived>::TraverseMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A) {
    1954             :   if (!getDerived().VisitAttr(A))
    1955             :     return false;
    1956             :   if (!getDerived().VisitMaxFieldAlignmentAttr(A))
    1957             :     return false;
    1958             :   return true;
    1959             : }
    1960             : 
    1961             : template <typename Derived>
    1962             : bool VISITORCLASS<Derived>::TraverseMayAliasAttr(MayAliasAttr *A) {
    1963             :   if (!getDerived().VisitAttr(A))
    1964             :     return false;
    1965             :   if (!getDerived().VisitMayAliasAttr(A))
    1966             :     return false;
    1967             :   return true;
    1968             : }
    1969             : 
    1970             : template <typename Derived>
    1971             : bool VISITORCLASS<Derived>::TraverseMicroMipsAttr(MicroMipsAttr *A) {
    1972             :   if (!getDerived().VisitAttr(A))
    1973             :     return false;
    1974             :   if (!getDerived().VisitMicroMipsAttr(A))
    1975             :     return false;
    1976             :   return true;
    1977             : }
    1978             : 
    1979             : template <typename Derived>
    1980             : bool VISITORCLASS<Derived>::TraverseMinSizeAttr(MinSizeAttr *A) {
    1981             :   if (!getDerived().VisitAttr(A))
    1982             :     return false;
    1983             :   if (!getDerived().VisitMinSizeAttr(A))
    1984             :     return false;
    1985             :   return true;
    1986             : }
    1987             : 
    1988             : template <typename Derived>
    1989             : bool VISITORCLASS<Derived>::TraverseMinVectorWidthAttr(MinVectorWidthAttr *A) {
    1990             :   if (!getDerived().VisitAttr(A))
    1991             :     return false;
    1992             :   if (!getDerived().VisitMinVectorWidthAttr(A))
    1993             :     return false;
    1994             :   return true;
    1995             : }
    1996             : 
    1997             : template <typename Derived>
    1998             : bool VISITORCLASS<Derived>::TraverseMips16Attr(Mips16Attr *A) {
    1999             :   if (!getDerived().VisitAttr(A))
    2000             :     return false;
    2001             :   if (!getDerived().VisitMips16Attr(A))
    2002             :     return false;
    2003             :   return true;
    2004             : }
    2005             : 
    2006             : template <typename Derived>
    2007             : bool VISITORCLASS<Derived>::TraverseMipsInterruptAttr(MipsInterruptAttr *A) {
    2008             :   if (!getDerived().VisitAttr(A))
    2009             :     return false;
    2010             :   if (!getDerived().VisitMipsInterruptAttr(A))
    2011             :     return false;
    2012             :   return true;
    2013             : }
    2014             : 
    2015             : template <typename Derived>
    2016             : bool VISITORCLASS<Derived>::TraverseMipsLongCallAttr(MipsLongCallAttr *A) {
    2017             :   if (!getDerived().VisitAttr(A))
    2018             :     return false;
    2019             :   if (!getDerived().VisitMipsLongCallAttr(A))
    2020             :     return false;
    2021             :   return true;
    2022             : }
    2023             : 
    2024             : template <typename Derived>
    2025             : bool VISITORCLASS<Derived>::TraverseMipsShortCallAttr(MipsShortCallAttr *A) {
    2026             :   if (!getDerived().VisitAttr(A))
    2027             :     return false;
    2028             :   if (!getDerived().VisitMipsShortCallAttr(A))
    2029             :     return false;
    2030             :   return true;
    2031             : }
    2032             : 
    2033             : template <typename Derived>
    2034             : bool VISITORCLASS<Derived>::TraverseModeAttr(ModeAttr *A) {
    2035             :   if (!getDerived().VisitAttr(A))
    2036             :     return false;
    2037             :   if (!getDerived().VisitModeAttr(A))
    2038             :     return false;
    2039             :   return true;
    2040             : }
    2041             : 
    2042             : template <typename Derived>
    2043             : bool VISITORCLASS<Derived>::TraverseNSConsumedAttr(NSConsumedAttr *A) {
    2044             :   if (!getDerived().VisitAttr(A))
    2045             :     return false;
    2046             :   if (!getDerived().VisitNSConsumedAttr(A))
    2047             :     return false;
    2048             :   return true;
    2049             : }
    2050             : 
    2051             : template <typename Derived>
    2052             : bool VISITORCLASS<Derived>::TraverseNSConsumesSelfAttr(NSConsumesSelfAttr *A) {
    2053             :   if (!getDerived().VisitAttr(A))
    2054             :     return false;
    2055             :   if (!getDerived().VisitNSConsumesSelfAttr(A))
    2056             :     return false;
    2057             :   return true;
    2058             : }
    2059             : 
    2060             : template <typename Derived>
    2061             : bool VISITORCLASS<Derived>::TraverseNSReturnsAutoreleasedAttr(NSReturnsAutoreleasedAttr *A) {
    2062             :   if (!getDerived().VisitAttr(A))
    2063             :     return false;
    2064             :   if (!getDerived().VisitNSReturnsAutoreleasedAttr(A))
    2065             :     return false;
    2066             :   return true;
    2067             : }
    2068             : 
    2069             : template <typename Derived>
    2070             : bool VISITORCLASS<Derived>::TraverseNSReturnsNotRetainedAttr(NSReturnsNotRetainedAttr *A) {
    2071             :   if (!getDerived().VisitAttr(A))
    2072             :     return false;
    2073             :   if (!getDerived().VisitNSReturnsNotRetainedAttr(A))
    2074             :     return false;
    2075             :   return true;
    2076             : }
    2077             : 
    2078             : template <typename Derived>
    2079             : bool VISITORCLASS<Derived>::TraverseNSReturnsRetainedAttr(NSReturnsRetainedAttr *A) {
    2080             :   if (!getDerived().VisitAttr(A))
    2081             :     return false;
    2082             :   if (!getDerived().VisitNSReturnsRetainedAttr(A))
    2083             :     return false;
    2084             :   return true;
    2085             : }
    2086             : 
    2087             : template <typename Derived>
    2088             : bool VISITORCLASS<Derived>::TraverseNakedAttr(NakedAttr *A) {
    2089             :   if (!getDerived().VisitAttr(A))
    2090             :     return false;
    2091             :   if (!getDerived().VisitNakedAttr(A))
    2092             :     return false;
    2093             :   return true;
    2094             : }
    2095             : 
    2096             : template <typename Derived>
    2097             : bool VISITORCLASS<Derived>::TraverseNoAliasAttr(NoAliasAttr *A) {
    2098             :   if (!getDerived().VisitAttr(A))
    2099             :     return false;
    2100             :   if (!getDerived().VisitNoAliasAttr(A))
    2101             :     return false;
    2102             :   return true;
    2103             : }
    2104             : 
    2105             : template <typename Derived>
    2106             : bool VISITORCLASS<Derived>::TraverseNoCommonAttr(NoCommonAttr *A) {
    2107             :   if (!getDerived().VisitAttr(A))
    2108             :     return false;
    2109             :   if (!getDerived().VisitNoCommonAttr(A))
    2110             :     return false;
    2111             :   return true;
    2112             : }
    2113             : 
    2114             : template <typename Derived>
    2115             : bool VISITORCLASS<Derived>::TraverseNoDebugAttr(NoDebugAttr *A) {
    2116             :   if (!getDerived().VisitAttr(A))
    2117             :     return false;
    2118             :   if (!getDerived().VisitNoDebugAttr(A))
    2119             :     return false;
    2120             :   return true;
    2121             : }
    2122             : 
    2123             : template <typename Derived>
    2124             : bool VISITORCLASS<Derived>::TraverseNoDuplicateAttr(NoDuplicateAttr *A) {
    2125             :   if (!getDerived().VisitAttr(A))
    2126             :     return false;
    2127             :   if (!getDerived().VisitNoDuplicateAttr(A))
    2128             :     return false;
    2129             :   return true;
    2130             : }
    2131             : 
    2132             : template <typename Derived>
    2133             : bool VISITORCLASS<Derived>::TraverseNoEscapeAttr(NoEscapeAttr *A) {
    2134             :   if (!getDerived().VisitAttr(A))
    2135             :     return false;
    2136             :   if (!getDerived().VisitNoEscapeAttr(A))
    2137             :     return false;
    2138             :   return true;
    2139             : }
    2140             : 
    2141             : template <typename Derived>
    2142             : bool VISITORCLASS<Derived>::TraverseNoInlineAttr(NoInlineAttr *A) {
    2143             :   if (!getDerived().VisitAttr(A))
    2144             :     return false;
    2145             :   if (!getDerived().VisitNoInlineAttr(A))
    2146             :     return false;
    2147             :   return true;
    2148             : }
    2149             : 
    2150             : template <typename Derived>
    2151             : bool VISITORCLASS<Derived>::TraverseNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A) {
    2152             :   if (!getDerived().VisitAttr(A))
    2153             :     return false;
    2154             :   if (!getDerived().VisitNoInstrumentFunctionAttr(A))
    2155             :     return false;
    2156             :   return true;
    2157             : }
    2158             : 
    2159             : template <typename Derived>
    2160             : bool VISITORCLASS<Derived>::TraverseNoMicroMipsAttr(NoMicroMipsAttr *A) {
    2161             :   if (!getDerived().VisitAttr(A))
    2162             :     return false;
    2163             :   if (!getDerived().VisitNoMicroMipsAttr(A))
    2164             :     return false;
    2165             :   return true;
    2166             : }
    2167             : 
    2168             : template <typename Derived>
    2169             : bool VISITORCLASS<Derived>::TraverseNoMips16Attr(NoMips16Attr *A) {
    2170             :   if (!getDerived().VisitAttr(A))
    2171             :     return false;
    2172             :   if (!getDerived().VisitNoMips16Attr(A))
    2173             :     return false;
    2174             :   return true;
    2175             : }
    2176             : 
    2177             : template <typename Derived>
    2178             : bool VISITORCLASS<Derived>::TraverseNoReturnAttr(NoReturnAttr *A) {
    2179             :   if (!getDerived().VisitAttr(A))
    2180             :     return false;
    2181             :   if (!getDerived().VisitNoReturnAttr(A))
    2182             :     return false;
    2183             :   return true;
    2184             : }
    2185             : 
    2186             : template <typename Derived>
    2187             : bool VISITORCLASS<Derived>::TraverseNoSanitizeAttr(NoSanitizeAttr *A) {
    2188             :   if (!getDerived().VisitAttr(A))
    2189             :     return false;
    2190             :   if (!getDerived().VisitNoSanitizeAttr(A))
    2191             :     return false;
    2192             :   return true;
    2193             : }
    2194             : 
    2195             : template <typename Derived>
    2196             : bool VISITORCLASS<Derived>::TraverseNoSplitStackAttr(NoSplitStackAttr *A) {
    2197             :   if (!getDerived().VisitAttr(A))
    2198             :     return false;
    2199             :   if (!getDerived().VisitNoSplitStackAttr(A))
    2200             :     return false;
    2201             :   return true;
    2202             : }
    2203             : 
    2204             : template <typename Derived>
    2205             : bool VISITORCLASS<Derived>::TraverseNoStackProtectorAttr(NoStackProtectorAttr *A) {
    2206             :   if (!getDerived().VisitAttr(A))
    2207             :     return false;
    2208             :   if (!getDerived().VisitNoStackProtectorAttr(A))
    2209             :     return false;
    2210             :   return true;
    2211             : }
    2212             : 
    2213             : template <typename Derived>
    2214             : bool VISITORCLASS<Derived>::TraverseNoThreadSafetyAnalysisAttr(NoThreadSafetyAnalysisAttr *A) {
    2215             :   if (!getDerived().VisitAttr(A))
    2216             :     return false;
    2217             :   if (!getDerived().VisitNoThreadSafetyAnalysisAttr(A))
    2218             :     return false;
    2219             :   return true;
    2220             : }
    2221             : 
    2222             : template <typename Derived>
    2223             : bool VISITORCLASS<Derived>::TraverseNoThrowAttr(NoThrowAttr *A) {
    2224             :   if (!getDerived().VisitAttr(A))
    2225             :     return false;
    2226             :   if (!getDerived().VisitNoThrowAttr(A))
    2227             :     return false;
    2228             :   return true;
    2229             : }
    2230             : 
    2231             : template <typename Derived>
    2232             : bool VISITORCLASS<Derived>::TraverseNonNullAttr(NonNullAttr *A) {
    2233             :   if (!getDerived().VisitAttr(A))
    2234             :     return false;
    2235             :   if (!getDerived().VisitNonNullAttr(A))
    2236             :     return false;
    2237             :   return true;
    2238             : }
    2239             : 
    2240             : template <typename Derived>
    2241             : bool VISITORCLASS<Derived>::TraverseNotTailCalledAttr(NotTailCalledAttr *A) {
    2242             :   if (!getDerived().VisitAttr(A))
    2243             :     return false;
    2244             :   if (!getDerived().VisitNotTailCalledAttr(A))
    2245             :     return false;
    2246             :   return true;
    2247             : }
    2248             : 
    2249             : template <typename Derived>
    2250             : bool VISITORCLASS<Derived>::TraverseOMPCaptureKindAttr(OMPCaptureKindAttr *A) {
    2251             :   if (!getDerived().VisitAttr(A))
    2252             :     return false;
    2253             :   if (!getDerived().VisitOMPCaptureKindAttr(A))
    2254             :     return false;
    2255             :   return true;
    2256             : }
    2257             : 
    2258             : template <typename Derived>
    2259             : bool VISITORCLASS<Derived>::TraverseOMPCaptureNoInitAttr(OMPCaptureNoInitAttr *A) {
    2260             :   if (!getDerived().VisitAttr(A))
    2261             :     return false;
    2262             :   if (!getDerived().VisitOMPCaptureNoInitAttr(A))
    2263             :     return false;
    2264             :   return true;
    2265             : }
    2266             : 
    2267             : template <typename Derived>
    2268           0 : bool VISITORCLASS<Derived>::TraverseOMPDeclareSimdDeclAttr(OMPDeclareSimdDeclAttr *A) {
    2269             :   if (!getDerived().VisitAttr(A))
    2270             :     return false;
    2271             :   if (!getDerived().VisitOMPDeclareSimdDeclAttr(A))
    2272             :     return false;
    2273           0 :   if (!getDerived().TraverseStmt(A->getSimdlen()))
    2274             :     return false;
    2275             :   {
    2276           0 :     Expr * *I = A->uniforms_begin();
    2277           0 :     Expr * *E = A->uniforms_end();
    2278           0 :     for (; I != E; ++I) {
    2279           0 :       if (!getDerived().TraverseStmt(*I))
    2280             :         return false;
    2281             :     }
    2282             :   }
    2283             :   {
    2284           0 :     Expr * *I = A->aligneds_begin();
    2285           0 :     Expr * *E = A->aligneds_end();
    2286           0 :     for (; I != E; ++I) {
    2287           0 :       if (!getDerived().TraverseStmt(*I))
    2288             :         return false;
    2289             :     }
    2290             :   }
    2291             :   {
    2292           0 :     Expr * *I = A->alignments_begin();
    2293           0 :     Expr * *E = A->alignments_end();
    2294           0 :     for (; I != E; ++I) {
    2295           0 :       if (!getDerived().TraverseStmt(*I))
    2296             :         return false;
    2297             :     }
    2298             :   }
    2299             :   {
    2300           0 :     Expr * *I = A->linears_begin();
    2301           0 :     Expr * *E = A->linears_end();
    2302           0 :     for (; I != E; ++I) {
    2303           0 :       if (!getDerived().TraverseStmt(*I))
    2304             :         return false;
    2305             :     }
    2306             :   }
    2307             :   {
    2308           0 :     Expr * *I = A->steps_begin();
    2309           0 :     Expr * *E = A->steps_end();
    2310           0 :     for (; I != E; ++I) {
    2311           0 :       if (!getDerived().TraverseStmt(*I))
    2312             :         return false;
    2313             :     }
    2314             :   }
    2315             :   return true;
    2316             : }
    2317             : 
    2318             : template <typename Derived>
    2319             : bool VISITORCLASS<Derived>::TraverseOMPDeclareTargetDeclAttr(OMPDeclareTargetDeclAttr *A) {
    2320             :   if (!getDerived().VisitAttr(A))
    2321             :     return false;
    2322             :   if (!getDerived().VisitOMPDeclareTargetDeclAttr(A))
    2323             :     return false;
    2324             :   return true;
    2325             : }
    2326             : 
    2327             : template <typename Derived>
    2328           0 : bool VISITORCLASS<Derived>::TraverseOMPReferencedVarAttr(OMPReferencedVarAttr *A) {
    2329             :   if (!getDerived().VisitAttr(A))
    2330             :     return false;
    2331             :   if (!getDerived().VisitOMPReferencedVarAttr(A))
    2332             :     return false;
    2333           0 :   if (!getDerived().TraverseStmt(A->getRef()))
    2334             :     return false;
    2335           0 :   return true;
    2336             : }
    2337             : 
    2338             : template <typename Derived>
    2339             : bool VISITORCLASS<Derived>::TraverseOMPThreadPrivateDeclAttr(OMPThreadPrivateDeclAttr *A) {
    2340             :   if (!getDerived().VisitAttr(A))
    2341             :     return false;
    2342             :   if (!getDerived().VisitOMPThreadPrivateDeclAttr(A))
    2343             :     return false;
    2344             :   return true;
    2345             : }
    2346             : 
    2347             : template <typename Derived>
    2348             : bool VISITORCLASS<Derived>::TraverseObjCBoxableAttr(ObjCBoxableAttr *A) {
    2349             :   if (!getDerived().VisitAttr(A))
    2350             :     return false;
    2351             :   if (!getDerived().VisitObjCBoxableAttr(A))
    2352             :     return false;
    2353             :   return true;
    2354             : }
    2355             : 
    2356             : template <typename Derived>
    2357             : bool VISITORCLASS<Derived>::TraverseObjCBridgeAttr(ObjCBridgeAttr *A) {
    2358             :   if (!getDerived().VisitAttr(A))
    2359             :     return false;
    2360             :   if (!getDerived().VisitObjCBridgeAttr(A))
    2361             :     return false;
    2362             :   return true;
    2363             : }
    2364             : 
    2365             : template <typename Derived>
    2366             : bool VISITORCLASS<Derived>::TraverseObjCBridgeMutableAttr(ObjCBridgeMutableAttr *A) {
    2367             :   if (!getDerived().VisitAttr(A))
    2368             :     return false;
    2369             :   if (!getDerived().VisitObjCBridgeMutableAttr(A))
    2370             :     return false;
    2371             :   return true;
    2372             : }
    2373             : 
    2374             : template <typename Derived>
    2375             : bool VISITORCLASS<Derived>::TraverseObjCBridgeRelatedAttr(ObjCBridgeRelatedAttr *A) {
    2376             :   if (!getDerived().VisitAttr(A))
    2377             :     return false;
    2378             :   if (!getDerived().VisitObjCBridgeRelatedAttr(A))
    2379             :     return false;
    2380             :   return true;
    2381             : }
    2382             : 
    2383             : template <typename Derived>
    2384             : bool VISITORCLASS<Derived>::TraverseObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A) {
    2385             :   if (!getDerived().VisitAttr(A))
    2386             :     return false;
    2387             :   if (!getDerived().VisitObjCDesignatedInitializerAttr(A))
    2388             :     return false;
    2389             :   return true;
    2390             : }
    2391             : 
    2392             : template <typename Derived>
    2393             : bool VISITORCLASS<Derived>::TraverseObjCExceptionAttr(ObjCExceptionAttr *A) {
    2394             :   if (!getDerived().VisitAttr(A))
    2395             :     return false;
    2396             :   if (!getDerived().VisitObjCExceptionAttr(A))
    2397             :     return false;
    2398             :   return true;
    2399             : }
    2400             : 
    2401             : template <typename Derived>
    2402             : bool VISITORCLASS<Derived>::TraverseObjCExplicitProtocolImplAttr(ObjCExplicitProtocolImplAttr *A) {
    2403             :   if (!getDerived().VisitAttr(A))
    2404             :     return false;
    2405             :   if (!getDerived().VisitObjCExplicitProtocolImplAttr(A))
    2406             :     return false;
    2407             :   return true;
    2408             : }
    2409             : 
    2410             : template <typename Derived>
    2411             : bool VISITORCLASS<Derived>::TraverseObjCIndependentClassAttr(ObjCIndependentClassAttr *A) {
    2412             :   if (!getDerived().VisitAttr(A))
    2413             :     return false;
    2414             :   if (!getDerived().VisitObjCIndependentClassAttr(A))
    2415             :     return false;
    2416             :   return true;
    2417             : }
    2418             : 
    2419             : template <typename Derived>
    2420             : bool VISITORCLASS<Derived>::TraverseObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A) {
    2421             :   if (!getDerived().VisitAttr(A))
    2422             :     return false;
    2423             :   if (!getDerived().VisitObjCMethodFamilyAttr(A))
    2424             :     return false;
    2425             :   return true;
    2426             : }
    2427             : 
    2428             : template <typename Derived>
    2429             : bool VISITORCLASS<Derived>::TraverseObjCNSObjectAttr(ObjCNSObjectAttr *A) {
    2430             :   if (!getDerived().VisitAttr(A))
    2431             :     return false;
    2432             :   if (!getDerived().VisitObjCNSObjectAttr(A))
    2433             :     return false;
    2434             :   return true;
    2435             : }
    2436             : 
    2437             : template <typename Derived>
    2438             : bool VISITORCLASS<Derived>::TraverseObjCPreciseLifetimeAttr(ObjCPreciseLifetimeAttr *A) {
    2439             :   if (!getDerived().VisitAttr(A))
    2440             :     return false;
    2441             :   if (!getDerived().VisitObjCPreciseLifetimeAttr(A))
    2442             :     return false;
    2443             :   return true;
    2444             : }
    2445             : 
    2446             : template <typename Derived>
    2447             : bool VISITORCLASS<Derived>::TraverseObjCRequiresPropertyDefsAttr(ObjCRequiresPropertyDefsAttr *A) {
    2448             :   if (!getDerived().VisitAttr(A))
    2449             :     return false;
    2450             :   if (!getDerived().VisitObjCRequiresPropertyDefsAttr(A))
    2451             :     return false;
    2452             :   return true;
    2453             : }
    2454             : 
    2455             : template <typename Derived>
    2456             : bool VISITORCLASS<Derived>::TraverseObjCRequiresSuperAttr(ObjCRequiresSuperAttr *A) {
    2457             :   if (!getDerived().VisitAttr(A))
    2458             :     return false;
    2459             :   if (!getDerived().VisitObjCRequiresSuperAttr(A))
    2460             :     return false;
    2461             :   return true;
    2462             : }
    2463             : 
    2464             : template <typename Derived>
    2465             : bool VISITORCLASS<Derived>::TraverseObjCReturnsInnerPointerAttr(ObjCReturnsInnerPointerAttr *A) {
    2466             :   if (!getDerived().VisitAttr(A))
    2467             :     return false;
    2468             :   if (!getDerived().VisitObjCReturnsInnerPointerAttr(A))
    2469             :     return false;
    2470             :   return true;
    2471             : }
    2472             : 
    2473             : template <typename Derived>
    2474             : bool VISITORCLASS<Derived>::TraverseObjCRootClassAttr(ObjCRootClassAttr *A) {
    2475             :   if (!getDerived().VisitAttr(A))
    2476             :     return false;
    2477             :   if (!getDerived().VisitObjCRootClassAttr(A))
    2478             :     return false;
    2479             :   return true;
    2480             : }
    2481             : 
    2482             : template <typename Derived>
    2483             : bool VISITORCLASS<Derived>::TraverseObjCRuntimeNameAttr(ObjCRuntimeNameAttr *A) {
    2484             :   if (!getDerived().VisitAttr(A))
    2485             :     return false;
    2486             :   if (!getDerived().VisitObjCRuntimeNameAttr(A))
    2487             :     return false;
    2488             :   return true;
    2489             : }
    2490             : 
    2491             : template <typename Derived>
    2492             : bool VISITORCLASS<Derived>::TraverseObjCRuntimeVisibleAttr(ObjCRuntimeVisibleAttr *A) {
    2493             :   if (!getDerived().VisitAttr(A))
    2494             :     return false;
    2495             :   if (!getDerived().VisitObjCRuntimeVisibleAttr(A))
    2496             :     return false;
    2497             :   return true;
    2498             : }
    2499             : 
    2500             : template <typename Derived>
    2501             : bool VISITORCLASS<Derived>::TraverseObjCSubclassingRestrictedAttr(ObjCSubclassingRestrictedAttr *A) {
    2502             :   if (!getDerived().VisitAttr(A))
    2503             :     return false;
    2504             :   if (!getDerived().VisitObjCSubclassingRestrictedAttr(A))
    2505             :     return false;
    2506             :   return true;
    2507             : }
    2508             : 
    2509             : template <typename Derived>
    2510             : bool VISITORCLASS<Derived>::TraverseOpenCLAccessAttr(OpenCLAccessAttr *A) {
    2511             :   if (!getDerived().VisitAttr(A))
    2512             :     return false;
    2513             :   if (!getDerived().VisitOpenCLAccessAttr(A))
    2514             :     return false;
    2515             :   return true;
    2516             : }
    2517             : 
    2518             : template <typename Derived>
    2519             : bool VISITORCLASS<Derived>::TraverseOpenCLIntelReqdSubGroupSizeAttr(OpenCLIntelReqdSubGroupSizeAttr *A) {
    2520             :   if (!getDerived().VisitAttr(A))
    2521             :     return false;
    2522             :   if (!getDerived().VisitOpenCLIntelReqdSubGroupSizeAttr(A))
    2523             :     return false;
    2524             :   return true;
    2525             : }
    2526             : 
    2527             : template <typename Derived>
    2528             : bool VISITORCLASS<Derived>::TraverseOpenCLKernelAttr(OpenCLKernelAttr *A) {
    2529             :   if (!getDerived().VisitAttr(A))
    2530             :     return false;
    2531             :   if (!getDerived().VisitOpenCLKernelAttr(A))
    2532             :     return false;
    2533             :   return true;
    2534             : }
    2535             : 
    2536             : template <typename Derived>
    2537             : bool VISITORCLASS<Derived>::TraverseOpenCLUnrollHintAttr(OpenCLUnrollHintAttr *A) {
    2538             :   if (!getDerived().VisitAttr(A))
    2539             :     return false;
    2540             :   if (!getDerived().VisitOpenCLUnrollHintAttr(A))
    2541             :     return false;
    2542             :   return true;
    2543             : }
    2544             : 
    2545             : template <typename Derived>
    2546             : bool VISITORCLASS<Derived>::TraverseOptimizeNoneAttr(OptimizeNoneAttr *A) {
    2547             :   if (!getDerived().VisitAttr(A))
    2548             :     return false;
    2549             :   if (!getDerived().VisitOptimizeNoneAttr(A))
    2550             :     return false;
    2551             :   return true;
    2552             : }
    2553             : 
    2554             : template <typename Derived>
    2555             : bool VISITORCLASS<Derived>::TraverseOverloadableAttr(OverloadableAttr *A) {
    2556             :   if (!getDerived().VisitAttr(A))
    2557             :     return false;
    2558             :   if (!getDerived().VisitOverloadableAttr(A))
    2559             :     return false;
    2560             :   return true;
    2561             : }
    2562             : 
    2563             : template <typename Derived>
    2564             : bool VISITORCLASS<Derived>::TraverseOverrideAttr(OverrideAttr *A) {
    2565             :   if (!getDerived().VisitAttr(A))
    2566             :     return false;
    2567             :   if (!getDerived().VisitOverrideAttr(A))
    2568             :     return false;
    2569             :   return true;
    2570             : }
    2571             : 
    2572             : template <typename Derived>
    2573             : bool VISITORCLASS<Derived>::TraverseOwnershipAttr(OwnershipAttr *A) {
    2574             :   if (!getDerived().VisitAttr(A))
    2575             :     return false;
    2576             :   if (!getDerived().VisitOwnershipAttr(A))
    2577             :     return false;
    2578             :   return true;
    2579             : }
    2580             : 
    2581             : template <typename Derived>
    2582             : bool VISITORCLASS<Derived>::TraversePackedAttr(PackedAttr *A) {
    2583             :   if (!getDerived().VisitAttr(A))
    2584             :     return false;
    2585             :   if (!getDerived().VisitPackedAttr(A))
    2586             :     return false;
    2587             :   return true;
    2588             : }
    2589             : 
    2590             : template <typename Derived>
    2591             : bool VISITORCLASS<Derived>::TraverseParamTypestateAttr(ParamTypestateAttr *A) {
    2592             :   if (!getDerived().VisitAttr(A))
    2593             :     return false;
    2594             :   if (!getDerived().VisitParamTypestateAttr(A))
    2595             :     return false;
    2596             :   return true;
    2597             : }
    2598             : 
    2599             : template <typename Derived>
    2600             : bool VISITORCLASS<Derived>::TraversePascalAttr(PascalAttr *A) {
    2601             :   if (!getDerived().VisitAttr(A))
    2602             :     return false;
    2603             :   if (!getDerived().VisitPascalAttr(A))
    2604             :     return false;
    2605             :   return true;
    2606             : }
    2607             : 
    2608             : template <typename Derived>
    2609             : bool VISITORCLASS<Derived>::TraversePassObjectSizeAttr(PassObjectSizeAttr *A) {
    2610             :   if (!getDerived().VisitAttr(A))
    2611             :     return false;
    2612             :   if (!getDerived().VisitPassObjectSizeAttr(A))
    2613             :     return false;
    2614             :   return true;
    2615             : }
    2616             : 
    2617             : template <typename Derived>
    2618             : bool VISITORCLASS<Derived>::TraversePcsAttr(PcsAttr *A) {
    2619             :   if (!getDerived().VisitAttr(A))
    2620             :     return false;
    2621             :   if (!getDerived().VisitPcsAttr(A))
    2622             :     return false;
    2623             :   return true;
    2624             : }
    2625             : 
    2626             : template <typename Derived>
    2627             : bool VISITORCLASS<Derived>::TraversePragmaClangBSSSectionAttr(PragmaClangBSSSectionAttr *A) {
    2628             :   if (!getDerived().VisitAttr(A))
    2629             :     return false;
    2630             :   if (!getDerived().VisitPragmaClangBSSSectionAttr(A))
    2631             :     return false;
    2632             :   return true;
    2633             : }
    2634             : 
    2635             : template <typename Derived>
    2636             : bool VISITORCLASS<Derived>::TraversePragmaClangDataSectionAttr(PragmaClangDataSectionAttr *A) {
    2637             :   if (!getDerived().VisitAttr(A))
    2638             :     return false;
    2639             :   if (!getDerived().VisitPragmaClangDataSectionAttr(A))
    2640             :     return false;
    2641             :   return true;
    2642             : }
    2643             : 
    2644             : template <typename Derived>
    2645             : bool VISITORCLASS<Derived>::TraversePragmaClangRodataSectionAttr(PragmaClangRodataSectionAttr *A) {
    2646             :   if (!getDerived().VisitAttr(A))
    2647             :     return false;
    2648             :   if (!getDerived().VisitPragmaClangRodataSectionAttr(A))
    2649             :     return false;
    2650             :   return true;
    2651             : }
    2652             : 
    2653             : template <typename Derived>
    2654             : bool VISITORCLASS<Derived>::TraversePragmaClangTextSectionAttr(PragmaClangTextSectionAttr *A) {
    2655             :   if (!getDerived().VisitAttr(A))
    2656             :     return false;
    2657             :   if (!getDerived().VisitPragmaClangTextSectionAttr(A))
    2658             :     return false;
    2659             :   return true;
    2660             : }
    2661             : 
    2662             : template <typename Derived>
    2663             : bool VISITORCLASS<Derived>::TraversePreserveAllAttr(PreserveAllAttr *A) {
    2664             :   if (!getDerived().VisitAttr(A))
    2665             :     return false;
    2666             :   if (!getDerived().VisitPreserveAllAttr(A))
    2667             :     return false;
    2668             :   return true;
    2669             : }
    2670             : 
    2671             : template <typename Derived>
    2672             : bool VISITORCLASS<Derived>::TraversePreserveMostAttr(PreserveMostAttr *A) {
    2673             :   if (!getDerived().VisitAttr(A))
    2674             :     return false;
    2675             :   if (!getDerived().VisitPreserveMostAttr(A))
    2676             :     return false;
    2677             :   return true;
    2678             : }
    2679             : 
    2680             : template <typename Derived>
    2681           0 : bool VISITORCLASS<Derived>::TraversePtGuardedByAttr(PtGuardedByAttr *A) {
    2682             :   if (!getDerived().VisitAttr(A))
    2683             :     return false;
    2684             :   if (!getDerived().VisitPtGuardedByAttr(A))
    2685             :     return false;
    2686           0 :   if (!getDerived().TraverseStmt(A->getArg()))
    2687             :     return false;
    2688           0 :   return true;
    2689             : }
    2690             : 
    2691             : template <typename Derived>
    2692             : bool VISITORCLASS<Derived>::TraversePtGuardedVarAttr(PtGuardedVarAttr *A) {
    2693             :   if (!getDerived().VisitAttr(A))
    2694             :     return false;
    2695             :   if (!getDerived().VisitPtGuardedVarAttr(A))
    2696             :     return false;
    2697             :   return true;
    2698             : }
    2699             : 
    2700             : template <typename Derived>
    2701             : bool VISITORCLASS<Derived>::TraversePureAttr(PureAttr *A) {
    2702             :   if (!getDerived().VisitAttr(A))
    2703             :     return false;
    2704             :   if (!getDerived().VisitPureAttr(A))
    2705             :     return false;
    2706             :   return true;
    2707             : }
    2708             : 
    2709             : template <typename Derived>
    2710             : bool VISITORCLASS<Derived>::TraverseRegCallAttr(RegCallAttr *A) {
    2711             :   if (!getDerived().VisitAttr(A))
    2712             :     return false;
    2713             :   if (!getDerived().VisitRegCallAttr(A))
    2714             :     return false;
    2715             :   return true;
    2716             : }
    2717             : 
    2718             : template <typename Derived>
    2719           0 : bool VISITORCLASS<Derived>::TraverseReleaseCapabilityAttr(ReleaseCapabilityAttr *A) {
    2720             :   if (!getDerived().VisitAttr(A))
    2721             :     return false;
    2722             :   if (!getDerived().VisitReleaseCapabilityAttr(A))
    2723             :     return false;
    2724             :   {
    2725           0 :     Expr * *I = A->args_begin();
    2726           0 :     Expr * *E = A->args_end();
    2727           0 :     for (; I != E; ++I) {
    2728           0 :       if (!getDerived().TraverseStmt(*I))
    2729             :         return false;
    2730             :     }
    2731             :   }
    2732             :   return true;
    2733             : }
    2734             : 
    2735             : template <typename Derived>
    2736             : bool VISITORCLASS<Derived>::TraverseRenderScriptKernelAttr(RenderScriptKernelAttr *A) {
    2737             :   if (!getDerived().VisitAttr(A))
    2738             :     return false;
    2739             :   if (!getDerived().VisitRenderScriptKernelAttr(A))
    2740             :     return false;
    2741             :   return true;
    2742             : }
    2743             : 
    2744             : template <typename Derived>
    2745             : bool VISITORCLASS<Derived>::TraverseReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A) {
    2746             :   if (!getDerived().VisitAttr(A))
    2747             :     return false;
    2748             :   if (!getDerived().VisitReqdWorkGroupSizeAttr(A))
    2749             :     return false;
    2750             :   return true;
    2751             : }
    2752             : 
    2753             : template <typename Derived>
    2754             : bool VISITORCLASS<Derived>::TraverseRequireConstantInitAttr(RequireConstantInitAttr *A) {
    2755             :   if (!getDerived().VisitAttr(A))
    2756             :     return false;
    2757             :   if (!getDerived().VisitRequireConstantInitAttr(A))
    2758             :     return false;
    2759             :   return true;
    2760             : }
    2761             : 
    2762             : template <typename Derived>
    2763           1 : bool VISITORCLASS<Derived>::TraverseRequiresCapabilityAttr(RequiresCapabilityAttr *A) {
    2764             :   if (!getDerived().VisitAttr(A))
    2765             :     return false;
    2766             :   if (!getDerived().VisitRequiresCapabilityAttr(A))
    2767             :     return false;
    2768             :   {
    2769           1 :     Expr * *I = A->args_begin();
    2770           1 :     Expr * *E = A->args_end();
    2771           5 :     for (; I != E; ++I) {
    2772           2 :       if (!getDerived().TraverseStmt(*I))
    2773             :         return false;
    2774             :     }
    2775             :   }
    2776             :   return true;
    2777             : }
    2778             : 
    2779             : template <typename Derived>
    2780             : bool VISITORCLASS<Derived>::TraverseRestrictAttr(RestrictAttr *A) {
    2781             :   if (!getDerived().VisitAttr(A))
    2782             :     return false;
    2783             :   if (!getDerived().VisitRestrictAttr(A))
    2784             :     return false;
    2785             :   return true;
    2786             : }
    2787             : 
    2788             : template <typename Derived>
    2789             : bool VISITORCLASS<Derived>::TraverseReturnTypestateAttr(ReturnTypestateAttr *A) {
    2790             :   if (!getDerived().VisitAttr(A))
    2791             :     return false;
    2792             :   if (!getDerived().VisitReturnTypestateAttr(A))
    2793             :     return false;
    2794             :   return true;
    2795             : }
    2796             : 
    2797             : template <typename Derived>
    2798             : bool VISITORCLASS<Derived>::TraverseReturnsNonNullAttr(ReturnsNonNullAttr *A) {
    2799             :   if (!getDerived().VisitAttr(A))
    2800             :     return false;
    2801             :   if (!getDerived().VisitReturnsNonNullAttr(A))
    2802             :     return false;
    2803             :   return true;
    2804             : }
    2805             : 
    2806             : template <typename Derived>
    2807             : bool VISITORCLASS<Derived>::TraverseReturnsTwiceAttr(ReturnsTwiceAttr *A) {
    2808             :   if (!getDerived().VisitAttr(A))
    2809             :     return false;
    2810             :   if (!getDerived().VisitReturnsTwiceAttr(A))
    2811             :     return false;
    2812             :   return true;
    2813             : }
    2814             : 
    2815             : template <typename Derived>
    2816             : bool VISITORCLASS<Derived>::TraverseScopedLockableAttr(ScopedLockableAttr *A) {
    2817             :   if (!getDerived().VisitAttr(A))
    2818             :     return false;
    2819             :   if (!getDerived().VisitScopedLockableAttr(A))
    2820             :     return false;
    2821             :   return true;
    2822             : }
    2823             : 
    2824             : template <typename Derived>
    2825             : bool VISITORCLASS<Derived>::TraverseSectionAttr(SectionAttr *A) {
    2826             :   if (!getDerived().VisitAttr(A))
    2827             :     return false;
    2828             :   if (!getDerived().VisitSectionAttr(A))
    2829             :     return false;
    2830             :   return true;
    2831             : }
    2832             : 
    2833             : template <typename Derived>
    2834             : bool VISITORCLASS<Derived>::TraverseSelectAnyAttr(SelectAnyAttr *A) {
    2835             :   if (!getDerived().VisitAttr(A))
    2836             :     return false;
    2837             :   if (!getDerived().VisitSelectAnyAttr(A))
    2838             :     return false;
    2839             :   return true;
    2840             : }
    2841             : 
    2842             : template <typename Derived>
    2843             : bool VISITORCLASS<Derived>::TraverseSentinelAttr(SentinelAttr *A) {
    2844             :   if (!getDerived().VisitAttr(A))
    2845             :     return false;
    2846             :   if (!getDerived().VisitSentinelAttr(A))
    2847             :     return false;
    2848             :   return true;
    2849             : }
    2850             : 
    2851             : template <typename Derived>
    2852             : bool VISITORCLASS<Derived>::TraverseSetTypestateAttr(SetTypestateAttr *A) {
    2853             :   if (!getDerived().VisitAttr(A))
    2854             :     return false;
    2855             :   if (!getDerived().VisitSetTypestateAttr(A))
    2856             :     return false;
    2857             :   return true;
    2858             : }
    2859             : 
    2860             : template <typename Derived>
    2861           0 : bool VISITORCLASS<Derived>::TraverseSharedTrylockFunctionAttr(SharedTrylockFunctionAttr *A) {
    2862             :   if (!getDerived().VisitAttr(A))
    2863             :     return false;
    2864             :   if (!getDerived().VisitSharedTrylockFunctionAttr(A))
    2865             :     return false;
    2866           0 :   if (!getDerived().TraverseStmt(A->getSuccessValue()))
    2867             :     return false;
    2868             :   {
    2869           0 :     Expr * *I = A->args_begin();
    2870           0 :     Expr * *E = A->args_end();
    2871           0 :     for (; I != E; ++I) {
    2872           0 :       if (!getDerived().TraverseStmt(*I))
    2873             :         return false;
    2874             :     }
    2875             :   }
    2876             :   return true;
    2877             : }
    2878             : 
    2879             : template <typename Derived>
    2880             : bool VISITORCLASS<Derived>::TraverseStdCallAttr(StdCallAttr *A) {
    2881             :   if (!getDerived().VisitAttr(A))
    2882             :     return false;
    2883             :   if (!getDerived().VisitStdCallAttr(A))
    2884             :     return false;
    2885             :   return true;
    2886             : }
    2887             : 
    2888             : template <typename Derived>
    2889             : bool VISITORCLASS<Derived>::TraverseSuppressAttr(SuppressAttr *A) {
    2890             :   if (!getDerived().VisitAttr(A))
    2891             :     return false;
    2892             :   if (!getDerived().VisitSuppressAttr(A))
    2893             :     return false;
    2894             :   return true;
    2895             : }
    2896             : 
    2897             : template <typename Derived>
    2898             : bool VISITORCLASS<Derived>::TraverseSwiftCallAttr(SwiftCallAttr *A) {
    2899             :   if (!getDerived().VisitAttr(A))
    2900             :     return false;
    2901             :   if (!getDerived().VisitSwiftCallAttr(A))
    2902             :     return false;
    2903             :   return true;
    2904             : }
    2905             : 
    2906             : template <typename Derived>
    2907             : bool VISITORCLASS<Derived>::TraverseSwiftContextAttr(SwiftContextAttr *A) {
    2908             :   if (!getDerived().VisitAttr(A))
    2909             :     return false;
    2910             :   if (!getDerived().VisitSwiftContextAttr(A))
    2911             :     return false;
    2912             :   return true;
    2913             : }
    2914             : 
    2915             : template <typename Derived>
    2916             : bool VISITORCLASS<Derived>::TraverseSwiftErrorResultAttr(SwiftErrorResultAttr *A) {
    2917             :   if (!getDerived().VisitAttr(A))
    2918             :     return false;
    2919             :   if (!getDerived().VisitSwiftErrorResultAttr(A))
    2920             :     return false;
    2921             :   return true;
    2922             : }
    2923             : 
    2924             : template <typename Derived>
    2925             : bool VISITORCLASS<Derived>::TraverseSwiftIndirectResultAttr(SwiftIndirectResultAttr *A) {
    2926             :   if (!getDerived().VisitAttr(A))
    2927             :     return false;
    2928             :   if (!getDerived().VisitSwiftIndirectResultAttr(A))
    2929             :     return false;
    2930             :   return true;
    2931             : }
    2932             : 
    2933             : template <typename Derived>
    2934             : bool VISITORCLASS<Derived>::TraverseSysVABIAttr(SysVABIAttr *A) {
    2935             :   if (!getDerived().VisitAttr(A))
    2936             :     return false;
    2937             :   if (!getDerived().VisitSysVABIAttr(A))
    2938             :     return false;
    2939             :   return true;
    2940             : }
    2941             : 
    2942             : template <typename Derived>
    2943             : bool VISITORCLASS<Derived>::TraverseTLSModelAttr(TLSModelAttr *A) {
    2944             :   if (!getDerived().VisitAttr(A))
    2945             :     return false;
    2946             :   if (!getDerived().VisitTLSModelAttr(A))
    2947             :     return false;
    2948             :   return true;
    2949             : }
    2950             : 
    2951             : template <typename Derived>
    2952             : bool VISITORCLASS<Derived>::TraverseTargetAttr(TargetAttr *A) {
    2953             :   if (!getDerived().VisitAttr(A))
    2954             :     return false;
    2955             :   if (!getDerived().VisitTargetAttr(A))
    2956             :     return false;
    2957             :   return true;
    2958             : }
    2959             : 
    2960             : template <typename Derived>
    2961             : bool VISITORCLASS<Derived>::TraverseTestTypestateAttr(TestTypestateAttr *A) {
    2962             :   if (!getDerived().VisitAttr(A))
    2963             :     return false;
    2964             :   if (!getDerived().VisitTestTypestateAttr(A))
    2965             :     return false;
    2966             :   return true;
    2967             : }
    2968             : 
    2969             : template <typename Derived>
    2970             : bool VISITORCLASS<Derived>::TraverseThisCallAttr(ThisCallAttr *A) {
    2971             :   if (!getDerived().VisitAttr(A))
    2972             :     return false;
    2973             :   if (!getDerived().VisitThisCallAttr(A))
    2974             :     return false;
    2975             :   return true;
    2976             : }
    2977             : 
    2978             : template <typename Derived>
    2979             : bool VISITORCLASS<Derived>::TraverseThreadAttr(ThreadAttr *A) {
    2980             :   if (!getDerived().VisitAttr(A))
    2981             :     return false;
    2982             :   if (!getDerived().VisitThreadAttr(A))
    2983             :     return false;
    2984             :   return true;
    2985             : }
    2986             : 
    2987             : template <typename Derived>
    2988             : bool VISITORCLASS<Derived>::TraverseTransparentUnionAttr(TransparentUnionAttr *A) {
    2989             :   if (!getDerived().VisitAttr(A))
    2990             :     return false;
    2991             :   if (!getDerived().VisitTransparentUnionAttr(A))
    2992             :     return false;
    2993             :   return true;
    2994             : }
    2995             : 
    2996             : template <typename Derived>
    2997             : bool VISITORCLASS<Derived>::TraverseTrivialABIAttr(TrivialABIAttr *A) {
    2998             :   if (!getDerived().VisitAttr(A))
    2999             :     return false;
    3000             :   if (!getDerived().VisitTrivialABIAttr(A))
    3001             :     return false;
    3002             :   return true;
    3003             : }
    3004             : 
    3005             : template <typename Derived>
    3006           0 : bool VISITORCLASS<Derived>::TraverseTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A) {
    3007             :   if (!getDerived().VisitAttr(A))
    3008             :     return false;
    3009             :   if (!getDerived().VisitTryAcquireCapabilityAttr(A))
    3010             :     return false;
    3011           0 :   if (!getDerived().TraverseStmt(A->getSuccessValue()))
    3012             :     return false;
    3013             :   {
    3014           0 :     Expr * *I = A->args_begin();
    3015           0 :     Expr * *E = A->args_end();
    3016           0 :     for (; I != E; ++I) {
    3017           0 :       if (!getDerived().TraverseStmt(*I))
    3018             :         return false;
    3019             :     }
    3020             :   }
    3021             :   return true;
    3022             : }
    3023             : 
    3024             : template <typename Derived>
    3025           0 : bool VISITORCLASS<Derived>::TraverseTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A) {
    3026             :   if (!getDerived().VisitAttr(A))
    3027             :     return false;
    3028             :   if (!getDerived().VisitTypeTagForDatatypeAttr(A))
    3029             :     return false;
    3030           0 :   if (auto *TSI = A->getMatchingCTypeLoc())
    3031           0 :     if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
    3032             :       return false;
    3033             :   return true;
    3034             : }
    3035             : 
    3036             : template <typename Derived>
    3037             : bool VISITORCLASS<Derived>::TraverseTypeVisibilityAttr(TypeVisibilityAttr *A) {
    3038             :   if (!getDerived().VisitAttr(A))
    3039             :     return false;
    3040             :   if (!getDerived().VisitTypeVisibilityAttr(A))
    3041             :     return false;
    3042             :   return true;
    3043             : }
    3044             : 
    3045             : template <typename Derived>
    3046             : bool VISITORCLASS<Derived>::TraverseUnavailableAttr(UnavailableAttr *A) {
    3047             :   if (!getDerived().VisitAttr(A))
    3048             :     return false;
    3049             :   if (!getDerived().VisitUnavailableAttr(A))
    3050             :     return false;
    3051             :   return true;
    3052             : }
    3053             : 
    3054             : template <typename Derived>
    3055             : bool VISITORCLASS<Derived>::TraverseUnusedAttr(UnusedAttr *A) {
    3056             :   if (!getDerived().VisitAttr(A))
    3057             :     return false;
    3058             :   if (!getDerived().VisitUnusedAttr(A))
    3059             :     return false;
    3060             :   return true;
    3061             : }
    3062             : 
    3063             : template <typename Derived>
    3064             : bool VISITORCLASS<Derived>::TraverseUsedAttr(UsedAttr *A) {
    3065             :   if (!getDerived().VisitAttr(A))
    3066             :     return false;
    3067             :   if (!getDerived().VisitUsedAttr(A))
    3068             :     return false;
    3069             :   return true;
    3070             : }
    3071             : 
    3072             : template <typename Derived>
    3073             : bool VISITORCLASS<Derived>::TraverseUuidAttr(UuidAttr *A) {
    3074             :   if (!getDerived().VisitAttr(A))
    3075             :     return false;
    3076             :   if (!getDerived().VisitUuidAttr(A))
    3077             :     return false;
    3078             :   return true;
    3079             : }
    3080             : 
    3081             : template <typename Derived>
    3082             : bool VISITORCLASS<Derived>::TraverseVecReturnAttr(VecReturnAttr *A) {
    3083             :   if (!getDerived().VisitAttr(A))
    3084             :     return false;
    3085             :   if (!getDerived().VisitVecReturnAttr(A))
    3086             :     return false;
    3087             :   return true;
    3088             : }
    3089             : 
    3090             : template <typename Derived>
    3091           0 : bool VISITORCLASS<Derived>::TraverseVecTypeHintAttr(VecTypeHintAttr *A) {
    3092             :   if (!getDerived().VisitAttr(A))
    3093             :     return false;
    3094             :   if (!getDerived().VisitVecTypeHintAttr(A))
    3095             :     return false;
    3096           0 :   if (auto *TSI = A->getTypeHintLoc())
    3097           0 :     if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
    3098             :       return false;
    3099             :   return true;
    3100             : }
    3101             : 
    3102             : template <typename Derived>
    3103             : bool VISITORCLASS<Derived>::TraverseVectorCallAttr(VectorCallAttr *A) {
    3104             :   if (!getDerived().VisitAttr(A))
    3105             :     return false;
    3106             :   if (!getDerived().VisitVectorCallAttr(A))
    3107             :     return false;
    3108             :   return true;
    3109             : }
    3110             : 
    3111             : template <typename Derived>
    3112             : bool VISITORCLASS<Derived>::TraverseVisibilityAttr(VisibilityAttr *A) {
    3113             :   if (!getDerived().VisitAttr(A))
    3114             :     return false;
    3115             :   if (!getDerived().VisitVisibilityAttr(A))
    3116             :     return false;
    3117             :   return true;
    3118             : }
    3119             : 
    3120             : template <typename Derived>
    3121             : bool VISITORCLASS<Derived>::TraverseWarnUnusedAttr(WarnUnusedAttr *A) {
    3122             :   if (!getDerived().VisitAttr(A))
    3123             :     return false;
    3124             :   if (!getDerived().VisitWarnUnusedAttr(A))
    3125             :     return false;
    3126             :   return true;
    3127             : }
    3128             : 
    3129             : template <typename Derived>
    3130             : bool VISITORCLASS<Derived>::TraverseWarnUnusedResultAttr(WarnUnusedResultAttr *A) {
    3131             :   if (!getDerived().VisitAttr(A))
    3132             :     return false;
    3133             :   if (!getDerived().VisitWarnUnusedResultAttr(A))
    3134             :     return false;
    3135             :   return true;
    3136             : }
    3137             : 
    3138             : template <typename Derived>
    3139             : bool VISITORCLASS<Derived>::TraverseWeakAttr(WeakAttr *A) {
    3140             :   if (!getDerived().VisitAttr(A))
    3141             :     return false;
    3142             :   if (!getDerived().VisitWeakAttr(A))
    3143             :     return false;
    3144             :   return true;
    3145             : }
    3146             : 
    3147             : template <typename Derived>
    3148             : bool VISITORCLASS<Derived>::TraverseWeakImportAttr(WeakImportAttr *A) {
    3149             :   if (!getDerived().VisitAttr(A))
    3150             :     return false;
    3151             :   if (!getDerived().VisitWeakImportAttr(A))
    3152             :     return false;
    3153             :   return true;
    3154             : }
    3155             : 
    3156             : template <typename Derived>
    3157             : bool VISITORCLASS<Derived>::TraverseWeakRefAttr(WeakRefAttr *A) {
    3158             :   if (!getDerived().VisitAttr(A))
    3159             :     return false;
    3160             :   if (!getDerived().VisitWeakRefAttr(A))
    3161             :     return false;
    3162             :   return true;
    3163             : }
    3164             : 
    3165             : template <typename Derived>
    3166             : bool VISITORCLASS<Derived>::TraverseWorkGroupSizeHintAttr(WorkGroupSizeHintAttr *A) {
    3167             :   if (!getDerived().VisitAttr(A))
    3168             :     return false;
    3169             :   if (!getDerived().VisitWorkGroupSizeHintAttr(A))
    3170             :     return false;
    3171             :   return true;
    3172             : }
    3173             : 
    3174             : template <typename Derived>
    3175             : bool VISITORCLASS<Derived>::TraverseX86ForceAlignArgPointerAttr(X86ForceAlignArgPointerAttr *A) {
    3176             :   if (!getDerived().VisitAttr(A))
    3177             :     return false;
    3178             :   if (!getDerived().VisitX86ForceAlignArgPointerAttr(A))
    3179             :     return false;
    3180             :   return true;
    3181             : }
    3182             : 
    3183             : template <typename Derived>
    3184             : bool VISITORCLASS<Derived>::TraverseXRayInstrumentAttr(XRayInstrumentAttr *A) {
    3185             :   if (!getDerived().VisitAttr(A))
    3186             :     return false;
    3187             :   if (!getDerived().VisitXRayInstrumentAttr(A))
    3188             :     return false;
    3189             :   return true;
    3190             : }
    3191             : 
    3192             : template <typename Derived>
    3193             : bool VISITORCLASS<Derived>::TraverseXRayLogArgsAttr(XRayLogArgsAttr *A) {
    3194             :   if (!getDerived().VisitAttr(A))
    3195             :     return false;
    3196             :   if (!getDerived().VisitXRayLogArgsAttr(A))
    3197             :     return false;
    3198             :   return true;
    3199             : }
    3200             : 
    3201             : template <typename Derived>
    3202       14908 : bool VISITORCLASS<Derived>::TraverseAttr(Attr *A) {
    3203       14908 :   if (!A)
    3204             :     return true;
    3205             : 
    3206       14908 :   switch (A->getKind()) {
    3207             :     case attr::AMDGPUFlatWorkGroupSize:
    3208           0 :       return getDerived().TraverseAMDGPUFlatWorkGroupSizeAttr(cast<AMDGPUFlatWorkGroupSizeAttr>(A));
    3209             :     case attr::AMDGPUNumSGPR:
    3210           0 :       return getDerived().TraverseAMDGPUNumSGPRAttr(cast<AMDGPUNumSGPRAttr>(A));
    3211             :     case attr::AMDGPUNumVGPR:
    3212           0 :       return getDerived().TraverseAMDGPUNumVGPRAttr(cast<AMDGPUNumVGPRAttr>(A));
    3213             :     case attr::AMDGPUWavesPerEU:
    3214           0 :       return getDerived().TraverseAMDGPUWavesPerEUAttr(cast<AMDGPUWavesPerEUAttr>(A));
    3215             :     case attr::ARMInterrupt:
    3216           0 :       return getDerived().TraverseARMInterruptAttr(cast<ARMInterruptAttr>(A));
    3217             :     case attr::AVRInterrupt:
    3218           0 :       return getDerived().TraverseAVRInterruptAttr(cast<AVRInterruptAttr>(A));
    3219             :     case attr::AVRSignal:
    3220           0 :       return getDerived().TraverseAVRSignalAttr(cast<AVRSignalAttr>(A));
    3221             :     case attr::AbiTag:
    3222           0 :       return getDerived().TraverseAbiTagAttr(cast<AbiTagAttr>(A));
    3223             :     case attr::AcquireCapability:
    3224           0 :       return getDerived().TraverseAcquireCapabilityAttr(cast<AcquireCapabilityAttr>(A));
    3225             :     case attr::AcquiredAfter:
    3226           0 :       return getDerived().TraverseAcquiredAfterAttr(cast<AcquiredAfterAttr>(A));
    3227             :     case attr::AcquiredBefore:
    3228           0 :       return getDerived().TraverseAcquiredBeforeAttr(cast<AcquiredBeforeAttr>(A));
    3229             :     case attr::Alias:
    3230           0 :       return getDerived().TraverseAliasAttr(cast<AliasAttr>(A));
    3231             :     case attr::AlignMac68k:
    3232           0 :       return getDerived().TraverseAlignMac68kAttr(cast<AlignMac68kAttr>(A));
    3233             :     case attr::AlignValue:
    3234           0 :       return getDerived().TraverseAlignValueAttr(cast<AlignValueAttr>(A));
    3235             :     case attr::Aligned:
    3236          74 :       return getDerived().TraverseAlignedAttr(cast<AlignedAttr>(A));
    3237             :     case attr::AllocAlign:
    3238           0 :       return getDerived().TraverseAllocAlignAttr(cast<AllocAlignAttr>(A));
    3239             :     case attr::AllocSize:
    3240           0 :       return getDerived().TraverseAllocSizeAttr(cast<AllocSizeAttr>(A));
    3241             :     case attr::AlwaysInline:
    3242           0 :       return getDerived().TraverseAlwaysInlineAttr(cast<AlwaysInlineAttr>(A));
    3243             :     case attr::AnalyzerNoReturn:
    3244           0 :       return getDerived().TraverseAnalyzerNoReturnAttr(cast<AnalyzerNoReturnAttr>(A));
    3245             :     case attr::Annotate:
    3246           0 :       return getDerived().TraverseAnnotateAttr(cast<AnnotateAttr>(A));
    3247             :     case attr::AnyX86Interrupt:
    3248           0 :       return getDerived().TraverseAnyX86InterruptAttr(cast<AnyX86InterruptAttr>(A));
    3249             :     case attr::AnyX86NoCallerSavedRegisters:
    3250           0 :       return getDerived().TraverseAnyX86NoCallerSavedRegistersAttr(cast<AnyX86NoCallerSavedRegistersAttr>(A));
    3251             :     case attr::AnyX86NoCfCheck:
    3252           0 :       return getDerived().TraverseAnyX86NoCfCheckAttr(cast<AnyX86NoCfCheckAttr>(A));
    3253             :     case attr::ArcWeakrefUnavailable:
    3254           0 :       return getDerived().TraverseArcWeakrefUnavailableAttr(cast<ArcWeakrefUnavailableAttr>(A));
    3255             :     case attr::ArgumentWithTypeTag:
    3256           0 :       return getDerived().TraverseArgumentWithTypeTagAttr(cast<ArgumentWithTypeTagAttr>(A));
    3257             :     case attr::Artificial:
    3258           0 :       return getDerived().TraverseArtificialAttr(cast<ArtificialAttr>(A));
    3259             :     case attr::AsmLabel:
    3260           0 :       return getDerived().TraverseAsmLabelAttr(cast<AsmLabelAttr>(A));
    3261             :     case attr::AssertCapability:
    3262           0 :       return getDerived().TraverseAssertCapabilityAttr(cast<AssertCapabilityAttr>(A));
    3263             :     case attr::AssertExclusiveLock:
    3264           0 :       return getDerived().TraverseAssertExclusiveLockAttr(cast<AssertExclusiveLockAttr>(A));
    3265             :     case attr::AssertSharedLock:
    3266           0 :       return getDerived().TraverseAssertSharedLockAttr(cast<AssertSharedLockAttr>(A));
    3267             :     case attr::AssumeAligned:
    3268           0 :       return getDerived().TraverseAssumeAlignedAttr(cast<AssumeAlignedAttr>(A));
    3269             :     case attr::Availability:
    3270           0 :       return getDerived().TraverseAvailabilityAttr(cast<AvailabilityAttr>(A));
    3271             :     case attr::Blocks:
    3272           0 :       return getDerived().TraverseBlocksAttr(cast<BlocksAttr>(A));
    3273             :     case attr::C11NoReturn:
    3274           0 :       return getDerived().TraverseC11NoReturnAttr(cast<C11NoReturnAttr>(A));
    3275             :     case attr::CDecl:
    3276           0 :       return getDerived().TraverseCDeclAttr(cast<CDeclAttr>(A));
    3277             :     case attr::CFAuditedTransfer:
    3278           0 :       return getDerived().TraverseCFAuditedTransferAttr(cast<CFAuditedTransferAttr>(A));
    3279             :     case attr::CFConsumed:
    3280           0 :       return getDerived().TraverseCFConsumedAttr(cast<CFConsumedAttr>(A));
    3281             :     case attr::CFReturnsNotRetained:
    3282           0 :       return getDerived().TraverseCFReturnsNotRetainedAttr(cast<CFReturnsNotRetainedAttr>(A));
    3283             :     case attr::CFReturnsRetained:
    3284           0 :       return getDerived().TraverseCFReturnsRetainedAttr(cast<CFReturnsRetainedAttr>(A));
    3285             :     case attr::CFUnknownTransfer:
    3286           0 :       return getDerived().TraverseCFUnknownTransferAttr(cast<CFUnknownTransferAttr>(A));
    3287             :     case attr::CUDAConstant:
    3288           0 :       return getDerived().TraverseCUDAConstantAttr(cast<CUDAConstantAttr>(A));
    3289             :     case attr::CUDADevice:
    3290           0 :       return getDerived().TraverseCUDADeviceAttr(cast<CUDADeviceAttr>(A));
    3291             :     case attr::CUDAGlobal:
    3292           0 :       return getDerived().TraverseCUDAGlobalAttr(cast<CUDAGlobalAttr>(A));
    3293             :     case attr::CUDAHost:
    3294           0 :       return getDerived().TraverseCUDAHostAttr(cast<CUDAHostAttr>(A));
    3295             :     case attr::CUDAInvalidTarget:
    3296           0 :       return getDerived().TraverseCUDAInvalidTargetAttr(cast<CUDAInvalidTargetAttr>(A));
    3297             :     case attr::CUDALaunchBounds:
    3298           0 :       return getDerived().TraverseCUDALaunchBoundsAttr(cast<CUDALaunchBoundsAttr>(A));
    3299             :     case attr::CUDAShared:
    3300           0 :       return getDerived().TraverseCUDASharedAttr(cast<CUDASharedAttr>(A));
    3301             :     case attr::CXX11NoReturn:
    3302           0 :       return getDerived().TraverseCXX11NoReturnAttr(cast<CXX11NoReturnAttr>(A));
    3303             :     case attr::CallableWhen:
    3304           0 :       return getDerived().TraverseCallableWhenAttr(cast<CallableWhenAttr>(A));
    3305             :     case attr::Capability:
    3306           0 :       return getDerived().TraverseCapabilityAttr(cast<CapabilityAttr>(A));
    3307             :     case attr::CapturedRecord:
    3308           0 :       return getDerived().TraverseCapturedRecordAttr(cast<CapturedRecordAttr>(A));
    3309             :     case attr::CarriesDependency:
    3310           0 :       return getDerived().TraverseCarriesDependencyAttr(cast<CarriesDependencyAttr>(A));
    3311             :     case attr::Cleanup:
    3312           0 :       return getDerived().TraverseCleanupAttr(cast<CleanupAttr>(A));
    3313             :     case attr::Cold:
    3314           0 :       return getDerived().TraverseColdAttr(cast<ColdAttr>(A));
    3315             :     case attr::Common:
    3316           0 :       return getDerived().TraverseCommonAttr(cast<CommonAttr>(A));
    3317             :     case attr::Const:
    3318           0 :       return getDerived().TraverseConstAttr(cast<ConstAttr>(A));
    3319             :     case attr::Constructor:
    3320           0 :       return getDerived().TraverseConstructorAttr(cast<ConstructorAttr>(A));
    3321             :     case attr::Consumable:
    3322           0 :       return getDerived().TraverseConsumableAttr(cast<ConsumableAttr>(A));
    3323             :     case attr::ConsumableAutoCast:
    3324           0 :       return getDerived().TraverseConsumableAutoCastAttr(cast<ConsumableAutoCastAttr>(A));
    3325             :     case attr::ConsumableSetOnRead:
    3326           0 :       return getDerived().TraverseConsumableSetOnReadAttr(cast<ConsumableSetOnReadAttr>(A));
    3327             :     case attr::Convergent:
    3328           0 :       return getDerived().TraverseConvergentAttr(cast<ConvergentAttr>(A));
    3329             :     case attr::DLLExport:
    3330           0 :       return getDerived().TraverseDLLExportAttr(cast<DLLExportAttr>(A));
    3331             :     case attr::DLLImport:
    3332           0 :       return getDerived().TraverseDLLImportAttr(cast<DLLImportAttr>(A));
    3333             :     case attr::Deprecated:
    3334           0 :       return getDerived().TraverseDeprecatedAttr(cast<DeprecatedAttr>(A));
    3335             :     case attr::Destructor:
    3336           0 :       return getDerived().TraverseDestructorAttr(cast<DestructorAttr>(A));
    3337             :     case attr::DiagnoseIf:
    3338           0 :       return getDerived().TraverseDiagnoseIfAttr(cast<DiagnoseIfAttr>(A));
    3339             :     case attr::DisableTailCalls:
    3340           0 :       return getDerived().TraverseDisableTailCallsAttr(cast<DisableTailCallsAttr>(A));
    3341             :     case attr::EmptyBases:
    3342           0 :       return getDerived().TraverseEmptyBasesAttr(cast<EmptyBasesAttr>(A));
    3343             :     case attr::EnableIf:
    3344           0 :       return getDerived().TraverseEnableIfAttr(cast<EnableIfAttr>(A));
    3345             :     case attr::EnumExtensibility:
    3346           0 :       return getDerived().TraverseEnumExtensibilityAttr(cast<EnumExtensibilityAttr>(A));
    3347             :     case attr::ExclusiveTrylockFunction:
    3348           0 :       return getDerived().TraverseExclusiveTrylockFunctionAttr(cast<ExclusiveTrylockFunctionAttr>(A));
    3349             :     case attr::ExternalSourceSymbol:
    3350           0 :       return getDerived().TraverseExternalSourceSymbolAttr(cast<ExternalSourceSymbolAttr>(A));
    3351             :     case attr::FallThrough:
    3352           0 :       return getDerived().TraverseFallThroughAttr(cast<FallThroughAttr>(A));
    3353             :     case attr::FastCall:
    3354           0 :       return getDerived().TraverseFastCallAttr(cast<FastCallAttr>(A));
    3355             :     case attr::Final:
    3356           0 :       return getDerived().TraverseFinalAttr(cast<FinalAttr>(A));
    3357             :     case attr::FlagEnum:
    3358           0 :       return getDerived().TraverseFlagEnumAttr(cast<FlagEnumAttr>(A));
    3359             :     case attr::Flatten:
    3360           0 :       return getDerived().TraverseFlattenAttr(cast<FlattenAttr>(A));
    3361             :     case attr::Format:
    3362           0 :       return getDerived().TraverseFormatAttr(cast<FormatAttr>(A));
    3363             :     case attr::FormatArg:
    3364           0 :       return getDerived().TraverseFormatArgAttr(cast<FormatArgAttr>(A));
    3365             :     case attr::GNUInline:
    3366           0 :       return getDerived().TraverseGNUInlineAttr(cast<GNUInlineAttr>(A));
    3367             :     case attr::GuardedBy:
    3368           1 :       return getDerived().TraverseGuardedByAttr(cast<GuardedByAttr>(A));
    3369             :     case attr::GuardedVar:
    3370           0 :       return getDerived().TraverseGuardedVarAttr(cast<GuardedVarAttr>(A));
    3371             :     case attr::Hot:
    3372           0 :       return getDerived().TraverseHotAttr(cast<HotAttr>(A));
    3373             :     case attr::IBAction:
    3374           0 :       return getDerived().TraverseIBActionAttr(cast<IBActionAttr>(A));
    3375             :     case attr::IBOutlet:
    3376           0 :       return getDerived().TraverseIBOutletAttr(cast<IBOutletAttr>(A));
    3377             :     case attr::IBOutletCollection:
    3378           0 :       return getDerived().TraverseIBOutletCollectionAttr(cast<IBOutletCollectionAttr>(A));
    3379             :     case attr::IFunc:
    3380           0 :       return getDerived().TraverseIFuncAttr(cast<IFuncAttr>(A));
    3381             :     case attr::InitPriority:
    3382           0 :       return getDerived().TraverseInitPriorityAttr(cast<InitPriorityAttr>(A));
    3383             :     case attr::InitSeg:
    3384           0 :       return getDerived().TraverseInitSegAttr(cast<InitSegAttr>(A));
    3385             :     case attr::IntelOclBicc:
    3386           0 :       return getDerived().TraverseIntelOclBiccAttr(cast<IntelOclBiccAttr>(A));
    3387             :     case attr::InternalLinkage:
    3388           0 :       return getDerived().TraverseInternalLinkageAttr(cast<InternalLinkageAttr>(A));
    3389             :     case attr::LTOVisibilityPublic:
    3390           0 :       return getDerived().TraverseLTOVisibilityPublicAttr(cast<LTOVisibilityPublicAttr>(A));
    3391             :     case attr::LayoutVersion:
    3392           0 :       return getDerived().TraverseLayoutVersionAttr(cast<LayoutVersionAttr>(A));
    3393             :     case attr::LockReturned:
    3394           0 :       return getDerived().TraverseLockReturnedAttr(cast<LockReturnedAttr>(A));
    3395             :     case attr::LocksExcluded:
    3396           0 :       return getDerived().TraverseLocksExcludedAttr(cast<LocksExcludedAttr>(A));
    3397             :     case attr::LoopHint:
    3398           0 :       return getDerived().TraverseLoopHintAttr(cast<LoopHintAttr>(A));
    3399             :     case attr::MSABI:
    3400           0 :       return getDerived().TraverseMSABIAttr(cast<MSABIAttr>(A));
    3401             :     case attr::MSInheritance:
    3402           0 :       return getDerived().TraverseMSInheritanceAttr(cast<MSInheritanceAttr>(A));
    3403             :     case attr::MSNoVTable:
    3404           0 :       return getDerived().TraverseMSNoVTableAttr(cast<MSNoVTableAttr>(A));
    3405             :     case attr::MSP430Interrupt:
    3406           0 :       return getDerived().TraverseMSP430InterruptAttr(cast<MSP430InterruptAttr>(A));
    3407             :     case attr::MSStruct:
    3408           0 :       return getDerived().TraverseMSStructAttr(cast<MSStructAttr>(A));
    3409             :     case attr::MSVtorDisp:
    3410           0 :       return getDerived().TraverseMSVtorDispAttr(cast<MSVtorDispAttr>(A));
    3411             :     case attr::MaxFieldAlignment:
    3412           0 :       return getDerived().TraverseMaxFieldAlignmentAttr(cast<MaxFieldAlignmentAttr>(A));
    3413             :     case attr::MayAlias:
    3414           0 :       return getDerived().TraverseMayAliasAttr(cast<MayAliasAttr>(A));
    3415             :     case attr::MicroMips:
    3416           0 :       return getDerived().TraverseMicroMipsAttr(cast<MicroMipsAttr>(A));
    3417             :     case attr::MinSize:
    3418           0 :       return getDerived().TraverseMinSizeAttr(cast<MinSizeAttr>(A));
    3419             :     case attr::MinVectorWidth:
    3420           0 :       return getDerived().TraverseMinVectorWidthAttr(cast<MinVectorWidthAttr>(A));
    3421             :     case attr::Mips16:
    3422           0 :       return getDerived().TraverseMips16Attr(cast<Mips16Attr>(A));
    3423             :     case attr::MipsInterrupt:
    3424           0 :       return getDerived().TraverseMipsInterruptAttr(cast<MipsInterruptAttr>(A));
    3425             :     case attr::MipsLongCall:
    3426           0 :       return getDerived().TraverseMipsLongCallAttr(cast<MipsLongCallAttr>(A));
    3427             :     case attr::MipsShortCall:
    3428           0 :       return getDerived().TraverseMipsShortCallAttr(cast<MipsShortCallAttr>(A));
    3429             :     case attr::Mode:
    3430           0 :       return getDerived().TraverseModeAttr(cast<ModeAttr>(A));
    3431             :     case attr::NSConsumed:
    3432           0 :       return getDerived().TraverseNSConsumedAttr(cast<NSConsumedAttr>(A));
    3433             :     case attr::NSConsumesSelf:
    3434           0 :       return getDerived().TraverseNSConsumesSelfAttr(cast<NSConsumesSelfAttr>(A));
    3435             :     case attr::NSReturnsAutoreleased:
    3436           0 :       return getDerived().TraverseNSReturnsAutoreleasedAttr(cast<NSReturnsAutoreleasedAttr>(A));
    3437             :     case attr::NSReturnsNotRetained:
    3438           0 :       return getDerived().TraverseNSReturnsNotRetainedAttr(cast<NSReturnsNotRetainedAttr>(A));
    3439             :     case attr::NSReturnsRetained:
    3440           0 :       return getDerived().TraverseNSReturnsRetainedAttr(cast<NSReturnsRetainedAttr>(A));
    3441             :     case attr::Naked:
    3442           0 :       return getDerived().TraverseNakedAttr(cast<NakedAttr>(A));
    3443             :     case attr::NoAlias:
    3444           0 :       return getDerived().TraverseNoAliasAttr(cast<NoAliasAttr>(A));
    3445             :     case attr::NoCommon:
    3446           0 :       return getDerived().TraverseNoCommonAttr(cast<NoCommonAttr>(A));
    3447             :     case attr::NoDebug:
    3448           0 :       return getDerived().TraverseNoDebugAttr(cast<NoDebugAttr>(A));
    3449             :     case attr::NoDuplicate:
    3450           0 :       return getDerived().TraverseNoDuplicateAttr(cast<NoDuplicateAttr>(A));
    3451             :     case attr::NoEscape:
    3452           0 :       return getDerived().TraverseNoEscapeAttr(cast<NoEscapeAttr>(A));
    3453             :     case attr::NoInline:
    3454           0 :       return getDerived().TraverseNoInlineAttr(cast<NoInlineAttr>(A));
    3455             :     case attr::NoInstrumentFunction:
    3456           0 :       return getDerived().TraverseNoInstrumentFunctionAttr(cast<NoInstrumentFunctionAttr>(A));
    3457             :     case attr::NoMicroMips:
    3458           0 :       return getDerived().TraverseNoMicroMipsAttr(cast<NoMicroMipsAttr>(A));
    3459             :     case attr::NoMips16:
    3460           0 :       return getDerived().TraverseNoMips16Attr(cast<NoMips16Attr>(A));
    3461             :     case attr::NoReturn:
    3462           0 :       return getDerived().TraverseNoReturnAttr(cast<NoReturnAttr>(A));
    3463             :     case attr::NoSanitize:
    3464           0 :       return getDerived().TraverseNoSanitizeAttr(cast<NoSanitizeAttr>(A));
    3465             :     case attr::NoSplitStack:
    3466           0 :       return getDerived().TraverseNoSplitStackAttr(cast<NoSplitStackAttr>(A));
    3467             :     case attr::NoStackProtector:
    3468           0 :       return getDerived().TraverseNoStackProtectorAttr(cast<NoStackProtectorAttr>(A));
    3469             :     case attr::NoThreadSafetyAnalysis:
    3470           0 :       return getDerived().TraverseNoThreadSafetyAnalysisAttr(cast<NoThreadSafetyAnalysisAttr>(A));
    3471             :     case attr::NoThrow:
    3472           0 :       return getDerived().TraverseNoThrowAttr(cast<NoThrowAttr>(A));
    3473             :     case attr::NonNull:
    3474           0 :       return getDerived().TraverseNonNullAttr(cast<NonNullAttr>(A));
    3475             :     case attr::NotTailCalled:
    3476           0 :       return getDerived().TraverseNotTailCalledAttr(cast<NotTailCalledAttr>(A));
    3477             :     case attr::OMPCaptureKind:
    3478           0 :       return getDerived().TraverseOMPCaptureKindAttr(cast<OMPCaptureKindAttr>(A));
    3479             :     case attr::OMPCaptureNoInit:
    3480           0 :       return getDerived().TraverseOMPCaptureNoInitAttr(cast<OMPCaptureNoInitAttr>(A));
    3481             :     case attr::OMPDeclareSimdDecl:
    3482           0 :       return getDerived().TraverseOMPDeclareSimdDeclAttr(cast<OMPDeclareSimdDeclAttr>(A));
    3483             :     case attr::OMPDeclareTargetDecl:
    3484           0 :       return getDerived().TraverseOMPDeclareTargetDeclAttr(cast<OMPDeclareTargetDeclAttr>(A));
    3485             :     case attr::OMPReferencedVar:
    3486           0 :       return getDerived().TraverseOMPReferencedVarAttr(cast<OMPReferencedVarAttr>(A));
    3487             :     case attr::OMPThreadPrivateDecl:
    3488           0 :       return getDerived().TraverseOMPThreadPrivateDeclAttr(cast<OMPThreadPrivateDeclAttr>(A));
    3489             :     case attr::ObjCBoxable:
    3490           0 :       return getDerived().TraverseObjCBoxableAttr(cast<ObjCBoxableAttr>(A));
    3491             :     case attr::ObjCBridge:
    3492           0 :       return getDerived().TraverseObjCBridgeAttr(cast<ObjCBridgeAttr>(A));
    3493             :     case attr::ObjCBridgeMutable:
    3494           0 :       return getDerived().TraverseObjCBridgeMutableAttr(cast<ObjCBridgeMutableAttr>(A));
    3495             :     case attr::ObjCBridgeRelated:
    3496           0 :       return getDerived().TraverseObjCBridgeRelatedAttr(cast<ObjCBridgeRelatedAttr>(A));
    3497             :     case attr::ObjCDesignatedInitializer:
    3498           0 :       return getDerived().TraverseObjCDesignatedInitializerAttr(cast<ObjCDesignatedInitializerAttr>(A));
    3499             :     case attr::ObjCException:
    3500           0 :       return getDerived().TraverseObjCExceptionAttr(cast<ObjCExceptionAttr>(A));
    3501             :     case attr::ObjCExplicitProtocolImpl:
    3502           0 :       return getDerived().TraverseObjCExplicitProtocolImplAttr(cast<ObjCExplicitProtocolImplAttr>(A));
    3503             :     case attr::ObjCIndependentClass:
    3504           0 :       return getDerived().TraverseObjCIndependentClassAttr(cast<ObjCIndependentClassAttr>(A));
    3505             :     case attr::ObjCMethodFamily:
    3506           0 :       return getDerived().TraverseObjCMethodFamilyAttr(cast<ObjCMethodFamilyAttr>(A));
    3507             :     case attr::ObjCNSObject:
    3508           0 :       return getDerived().TraverseObjCNSObjectAttr(cast<ObjCNSObjectAttr>(A));
    3509             :     case attr::ObjCPreciseLifetime:
    3510           0 :       return getDerived().TraverseObjCPreciseLifetimeAttr(cast<ObjCPreciseLifetimeAttr>(A));
    3511             :     case attr::ObjCRequiresPropertyDefs:
    3512           0 :       return getDerived().TraverseObjCRequiresPropertyDefsAttr(cast<ObjCRequiresPropertyDefsAttr>(A));
    3513             :     case attr::ObjCRequiresSuper:
    3514           0 :       return getDerived().TraverseObjCRequiresSuperAttr(cast<ObjCRequiresSuperAttr>(A));
    3515             :     case attr::ObjCReturnsInnerPointer:
    3516           0 :       return getDerived().TraverseObjCReturnsInnerPointerAttr(cast<ObjCReturnsInnerPointerAttr>(A));
    3517             :     case attr::ObjCRootClass:
    3518           0 :       return getDerived().TraverseObjCRootClassAttr(cast<ObjCRootClassAttr>(A));
    3519             :     case attr::ObjCRuntimeName:
    3520           0 :       return getDerived().TraverseObjCRuntimeNameAttr(cast<ObjCRuntimeNameAttr>(A));
    3521             :     case attr::ObjCRuntimeVisible:
    3522           0 :       return getDerived().TraverseObjCRuntimeVisibleAttr(cast<ObjCRuntimeVisibleAttr>(A));
    3523             :     case attr::ObjCSubclassingRestricted:
    3524           0 :       return getDerived().TraverseObjCSubclassingRestrictedAttr(cast<ObjCSubclassingRestrictedAttr>(A));
    3525             :     case attr::OpenCLAccess:
    3526           0 :       return getDerived().TraverseOpenCLAccessAttr(cast<OpenCLAccessAttr>(A));
    3527             :     case attr::OpenCLIntelReqdSubGroupSize:
    3528           0 :       return getDerived().TraverseOpenCLIntelReqdSubGroupSizeAttr(cast<OpenCLIntelReqdSubGroupSizeAttr>(A));
    3529             :     case attr::OpenCLKernel:
    3530           0 :       return getDerived().TraverseOpenCLKernelAttr(cast<OpenCLKernelAttr>(A));
    3531             :     case attr::OpenCLUnrollHint:
    3532           0 :       return getDerived().TraverseOpenCLUnrollHintAttr(cast<OpenCLUnrollHintAttr>(A));
    3533             :     case attr::OptimizeNone:
    3534           0 :       return getDerived().TraverseOptimizeNoneAttr(cast<OptimizeNoneAttr>(A));
    3535             :     case attr::Overloadable:
    3536           0 :       return getDerived().TraverseOverloadableAttr(cast<OverloadableAttr>(A));
    3537             :     case attr::Override:
    3538           0 :       return getDerived().TraverseOverrideAttr(cast<OverrideAttr>(A));
    3539             :     case attr::Ownership:
    3540           0 :       return getDerived().TraverseOwnershipAttr(cast<OwnershipAttr>(A));
    3541             :     case attr::Packed:
    3542           0 :       return getDerived().TraversePackedAttr(cast<PackedAttr>(A));
    3543             :     case attr::ParamTypestate:
    3544           0 :       return getDerived().TraverseParamTypestateAttr(cast<ParamTypestateAttr>(A));
    3545             :     case attr::Pascal:
    3546           0 :       return getDerived().TraversePascalAttr(cast<PascalAttr>(A));
    3547             :     case attr::PassObjectSize:
    3548           0 :       return getDerived().TraversePassObjectSizeAttr(cast<PassObjectSizeAttr>(A));
    3549             :     case attr::Pcs:
    3550           0 :       return getDerived().TraversePcsAttr(cast<PcsAttr>(A));
    3551             :     case attr::PragmaClangBSSSection:
    3552           0 :       return getDerived().TraversePragmaClangBSSSectionAttr(cast<PragmaClangBSSSectionAttr>(A));
    3553             :     case attr::PragmaClangDataSection:
    3554           0 :       return getDerived().TraversePragmaClangDataSectionAttr(cast<PragmaClangDataSectionAttr>(A));
    3555             :     case attr::PragmaClangRodataSection:
    3556           0 :       return getDerived().TraversePragmaClangRodataSectionAttr(cast<PragmaClangRodataSectionAttr>(A));
    3557             :     case attr::PragmaClangTextSection:
    3558           0 :       return getDerived().TraversePragmaClangTextSectionAttr(cast<PragmaClangTextSectionAttr>(A));
    3559             :     case attr::PreserveAll:
    3560           0 :       return getDerived().TraversePreserveAllAttr(cast<PreserveAllAttr>(A));
    3561             :     case attr::PreserveMost:
    3562           0 :       return getDerived().TraversePreserveMostAttr(cast<PreserveMostAttr>(A));
    3563             :     case attr::PtGuardedBy:
    3564           0 :       return getDerived().TraversePtGuardedByAttr(cast<PtGuardedByAttr>(A));
    3565             :     case attr::PtGuardedVar:
    3566           0 :       return getDerived().TraversePtGuardedVarAttr(cast<PtGuardedVarAttr>(A));
    3567             :     case attr::Pure:
    3568           0 :       return getDerived().TraversePureAttr(cast<PureAttr>(A));
    3569             :     case attr::RegCall:
    3570           0 :       return getDerived().TraverseRegCallAttr(cast<RegCallAttr>(A));
    3571             :     case attr::ReleaseCapability:
    3572           0 :       return getDerived().TraverseReleaseCapabilityAttr(cast<ReleaseCapabilityAttr>(A));
    3573             :     case attr::RenderScriptKernel:
    3574           0 :       return getDerived().TraverseRenderScriptKernelAttr(cast<RenderScriptKernelAttr>(A));
    3575             :     case attr::ReqdWorkGroupSize:
    3576           0 :       return getDerived().TraverseReqdWorkGroupSizeAttr(cast<ReqdWorkGroupSizeAttr>(A));
    3577             :     case attr::RequireConstantInit:
    3578           0 :       return getDerived().TraverseRequireConstantInitAttr(cast<RequireConstantInitAttr>(A));
    3579             :     case attr::RequiresCapability:
    3580           1 :       return getDerived().TraverseRequiresCapabilityAttr(cast<RequiresCapabilityAttr>(A));
    3581             :     case attr::Restrict:
    3582           0 :       return getDerived().TraverseRestrictAttr(cast<RestrictAttr>(A));
    3583             :     case attr::ReturnTypestate:
    3584           0 :       return getDerived().TraverseReturnTypestateAttr(cast<ReturnTypestateAttr>(A));
    3585             :     case attr::ReturnsNonNull:
    3586           0 :       return getDerived().TraverseReturnsNonNullAttr(cast<ReturnsNonNullAttr>(A));
    3587             :     case attr::ReturnsTwice:
    3588           0 :       return getDerived().TraverseReturnsTwiceAttr(cast<ReturnsTwiceAttr>(A));
    3589             :     case attr::ScopedLockable:
    3590           0 :       return getDerived().TraverseScopedLockableAttr(cast<ScopedLockableAttr>(A));
    3591             :     case attr::Section:
    3592           0 :       return getDerived().TraverseSectionAttr(cast<SectionAttr>(A));
    3593             :     case attr::SelectAny:
    3594           0 :       return getDerived().TraverseSelectAnyAttr(cast<SelectAnyAttr>(A));
    3595             :     case attr::Sentinel:
    3596           0 :       return getDerived().TraverseSentinelAttr(cast<SentinelAttr>(A));
    3597             :     case attr::SetTypestate:
    3598           0 :       return getDerived().TraverseSetTypestateAttr(cast<SetTypestateAttr>(A));
    3599             :     case attr::SharedTrylockFunction:
    3600           0 :       return getDerived().TraverseSharedTrylockFunctionAttr(cast<SharedTrylockFunctionAttr>(A));
    3601             :     case attr::StdCall:
    3602           0 :       return getDerived().TraverseStdCallAttr(cast<StdCallAttr>(A));
    3603             :     case attr::Suppress:
    3604           0 :       return getDerived().TraverseSuppressAttr(cast<SuppressAttr>(A));
    3605             :     case attr::SwiftCall:
    3606           0 :       return getDerived().TraverseSwiftCallAttr(cast<SwiftCallAttr>(A));
    3607             :     case attr::SwiftContext:
    3608           0 :       return getDerived().TraverseSwiftContextAttr(cast<SwiftContextAttr>(A));
    3609             :     case attr::SwiftErrorResult:
    3610           0 :       return getDerived().TraverseSwiftErrorResultAttr(cast<SwiftErrorResultAttr>(A));
    3611             :     case attr::SwiftIndirectResult:
    3612           0 :       return getDerived().TraverseSwiftIndirectResultAttr(cast<SwiftIndirectResultAttr>(A));
    3613             :     case attr::SysVABI:
    3614           0 :       return getDerived().TraverseSysVABIAttr(cast<SysVABIAttr>(A));
    3615             :     case attr::TLSModel:
    3616           0 :       return getDerived().TraverseTLSModelAttr(cast<TLSModelAttr>(A));
    3617             :     case attr::Target:
    3618           0 :       return getDerived().TraverseTargetAttr(cast<TargetAttr>(A));
    3619             :     case attr::TestTypestate:
    3620           0 :       return getDerived().TraverseTestTypestateAttr(cast<TestTypestateAttr>(A));
    3621             :     case attr::ThisCall:
    3622           0 :       return getDerived().TraverseThisCallAttr(cast<ThisCallAttr>(A));
    3623             :     case attr::Thread:
    3624           0 :       return getDerived().TraverseThreadAttr(cast<ThreadAttr>(A));
    3625             :     case attr::TransparentUnion:
    3626           0 :       return getDerived().TraverseTransparentUnionAttr(cast<TransparentUnionAttr>(A));
    3627             :     case attr::TrivialABI:
    3628           0 :       return getDerived().TraverseTrivialABIAttr(cast<TrivialABIAttr>(A));
    3629             :     case attr::TryAcquireCapability:
    3630           0 :       return getDerived().TraverseTryAcquireCapabilityAttr(cast<TryAcquireCapabilityAttr>(A));
    3631             :     case attr::TypeTagForDatatype:
    3632           0 :       return getDerived().TraverseTypeTagForDatatypeAttr(cast<TypeTagForDatatypeAttr>(A));
    3633             :     case attr::TypeVisibility:
    3634           0 :       return getDerived().TraverseTypeVisibilityAttr(cast<TypeVisibilityAttr>(A));
    3635             :     case attr::Unavailable:
    3636           0 :       return getDerived().TraverseUnavailableAttr(cast<UnavailableAttr>(A));
    3637             :     case attr::Unused:
    3638           0 :       return getDerived().TraverseUnusedAttr(cast<UnusedAttr>(A));
    3639             :     case attr::Used:
    3640           0 :       return getDerived().TraverseUsedAttr(cast<UsedAttr>(A));
    3641             :     case attr::Uuid:
    3642           0 :       return getDerived().TraverseUuidAttr(cast<UuidAttr>(A));
    3643             :     case attr::VecReturn:
    3644           0 :       return getDerived().TraverseVecReturnAttr(cast<VecReturnAttr>(A));
    3645             :     case attr::VecTypeHint:
    3646           0 :       return getDerived().TraverseVecTypeHintAttr(cast<VecTypeHintAttr>(A));
    3647             :     case attr::VectorCall:
    3648           0 :       return getDerived().TraverseVectorCallAttr(cast<VectorCallAttr>(A));
    3649             :     case attr::Visibility:
    3650           0 :       return getDerived().TraverseVisibilityAttr(cast<VisibilityAttr>(A));
    3651             :     case attr::WarnUnused:
    3652           0 :       return getDerived().TraverseWarnUnusedAttr(cast<WarnUnusedAttr>(A));
    3653             :     case attr::WarnUnusedResult:
    3654           0 :       return getDerived().TraverseWarnUnusedResultAttr(cast<WarnUnusedResultAttr>(A));
    3655             :     case attr::Weak:
    3656           0 :       return getDerived().TraverseWeakAttr(cast<WeakAttr>(A));
    3657             :     case attr::WeakImport:
    3658           0 :       return getDerived().TraverseWeakImportAttr(cast<WeakImportAttr>(A));
    3659             :     case attr::WeakRef:
    3660           0 :       return getDerived().TraverseWeakRefAttr(cast<WeakRefAttr>(A));
    3661             :     case attr::WorkGroupSizeHint:
    3662           0 :       return getDerived().TraverseWorkGroupSizeHintAttr(cast<WorkGroupSizeHintAttr>(A));
    3663             :     case attr::X86ForceAlignArgPointer:
    3664           0 :       return getDerived().TraverseX86ForceAlignArgPointerAttr(cast<X86ForceAlignArgPointerAttr>(A));
    3665             :     case attr::XRayInstrument:
    3666           0 :       return getDerived().TraverseXRayInstrumentAttr(cast<XRayInstrumentAttr>(A));
    3667             :     case attr::XRayLogArgs:
    3668           0 :       return getDerived().TraverseXRayLogArgsAttr(cast<XRayLogArgsAttr>(A));
    3669             :   }
    3670           0 :   llvm_unreachable("bad attribute kind");
    3671             : }
    3672             : #endif  // ATTR_VISITOR_DECLS_ONLY

Generated by: LCOV version 1.13