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: 26 1028 2.5 %
Date: 2017-09-14 15:23:50 Functions: 51 2319 2.2 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13