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

Generated by: LCOV version 1.13