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

Generated by: LCOV version 1.13