Back to home page

EIC code displayed by LXR
 
 

    

Warning, /include/clang/AST/AttrVisitor.inc is written in an unsupported language. File is not indexed. 

0001 /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
0002 |*                                                                            *|
0003 |* Used by RecursiveASTVisitor to visit attributes.                           *|
0004 |*                                                                            *|
0005 |* Automatically generated file, do not edit!                                 *|
0006 |* From: Attr.td                                                              *|
0007 |*                                                                            *|
0008 \*===----------------------------------------------------------------------===*/
0009 
0010 #ifdef ATTR_VISITOR_DECLS_ONLY
0011 
0012   bool TraverseAArch64SVEPcsAttr(AArch64SVEPcsAttr *A);
0013   bool VisitAArch64SVEPcsAttr(AArch64SVEPcsAttr *A) {
0014     return true; 
0015   }
0016   bool TraverseAArch64VectorPcsAttr(AArch64VectorPcsAttr *A);
0017   bool VisitAArch64VectorPcsAttr(AArch64VectorPcsAttr *A) {
0018     return true; 
0019   }
0020   bool TraverseAMDGPUFlatWorkGroupSizeAttr(AMDGPUFlatWorkGroupSizeAttr *A);
0021   bool VisitAMDGPUFlatWorkGroupSizeAttr(AMDGPUFlatWorkGroupSizeAttr *A) {
0022     return true; 
0023   }
0024   bool TraverseAMDGPUKernelCallAttr(AMDGPUKernelCallAttr *A);
0025   bool VisitAMDGPUKernelCallAttr(AMDGPUKernelCallAttr *A) {
0026     return true; 
0027   }
0028   bool TraverseAMDGPUMaxNumWorkGroupsAttr(AMDGPUMaxNumWorkGroupsAttr *A);
0029   bool VisitAMDGPUMaxNumWorkGroupsAttr(AMDGPUMaxNumWorkGroupsAttr *A) {
0030     return true; 
0031   }
0032   bool TraverseAMDGPUNumSGPRAttr(AMDGPUNumSGPRAttr *A);
0033   bool VisitAMDGPUNumSGPRAttr(AMDGPUNumSGPRAttr *A) {
0034     return true; 
0035   }
0036   bool TraverseAMDGPUNumVGPRAttr(AMDGPUNumVGPRAttr *A);
0037   bool VisitAMDGPUNumVGPRAttr(AMDGPUNumVGPRAttr *A) {
0038     return true; 
0039   }
0040   bool TraverseAMDGPUWavesPerEUAttr(AMDGPUWavesPerEUAttr *A);
0041   bool VisitAMDGPUWavesPerEUAttr(AMDGPUWavesPerEUAttr *A) {
0042     return true; 
0043   }
0044   bool TraverseARMInterruptAttr(ARMInterruptAttr *A);
0045   bool VisitARMInterruptAttr(ARMInterruptAttr *A) {
0046     return true; 
0047   }
0048   bool TraverseAVRInterruptAttr(AVRInterruptAttr *A);
0049   bool VisitAVRInterruptAttr(AVRInterruptAttr *A) {
0050     return true; 
0051   }
0052   bool TraverseAVRSignalAttr(AVRSignalAttr *A);
0053   bool VisitAVRSignalAttr(AVRSignalAttr *A) {
0054     return true; 
0055   }
0056   bool TraverseAbiTagAttr(AbiTagAttr *A);
0057   bool VisitAbiTagAttr(AbiTagAttr *A) {
0058     return true; 
0059   }
0060   bool TraverseAcquireCapabilityAttr(AcquireCapabilityAttr *A);
0061   bool VisitAcquireCapabilityAttr(AcquireCapabilityAttr *A) {
0062     return true; 
0063   }
0064   bool TraverseAcquireHandleAttr(AcquireHandleAttr *A);
0065   bool VisitAcquireHandleAttr(AcquireHandleAttr *A) {
0066     return true; 
0067   }
0068   bool TraverseAcquiredAfterAttr(AcquiredAfterAttr *A);
0069   bool VisitAcquiredAfterAttr(AcquiredAfterAttr *A) {
0070     return true; 
0071   }
0072   bool TraverseAcquiredBeforeAttr(AcquiredBeforeAttr *A);
0073   bool VisitAcquiredBeforeAttr(AcquiredBeforeAttr *A) {
0074     return true; 
0075   }
0076   bool TraverseAddressSpaceAttr(AddressSpaceAttr *A);
0077   bool VisitAddressSpaceAttr(AddressSpaceAttr *A) {
0078     return true; 
0079   }
0080   bool TraverseAliasAttr(AliasAttr *A);
0081   bool VisitAliasAttr(AliasAttr *A) {
0082     return true; 
0083   }
0084   bool TraverseAlignMac68kAttr(AlignMac68kAttr *A);
0085   bool VisitAlignMac68kAttr(AlignMac68kAttr *A) {
0086     return true; 
0087   }
0088   bool TraverseAlignNaturalAttr(AlignNaturalAttr *A);
0089   bool VisitAlignNaturalAttr(AlignNaturalAttr *A) {
0090     return true; 
0091   }
0092   bool TraverseAlignValueAttr(AlignValueAttr *A);
0093   bool VisitAlignValueAttr(AlignValueAttr *A) {
0094     return true; 
0095   }
0096   bool TraverseAlignedAttr(AlignedAttr *A);
0097   bool VisitAlignedAttr(AlignedAttr *A) {
0098     return true; 
0099   }
0100   bool TraverseAllocAlignAttr(AllocAlignAttr *A);
0101   bool VisitAllocAlignAttr(AllocAlignAttr *A) {
0102     return true; 
0103   }
0104   bool TraverseAllocSizeAttr(AllocSizeAttr *A);
0105   bool VisitAllocSizeAttr(AllocSizeAttr *A) {
0106     return true; 
0107   }
0108   bool TraverseAllocatingAttr(AllocatingAttr *A);
0109   bool VisitAllocatingAttr(AllocatingAttr *A) {
0110     return true; 
0111   }
0112   bool TraverseAlwaysDestroyAttr(AlwaysDestroyAttr *A);
0113   bool VisitAlwaysDestroyAttr(AlwaysDestroyAttr *A) {
0114     return true; 
0115   }
0116   bool TraverseAlwaysInlineAttr(AlwaysInlineAttr *A);
0117   bool VisitAlwaysInlineAttr(AlwaysInlineAttr *A) {
0118     return true; 
0119   }
0120   bool TraverseAnalyzerNoReturnAttr(AnalyzerNoReturnAttr *A);
0121   bool VisitAnalyzerNoReturnAttr(AnalyzerNoReturnAttr *A) {
0122     return true; 
0123   }
0124   bool TraverseAnnotateAttr(AnnotateAttr *A);
0125   bool VisitAnnotateAttr(AnnotateAttr *A) {
0126     return true; 
0127   }
0128   bool TraverseAnnotateTypeAttr(AnnotateTypeAttr *A);
0129   bool VisitAnnotateTypeAttr(AnnotateTypeAttr *A) {
0130     return true; 
0131   }
0132   bool TraverseAnyX86InterruptAttr(AnyX86InterruptAttr *A);
0133   bool VisitAnyX86InterruptAttr(AnyX86InterruptAttr *A) {
0134     return true; 
0135   }
0136   bool TraverseAnyX86NoCallerSavedRegistersAttr(AnyX86NoCallerSavedRegistersAttr *A);
0137   bool VisitAnyX86NoCallerSavedRegistersAttr(AnyX86NoCallerSavedRegistersAttr *A) {
0138     return true; 
0139   }
0140   bool TraverseAnyX86NoCfCheckAttr(AnyX86NoCfCheckAttr *A);
0141   bool VisitAnyX86NoCfCheckAttr(AnyX86NoCfCheckAttr *A) {
0142     return true; 
0143   }
0144   bool TraverseArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A);
0145   bool VisitArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A) {
0146     return true; 
0147   }
0148   bool TraverseArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *A);
0149   bool VisitArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *A) {
0150     return true; 
0151   }
0152   bool TraverseArmAgnosticAttr(ArmAgnosticAttr *A);
0153   bool VisitArmAgnosticAttr(ArmAgnosticAttr *A) {
0154     return true; 
0155   }
0156   bool TraverseArmBuiltinAliasAttr(ArmBuiltinAliasAttr *A);
0157   bool VisitArmBuiltinAliasAttr(ArmBuiltinAliasAttr *A) {
0158     return true; 
0159   }
0160   bool TraverseArmInAttr(ArmInAttr *A);
0161   bool VisitArmInAttr(ArmInAttr *A) {
0162     return true; 
0163   }
0164   bool TraverseArmInOutAttr(ArmInOutAttr *A);
0165   bool VisitArmInOutAttr(ArmInOutAttr *A) {
0166     return true; 
0167   }
0168   bool TraverseArmLocallyStreamingAttr(ArmLocallyStreamingAttr *A);
0169   bool VisitArmLocallyStreamingAttr(ArmLocallyStreamingAttr *A) {
0170     return true; 
0171   }
0172   bool TraverseArmMveStrictPolymorphismAttr(ArmMveStrictPolymorphismAttr *A);
0173   bool VisitArmMveStrictPolymorphismAttr(ArmMveStrictPolymorphismAttr *A) {
0174     return true; 
0175   }
0176   bool TraverseArmNewAttr(ArmNewAttr *A);
0177   bool VisitArmNewAttr(ArmNewAttr *A) {
0178     return true; 
0179   }
0180   bool TraverseArmOutAttr(ArmOutAttr *A);
0181   bool VisitArmOutAttr(ArmOutAttr *A) {
0182     return true; 
0183   }
0184   bool TraverseArmPreservesAttr(ArmPreservesAttr *A);
0185   bool VisitArmPreservesAttr(ArmPreservesAttr *A) {
0186     return true; 
0187   }
0188   bool TraverseArmStreamingAttr(ArmStreamingAttr *A);
0189   bool VisitArmStreamingAttr(ArmStreamingAttr *A) {
0190     return true; 
0191   }
0192   bool TraverseArmStreamingCompatibleAttr(ArmStreamingCompatibleAttr *A);
0193   bool VisitArmStreamingCompatibleAttr(ArmStreamingCompatibleAttr *A) {
0194     return true; 
0195   }
0196   bool TraverseArtificialAttr(ArtificialAttr *A);
0197   bool VisitArtificialAttr(ArtificialAttr *A) {
0198     return true; 
0199   }
0200   bool TraverseAsmLabelAttr(AsmLabelAttr *A);
0201   bool VisitAsmLabelAttr(AsmLabelAttr *A) {
0202     return true; 
0203   }
0204   bool TraverseAssertCapabilityAttr(AssertCapabilityAttr *A);
0205   bool VisitAssertCapabilityAttr(AssertCapabilityAttr *A) {
0206     return true; 
0207   }
0208   bool TraverseAssertExclusiveLockAttr(AssertExclusiveLockAttr *A);
0209   bool VisitAssertExclusiveLockAttr(AssertExclusiveLockAttr *A) {
0210     return true; 
0211   }
0212   bool TraverseAssertSharedLockAttr(AssertSharedLockAttr *A);
0213   bool VisitAssertSharedLockAttr(AssertSharedLockAttr *A) {
0214     return true; 
0215   }
0216   bool TraverseAssumeAlignedAttr(AssumeAlignedAttr *A);
0217   bool VisitAssumeAlignedAttr(AssumeAlignedAttr *A) {
0218     return true; 
0219   }
0220   bool TraverseAvailabilityAttr(AvailabilityAttr *A);
0221   bool VisitAvailabilityAttr(AvailabilityAttr *A) {
0222     return true; 
0223   }
0224   bool TraverseAvailableOnlyInDefaultEvalMethodAttr(AvailableOnlyInDefaultEvalMethodAttr *A);
0225   bool VisitAvailableOnlyInDefaultEvalMethodAttr(AvailableOnlyInDefaultEvalMethodAttr *A) {
0226     return true; 
0227   }
0228   bool TraverseBPFFastCallAttr(BPFFastCallAttr *A);
0229   bool VisitBPFFastCallAttr(BPFFastCallAttr *A) {
0230     return true; 
0231   }
0232   bool TraverseBPFPreserveAccessIndexAttr(BPFPreserveAccessIndexAttr *A);
0233   bool VisitBPFPreserveAccessIndexAttr(BPFPreserveAccessIndexAttr *A) {
0234     return true; 
0235   }
0236   bool TraverseBPFPreserveStaticOffsetAttr(BPFPreserveStaticOffsetAttr *A);
0237   bool VisitBPFPreserveStaticOffsetAttr(BPFPreserveStaticOffsetAttr *A) {
0238     return true; 
0239   }
0240   bool TraverseBTFDeclTagAttr(BTFDeclTagAttr *A);
0241   bool VisitBTFDeclTagAttr(BTFDeclTagAttr *A) {
0242     return true; 
0243   }
0244   bool TraverseBTFTypeTagAttr(BTFTypeTagAttr *A);
0245   bool VisitBTFTypeTagAttr(BTFTypeTagAttr *A) {
0246     return true; 
0247   }
0248   bool TraverseBlockingAttr(BlockingAttr *A);
0249   bool VisitBlockingAttr(BlockingAttr *A) {
0250     return true; 
0251   }
0252   bool TraverseBlocksAttr(BlocksAttr *A);
0253   bool VisitBlocksAttr(BlocksAttr *A) {
0254     return true; 
0255   }
0256   bool TraverseBuiltinAttr(BuiltinAttr *A);
0257   bool VisitBuiltinAttr(BuiltinAttr *A) {
0258     return true; 
0259   }
0260   bool TraverseBuiltinAliasAttr(BuiltinAliasAttr *A);
0261   bool VisitBuiltinAliasAttr(BuiltinAliasAttr *A) {
0262     return true; 
0263   }
0264   bool TraverseC11NoReturnAttr(C11NoReturnAttr *A);
0265   bool VisitC11NoReturnAttr(C11NoReturnAttr *A) {
0266     return true; 
0267   }
0268   bool TraverseCDeclAttr(CDeclAttr *A);
0269   bool VisitCDeclAttr(CDeclAttr *A) {
0270     return true; 
0271   }
0272   bool TraverseCFAuditedTransferAttr(CFAuditedTransferAttr *A);
0273   bool VisitCFAuditedTransferAttr(CFAuditedTransferAttr *A) {
0274     return true; 
0275   }
0276   bool TraverseCFConsumedAttr(CFConsumedAttr *A);
0277   bool VisitCFConsumedAttr(CFConsumedAttr *A) {
0278     return true; 
0279   }
0280   bool TraverseCFGuardAttr(CFGuardAttr *A);
0281   bool VisitCFGuardAttr(CFGuardAttr *A) {
0282     return true; 
0283   }
0284   bool TraverseCFICanonicalJumpTableAttr(CFICanonicalJumpTableAttr *A);
0285   bool VisitCFICanonicalJumpTableAttr(CFICanonicalJumpTableAttr *A) {
0286     return true; 
0287   }
0288   bool TraverseCFReturnsNotRetainedAttr(CFReturnsNotRetainedAttr *A);
0289   bool VisitCFReturnsNotRetainedAttr(CFReturnsNotRetainedAttr *A) {
0290     return true; 
0291   }
0292   bool TraverseCFReturnsRetainedAttr(CFReturnsRetainedAttr *A);
0293   bool VisitCFReturnsRetainedAttr(CFReturnsRetainedAttr *A) {
0294     return true; 
0295   }
0296   bool TraverseCFUnknownTransferAttr(CFUnknownTransferAttr *A);
0297   bool VisitCFUnknownTransferAttr(CFUnknownTransferAttr *A) {
0298     return true; 
0299   }
0300   bool TraverseCPUDispatchAttr(CPUDispatchAttr *A);
0301   bool VisitCPUDispatchAttr(CPUDispatchAttr *A) {
0302     return true; 
0303   }
0304   bool TraverseCPUSpecificAttr(CPUSpecificAttr *A);
0305   bool VisitCPUSpecificAttr(CPUSpecificAttr *A) {
0306     return true; 
0307   }
0308   bool TraverseCUDAConstantAttr(CUDAConstantAttr *A);
0309   bool VisitCUDAConstantAttr(CUDAConstantAttr *A) {
0310     return true; 
0311   }
0312   bool TraverseCUDADeviceAttr(CUDADeviceAttr *A);
0313   bool VisitCUDADeviceAttr(CUDADeviceAttr *A) {
0314     return true; 
0315   }
0316   bool TraverseCUDADeviceBuiltinSurfaceTypeAttr(CUDADeviceBuiltinSurfaceTypeAttr *A);
0317   bool VisitCUDADeviceBuiltinSurfaceTypeAttr(CUDADeviceBuiltinSurfaceTypeAttr *A) {
0318     return true; 
0319   }
0320   bool TraverseCUDADeviceBuiltinTextureTypeAttr(CUDADeviceBuiltinTextureTypeAttr *A);
0321   bool VisitCUDADeviceBuiltinTextureTypeAttr(CUDADeviceBuiltinTextureTypeAttr *A) {
0322     return true; 
0323   }
0324   bool TraverseCUDAGlobalAttr(CUDAGlobalAttr *A);
0325   bool VisitCUDAGlobalAttr(CUDAGlobalAttr *A) {
0326     return true; 
0327   }
0328   bool TraverseCUDAGridConstantAttr(CUDAGridConstantAttr *A);
0329   bool VisitCUDAGridConstantAttr(CUDAGridConstantAttr *A) {
0330     return true; 
0331   }
0332   bool TraverseCUDAHostAttr(CUDAHostAttr *A);
0333   bool VisitCUDAHostAttr(CUDAHostAttr *A) {
0334     return true; 
0335   }
0336   bool TraverseCUDAInvalidTargetAttr(CUDAInvalidTargetAttr *A);
0337   bool VisitCUDAInvalidTargetAttr(CUDAInvalidTargetAttr *A) {
0338     return true; 
0339   }
0340   bool TraverseCUDALaunchBoundsAttr(CUDALaunchBoundsAttr *A);
0341   bool VisitCUDALaunchBoundsAttr(CUDALaunchBoundsAttr *A) {
0342     return true; 
0343   }
0344   bool TraverseCUDASharedAttr(CUDASharedAttr *A);
0345   bool VisitCUDASharedAttr(CUDASharedAttr *A) {
0346     return true; 
0347   }
0348   bool TraverseCXX11NoReturnAttr(CXX11NoReturnAttr *A);
0349   bool VisitCXX11NoReturnAttr(CXX11NoReturnAttr *A) {
0350     return true; 
0351   }
0352   bool TraverseCXXAssumeAttr(CXXAssumeAttr *A);
0353   bool VisitCXXAssumeAttr(CXXAssumeAttr *A) {
0354     return true; 
0355   }
0356   bool TraverseCallableWhenAttr(CallableWhenAttr *A);
0357   bool VisitCallableWhenAttr(CallableWhenAttr *A) {
0358     return true; 
0359   }
0360   bool TraverseCallbackAttr(CallbackAttr *A);
0361   bool VisitCallbackAttr(CallbackAttr *A) {
0362     return true; 
0363   }
0364   bool TraverseCalledOnceAttr(CalledOnceAttr *A);
0365   bool VisitCalledOnceAttr(CalledOnceAttr *A) {
0366     return true; 
0367   }
0368   bool TraverseCapabilityAttr(CapabilityAttr *A);
0369   bool VisitCapabilityAttr(CapabilityAttr *A) {
0370     return true; 
0371   }
0372   bool TraverseCapturedRecordAttr(CapturedRecordAttr *A);
0373   bool VisitCapturedRecordAttr(CapturedRecordAttr *A) {
0374     return true; 
0375   }
0376   bool TraverseCarriesDependencyAttr(CarriesDependencyAttr *A);
0377   bool VisitCarriesDependencyAttr(CarriesDependencyAttr *A) {
0378     return true; 
0379   }
0380   bool TraverseCleanupAttr(CleanupAttr *A);
0381   bool VisitCleanupAttr(CleanupAttr *A) {
0382     return true; 
0383   }
0384   bool TraverseClspvLibclcBuiltinAttr(ClspvLibclcBuiltinAttr *A);
0385   bool VisitClspvLibclcBuiltinAttr(ClspvLibclcBuiltinAttr *A) {
0386     return true; 
0387   }
0388   bool TraverseCmseNSCallAttr(CmseNSCallAttr *A);
0389   bool VisitCmseNSCallAttr(CmseNSCallAttr *A) {
0390     return true; 
0391   }
0392   bool TraverseCmseNSEntryAttr(CmseNSEntryAttr *A);
0393   bool VisitCmseNSEntryAttr(CmseNSEntryAttr *A) {
0394     return true; 
0395   }
0396   bool TraverseCodeAlignAttr(CodeAlignAttr *A);
0397   bool VisitCodeAlignAttr(CodeAlignAttr *A) {
0398     return true; 
0399   }
0400   bool TraverseCodeModelAttr(CodeModelAttr *A);
0401   bool VisitCodeModelAttr(CodeModelAttr *A) {
0402     return true; 
0403   }
0404   bool TraverseCodeSegAttr(CodeSegAttr *A);
0405   bool VisitCodeSegAttr(CodeSegAttr *A) {
0406     return true; 
0407   }
0408   bool TraverseColdAttr(ColdAttr *A);
0409   bool VisitColdAttr(ColdAttr *A) {
0410     return true; 
0411   }
0412   bool TraverseCommonAttr(CommonAttr *A);
0413   bool VisitCommonAttr(CommonAttr *A) {
0414     return true; 
0415   }
0416   bool TraverseConstAttr(ConstAttr *A);
0417   bool VisitConstAttr(ConstAttr *A) {
0418     return true; 
0419   }
0420   bool TraverseConstInitAttr(ConstInitAttr *A);
0421   bool VisitConstInitAttr(ConstInitAttr *A) {
0422     return true; 
0423   }
0424   bool TraverseConstructorAttr(ConstructorAttr *A);
0425   bool VisitConstructorAttr(ConstructorAttr *A) {
0426     return true; 
0427   }
0428   bool TraverseConsumableAttr(ConsumableAttr *A);
0429   bool VisitConsumableAttr(ConsumableAttr *A) {
0430     return true; 
0431   }
0432   bool TraverseConsumableAutoCastAttr(ConsumableAutoCastAttr *A);
0433   bool VisitConsumableAutoCastAttr(ConsumableAutoCastAttr *A) {
0434     return true; 
0435   }
0436   bool TraverseConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A);
0437   bool VisitConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A) {
0438     return true; 
0439   }
0440   bool TraverseConvergentAttr(ConvergentAttr *A);
0441   bool VisitConvergentAttr(ConvergentAttr *A) {
0442     return true; 
0443   }
0444   bool TraverseCoroAwaitElidableAttr(CoroAwaitElidableAttr *A);
0445   bool VisitCoroAwaitElidableAttr(CoroAwaitElidableAttr *A) {
0446     return true; 
0447   }
0448   bool TraverseCoroAwaitElidableArgumentAttr(CoroAwaitElidableArgumentAttr *A);
0449   bool VisitCoroAwaitElidableArgumentAttr(CoroAwaitElidableArgumentAttr *A) {
0450     return true; 
0451   }
0452   bool TraverseCoroDisableLifetimeBoundAttr(CoroDisableLifetimeBoundAttr *A);
0453   bool VisitCoroDisableLifetimeBoundAttr(CoroDisableLifetimeBoundAttr *A) {
0454     return true; 
0455   }
0456   bool TraverseCoroLifetimeBoundAttr(CoroLifetimeBoundAttr *A);
0457   bool VisitCoroLifetimeBoundAttr(CoroLifetimeBoundAttr *A) {
0458     return true; 
0459   }
0460   bool TraverseCoroOnlyDestroyWhenCompleteAttr(CoroOnlyDestroyWhenCompleteAttr *A);
0461   bool VisitCoroOnlyDestroyWhenCompleteAttr(CoroOnlyDestroyWhenCompleteAttr *A) {
0462     return true; 
0463   }
0464   bool TraverseCoroReturnTypeAttr(CoroReturnTypeAttr *A);
0465   bool VisitCoroReturnTypeAttr(CoroReturnTypeAttr *A) {
0466     return true; 
0467   }
0468   bool TraverseCoroWrapperAttr(CoroWrapperAttr *A);
0469   bool VisitCoroWrapperAttr(CoroWrapperAttr *A) {
0470     return true; 
0471   }
0472   bool TraverseCountedByAttr(CountedByAttr *A);
0473   bool VisitCountedByAttr(CountedByAttr *A) {
0474     return true; 
0475   }
0476   bool TraverseCountedByOrNullAttr(CountedByOrNullAttr *A);
0477   bool VisitCountedByOrNullAttr(CountedByOrNullAttr *A) {
0478     return true; 
0479   }
0480   bool TraverseDLLExportAttr(DLLExportAttr *A);
0481   bool VisitDLLExportAttr(DLLExportAttr *A) {
0482     return true; 
0483   }
0484   bool TraverseDLLExportStaticLocalAttr(DLLExportStaticLocalAttr *A);
0485   bool VisitDLLExportStaticLocalAttr(DLLExportStaticLocalAttr *A) {
0486     return true; 
0487   }
0488   bool TraverseDLLImportAttr(DLLImportAttr *A);
0489   bool VisitDLLImportAttr(DLLImportAttr *A) {
0490     return true; 
0491   }
0492   bool TraverseDLLImportStaticLocalAttr(DLLImportStaticLocalAttr *A);
0493   bool VisitDLLImportStaticLocalAttr(DLLImportStaticLocalAttr *A) {
0494     return true; 
0495   }
0496   bool TraverseDeprecatedAttr(DeprecatedAttr *A);
0497   bool VisitDeprecatedAttr(DeprecatedAttr *A) {
0498     return true; 
0499   }
0500   bool TraverseDestructorAttr(DestructorAttr *A);
0501   bool VisitDestructorAttr(DestructorAttr *A) {
0502     return true; 
0503   }
0504   bool TraverseDiagnoseAsBuiltinAttr(DiagnoseAsBuiltinAttr *A);
0505   bool VisitDiagnoseAsBuiltinAttr(DiagnoseAsBuiltinAttr *A) {
0506     return true; 
0507   }
0508   bool TraverseDiagnoseIfAttr(DiagnoseIfAttr *A);
0509   bool VisitDiagnoseIfAttr(DiagnoseIfAttr *A) {
0510     return true; 
0511   }
0512   bool TraverseDisableSanitizerInstrumentationAttr(DisableSanitizerInstrumentationAttr *A);
0513   bool VisitDisableSanitizerInstrumentationAttr(DisableSanitizerInstrumentationAttr *A) {
0514     return true; 
0515   }
0516   bool TraverseDisableTailCallsAttr(DisableTailCallsAttr *A);
0517   bool VisitDisableTailCallsAttr(DisableTailCallsAttr *A) {
0518     return true; 
0519   }
0520   bool TraverseEmptyBasesAttr(EmptyBasesAttr *A);
0521   bool VisitEmptyBasesAttr(EmptyBasesAttr *A) {
0522     return true; 
0523   }
0524   bool TraverseEnableIfAttr(EnableIfAttr *A);
0525   bool VisitEnableIfAttr(EnableIfAttr *A) {
0526     return true; 
0527   }
0528   bool TraverseEnforceTCBAttr(EnforceTCBAttr *A);
0529   bool VisitEnforceTCBAttr(EnforceTCBAttr *A) {
0530     return true; 
0531   }
0532   bool TraverseEnforceTCBLeafAttr(EnforceTCBLeafAttr *A);
0533   bool VisitEnforceTCBLeafAttr(EnforceTCBLeafAttr *A) {
0534     return true; 
0535   }
0536   bool TraverseEnumExtensibilityAttr(EnumExtensibilityAttr *A);
0537   bool VisitEnumExtensibilityAttr(EnumExtensibilityAttr *A) {
0538     return true; 
0539   }
0540   bool TraverseErrorAttr(ErrorAttr *A);
0541   bool VisitErrorAttr(ErrorAttr *A) {
0542     return true; 
0543   }
0544   bool TraverseExcludeFromExplicitInstantiationAttr(ExcludeFromExplicitInstantiationAttr *A);
0545   bool VisitExcludeFromExplicitInstantiationAttr(ExcludeFromExplicitInstantiationAttr *A) {
0546     return true; 
0547   }
0548   bool TraverseExclusiveTrylockFunctionAttr(ExclusiveTrylockFunctionAttr *A);
0549   bool VisitExclusiveTrylockFunctionAttr(ExclusiveTrylockFunctionAttr *A) {
0550     return true; 
0551   }
0552   bool TraverseExplicitInitAttr(ExplicitInitAttr *A);
0553   bool VisitExplicitInitAttr(ExplicitInitAttr *A) {
0554     return true; 
0555   }
0556   bool TraverseExternalSourceSymbolAttr(ExternalSourceSymbolAttr *A);
0557   bool VisitExternalSourceSymbolAttr(ExternalSourceSymbolAttr *A) {
0558     return true; 
0559   }
0560   bool TraverseFallThroughAttr(FallThroughAttr *A);
0561   bool VisitFallThroughAttr(FallThroughAttr *A) {
0562     return true; 
0563   }
0564   bool TraverseFastCallAttr(FastCallAttr *A);
0565   bool VisitFastCallAttr(FastCallAttr *A) {
0566     return true; 
0567   }
0568   bool TraverseFinalAttr(FinalAttr *A);
0569   bool VisitFinalAttr(FinalAttr *A) {
0570     return true; 
0571   }
0572   bool TraverseFlagEnumAttr(FlagEnumAttr *A);
0573   bool VisitFlagEnumAttr(FlagEnumAttr *A) {
0574     return true; 
0575   }
0576   bool TraverseFlattenAttr(FlattenAttr *A);
0577   bool VisitFlattenAttr(FlattenAttr *A) {
0578     return true; 
0579   }
0580   bool TraverseFormatAttr(FormatAttr *A);
0581   bool VisitFormatAttr(FormatAttr *A) {
0582     return true; 
0583   }
0584   bool TraverseFormatArgAttr(FormatArgAttr *A);
0585   bool VisitFormatArgAttr(FormatArgAttr *A) {
0586     return true; 
0587   }
0588   bool TraverseFunctionReturnThunksAttr(FunctionReturnThunksAttr *A);
0589   bool VisitFunctionReturnThunksAttr(FunctionReturnThunksAttr *A) {
0590     return true; 
0591   }
0592   bool TraverseGNUInlineAttr(GNUInlineAttr *A);
0593   bool VisitGNUInlineAttr(GNUInlineAttr *A) {
0594     return true; 
0595   }
0596   bool TraverseGuardedByAttr(GuardedByAttr *A);
0597   bool VisitGuardedByAttr(GuardedByAttr *A) {
0598     return true; 
0599   }
0600   bool TraverseGuardedVarAttr(GuardedVarAttr *A);
0601   bool VisitGuardedVarAttr(GuardedVarAttr *A) {
0602     return true; 
0603   }
0604   bool TraverseHIPManagedAttr(HIPManagedAttr *A);
0605   bool VisitHIPManagedAttr(HIPManagedAttr *A) {
0606     return true; 
0607   }
0608   bool TraverseHLSLContainedTypeAttr(HLSLContainedTypeAttr *A);
0609   bool VisitHLSLContainedTypeAttr(HLSLContainedTypeAttr *A) {
0610     return true; 
0611   }
0612   bool TraverseHLSLControlFlowHintAttr(HLSLControlFlowHintAttr *A);
0613   bool VisitHLSLControlFlowHintAttr(HLSLControlFlowHintAttr *A) {
0614     return true; 
0615   }
0616   bool TraverseHLSLGroupSharedAddressSpaceAttr(HLSLGroupSharedAddressSpaceAttr *A);
0617   bool VisitHLSLGroupSharedAddressSpaceAttr(HLSLGroupSharedAddressSpaceAttr *A) {
0618     return true; 
0619   }
0620   bool TraverseHLSLLoopHintAttr(HLSLLoopHintAttr *A);
0621   bool VisitHLSLLoopHintAttr(HLSLLoopHintAttr *A) {
0622     return true; 
0623   }
0624   bool TraverseHLSLNumThreadsAttr(HLSLNumThreadsAttr *A);
0625   bool VisitHLSLNumThreadsAttr(HLSLNumThreadsAttr *A) {
0626     return true; 
0627   }
0628   bool TraverseHLSLPackOffsetAttr(HLSLPackOffsetAttr *A);
0629   bool VisitHLSLPackOffsetAttr(HLSLPackOffsetAttr *A) {
0630     return true; 
0631   }
0632   bool TraverseHLSLParamModifierAttr(HLSLParamModifierAttr *A);
0633   bool VisitHLSLParamModifierAttr(HLSLParamModifierAttr *A) {
0634     return true; 
0635   }
0636   bool TraverseHLSLROVAttr(HLSLROVAttr *A);
0637   bool VisitHLSLROVAttr(HLSLROVAttr *A) {
0638     return true; 
0639   }
0640   bool TraverseHLSLRawBufferAttr(HLSLRawBufferAttr *A);
0641   bool VisitHLSLRawBufferAttr(HLSLRawBufferAttr *A) {
0642     return true; 
0643   }
0644   bool TraverseHLSLResourceAttr(HLSLResourceAttr *A);
0645   bool VisitHLSLResourceAttr(HLSLResourceAttr *A) {
0646     return true; 
0647   }
0648   bool TraverseHLSLResourceBindingAttr(HLSLResourceBindingAttr *A);
0649   bool VisitHLSLResourceBindingAttr(HLSLResourceBindingAttr *A) {
0650     return true; 
0651   }
0652   bool TraverseHLSLResourceClassAttr(HLSLResourceClassAttr *A);
0653   bool VisitHLSLResourceClassAttr(HLSLResourceClassAttr *A) {
0654     return true; 
0655   }
0656   bool TraverseHLSLSV_DispatchThreadIDAttr(HLSLSV_DispatchThreadIDAttr *A);
0657   bool VisitHLSLSV_DispatchThreadIDAttr(HLSLSV_DispatchThreadIDAttr *A) {
0658     return true; 
0659   }
0660   bool TraverseHLSLSV_GroupIDAttr(HLSLSV_GroupIDAttr *A);
0661   bool VisitHLSLSV_GroupIDAttr(HLSLSV_GroupIDAttr *A) {
0662     return true; 
0663   }
0664   bool TraverseHLSLSV_GroupIndexAttr(HLSLSV_GroupIndexAttr *A);
0665   bool VisitHLSLSV_GroupIndexAttr(HLSLSV_GroupIndexAttr *A) {
0666     return true; 
0667   }
0668   bool TraverseHLSLSV_GroupThreadIDAttr(HLSLSV_GroupThreadIDAttr *A);
0669   bool VisitHLSLSV_GroupThreadIDAttr(HLSLSV_GroupThreadIDAttr *A) {
0670     return true; 
0671   }
0672   bool TraverseHLSLShaderAttr(HLSLShaderAttr *A);
0673   bool VisitHLSLShaderAttr(HLSLShaderAttr *A) {
0674     return true; 
0675   }
0676   bool TraverseHLSLWaveSizeAttr(HLSLWaveSizeAttr *A);
0677   bool VisitHLSLWaveSizeAttr(HLSLWaveSizeAttr *A) {
0678     return true; 
0679   }
0680   bool TraverseHotAttr(HotAttr *A);
0681   bool VisitHotAttr(HotAttr *A) {
0682     return true; 
0683   }
0684   bool TraverseHybridPatchableAttr(HybridPatchableAttr *A);
0685   bool VisitHybridPatchableAttr(HybridPatchableAttr *A) {
0686     return true; 
0687   }
0688   bool TraverseIBActionAttr(IBActionAttr *A);
0689   bool VisitIBActionAttr(IBActionAttr *A) {
0690     return true; 
0691   }
0692   bool TraverseIBOutletAttr(IBOutletAttr *A);
0693   bool VisitIBOutletAttr(IBOutletAttr *A) {
0694     return true; 
0695   }
0696   bool TraverseIBOutletCollectionAttr(IBOutletCollectionAttr *A);
0697   bool VisitIBOutletCollectionAttr(IBOutletCollectionAttr *A) {
0698     return true; 
0699   }
0700   bool TraverseIFuncAttr(IFuncAttr *A);
0701   bool VisitIFuncAttr(IFuncAttr *A) {
0702     return true; 
0703   }
0704   bool TraverseInitPriorityAttr(InitPriorityAttr *A);
0705   bool VisitInitPriorityAttr(InitPriorityAttr *A) {
0706     return true; 
0707   }
0708   bool TraverseInitSegAttr(InitSegAttr *A);
0709   bool VisitInitSegAttr(InitSegAttr *A) {
0710     return true; 
0711   }
0712   bool TraverseIntelOclBiccAttr(IntelOclBiccAttr *A);
0713   bool VisitIntelOclBiccAttr(IntelOclBiccAttr *A) {
0714     return true; 
0715   }
0716   bool TraverseInternalLinkageAttr(InternalLinkageAttr *A);
0717   bool VisitInternalLinkageAttr(InternalLinkageAttr *A) {
0718     return true; 
0719   }
0720   bool TraverseLTOVisibilityPublicAttr(LTOVisibilityPublicAttr *A);
0721   bool VisitLTOVisibilityPublicAttr(LTOVisibilityPublicAttr *A) {
0722     return true; 
0723   }
0724   bool TraverseLayoutVersionAttr(LayoutVersionAttr *A);
0725   bool VisitLayoutVersionAttr(LayoutVersionAttr *A) {
0726     return true; 
0727   }
0728   bool TraverseLeafAttr(LeafAttr *A);
0729   bool VisitLeafAttr(LeafAttr *A) {
0730     return true; 
0731   }
0732   bool TraverseLifetimeBoundAttr(LifetimeBoundAttr *A);
0733   bool VisitLifetimeBoundAttr(LifetimeBoundAttr *A) {
0734     return true; 
0735   }
0736   bool TraverseLifetimeCaptureByAttr(LifetimeCaptureByAttr *A);
0737   bool VisitLifetimeCaptureByAttr(LifetimeCaptureByAttr *A) {
0738     return true; 
0739   }
0740   bool TraverseLikelyAttr(LikelyAttr *A);
0741   bool VisitLikelyAttr(LikelyAttr *A) {
0742     return true; 
0743   }
0744   bool TraverseLoaderUninitializedAttr(LoaderUninitializedAttr *A);
0745   bool VisitLoaderUninitializedAttr(LoaderUninitializedAttr *A) {
0746     return true; 
0747   }
0748   bool TraverseLockReturnedAttr(LockReturnedAttr *A);
0749   bool VisitLockReturnedAttr(LockReturnedAttr *A) {
0750     return true; 
0751   }
0752   bool TraverseLocksExcludedAttr(LocksExcludedAttr *A);
0753   bool VisitLocksExcludedAttr(LocksExcludedAttr *A) {
0754     return true; 
0755   }
0756   bool TraverseLoopHintAttr(LoopHintAttr *A);
0757   bool VisitLoopHintAttr(LoopHintAttr *A) {
0758     return true; 
0759   }
0760   bool TraverseM68kInterruptAttr(M68kInterruptAttr *A);
0761   bool VisitM68kInterruptAttr(M68kInterruptAttr *A) {
0762     return true; 
0763   }
0764   bool TraverseM68kRTDAttr(M68kRTDAttr *A);
0765   bool VisitM68kRTDAttr(M68kRTDAttr *A) {
0766     return true; 
0767   }
0768   bool TraverseMIGServerRoutineAttr(MIGServerRoutineAttr *A);
0769   bool VisitMIGServerRoutineAttr(MIGServerRoutineAttr *A) {
0770     return true; 
0771   }
0772   bool TraverseMSABIAttr(MSABIAttr *A);
0773   bool VisitMSABIAttr(MSABIAttr *A) {
0774     return true; 
0775   }
0776   bool TraverseMSAllocatorAttr(MSAllocatorAttr *A);
0777   bool VisitMSAllocatorAttr(MSAllocatorAttr *A) {
0778     return true; 
0779   }
0780   bool TraverseMSConstexprAttr(MSConstexprAttr *A);
0781   bool VisitMSConstexprAttr(MSConstexprAttr *A) {
0782     return true; 
0783   }
0784   bool TraverseMSInheritanceAttr(MSInheritanceAttr *A);
0785   bool VisitMSInheritanceAttr(MSInheritanceAttr *A) {
0786     return true; 
0787   }
0788   bool TraverseMSNoVTableAttr(MSNoVTableAttr *A);
0789   bool VisitMSNoVTableAttr(MSNoVTableAttr *A) {
0790     return true; 
0791   }
0792   bool TraverseMSP430InterruptAttr(MSP430InterruptAttr *A);
0793   bool VisitMSP430InterruptAttr(MSP430InterruptAttr *A) {
0794     return true; 
0795   }
0796   bool TraverseMSStructAttr(MSStructAttr *A);
0797   bool VisitMSStructAttr(MSStructAttr *A) {
0798     return true; 
0799   }
0800   bool TraverseMSVtorDispAttr(MSVtorDispAttr *A);
0801   bool VisitMSVtorDispAttr(MSVtorDispAttr *A) {
0802     return true; 
0803   }
0804   bool TraverseMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A);
0805   bool VisitMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A) {
0806     return true; 
0807   }
0808   bool TraverseMayAliasAttr(MayAliasAttr *A);
0809   bool VisitMayAliasAttr(MayAliasAttr *A) {
0810     return true; 
0811   }
0812   bool TraverseMaybeUndefAttr(MaybeUndefAttr *A);
0813   bool VisitMaybeUndefAttr(MaybeUndefAttr *A) {
0814     return true; 
0815   }
0816   bool TraverseMicroMipsAttr(MicroMipsAttr *A);
0817   bool VisitMicroMipsAttr(MicroMipsAttr *A) {
0818     return true; 
0819   }
0820   bool TraverseMinSizeAttr(MinSizeAttr *A);
0821   bool VisitMinSizeAttr(MinSizeAttr *A) {
0822     return true; 
0823   }
0824   bool TraverseMinVectorWidthAttr(MinVectorWidthAttr *A);
0825   bool VisitMinVectorWidthAttr(MinVectorWidthAttr *A) {
0826     return true; 
0827   }
0828   bool TraverseMips16Attr(Mips16Attr *A);
0829   bool VisitMips16Attr(Mips16Attr *A) {
0830     return true; 
0831   }
0832   bool TraverseMipsInterruptAttr(MipsInterruptAttr *A);
0833   bool VisitMipsInterruptAttr(MipsInterruptAttr *A) {
0834     return true; 
0835   }
0836   bool TraverseMipsLongCallAttr(MipsLongCallAttr *A);
0837   bool VisitMipsLongCallAttr(MipsLongCallAttr *A) {
0838     return true; 
0839   }
0840   bool TraverseMipsShortCallAttr(MipsShortCallAttr *A);
0841   bool VisitMipsShortCallAttr(MipsShortCallAttr *A) {
0842     return true; 
0843   }
0844   bool TraverseModeAttr(ModeAttr *A);
0845   bool VisitModeAttr(ModeAttr *A) {
0846     return true; 
0847   }
0848   bool TraverseMustTailAttr(MustTailAttr *A);
0849   bool VisitMustTailAttr(MustTailAttr *A) {
0850     return true; 
0851   }
0852   bool TraverseNSConsumedAttr(NSConsumedAttr *A);
0853   bool VisitNSConsumedAttr(NSConsumedAttr *A) {
0854     return true; 
0855   }
0856   bool TraverseNSConsumesSelfAttr(NSConsumesSelfAttr *A);
0857   bool VisitNSConsumesSelfAttr(NSConsumesSelfAttr *A) {
0858     return true; 
0859   }
0860   bool TraverseNSErrorDomainAttr(NSErrorDomainAttr *A);
0861   bool VisitNSErrorDomainAttr(NSErrorDomainAttr *A) {
0862     return true; 
0863   }
0864   bool TraverseNSReturnsAutoreleasedAttr(NSReturnsAutoreleasedAttr *A);
0865   bool VisitNSReturnsAutoreleasedAttr(NSReturnsAutoreleasedAttr *A) {
0866     return true; 
0867   }
0868   bool TraverseNSReturnsNotRetainedAttr(NSReturnsNotRetainedAttr *A);
0869   bool VisitNSReturnsNotRetainedAttr(NSReturnsNotRetainedAttr *A) {
0870     return true; 
0871   }
0872   bool TraverseNSReturnsRetainedAttr(NSReturnsRetainedAttr *A);
0873   bool VisitNSReturnsRetainedAttr(NSReturnsRetainedAttr *A) {
0874     return true; 
0875   }
0876   bool TraverseNVPTXKernelAttr(NVPTXKernelAttr *A);
0877   bool VisitNVPTXKernelAttr(NVPTXKernelAttr *A) {
0878     return true; 
0879   }
0880   bool TraverseNakedAttr(NakedAttr *A);
0881   bool VisitNakedAttr(NakedAttr *A) {
0882     return true; 
0883   }
0884   bool TraverseNoAliasAttr(NoAliasAttr *A);
0885   bool VisitNoAliasAttr(NoAliasAttr *A) {
0886     return true; 
0887   }
0888   bool TraverseNoBuiltinAttr(NoBuiltinAttr *A);
0889   bool VisitNoBuiltinAttr(NoBuiltinAttr *A) {
0890     return true; 
0891   }
0892   bool TraverseNoCommonAttr(NoCommonAttr *A);
0893   bool VisitNoCommonAttr(NoCommonAttr *A) {
0894     return true; 
0895   }
0896   bool TraverseNoConvergentAttr(NoConvergentAttr *A);
0897   bool VisitNoConvergentAttr(NoConvergentAttr *A) {
0898     return true; 
0899   }
0900   bool TraverseNoDebugAttr(NoDebugAttr *A);
0901   bool VisitNoDebugAttr(NoDebugAttr *A) {
0902     return true; 
0903   }
0904   bool TraverseNoDerefAttr(NoDerefAttr *A);
0905   bool VisitNoDerefAttr(NoDerefAttr *A) {
0906     return true; 
0907   }
0908   bool TraverseNoDestroyAttr(NoDestroyAttr *A);
0909   bool VisitNoDestroyAttr(NoDestroyAttr *A) {
0910     return true; 
0911   }
0912   bool TraverseNoDuplicateAttr(NoDuplicateAttr *A);
0913   bool VisitNoDuplicateAttr(NoDuplicateAttr *A) {
0914     return true; 
0915   }
0916   bool TraverseNoEscapeAttr(NoEscapeAttr *A);
0917   bool VisitNoEscapeAttr(NoEscapeAttr *A) {
0918     return true; 
0919   }
0920   bool TraverseNoInlineAttr(NoInlineAttr *A);
0921   bool VisitNoInlineAttr(NoInlineAttr *A) {
0922     return true; 
0923   }
0924   bool TraverseNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A);
0925   bool VisitNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A) {
0926     return true; 
0927   }
0928   bool TraverseNoMergeAttr(NoMergeAttr *A);
0929   bool VisitNoMergeAttr(NoMergeAttr *A) {
0930     return true; 
0931   }
0932   bool TraverseNoMicroMipsAttr(NoMicroMipsAttr *A);
0933   bool VisitNoMicroMipsAttr(NoMicroMipsAttr *A) {
0934     return true; 
0935   }
0936   bool TraverseNoMips16Attr(NoMips16Attr *A);
0937   bool VisitNoMips16Attr(NoMips16Attr *A) {
0938     return true; 
0939   }
0940   bool TraverseNoProfileFunctionAttr(NoProfileFunctionAttr *A);
0941   bool VisitNoProfileFunctionAttr(NoProfileFunctionAttr *A) {
0942     return true; 
0943   }
0944   bool TraverseNoRandomizeLayoutAttr(NoRandomizeLayoutAttr *A);
0945   bool VisitNoRandomizeLayoutAttr(NoRandomizeLayoutAttr *A) {
0946     return true; 
0947   }
0948   bool TraverseNoReturnAttr(NoReturnAttr *A);
0949   bool VisitNoReturnAttr(NoReturnAttr *A) {
0950     return true; 
0951   }
0952   bool TraverseNoSanitizeAttr(NoSanitizeAttr *A);
0953   bool VisitNoSanitizeAttr(NoSanitizeAttr *A) {
0954     return true; 
0955   }
0956   bool TraverseNoSpecializationsAttr(NoSpecializationsAttr *A);
0957   bool VisitNoSpecializationsAttr(NoSpecializationsAttr *A) {
0958     return true; 
0959   }
0960   bool TraverseNoSpeculativeLoadHardeningAttr(NoSpeculativeLoadHardeningAttr *A);
0961   bool VisitNoSpeculativeLoadHardeningAttr(NoSpeculativeLoadHardeningAttr *A) {
0962     return true; 
0963   }
0964   bool TraverseNoSplitStackAttr(NoSplitStackAttr *A);
0965   bool VisitNoSplitStackAttr(NoSplitStackAttr *A) {
0966     return true; 
0967   }
0968   bool TraverseNoStackProtectorAttr(NoStackProtectorAttr *A);
0969   bool VisitNoStackProtectorAttr(NoStackProtectorAttr *A) {
0970     return true; 
0971   }
0972   bool TraverseNoThreadSafetyAnalysisAttr(NoThreadSafetyAnalysisAttr *A);
0973   bool VisitNoThreadSafetyAnalysisAttr(NoThreadSafetyAnalysisAttr *A) {
0974     return true; 
0975   }
0976   bool TraverseNoThrowAttr(NoThrowAttr *A);
0977   bool VisitNoThrowAttr(NoThrowAttr *A) {
0978     return true; 
0979   }
0980   bool TraverseNoTrivialAutoVarInitAttr(NoTrivialAutoVarInitAttr *A);
0981   bool VisitNoTrivialAutoVarInitAttr(NoTrivialAutoVarInitAttr *A) {
0982     return true; 
0983   }
0984   bool TraverseNoUniqueAddressAttr(NoUniqueAddressAttr *A);
0985   bool VisitNoUniqueAddressAttr(NoUniqueAddressAttr *A) {
0986     return true; 
0987   }
0988   bool TraverseNoUwtableAttr(NoUwtableAttr *A);
0989   bool VisitNoUwtableAttr(NoUwtableAttr *A) {
0990     return true; 
0991   }
0992   bool TraverseNonAllocatingAttr(NonAllocatingAttr *A);
0993   bool VisitNonAllocatingAttr(NonAllocatingAttr *A) {
0994     return true; 
0995   }
0996   bool TraverseNonBlockingAttr(NonBlockingAttr *A);
0997   bool VisitNonBlockingAttr(NonBlockingAttr *A) {
0998     return true; 
0999   }
1000   bool TraverseNonNullAttr(NonNullAttr *A);
1001   bool VisitNonNullAttr(NonNullAttr *A) {
1002     return true; 
1003   }
1004   bool TraverseNotTailCalledAttr(NotTailCalledAttr *A);
1005   bool VisitNotTailCalledAttr(NotTailCalledAttr *A) {
1006     return true; 
1007   }
1008   bool TraverseOMPAllocateDeclAttr(OMPAllocateDeclAttr *A);
1009   bool VisitOMPAllocateDeclAttr(OMPAllocateDeclAttr *A) {
1010     return true; 
1011   }
1012   bool TraverseOMPAssumeAttr(OMPAssumeAttr *A);
1013   bool VisitOMPAssumeAttr(OMPAssumeAttr *A) {
1014     return true; 
1015   }
1016   bool TraverseOMPCaptureKindAttr(OMPCaptureKindAttr *A);
1017   bool VisitOMPCaptureKindAttr(OMPCaptureKindAttr *A) {
1018     return true; 
1019   }
1020   bool TraverseOMPCaptureNoInitAttr(OMPCaptureNoInitAttr *A);
1021   bool VisitOMPCaptureNoInitAttr(OMPCaptureNoInitAttr *A) {
1022     return true; 
1023   }
1024   bool TraverseOMPDeclareSimdDeclAttr(OMPDeclareSimdDeclAttr *A);
1025   bool VisitOMPDeclareSimdDeclAttr(OMPDeclareSimdDeclAttr *A) {
1026     return true; 
1027   }
1028   bool TraverseOMPDeclareTargetDeclAttr(OMPDeclareTargetDeclAttr *A);
1029   bool VisitOMPDeclareTargetDeclAttr(OMPDeclareTargetDeclAttr *A) {
1030     return true; 
1031   }
1032   bool TraverseOMPDeclareVariantAttr(OMPDeclareVariantAttr *A);
1033   bool VisitOMPDeclareVariantAttr(OMPDeclareVariantAttr *A) {
1034     return true; 
1035   }
1036   bool TraverseOMPReferencedVarAttr(OMPReferencedVarAttr *A);
1037   bool VisitOMPReferencedVarAttr(OMPReferencedVarAttr *A) {
1038     return true; 
1039   }
1040   bool TraverseOMPThreadPrivateDeclAttr(OMPThreadPrivateDeclAttr *A);
1041   bool VisitOMPThreadPrivateDeclAttr(OMPThreadPrivateDeclAttr *A) {
1042     return true; 
1043   }
1044   bool TraverseOSConsumedAttr(OSConsumedAttr *A);
1045   bool VisitOSConsumedAttr(OSConsumedAttr *A) {
1046     return true; 
1047   }
1048   bool TraverseOSConsumesThisAttr(OSConsumesThisAttr *A);
1049   bool VisitOSConsumesThisAttr(OSConsumesThisAttr *A) {
1050     return true; 
1051   }
1052   bool TraverseOSReturnsNotRetainedAttr(OSReturnsNotRetainedAttr *A);
1053   bool VisitOSReturnsNotRetainedAttr(OSReturnsNotRetainedAttr *A) {
1054     return true; 
1055   }
1056   bool TraverseOSReturnsRetainedAttr(OSReturnsRetainedAttr *A);
1057   bool VisitOSReturnsRetainedAttr(OSReturnsRetainedAttr *A) {
1058     return true; 
1059   }
1060   bool TraverseOSReturnsRetainedOnNonZeroAttr(OSReturnsRetainedOnNonZeroAttr *A);
1061   bool VisitOSReturnsRetainedOnNonZeroAttr(OSReturnsRetainedOnNonZeroAttr *A) {
1062     return true; 
1063   }
1064   bool TraverseOSReturnsRetainedOnZeroAttr(OSReturnsRetainedOnZeroAttr *A);
1065   bool VisitOSReturnsRetainedOnZeroAttr(OSReturnsRetainedOnZeroAttr *A) {
1066     return true; 
1067   }
1068   bool TraverseObjCBoxableAttr(ObjCBoxableAttr *A);
1069   bool VisitObjCBoxableAttr(ObjCBoxableAttr *A) {
1070     return true; 
1071   }
1072   bool TraverseObjCBridgeAttr(ObjCBridgeAttr *A);
1073   bool VisitObjCBridgeAttr(ObjCBridgeAttr *A) {
1074     return true; 
1075   }
1076   bool TraverseObjCBridgeMutableAttr(ObjCBridgeMutableAttr *A);
1077   bool VisitObjCBridgeMutableAttr(ObjCBridgeMutableAttr *A) {
1078     return true; 
1079   }
1080   bool TraverseObjCBridgeRelatedAttr(ObjCBridgeRelatedAttr *A);
1081   bool VisitObjCBridgeRelatedAttr(ObjCBridgeRelatedAttr *A) {
1082     return true; 
1083   }
1084   bool TraverseObjCClassStubAttr(ObjCClassStubAttr *A);
1085   bool VisitObjCClassStubAttr(ObjCClassStubAttr *A) {
1086     return true; 
1087   }
1088   bool TraverseObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A);
1089   bool VisitObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A) {
1090     return true; 
1091   }
1092   bool TraverseObjCDirectAttr(ObjCDirectAttr *A);
1093   bool VisitObjCDirectAttr(ObjCDirectAttr *A) {
1094     return true; 
1095   }
1096   bool TraverseObjCDirectMembersAttr(ObjCDirectMembersAttr *A);
1097   bool VisitObjCDirectMembersAttr(ObjCDirectMembersAttr *A) {
1098     return true; 
1099   }
1100   bool TraverseObjCExceptionAttr(ObjCExceptionAttr *A);
1101   bool VisitObjCExceptionAttr(ObjCExceptionAttr *A) {
1102     return true; 
1103   }
1104   bool TraverseObjCExplicitProtocolImplAttr(ObjCExplicitProtocolImplAttr *A);
1105   bool VisitObjCExplicitProtocolImplAttr(ObjCExplicitProtocolImplAttr *A) {
1106     return true; 
1107   }
1108   bool TraverseObjCExternallyRetainedAttr(ObjCExternallyRetainedAttr *A);
1109   bool VisitObjCExternallyRetainedAttr(ObjCExternallyRetainedAttr *A) {
1110     return true; 
1111   }
1112   bool TraverseObjCGCAttr(ObjCGCAttr *A);
1113   bool VisitObjCGCAttr(ObjCGCAttr *A) {
1114     return true; 
1115   }
1116   bool TraverseObjCIndependentClassAttr(ObjCIndependentClassAttr *A);
1117   bool VisitObjCIndependentClassAttr(ObjCIndependentClassAttr *A) {
1118     return true; 
1119   }
1120   bool TraverseObjCInertUnsafeUnretainedAttr(ObjCInertUnsafeUnretainedAttr *A);
1121   bool VisitObjCInertUnsafeUnretainedAttr(ObjCInertUnsafeUnretainedAttr *A) {
1122     return true; 
1123   }
1124   bool TraverseObjCKindOfAttr(ObjCKindOfAttr *A);
1125   bool VisitObjCKindOfAttr(ObjCKindOfAttr *A) {
1126     return true; 
1127   }
1128   bool TraverseObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A);
1129   bool VisitObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A) {
1130     return true; 
1131   }
1132   bool TraverseObjCNSObjectAttr(ObjCNSObjectAttr *A);
1133   bool VisitObjCNSObjectAttr(ObjCNSObjectAttr *A) {
1134     return true; 
1135   }
1136   bool TraverseObjCNonLazyClassAttr(ObjCNonLazyClassAttr *A);
1137   bool VisitObjCNonLazyClassAttr(ObjCNonLazyClassAttr *A) {
1138     return true; 
1139   }
1140   bool TraverseObjCNonRuntimeProtocolAttr(ObjCNonRuntimeProtocolAttr *A);
1141   bool VisitObjCNonRuntimeProtocolAttr(ObjCNonRuntimeProtocolAttr *A) {
1142     return true; 
1143   }
1144   bool TraverseObjCOwnershipAttr(ObjCOwnershipAttr *A);
1145   bool VisitObjCOwnershipAttr(ObjCOwnershipAttr *A) {
1146     return true; 
1147   }
1148   bool TraverseObjCPreciseLifetimeAttr(ObjCPreciseLifetimeAttr *A);
1149   bool VisitObjCPreciseLifetimeAttr(ObjCPreciseLifetimeAttr *A) {
1150     return true; 
1151   }
1152   bool TraverseObjCRequiresPropertyDefsAttr(ObjCRequiresPropertyDefsAttr *A);
1153   bool VisitObjCRequiresPropertyDefsAttr(ObjCRequiresPropertyDefsAttr *A) {
1154     return true; 
1155   }
1156   bool TraverseObjCRequiresSuperAttr(ObjCRequiresSuperAttr *A);
1157   bool VisitObjCRequiresSuperAttr(ObjCRequiresSuperAttr *A) {
1158     return true; 
1159   }
1160   bool TraverseObjCReturnsInnerPointerAttr(ObjCReturnsInnerPointerAttr *A);
1161   bool VisitObjCReturnsInnerPointerAttr(ObjCReturnsInnerPointerAttr *A) {
1162     return true; 
1163   }
1164   bool TraverseObjCRootClassAttr(ObjCRootClassAttr *A);
1165   bool VisitObjCRootClassAttr(ObjCRootClassAttr *A) {
1166     return true; 
1167   }
1168   bool TraverseObjCRuntimeNameAttr(ObjCRuntimeNameAttr *A);
1169   bool VisitObjCRuntimeNameAttr(ObjCRuntimeNameAttr *A) {
1170     return true; 
1171   }
1172   bool TraverseObjCRuntimeVisibleAttr(ObjCRuntimeVisibleAttr *A);
1173   bool VisitObjCRuntimeVisibleAttr(ObjCRuntimeVisibleAttr *A) {
1174     return true; 
1175   }
1176   bool TraverseObjCSubclassingRestrictedAttr(ObjCSubclassingRestrictedAttr *A);
1177   bool VisitObjCSubclassingRestrictedAttr(ObjCSubclassingRestrictedAttr *A) {
1178     return true; 
1179   }
1180   bool TraverseOpenCLAccessAttr(OpenCLAccessAttr *A);
1181   bool VisitOpenCLAccessAttr(OpenCLAccessAttr *A) {
1182     return true; 
1183   }
1184   bool TraverseOpenCLConstantAddressSpaceAttr(OpenCLConstantAddressSpaceAttr *A);
1185   bool VisitOpenCLConstantAddressSpaceAttr(OpenCLConstantAddressSpaceAttr *A) {
1186     return true; 
1187   }
1188   bool TraverseOpenCLGenericAddressSpaceAttr(OpenCLGenericAddressSpaceAttr *A);
1189   bool VisitOpenCLGenericAddressSpaceAttr(OpenCLGenericAddressSpaceAttr *A) {
1190     return true; 
1191   }
1192   bool TraverseOpenCLGlobalAddressSpaceAttr(OpenCLGlobalAddressSpaceAttr *A);
1193   bool VisitOpenCLGlobalAddressSpaceAttr(OpenCLGlobalAddressSpaceAttr *A) {
1194     return true; 
1195   }
1196   bool TraverseOpenCLGlobalDeviceAddressSpaceAttr(OpenCLGlobalDeviceAddressSpaceAttr *A);
1197   bool VisitOpenCLGlobalDeviceAddressSpaceAttr(OpenCLGlobalDeviceAddressSpaceAttr *A) {
1198     return true; 
1199   }
1200   bool TraverseOpenCLGlobalHostAddressSpaceAttr(OpenCLGlobalHostAddressSpaceAttr *A);
1201   bool VisitOpenCLGlobalHostAddressSpaceAttr(OpenCLGlobalHostAddressSpaceAttr *A) {
1202     return true; 
1203   }
1204   bool TraverseOpenCLIntelReqdSubGroupSizeAttr(OpenCLIntelReqdSubGroupSizeAttr *A);
1205   bool VisitOpenCLIntelReqdSubGroupSizeAttr(OpenCLIntelReqdSubGroupSizeAttr *A) {
1206     return true; 
1207   }
1208   bool TraverseOpenCLKernelAttr(OpenCLKernelAttr *A);
1209   bool VisitOpenCLKernelAttr(OpenCLKernelAttr *A) {
1210     return true; 
1211   }
1212   bool TraverseOpenCLLocalAddressSpaceAttr(OpenCLLocalAddressSpaceAttr *A);
1213   bool VisitOpenCLLocalAddressSpaceAttr(OpenCLLocalAddressSpaceAttr *A) {
1214     return true; 
1215   }
1216   bool TraverseOpenCLPrivateAddressSpaceAttr(OpenCLPrivateAddressSpaceAttr *A);
1217   bool VisitOpenCLPrivateAddressSpaceAttr(OpenCLPrivateAddressSpaceAttr *A) {
1218     return true; 
1219   }
1220   bool TraverseOpenCLUnrollHintAttr(OpenCLUnrollHintAttr *A);
1221   bool VisitOpenCLUnrollHintAttr(OpenCLUnrollHintAttr *A) {
1222     return true; 
1223   }
1224   bool TraverseOptimizeNoneAttr(OptimizeNoneAttr *A);
1225   bool VisitOptimizeNoneAttr(OptimizeNoneAttr *A) {
1226     return true; 
1227   }
1228   bool TraverseOverloadableAttr(OverloadableAttr *A);
1229   bool VisitOverloadableAttr(OverloadableAttr *A) {
1230     return true; 
1231   }
1232   bool TraverseOverrideAttr(OverrideAttr *A);
1233   bool VisitOverrideAttr(OverrideAttr *A) {
1234     return true; 
1235   }
1236   bool TraverseOwnerAttr(OwnerAttr *A);
1237   bool VisitOwnerAttr(OwnerAttr *A) {
1238     return true; 
1239   }
1240   bool TraverseOwnershipAttr(OwnershipAttr *A);
1241   bool VisitOwnershipAttr(OwnershipAttr *A) {
1242     return true; 
1243   }
1244   bool TraversePackedAttr(PackedAttr *A);
1245   bool VisitPackedAttr(PackedAttr *A) {
1246     return true; 
1247   }
1248   bool TraverseParamTypestateAttr(ParamTypestateAttr *A);
1249   bool VisitParamTypestateAttr(ParamTypestateAttr *A) {
1250     return true; 
1251   }
1252   bool TraversePascalAttr(PascalAttr *A);
1253   bool VisitPascalAttr(PascalAttr *A) {
1254     return true; 
1255   }
1256   bool TraversePassObjectSizeAttr(PassObjectSizeAttr *A);
1257   bool VisitPassObjectSizeAttr(PassObjectSizeAttr *A) {
1258     return true; 
1259   }
1260   bool TraversePatchableFunctionEntryAttr(PatchableFunctionEntryAttr *A);
1261   bool VisitPatchableFunctionEntryAttr(PatchableFunctionEntryAttr *A) {
1262     return true; 
1263   }
1264   bool TraversePcsAttr(PcsAttr *A);
1265   bool VisitPcsAttr(PcsAttr *A) {
1266     return true; 
1267   }
1268   bool TraversePointerAttr(PointerAttr *A);
1269   bool VisitPointerAttr(PointerAttr *A) {
1270     return true; 
1271   }
1272   bool TraversePragmaClangBSSSectionAttr(PragmaClangBSSSectionAttr *A);
1273   bool VisitPragmaClangBSSSectionAttr(PragmaClangBSSSectionAttr *A) {
1274     return true; 
1275   }
1276   bool TraversePragmaClangDataSectionAttr(PragmaClangDataSectionAttr *A);
1277   bool VisitPragmaClangDataSectionAttr(PragmaClangDataSectionAttr *A) {
1278     return true; 
1279   }
1280   bool TraversePragmaClangRelroSectionAttr(PragmaClangRelroSectionAttr *A);
1281   bool VisitPragmaClangRelroSectionAttr(PragmaClangRelroSectionAttr *A) {
1282     return true; 
1283   }
1284   bool TraversePragmaClangRodataSectionAttr(PragmaClangRodataSectionAttr *A);
1285   bool VisitPragmaClangRodataSectionAttr(PragmaClangRodataSectionAttr *A) {
1286     return true; 
1287   }
1288   bool TraversePragmaClangTextSectionAttr(PragmaClangTextSectionAttr *A);
1289   bool VisitPragmaClangTextSectionAttr(PragmaClangTextSectionAttr *A) {
1290     return true; 
1291   }
1292   bool TraversePreferredNameAttr(PreferredNameAttr *A);
1293   bool VisitPreferredNameAttr(PreferredNameAttr *A) {
1294     return true; 
1295   }
1296   bool TraversePreferredTypeAttr(PreferredTypeAttr *A);
1297   bool VisitPreferredTypeAttr(PreferredTypeAttr *A) {
1298     return true; 
1299   }
1300   bool TraversePreserveAllAttr(PreserveAllAttr *A);
1301   bool VisitPreserveAllAttr(PreserveAllAttr *A) {
1302     return true; 
1303   }
1304   bool TraversePreserveMostAttr(PreserveMostAttr *A);
1305   bool VisitPreserveMostAttr(PreserveMostAttr *A) {
1306     return true; 
1307   }
1308   bool TraversePreserveNoneAttr(PreserveNoneAttr *A);
1309   bool VisitPreserveNoneAttr(PreserveNoneAttr *A) {
1310     return true; 
1311   }
1312   bool TraversePtGuardedByAttr(PtGuardedByAttr *A);
1313   bool VisitPtGuardedByAttr(PtGuardedByAttr *A) {
1314     return true; 
1315   }
1316   bool TraversePtGuardedVarAttr(PtGuardedVarAttr *A);
1317   bool VisitPtGuardedVarAttr(PtGuardedVarAttr *A) {
1318     return true; 
1319   }
1320   bool TraversePtr32Attr(Ptr32Attr *A);
1321   bool VisitPtr32Attr(Ptr32Attr *A) {
1322     return true; 
1323   }
1324   bool TraversePtr64Attr(Ptr64Attr *A);
1325   bool VisitPtr64Attr(Ptr64Attr *A) {
1326     return true; 
1327   }
1328   bool TraversePureAttr(PureAttr *A);
1329   bool VisitPureAttr(PureAttr *A) {
1330     return true; 
1331   }
1332   bool TraverseRISCVInterruptAttr(RISCVInterruptAttr *A);
1333   bool VisitRISCVInterruptAttr(RISCVInterruptAttr *A) {
1334     return true; 
1335   }
1336   bool TraverseRISCVVectorCCAttr(RISCVVectorCCAttr *A);
1337   bool VisitRISCVVectorCCAttr(RISCVVectorCCAttr *A) {
1338     return true; 
1339   }
1340   bool TraverseRandomizeLayoutAttr(RandomizeLayoutAttr *A);
1341   bool VisitRandomizeLayoutAttr(RandomizeLayoutAttr *A) {
1342     return true; 
1343   }
1344   bool TraverseReadOnlyPlacementAttr(ReadOnlyPlacementAttr *A);
1345   bool VisitReadOnlyPlacementAttr(ReadOnlyPlacementAttr *A) {
1346     return true; 
1347   }
1348   bool TraverseRegCallAttr(RegCallAttr *A);
1349   bool VisitRegCallAttr(RegCallAttr *A) {
1350     return true; 
1351   }
1352   bool TraverseReinitializesAttr(ReinitializesAttr *A);
1353   bool VisitReinitializesAttr(ReinitializesAttr *A) {
1354     return true; 
1355   }
1356   bool TraverseReleaseCapabilityAttr(ReleaseCapabilityAttr *A);
1357   bool VisitReleaseCapabilityAttr(ReleaseCapabilityAttr *A) {
1358     return true; 
1359   }
1360   bool TraverseReleaseHandleAttr(ReleaseHandleAttr *A);
1361   bool VisitReleaseHandleAttr(ReleaseHandleAttr *A) {
1362     return true; 
1363   }
1364   bool TraverseReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A);
1365   bool VisitReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A) {
1366     return true; 
1367   }
1368   bool TraverseRequiresCapabilityAttr(RequiresCapabilityAttr *A);
1369   bool VisitRequiresCapabilityAttr(RequiresCapabilityAttr *A) {
1370     return true; 
1371   }
1372   bool TraverseRestrictAttr(RestrictAttr *A);
1373   bool VisitRestrictAttr(RestrictAttr *A) {
1374     return true; 
1375   }
1376   bool TraverseRetainAttr(RetainAttr *A);
1377   bool VisitRetainAttr(RetainAttr *A) {
1378     return true; 
1379   }
1380   bool TraverseReturnTypestateAttr(ReturnTypestateAttr *A);
1381   bool VisitReturnTypestateAttr(ReturnTypestateAttr *A) {
1382     return true; 
1383   }
1384   bool TraverseReturnsNonNullAttr(ReturnsNonNullAttr *A);
1385   bool VisitReturnsNonNullAttr(ReturnsNonNullAttr *A) {
1386     return true; 
1387   }
1388   bool TraverseReturnsTwiceAttr(ReturnsTwiceAttr *A);
1389   bool VisitReturnsTwiceAttr(ReturnsTwiceAttr *A) {
1390     return true; 
1391   }
1392   bool TraverseSPtrAttr(SPtrAttr *A);
1393   bool VisitSPtrAttr(SPtrAttr *A) {
1394     return true; 
1395   }
1396   bool TraverseSYCLKernelAttr(SYCLKernelAttr *A);
1397   bool VisitSYCLKernelAttr(SYCLKernelAttr *A) {
1398     return true; 
1399   }
1400   bool TraverseSYCLKernelEntryPointAttr(SYCLKernelEntryPointAttr *A);
1401   bool VisitSYCLKernelEntryPointAttr(SYCLKernelEntryPointAttr *A) {
1402     return true; 
1403   }
1404   bool TraverseSYCLSpecialClassAttr(SYCLSpecialClassAttr *A);
1405   bool VisitSYCLSpecialClassAttr(SYCLSpecialClassAttr *A) {
1406     return true; 
1407   }
1408   bool TraverseScopedLockableAttr(ScopedLockableAttr *A);
1409   bool VisitScopedLockableAttr(ScopedLockableAttr *A) {
1410     return true; 
1411   }
1412   bool TraverseSectionAttr(SectionAttr *A);
1413   bool VisitSectionAttr(SectionAttr *A) {
1414     return true; 
1415   }
1416   bool TraverseSelectAnyAttr(SelectAnyAttr *A);
1417   bool VisitSelectAnyAttr(SelectAnyAttr *A) {
1418     return true; 
1419   }
1420   bool TraverseSentinelAttr(SentinelAttr *A);
1421   bool VisitSentinelAttr(SentinelAttr *A) {
1422     return true; 
1423   }
1424   bool TraverseSetTypestateAttr(SetTypestateAttr *A);
1425   bool VisitSetTypestateAttr(SetTypestateAttr *A) {
1426     return true; 
1427   }
1428   bool TraverseSharedTrylockFunctionAttr(SharedTrylockFunctionAttr *A);
1429   bool VisitSharedTrylockFunctionAttr(SharedTrylockFunctionAttr *A) {
1430     return true; 
1431   }
1432   bool TraverseSizedByAttr(SizedByAttr *A);
1433   bool VisitSizedByAttr(SizedByAttr *A) {
1434     return true; 
1435   }
1436   bool TraverseSizedByOrNullAttr(SizedByOrNullAttr *A);
1437   bool VisitSizedByOrNullAttr(SizedByOrNullAttr *A) {
1438     return true; 
1439   }
1440   bool TraverseSpeculativeLoadHardeningAttr(SpeculativeLoadHardeningAttr *A);
1441   bool VisitSpeculativeLoadHardeningAttr(SpeculativeLoadHardeningAttr *A) {
1442     return true; 
1443   }
1444   bool TraverseStandaloneDebugAttr(StandaloneDebugAttr *A);
1445   bool VisitStandaloneDebugAttr(StandaloneDebugAttr *A) {
1446     return true; 
1447   }
1448   bool TraverseStdCallAttr(StdCallAttr *A);
1449   bool VisitStdCallAttr(StdCallAttr *A) {
1450     return true; 
1451   }
1452   bool TraverseStrictFPAttr(StrictFPAttr *A);
1453   bool VisitStrictFPAttr(StrictFPAttr *A) {
1454     return true; 
1455   }
1456   bool TraverseStrictGuardStackCheckAttr(StrictGuardStackCheckAttr *A);
1457   bool VisitStrictGuardStackCheckAttr(StrictGuardStackCheckAttr *A) {
1458     return true; 
1459   }
1460   bool TraverseSuppressAttr(SuppressAttr *A);
1461   bool VisitSuppressAttr(SuppressAttr *A) {
1462     return true; 
1463   }
1464   bool TraverseSwiftAsyncAttr(SwiftAsyncAttr *A);
1465   bool VisitSwiftAsyncAttr(SwiftAsyncAttr *A) {
1466     return true; 
1467   }
1468   bool TraverseSwiftAsyncCallAttr(SwiftAsyncCallAttr *A);
1469   bool VisitSwiftAsyncCallAttr(SwiftAsyncCallAttr *A) {
1470     return true; 
1471   }
1472   bool TraverseSwiftAsyncContextAttr(SwiftAsyncContextAttr *A);
1473   bool VisitSwiftAsyncContextAttr(SwiftAsyncContextAttr *A) {
1474     return true; 
1475   }
1476   bool TraverseSwiftAsyncErrorAttr(SwiftAsyncErrorAttr *A);
1477   bool VisitSwiftAsyncErrorAttr(SwiftAsyncErrorAttr *A) {
1478     return true; 
1479   }
1480   bool TraverseSwiftAsyncNameAttr(SwiftAsyncNameAttr *A);
1481   bool VisitSwiftAsyncNameAttr(SwiftAsyncNameAttr *A) {
1482     return true; 
1483   }
1484   bool TraverseSwiftAttrAttr(SwiftAttrAttr *A);
1485   bool VisitSwiftAttrAttr(SwiftAttrAttr *A) {
1486     return true; 
1487   }
1488   bool TraverseSwiftBridgeAttr(SwiftBridgeAttr *A);
1489   bool VisitSwiftBridgeAttr(SwiftBridgeAttr *A) {
1490     return true; 
1491   }
1492   bool TraverseSwiftBridgedTypedefAttr(SwiftBridgedTypedefAttr *A);
1493   bool VisitSwiftBridgedTypedefAttr(SwiftBridgedTypedefAttr *A) {
1494     return true; 
1495   }
1496   bool TraverseSwiftCallAttr(SwiftCallAttr *A);
1497   bool VisitSwiftCallAttr(SwiftCallAttr *A) {
1498     return true; 
1499   }
1500   bool TraverseSwiftContextAttr(SwiftContextAttr *A);
1501   bool VisitSwiftContextAttr(SwiftContextAttr *A) {
1502     return true; 
1503   }
1504   bool TraverseSwiftErrorAttr(SwiftErrorAttr *A);
1505   bool VisitSwiftErrorAttr(SwiftErrorAttr *A) {
1506     return true; 
1507   }
1508   bool TraverseSwiftErrorResultAttr(SwiftErrorResultAttr *A);
1509   bool VisitSwiftErrorResultAttr(SwiftErrorResultAttr *A) {
1510     return true; 
1511   }
1512   bool TraverseSwiftImportAsNonGenericAttr(SwiftImportAsNonGenericAttr *A);
1513   bool VisitSwiftImportAsNonGenericAttr(SwiftImportAsNonGenericAttr *A) {
1514     return true; 
1515   }
1516   bool TraverseSwiftImportPropertyAsAccessorsAttr(SwiftImportPropertyAsAccessorsAttr *A);
1517   bool VisitSwiftImportPropertyAsAccessorsAttr(SwiftImportPropertyAsAccessorsAttr *A) {
1518     return true; 
1519   }
1520   bool TraverseSwiftIndirectResultAttr(SwiftIndirectResultAttr *A);
1521   bool VisitSwiftIndirectResultAttr(SwiftIndirectResultAttr *A) {
1522     return true; 
1523   }
1524   bool TraverseSwiftNameAttr(SwiftNameAttr *A);
1525   bool VisitSwiftNameAttr(SwiftNameAttr *A) {
1526     return true; 
1527   }
1528   bool TraverseSwiftNewTypeAttr(SwiftNewTypeAttr *A);
1529   bool VisitSwiftNewTypeAttr(SwiftNewTypeAttr *A) {
1530     return true; 
1531   }
1532   bool TraverseSwiftObjCMembersAttr(SwiftObjCMembersAttr *A);
1533   bool VisitSwiftObjCMembersAttr(SwiftObjCMembersAttr *A) {
1534     return true; 
1535   }
1536   bool TraverseSwiftPrivateAttr(SwiftPrivateAttr *A);
1537   bool VisitSwiftPrivateAttr(SwiftPrivateAttr *A) {
1538     return true; 
1539   }
1540   bool TraverseSwiftVersionedAdditionAttr(SwiftVersionedAdditionAttr *A);
1541   bool VisitSwiftVersionedAdditionAttr(SwiftVersionedAdditionAttr *A) {
1542     return true; 
1543   }
1544   bool TraverseSwiftVersionedRemovalAttr(SwiftVersionedRemovalAttr *A);
1545   bool VisitSwiftVersionedRemovalAttr(SwiftVersionedRemovalAttr *A) {
1546     return true; 
1547   }
1548   bool TraverseSysVABIAttr(SysVABIAttr *A);
1549   bool VisitSysVABIAttr(SysVABIAttr *A) {
1550     return true; 
1551   }
1552   bool TraverseTLSModelAttr(TLSModelAttr *A);
1553   bool VisitTLSModelAttr(TLSModelAttr *A) {
1554     return true; 
1555   }
1556   bool TraverseTargetAttr(TargetAttr *A);
1557   bool VisitTargetAttr(TargetAttr *A) {
1558     return true; 
1559   }
1560   bool TraverseTargetClonesAttr(TargetClonesAttr *A);
1561   bool VisitTargetClonesAttr(TargetClonesAttr *A) {
1562     return true; 
1563   }
1564   bool TraverseTargetVersionAttr(TargetVersionAttr *A);
1565   bool VisitTargetVersionAttr(TargetVersionAttr *A) {
1566     return true; 
1567   }
1568   bool TraverseTestTypestateAttr(TestTypestateAttr *A);
1569   bool VisitTestTypestateAttr(TestTypestateAttr *A) {
1570     return true; 
1571   }
1572   bool TraverseThisCallAttr(ThisCallAttr *A);
1573   bool VisitThisCallAttr(ThisCallAttr *A) {
1574     return true; 
1575   }
1576   bool TraverseThreadAttr(ThreadAttr *A);
1577   bool VisitThreadAttr(ThreadAttr *A) {
1578     return true; 
1579   }
1580   bool TraverseTransparentUnionAttr(TransparentUnionAttr *A);
1581   bool VisitTransparentUnionAttr(TransparentUnionAttr *A) {
1582     return true; 
1583   }
1584   bool TraverseTrivialABIAttr(TrivialABIAttr *A);
1585   bool VisitTrivialABIAttr(TrivialABIAttr *A) {
1586     return true; 
1587   }
1588   bool TraverseTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A);
1589   bool VisitTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A) {
1590     return true; 
1591   }
1592   bool TraverseTypeNonNullAttr(TypeNonNullAttr *A);
1593   bool VisitTypeNonNullAttr(TypeNonNullAttr *A) {
1594     return true; 
1595   }
1596   bool TraverseTypeNullUnspecifiedAttr(TypeNullUnspecifiedAttr *A);
1597   bool VisitTypeNullUnspecifiedAttr(TypeNullUnspecifiedAttr *A) {
1598     return true; 
1599   }
1600   bool TraverseTypeNullableAttr(TypeNullableAttr *A);
1601   bool VisitTypeNullableAttr(TypeNullableAttr *A) {
1602     return true; 
1603   }
1604   bool TraverseTypeNullableResultAttr(TypeNullableResultAttr *A);
1605   bool VisitTypeNullableResultAttr(TypeNullableResultAttr *A) {
1606     return true; 
1607   }
1608   bool TraverseTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A);
1609   bool VisitTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A) {
1610     return true; 
1611   }
1612   bool TraverseTypeVisibilityAttr(TypeVisibilityAttr *A);
1613   bool VisitTypeVisibilityAttr(TypeVisibilityAttr *A) {
1614     return true; 
1615   }
1616   bool TraverseUPtrAttr(UPtrAttr *A);
1617   bool VisitUPtrAttr(UPtrAttr *A) {
1618     return true; 
1619   }
1620   bool TraverseUnavailableAttr(UnavailableAttr *A);
1621   bool VisitUnavailableAttr(UnavailableAttr *A) {
1622     return true; 
1623   }
1624   bool TraverseUninitializedAttr(UninitializedAttr *A);
1625   bool VisitUninitializedAttr(UninitializedAttr *A) {
1626     return true; 
1627   }
1628   bool TraverseUnlikelyAttr(UnlikelyAttr *A);
1629   bool VisitUnlikelyAttr(UnlikelyAttr *A) {
1630     return true; 
1631   }
1632   bool TraverseUnsafeBufferUsageAttr(UnsafeBufferUsageAttr *A);
1633   bool VisitUnsafeBufferUsageAttr(UnsafeBufferUsageAttr *A) {
1634     return true; 
1635   }
1636   bool TraverseUnusedAttr(UnusedAttr *A);
1637   bool VisitUnusedAttr(UnusedAttr *A) {
1638     return true; 
1639   }
1640   bool TraverseUseHandleAttr(UseHandleAttr *A);
1641   bool VisitUseHandleAttr(UseHandleAttr *A) {
1642     return true; 
1643   }
1644   bool TraverseUsedAttr(UsedAttr *A);
1645   bool VisitUsedAttr(UsedAttr *A) {
1646     return true; 
1647   }
1648   bool TraverseUsingIfExistsAttr(UsingIfExistsAttr *A);
1649   bool VisitUsingIfExistsAttr(UsingIfExistsAttr *A) {
1650     return true; 
1651   }
1652   bool TraverseUuidAttr(UuidAttr *A);
1653   bool VisitUuidAttr(UuidAttr *A) {
1654     return true; 
1655   }
1656   bool TraverseVTablePointerAuthenticationAttr(VTablePointerAuthenticationAttr *A);
1657   bool VisitVTablePointerAuthenticationAttr(VTablePointerAuthenticationAttr *A) {
1658     return true; 
1659   }
1660   bool TraverseVecReturnAttr(VecReturnAttr *A);
1661   bool VisitVecReturnAttr(VecReturnAttr *A) {
1662     return true; 
1663   }
1664   bool TraverseVecTypeHintAttr(VecTypeHintAttr *A);
1665   bool VisitVecTypeHintAttr(VecTypeHintAttr *A) {
1666     return true; 
1667   }
1668   bool TraverseVectorCallAttr(VectorCallAttr *A);
1669   bool VisitVectorCallAttr(VectorCallAttr *A) {
1670     return true; 
1671   }
1672   bool TraverseVisibilityAttr(VisibilityAttr *A);
1673   bool VisitVisibilityAttr(VisibilityAttr *A) {
1674     return true; 
1675   }
1676   bool TraverseWarnUnusedAttr(WarnUnusedAttr *A);
1677   bool VisitWarnUnusedAttr(WarnUnusedAttr *A) {
1678     return true; 
1679   }
1680   bool TraverseWarnUnusedResultAttr(WarnUnusedResultAttr *A);
1681   bool VisitWarnUnusedResultAttr(WarnUnusedResultAttr *A) {
1682     return true; 
1683   }
1684   bool TraverseWeakAttr(WeakAttr *A);
1685   bool VisitWeakAttr(WeakAttr *A) {
1686     return true; 
1687   }
1688   bool TraverseWeakImportAttr(WeakImportAttr *A);
1689   bool VisitWeakImportAttr(WeakImportAttr *A) {
1690     return true; 
1691   }
1692   bool TraverseWeakRefAttr(WeakRefAttr *A);
1693   bool VisitWeakRefAttr(WeakRefAttr *A) {
1694     return true; 
1695   }
1696   bool TraverseWebAssemblyExportNameAttr(WebAssemblyExportNameAttr *A);
1697   bool VisitWebAssemblyExportNameAttr(WebAssemblyExportNameAttr *A) {
1698     return true; 
1699   }
1700   bool TraverseWebAssemblyFuncrefAttr(WebAssemblyFuncrefAttr *A);
1701   bool VisitWebAssemblyFuncrefAttr(WebAssemblyFuncrefAttr *A) {
1702     return true; 
1703   }
1704   bool TraverseWebAssemblyImportModuleAttr(WebAssemblyImportModuleAttr *A);
1705   bool VisitWebAssemblyImportModuleAttr(WebAssemblyImportModuleAttr *A) {
1706     return true; 
1707   }
1708   bool TraverseWebAssemblyImportNameAttr(WebAssemblyImportNameAttr *A);
1709   bool VisitWebAssemblyImportNameAttr(WebAssemblyImportNameAttr *A) {
1710     return true; 
1711   }
1712   bool TraverseWorkGroupSizeHintAttr(WorkGroupSizeHintAttr *A);
1713   bool VisitWorkGroupSizeHintAttr(WorkGroupSizeHintAttr *A) {
1714     return true; 
1715   }
1716   bool TraverseX86ForceAlignArgPointerAttr(X86ForceAlignArgPointerAttr *A);
1717   bool VisitX86ForceAlignArgPointerAttr(X86ForceAlignArgPointerAttr *A) {
1718     return true; 
1719   }
1720   bool TraverseXRayInstrumentAttr(XRayInstrumentAttr *A);
1721   bool VisitXRayInstrumentAttr(XRayInstrumentAttr *A) {
1722     return true; 
1723   }
1724   bool TraverseXRayLogArgsAttr(XRayLogArgsAttr *A);
1725   bool VisitXRayLogArgsAttr(XRayLogArgsAttr *A) {
1726     return true; 
1727   }
1728   bool TraverseZeroCallUsedRegsAttr(ZeroCallUsedRegsAttr *A);
1729   bool VisitZeroCallUsedRegsAttr(ZeroCallUsedRegsAttr *A) {
1730     return true; 
1731   }
1732 
1733 #else // ATTR_VISITOR_DECLS_ONLY
1734 
1735 template <typename Derived>
1736 bool VISITORCLASS<Derived>::TraverseAArch64SVEPcsAttr(AArch64SVEPcsAttr *A) {
1737   if (!getDerived().VisitAttr(A))
1738     return false;
1739   if (!getDerived().VisitAArch64SVEPcsAttr(A))
1740     return false;
1741   return true;
1742 }
1743 
1744 template <typename Derived>
1745 bool VISITORCLASS<Derived>::TraverseAArch64VectorPcsAttr(AArch64VectorPcsAttr *A) {
1746   if (!getDerived().VisitAttr(A))
1747     return false;
1748   if (!getDerived().VisitAArch64VectorPcsAttr(A))
1749     return false;
1750   return true;
1751 }
1752 
1753 template <typename Derived>
1754 bool VISITORCLASS<Derived>::TraverseAMDGPUFlatWorkGroupSizeAttr(AMDGPUFlatWorkGroupSizeAttr *A) {
1755   if (!getDerived().VisitAttr(A))
1756     return false;
1757   if (!getDerived().VisitAMDGPUFlatWorkGroupSizeAttr(A))
1758     return false;
1759   if (!getDerived().TraverseStmt(A->getMin()))
1760     return false;
1761   if (!getDerived().TraverseStmt(A->getMax()))
1762     return false;
1763   return true;
1764 }
1765 
1766 template <typename Derived>
1767 bool VISITORCLASS<Derived>::TraverseAMDGPUKernelCallAttr(AMDGPUKernelCallAttr *A) {
1768   if (!getDerived().VisitAttr(A))
1769     return false;
1770   if (!getDerived().VisitAMDGPUKernelCallAttr(A))
1771     return false;
1772   return true;
1773 }
1774 
1775 template <typename Derived>
1776 bool VISITORCLASS<Derived>::TraverseAMDGPUMaxNumWorkGroupsAttr(AMDGPUMaxNumWorkGroupsAttr *A) {
1777   if (!getDerived().VisitAttr(A))
1778     return false;
1779   if (!getDerived().VisitAMDGPUMaxNumWorkGroupsAttr(A))
1780     return false;
1781   if (!getDerived().TraverseStmt(A->getMaxNumWorkGroupsX()))
1782     return false;
1783   if (!getDerived().TraverseStmt(A->getMaxNumWorkGroupsY()))
1784     return false;
1785   if (!getDerived().TraverseStmt(A->getMaxNumWorkGroupsZ()))
1786     return false;
1787   return true;
1788 }
1789 
1790 template <typename Derived>
1791 bool VISITORCLASS<Derived>::TraverseAMDGPUNumSGPRAttr(AMDGPUNumSGPRAttr *A) {
1792   if (!getDerived().VisitAttr(A))
1793     return false;
1794   if (!getDerived().VisitAMDGPUNumSGPRAttr(A))
1795     return false;
1796   return true;
1797 }
1798 
1799 template <typename Derived>
1800 bool VISITORCLASS<Derived>::TraverseAMDGPUNumVGPRAttr(AMDGPUNumVGPRAttr *A) {
1801   if (!getDerived().VisitAttr(A))
1802     return false;
1803   if (!getDerived().VisitAMDGPUNumVGPRAttr(A))
1804     return false;
1805   return true;
1806 }
1807 
1808 template <typename Derived>
1809 bool VISITORCLASS<Derived>::TraverseAMDGPUWavesPerEUAttr(AMDGPUWavesPerEUAttr *A) {
1810   if (!getDerived().VisitAttr(A))
1811     return false;
1812   if (!getDerived().VisitAMDGPUWavesPerEUAttr(A))
1813     return false;
1814   if (!getDerived().TraverseStmt(A->getMin()))
1815     return false;
1816   if (!getDerived().TraverseStmt(A->getMax()))
1817     return false;
1818   return true;
1819 }
1820 
1821 template <typename Derived>
1822 bool VISITORCLASS<Derived>::TraverseARMInterruptAttr(ARMInterruptAttr *A) {
1823   if (!getDerived().VisitAttr(A))
1824     return false;
1825   if (!getDerived().VisitARMInterruptAttr(A))
1826     return false;
1827   return true;
1828 }
1829 
1830 template <typename Derived>
1831 bool VISITORCLASS<Derived>::TraverseAVRInterruptAttr(AVRInterruptAttr *A) {
1832   if (!getDerived().VisitAttr(A))
1833     return false;
1834   if (!getDerived().VisitAVRInterruptAttr(A))
1835     return false;
1836   return true;
1837 }
1838 
1839 template <typename Derived>
1840 bool VISITORCLASS<Derived>::TraverseAVRSignalAttr(AVRSignalAttr *A) {
1841   if (!getDerived().VisitAttr(A))
1842     return false;
1843   if (!getDerived().VisitAVRSignalAttr(A))
1844     return false;
1845   return true;
1846 }
1847 
1848 template <typename Derived>
1849 bool VISITORCLASS<Derived>::TraverseAbiTagAttr(AbiTagAttr *A) {
1850   if (!getDerived().VisitAttr(A))
1851     return false;
1852   if (!getDerived().VisitAbiTagAttr(A))
1853     return false;
1854   return true;
1855 }
1856 
1857 template <typename Derived>
1858 bool VISITORCLASS<Derived>::TraverseAcquireCapabilityAttr(AcquireCapabilityAttr *A) {
1859   if (!getDerived().VisitAttr(A))
1860     return false;
1861   if (!getDerived().VisitAcquireCapabilityAttr(A))
1862     return false;
1863   {
1864     Expr * *I = A->args_begin();
1865     Expr * *E = A->args_end();
1866     for (; I != E; ++I) {
1867       if (!getDerived().TraverseStmt(*I))
1868         return false;
1869     }
1870   }
1871   return true;
1872 }
1873 
1874 template <typename Derived>
1875 bool VISITORCLASS<Derived>::TraverseAcquireHandleAttr(AcquireHandleAttr *A) {
1876   if (!getDerived().VisitAttr(A))
1877     return false;
1878   if (!getDerived().VisitAcquireHandleAttr(A))
1879     return false;
1880   return true;
1881 }
1882 
1883 template <typename Derived>
1884 bool VISITORCLASS<Derived>::TraverseAcquiredAfterAttr(AcquiredAfterAttr *A) {
1885   if (!getDerived().VisitAttr(A))
1886     return false;
1887   if (!getDerived().VisitAcquiredAfterAttr(A))
1888     return false;
1889   {
1890     Expr * *I = A->args_begin();
1891     Expr * *E = A->args_end();
1892     for (; I != E; ++I) {
1893       if (!getDerived().TraverseStmt(*I))
1894         return false;
1895     }
1896   }
1897   return true;
1898 }
1899 
1900 template <typename Derived>
1901 bool VISITORCLASS<Derived>::TraverseAcquiredBeforeAttr(AcquiredBeforeAttr *A) {
1902   if (!getDerived().VisitAttr(A))
1903     return false;
1904   if (!getDerived().VisitAcquiredBeforeAttr(A))
1905     return false;
1906   {
1907     Expr * *I = A->args_begin();
1908     Expr * *E = A->args_end();
1909     for (; I != E; ++I) {
1910       if (!getDerived().TraverseStmt(*I))
1911         return false;
1912     }
1913   }
1914   return true;
1915 }
1916 
1917 template <typename Derived>
1918 bool VISITORCLASS<Derived>::TraverseAddressSpaceAttr(AddressSpaceAttr *A) {
1919   if (!getDerived().VisitAttr(A))
1920     return false;
1921   if (!getDerived().VisitAddressSpaceAttr(A))
1922     return false;
1923   return true;
1924 }
1925 
1926 template <typename Derived>
1927 bool VISITORCLASS<Derived>::TraverseAliasAttr(AliasAttr *A) {
1928   if (!getDerived().VisitAttr(A))
1929     return false;
1930   if (!getDerived().VisitAliasAttr(A))
1931     return false;
1932   return true;
1933 }
1934 
1935 template <typename Derived>
1936 bool VISITORCLASS<Derived>::TraverseAlignMac68kAttr(AlignMac68kAttr *A) {
1937   if (!getDerived().VisitAttr(A))
1938     return false;
1939   if (!getDerived().VisitAlignMac68kAttr(A))
1940     return false;
1941   return true;
1942 }
1943 
1944 template <typename Derived>
1945 bool VISITORCLASS<Derived>::TraverseAlignNaturalAttr(AlignNaturalAttr *A) {
1946   if (!getDerived().VisitAttr(A))
1947     return false;
1948   if (!getDerived().VisitAlignNaturalAttr(A))
1949     return false;
1950   return true;
1951 }
1952 
1953 template <typename Derived>
1954 bool VISITORCLASS<Derived>::TraverseAlignValueAttr(AlignValueAttr *A) {
1955   if (!getDerived().VisitAttr(A))
1956     return false;
1957   if (!getDerived().VisitAlignValueAttr(A))
1958     return false;
1959   if (!getDerived().TraverseStmt(A->getAlignment()))
1960     return false;
1961   return true;
1962 }
1963 
1964 template <typename Derived>
1965 bool VISITORCLASS<Derived>::TraverseAlignedAttr(AlignedAttr *A) {
1966   if (!getDerived().VisitAttr(A))
1967     return false;
1968   if (!getDerived().VisitAlignedAttr(A))
1969     return false;
1970   if (A->isAlignmentExpr()) {
1971     if (!getDerived().TraverseStmt(A->getAlignmentExpr()))
1972       return false;
1973   } else if (auto *TSI = A->getAlignmentType()) {
1974     if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
1975       return false;
1976   }
1977   return true;
1978 }
1979 
1980 template <typename Derived>
1981 bool VISITORCLASS<Derived>::TraverseAllocAlignAttr(AllocAlignAttr *A) {
1982   if (!getDerived().VisitAttr(A))
1983     return false;
1984   if (!getDerived().VisitAllocAlignAttr(A))
1985     return false;
1986   return true;
1987 }
1988 
1989 template <typename Derived>
1990 bool VISITORCLASS<Derived>::TraverseAllocSizeAttr(AllocSizeAttr *A) {
1991   if (!getDerived().VisitAttr(A))
1992     return false;
1993   if (!getDerived().VisitAllocSizeAttr(A))
1994     return false;
1995   return true;
1996 }
1997 
1998 template <typename Derived>
1999 bool VISITORCLASS<Derived>::TraverseAllocatingAttr(AllocatingAttr *A) {
2000   if (!getDerived().VisitAttr(A))
2001     return false;
2002   if (!getDerived().VisitAllocatingAttr(A))
2003     return false;
2004   return true;
2005 }
2006 
2007 template <typename Derived>
2008 bool VISITORCLASS<Derived>::TraverseAlwaysDestroyAttr(AlwaysDestroyAttr *A) {
2009   if (!getDerived().VisitAttr(A))
2010     return false;
2011   if (!getDerived().VisitAlwaysDestroyAttr(A))
2012     return false;
2013   return true;
2014 }
2015 
2016 template <typename Derived>
2017 bool VISITORCLASS<Derived>::TraverseAlwaysInlineAttr(AlwaysInlineAttr *A) {
2018   if (!getDerived().VisitAttr(A))
2019     return false;
2020   if (!getDerived().VisitAlwaysInlineAttr(A))
2021     return false;
2022   return true;
2023 }
2024 
2025 template <typename Derived>
2026 bool VISITORCLASS<Derived>::TraverseAnalyzerNoReturnAttr(AnalyzerNoReturnAttr *A) {
2027   if (!getDerived().VisitAttr(A))
2028     return false;
2029   if (!getDerived().VisitAnalyzerNoReturnAttr(A))
2030     return false;
2031   return true;
2032 }
2033 
2034 template <typename Derived>
2035 bool VISITORCLASS<Derived>::TraverseAnnotateAttr(AnnotateAttr *A) {
2036   if (!getDerived().VisitAttr(A))
2037     return false;
2038   if (!getDerived().VisitAnnotateAttr(A))
2039     return false;
2040   {
2041     Expr * *I = A->args_begin();
2042     Expr * *E = A->args_end();
2043     for (; I != E; ++I) {
2044       if (!getDerived().TraverseStmt(*I))
2045         return false;
2046     }
2047   }
2048   {
2049     Expr * *I = A->delayedArgs_begin();
2050     Expr * *E = A->delayedArgs_end();
2051     for (; I != E; ++I) {
2052       if (!getDerived().TraverseStmt(*I))
2053         return false;
2054     }
2055   }
2056   return true;
2057 }
2058 
2059 template <typename Derived>
2060 bool VISITORCLASS<Derived>::TraverseAnnotateTypeAttr(AnnotateTypeAttr *A) {
2061   if (!getDerived().VisitAttr(A))
2062     return false;
2063   if (!getDerived().VisitAnnotateTypeAttr(A))
2064     return false;
2065   {
2066     Expr * *I = A->args_begin();
2067     Expr * *E = A->args_end();
2068     for (; I != E; ++I) {
2069       if (!getDerived().TraverseStmt(*I))
2070         return false;
2071     }
2072   }
2073   {
2074     Expr * *I = A->delayedArgs_begin();
2075     Expr * *E = A->delayedArgs_end();
2076     for (; I != E; ++I) {
2077       if (!getDerived().TraverseStmt(*I))
2078         return false;
2079     }
2080   }
2081   return true;
2082 }
2083 
2084 template <typename Derived>
2085 bool VISITORCLASS<Derived>::TraverseAnyX86InterruptAttr(AnyX86InterruptAttr *A) {
2086   if (!getDerived().VisitAttr(A))
2087     return false;
2088   if (!getDerived().VisitAnyX86InterruptAttr(A))
2089     return false;
2090   return true;
2091 }
2092 
2093 template <typename Derived>
2094 bool VISITORCLASS<Derived>::TraverseAnyX86NoCallerSavedRegistersAttr(AnyX86NoCallerSavedRegistersAttr *A) {
2095   if (!getDerived().VisitAttr(A))
2096     return false;
2097   if (!getDerived().VisitAnyX86NoCallerSavedRegistersAttr(A))
2098     return false;
2099   return true;
2100 }
2101 
2102 template <typename Derived>
2103 bool VISITORCLASS<Derived>::TraverseAnyX86NoCfCheckAttr(AnyX86NoCfCheckAttr *A) {
2104   if (!getDerived().VisitAttr(A))
2105     return false;
2106   if (!getDerived().VisitAnyX86NoCfCheckAttr(A))
2107     return false;
2108   return true;
2109 }
2110 
2111 template <typename Derived>
2112 bool VISITORCLASS<Derived>::TraverseArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A) {
2113   if (!getDerived().VisitAttr(A))
2114     return false;
2115   if (!getDerived().VisitArcWeakrefUnavailableAttr(A))
2116     return false;
2117   return true;
2118 }
2119 
2120 template <typename Derived>
2121 bool VISITORCLASS<Derived>::TraverseArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *A) {
2122   if (!getDerived().VisitAttr(A))
2123     return false;
2124   if (!getDerived().VisitArgumentWithTypeTagAttr(A))
2125     return false;
2126   return true;
2127 }
2128 
2129 template <typename Derived>
2130 bool VISITORCLASS<Derived>::TraverseArmAgnosticAttr(ArmAgnosticAttr *A) {
2131   if (!getDerived().VisitAttr(A))
2132     return false;
2133   if (!getDerived().VisitArmAgnosticAttr(A))
2134     return false;
2135   return true;
2136 }
2137 
2138 template <typename Derived>
2139 bool VISITORCLASS<Derived>::TraverseArmBuiltinAliasAttr(ArmBuiltinAliasAttr *A) {
2140   if (!getDerived().VisitAttr(A))
2141     return false;
2142   if (!getDerived().VisitArmBuiltinAliasAttr(A))
2143     return false;
2144   return true;
2145 }
2146 
2147 template <typename Derived>
2148 bool VISITORCLASS<Derived>::TraverseArmInAttr(ArmInAttr *A) {
2149   if (!getDerived().VisitAttr(A))
2150     return false;
2151   if (!getDerived().VisitArmInAttr(A))
2152     return false;
2153   return true;
2154 }
2155 
2156 template <typename Derived>
2157 bool VISITORCLASS<Derived>::TraverseArmInOutAttr(ArmInOutAttr *A) {
2158   if (!getDerived().VisitAttr(A))
2159     return false;
2160   if (!getDerived().VisitArmInOutAttr(A))
2161     return false;
2162   return true;
2163 }
2164 
2165 template <typename Derived>
2166 bool VISITORCLASS<Derived>::TraverseArmLocallyStreamingAttr(ArmLocallyStreamingAttr *A) {
2167   if (!getDerived().VisitAttr(A))
2168     return false;
2169   if (!getDerived().VisitArmLocallyStreamingAttr(A))
2170     return false;
2171   return true;
2172 }
2173 
2174 template <typename Derived>
2175 bool VISITORCLASS<Derived>::TraverseArmMveStrictPolymorphismAttr(ArmMveStrictPolymorphismAttr *A) {
2176   if (!getDerived().VisitAttr(A))
2177     return false;
2178   if (!getDerived().VisitArmMveStrictPolymorphismAttr(A))
2179     return false;
2180   return true;
2181 }
2182 
2183 template <typename Derived>
2184 bool VISITORCLASS<Derived>::TraverseArmNewAttr(ArmNewAttr *A) {
2185   if (!getDerived().VisitAttr(A))
2186     return false;
2187   if (!getDerived().VisitArmNewAttr(A))
2188     return false;
2189   return true;
2190 }
2191 
2192 template <typename Derived>
2193 bool VISITORCLASS<Derived>::TraverseArmOutAttr(ArmOutAttr *A) {
2194   if (!getDerived().VisitAttr(A))
2195     return false;
2196   if (!getDerived().VisitArmOutAttr(A))
2197     return false;
2198   return true;
2199 }
2200 
2201 template <typename Derived>
2202 bool VISITORCLASS<Derived>::TraverseArmPreservesAttr(ArmPreservesAttr *A) {
2203   if (!getDerived().VisitAttr(A))
2204     return false;
2205   if (!getDerived().VisitArmPreservesAttr(A))
2206     return false;
2207   return true;
2208 }
2209 
2210 template <typename Derived>
2211 bool VISITORCLASS<Derived>::TraverseArmStreamingAttr(ArmStreamingAttr *A) {
2212   if (!getDerived().VisitAttr(A))
2213     return false;
2214   if (!getDerived().VisitArmStreamingAttr(A))
2215     return false;
2216   return true;
2217 }
2218 
2219 template <typename Derived>
2220 bool VISITORCLASS<Derived>::TraverseArmStreamingCompatibleAttr(ArmStreamingCompatibleAttr *A) {
2221   if (!getDerived().VisitAttr(A))
2222     return false;
2223   if (!getDerived().VisitArmStreamingCompatibleAttr(A))
2224     return false;
2225   return true;
2226 }
2227 
2228 template <typename Derived>
2229 bool VISITORCLASS<Derived>::TraverseArtificialAttr(ArtificialAttr *A) {
2230   if (!getDerived().VisitAttr(A))
2231     return false;
2232   if (!getDerived().VisitArtificialAttr(A))
2233     return false;
2234   return true;
2235 }
2236 
2237 template <typename Derived>
2238 bool VISITORCLASS<Derived>::TraverseAsmLabelAttr(AsmLabelAttr *A) {
2239   if (!getDerived().VisitAttr(A))
2240     return false;
2241   if (!getDerived().VisitAsmLabelAttr(A))
2242     return false;
2243   return true;
2244 }
2245 
2246 template <typename Derived>
2247 bool VISITORCLASS<Derived>::TraverseAssertCapabilityAttr(AssertCapabilityAttr *A) {
2248   if (!getDerived().VisitAttr(A))
2249     return false;
2250   if (!getDerived().VisitAssertCapabilityAttr(A))
2251     return false;
2252   {
2253     Expr * *I = A->args_begin();
2254     Expr * *E = A->args_end();
2255     for (; I != E; ++I) {
2256       if (!getDerived().TraverseStmt(*I))
2257         return false;
2258     }
2259   }
2260   return true;
2261 }
2262 
2263 template <typename Derived>
2264 bool VISITORCLASS<Derived>::TraverseAssertExclusiveLockAttr(AssertExclusiveLockAttr *A) {
2265   if (!getDerived().VisitAttr(A))
2266     return false;
2267   if (!getDerived().VisitAssertExclusiveLockAttr(A))
2268     return false;
2269   {
2270     Expr * *I = A->args_begin();
2271     Expr * *E = A->args_end();
2272     for (; I != E; ++I) {
2273       if (!getDerived().TraverseStmt(*I))
2274         return false;
2275     }
2276   }
2277   return true;
2278 }
2279 
2280 template <typename Derived>
2281 bool VISITORCLASS<Derived>::TraverseAssertSharedLockAttr(AssertSharedLockAttr *A) {
2282   if (!getDerived().VisitAttr(A))
2283     return false;
2284   if (!getDerived().VisitAssertSharedLockAttr(A))
2285     return false;
2286   {
2287     Expr * *I = A->args_begin();
2288     Expr * *E = A->args_end();
2289     for (; I != E; ++I) {
2290       if (!getDerived().TraverseStmt(*I))
2291         return false;
2292     }
2293   }
2294   return true;
2295 }
2296 
2297 template <typename Derived>
2298 bool VISITORCLASS<Derived>::TraverseAssumeAlignedAttr(AssumeAlignedAttr *A) {
2299   if (!getDerived().VisitAttr(A))
2300     return false;
2301   if (!getDerived().VisitAssumeAlignedAttr(A))
2302     return false;
2303   if (!getDerived().TraverseStmt(A->getAlignment()))
2304     return false;
2305   if (!getDerived().TraverseStmt(A->getOffset()))
2306     return false;
2307   return true;
2308 }
2309 
2310 template <typename Derived>
2311 bool VISITORCLASS<Derived>::TraverseAvailabilityAttr(AvailabilityAttr *A) {
2312   if (!getDerived().VisitAttr(A))
2313     return false;
2314   if (!getDerived().VisitAvailabilityAttr(A))
2315     return false;
2316   return true;
2317 }
2318 
2319 template <typename Derived>
2320 bool VISITORCLASS<Derived>::TraverseAvailableOnlyInDefaultEvalMethodAttr(AvailableOnlyInDefaultEvalMethodAttr *A) {
2321   if (!getDerived().VisitAttr(A))
2322     return false;
2323   if (!getDerived().VisitAvailableOnlyInDefaultEvalMethodAttr(A))
2324     return false;
2325   return true;
2326 }
2327 
2328 template <typename Derived>
2329 bool VISITORCLASS<Derived>::TraverseBPFFastCallAttr(BPFFastCallAttr *A) {
2330   if (!getDerived().VisitAttr(A))
2331     return false;
2332   if (!getDerived().VisitBPFFastCallAttr(A))
2333     return false;
2334   return true;
2335 }
2336 
2337 template <typename Derived>
2338 bool VISITORCLASS<Derived>::TraverseBPFPreserveAccessIndexAttr(BPFPreserveAccessIndexAttr *A) {
2339   if (!getDerived().VisitAttr(A))
2340     return false;
2341   if (!getDerived().VisitBPFPreserveAccessIndexAttr(A))
2342     return false;
2343   return true;
2344 }
2345 
2346 template <typename Derived>
2347 bool VISITORCLASS<Derived>::TraverseBPFPreserveStaticOffsetAttr(BPFPreserveStaticOffsetAttr *A) {
2348   if (!getDerived().VisitAttr(A))
2349     return false;
2350   if (!getDerived().VisitBPFPreserveStaticOffsetAttr(A))
2351     return false;
2352   return true;
2353 }
2354 
2355 template <typename Derived>
2356 bool VISITORCLASS<Derived>::TraverseBTFDeclTagAttr(BTFDeclTagAttr *A) {
2357   if (!getDerived().VisitAttr(A))
2358     return false;
2359   if (!getDerived().VisitBTFDeclTagAttr(A))
2360     return false;
2361   return true;
2362 }
2363 
2364 template <typename Derived>
2365 bool VISITORCLASS<Derived>::TraverseBTFTypeTagAttr(BTFTypeTagAttr *A) {
2366   if (!getDerived().VisitAttr(A))
2367     return false;
2368   if (!getDerived().VisitBTFTypeTagAttr(A))
2369     return false;
2370   return true;
2371 }
2372 
2373 template <typename Derived>
2374 bool VISITORCLASS<Derived>::TraverseBlockingAttr(BlockingAttr *A) {
2375   if (!getDerived().VisitAttr(A))
2376     return false;
2377   if (!getDerived().VisitBlockingAttr(A))
2378     return false;
2379   return true;
2380 }
2381 
2382 template <typename Derived>
2383 bool VISITORCLASS<Derived>::TraverseBlocksAttr(BlocksAttr *A) {
2384   if (!getDerived().VisitAttr(A))
2385     return false;
2386   if (!getDerived().VisitBlocksAttr(A))
2387     return false;
2388   return true;
2389 }
2390 
2391 template <typename Derived>
2392 bool VISITORCLASS<Derived>::TraverseBuiltinAttr(BuiltinAttr *A) {
2393   if (!getDerived().VisitAttr(A))
2394     return false;
2395   if (!getDerived().VisitBuiltinAttr(A))
2396     return false;
2397   return true;
2398 }
2399 
2400 template <typename Derived>
2401 bool VISITORCLASS<Derived>::TraverseBuiltinAliasAttr(BuiltinAliasAttr *A) {
2402   if (!getDerived().VisitAttr(A))
2403     return false;
2404   if (!getDerived().VisitBuiltinAliasAttr(A))
2405     return false;
2406   return true;
2407 }
2408 
2409 template <typename Derived>
2410 bool VISITORCLASS<Derived>::TraverseC11NoReturnAttr(C11NoReturnAttr *A) {
2411   if (!getDerived().VisitAttr(A))
2412     return false;
2413   if (!getDerived().VisitC11NoReturnAttr(A))
2414     return false;
2415   return true;
2416 }
2417 
2418 template <typename Derived>
2419 bool VISITORCLASS<Derived>::TraverseCDeclAttr(CDeclAttr *A) {
2420   if (!getDerived().VisitAttr(A))
2421     return false;
2422   if (!getDerived().VisitCDeclAttr(A))
2423     return false;
2424   return true;
2425 }
2426 
2427 template <typename Derived>
2428 bool VISITORCLASS<Derived>::TraverseCFAuditedTransferAttr(CFAuditedTransferAttr *A) {
2429   if (!getDerived().VisitAttr(A))
2430     return false;
2431   if (!getDerived().VisitCFAuditedTransferAttr(A))
2432     return false;
2433   return true;
2434 }
2435 
2436 template <typename Derived>
2437 bool VISITORCLASS<Derived>::TraverseCFConsumedAttr(CFConsumedAttr *A) {
2438   if (!getDerived().VisitAttr(A))
2439     return false;
2440   if (!getDerived().VisitCFConsumedAttr(A))
2441     return false;
2442   return true;
2443 }
2444 
2445 template <typename Derived>
2446 bool VISITORCLASS<Derived>::TraverseCFGuardAttr(CFGuardAttr *A) {
2447   if (!getDerived().VisitAttr(A))
2448     return false;
2449   if (!getDerived().VisitCFGuardAttr(A))
2450     return false;
2451   return true;
2452 }
2453 
2454 template <typename Derived>
2455 bool VISITORCLASS<Derived>::TraverseCFICanonicalJumpTableAttr(CFICanonicalJumpTableAttr *A) {
2456   if (!getDerived().VisitAttr(A))
2457     return false;
2458   if (!getDerived().VisitCFICanonicalJumpTableAttr(A))
2459     return false;
2460   return true;
2461 }
2462 
2463 template <typename Derived>
2464 bool VISITORCLASS<Derived>::TraverseCFReturnsNotRetainedAttr(CFReturnsNotRetainedAttr *A) {
2465   if (!getDerived().VisitAttr(A))
2466     return false;
2467   if (!getDerived().VisitCFReturnsNotRetainedAttr(A))
2468     return false;
2469   return true;
2470 }
2471 
2472 template <typename Derived>
2473 bool VISITORCLASS<Derived>::TraverseCFReturnsRetainedAttr(CFReturnsRetainedAttr *A) {
2474   if (!getDerived().VisitAttr(A))
2475     return false;
2476   if (!getDerived().VisitCFReturnsRetainedAttr(A))
2477     return false;
2478   return true;
2479 }
2480 
2481 template <typename Derived>
2482 bool VISITORCLASS<Derived>::TraverseCFUnknownTransferAttr(CFUnknownTransferAttr *A) {
2483   if (!getDerived().VisitAttr(A))
2484     return false;
2485   if (!getDerived().VisitCFUnknownTransferAttr(A))
2486     return false;
2487   return true;
2488 }
2489 
2490 template <typename Derived>
2491 bool VISITORCLASS<Derived>::TraverseCPUDispatchAttr(CPUDispatchAttr *A) {
2492   if (!getDerived().VisitAttr(A))
2493     return false;
2494   if (!getDerived().VisitCPUDispatchAttr(A))
2495     return false;
2496   return true;
2497 }
2498 
2499 template <typename Derived>
2500 bool VISITORCLASS<Derived>::TraverseCPUSpecificAttr(CPUSpecificAttr *A) {
2501   if (!getDerived().VisitAttr(A))
2502     return false;
2503   if (!getDerived().VisitCPUSpecificAttr(A))
2504     return false;
2505   return true;
2506 }
2507 
2508 template <typename Derived>
2509 bool VISITORCLASS<Derived>::TraverseCUDAConstantAttr(CUDAConstantAttr *A) {
2510   if (!getDerived().VisitAttr(A))
2511     return false;
2512   if (!getDerived().VisitCUDAConstantAttr(A))
2513     return false;
2514   return true;
2515 }
2516 
2517 template <typename Derived>
2518 bool VISITORCLASS<Derived>::TraverseCUDADeviceAttr(CUDADeviceAttr *A) {
2519   if (!getDerived().VisitAttr(A))
2520     return false;
2521   if (!getDerived().VisitCUDADeviceAttr(A))
2522     return false;
2523   return true;
2524 }
2525 
2526 template <typename Derived>
2527 bool VISITORCLASS<Derived>::TraverseCUDADeviceBuiltinSurfaceTypeAttr(CUDADeviceBuiltinSurfaceTypeAttr *A) {
2528   if (!getDerived().VisitAttr(A))
2529     return false;
2530   if (!getDerived().VisitCUDADeviceBuiltinSurfaceTypeAttr(A))
2531     return false;
2532   return true;
2533 }
2534 
2535 template <typename Derived>
2536 bool VISITORCLASS<Derived>::TraverseCUDADeviceBuiltinTextureTypeAttr(CUDADeviceBuiltinTextureTypeAttr *A) {
2537   if (!getDerived().VisitAttr(A))
2538     return false;
2539   if (!getDerived().VisitCUDADeviceBuiltinTextureTypeAttr(A))
2540     return false;
2541   return true;
2542 }
2543 
2544 template <typename Derived>
2545 bool VISITORCLASS<Derived>::TraverseCUDAGlobalAttr(CUDAGlobalAttr *A) {
2546   if (!getDerived().VisitAttr(A))
2547     return false;
2548   if (!getDerived().VisitCUDAGlobalAttr(A))
2549     return false;
2550   return true;
2551 }
2552 
2553 template <typename Derived>
2554 bool VISITORCLASS<Derived>::TraverseCUDAGridConstantAttr(CUDAGridConstantAttr *A) {
2555   if (!getDerived().VisitAttr(A))
2556     return false;
2557   if (!getDerived().VisitCUDAGridConstantAttr(A))
2558     return false;
2559   return true;
2560 }
2561 
2562 template <typename Derived>
2563 bool VISITORCLASS<Derived>::TraverseCUDAHostAttr(CUDAHostAttr *A) {
2564   if (!getDerived().VisitAttr(A))
2565     return false;
2566   if (!getDerived().VisitCUDAHostAttr(A))
2567     return false;
2568   return true;
2569 }
2570 
2571 template <typename Derived>
2572 bool VISITORCLASS<Derived>::TraverseCUDAInvalidTargetAttr(CUDAInvalidTargetAttr *A) {
2573   if (!getDerived().VisitAttr(A))
2574     return false;
2575   if (!getDerived().VisitCUDAInvalidTargetAttr(A))
2576     return false;
2577   return true;
2578 }
2579 
2580 template <typename Derived>
2581 bool VISITORCLASS<Derived>::TraverseCUDALaunchBoundsAttr(CUDALaunchBoundsAttr *A) {
2582   if (!getDerived().VisitAttr(A))
2583     return false;
2584   if (!getDerived().VisitCUDALaunchBoundsAttr(A))
2585     return false;
2586   if (!getDerived().TraverseStmt(A->getMaxThreads()))
2587     return false;
2588   if (!getDerived().TraverseStmt(A->getMinBlocks()))
2589     return false;
2590   if (!getDerived().TraverseStmt(A->getMaxBlocks()))
2591     return false;
2592   return true;
2593 }
2594 
2595 template <typename Derived>
2596 bool VISITORCLASS<Derived>::TraverseCUDASharedAttr(CUDASharedAttr *A) {
2597   if (!getDerived().VisitAttr(A))
2598     return false;
2599   if (!getDerived().VisitCUDASharedAttr(A))
2600     return false;
2601   return true;
2602 }
2603 
2604 template <typename Derived>
2605 bool VISITORCLASS<Derived>::TraverseCXX11NoReturnAttr(CXX11NoReturnAttr *A) {
2606   if (!getDerived().VisitAttr(A))
2607     return false;
2608   if (!getDerived().VisitCXX11NoReturnAttr(A))
2609     return false;
2610   return true;
2611 }
2612 
2613 template <typename Derived>
2614 bool VISITORCLASS<Derived>::TraverseCXXAssumeAttr(CXXAssumeAttr *A) {
2615   if (!getDerived().VisitAttr(A))
2616     return false;
2617   if (!getDerived().VisitCXXAssumeAttr(A))
2618     return false;
2619   if (!getDerived().TraverseStmt(A->getAssumption()))
2620     return false;
2621   return true;
2622 }
2623 
2624 template <typename Derived>
2625 bool VISITORCLASS<Derived>::TraverseCallableWhenAttr(CallableWhenAttr *A) {
2626   if (!getDerived().VisitAttr(A))
2627     return false;
2628   if (!getDerived().VisitCallableWhenAttr(A))
2629     return false;
2630   return true;
2631 }
2632 
2633 template <typename Derived>
2634 bool VISITORCLASS<Derived>::TraverseCallbackAttr(CallbackAttr *A) {
2635   if (!getDerived().VisitAttr(A))
2636     return false;
2637   if (!getDerived().VisitCallbackAttr(A))
2638     return false;
2639   return true;
2640 }
2641 
2642 template <typename Derived>
2643 bool VISITORCLASS<Derived>::TraverseCalledOnceAttr(CalledOnceAttr *A) {
2644   if (!getDerived().VisitAttr(A))
2645     return false;
2646   if (!getDerived().VisitCalledOnceAttr(A))
2647     return false;
2648   return true;
2649 }
2650 
2651 template <typename Derived>
2652 bool VISITORCLASS<Derived>::TraverseCapabilityAttr(CapabilityAttr *A) {
2653   if (!getDerived().VisitAttr(A))
2654     return false;
2655   if (!getDerived().VisitCapabilityAttr(A))
2656     return false;
2657   return true;
2658 }
2659 
2660 template <typename Derived>
2661 bool VISITORCLASS<Derived>::TraverseCapturedRecordAttr(CapturedRecordAttr *A) {
2662   if (!getDerived().VisitAttr(A))
2663     return false;
2664   if (!getDerived().VisitCapturedRecordAttr(A))
2665     return false;
2666   return true;
2667 }
2668 
2669 template <typename Derived>
2670 bool VISITORCLASS<Derived>::TraverseCarriesDependencyAttr(CarriesDependencyAttr *A) {
2671   if (!getDerived().VisitAttr(A))
2672     return false;
2673   if (!getDerived().VisitCarriesDependencyAttr(A))
2674     return false;
2675   return true;
2676 }
2677 
2678 template <typename Derived>
2679 bool VISITORCLASS<Derived>::TraverseCleanupAttr(CleanupAttr *A) {
2680   if (!getDerived().VisitAttr(A))
2681     return false;
2682   if (!getDerived().VisitCleanupAttr(A))
2683     return false;
2684   return true;
2685 }
2686 
2687 template <typename Derived>
2688 bool VISITORCLASS<Derived>::TraverseClspvLibclcBuiltinAttr(ClspvLibclcBuiltinAttr *A) {
2689   if (!getDerived().VisitAttr(A))
2690     return false;
2691   if (!getDerived().VisitClspvLibclcBuiltinAttr(A))
2692     return false;
2693   return true;
2694 }
2695 
2696 template <typename Derived>
2697 bool VISITORCLASS<Derived>::TraverseCmseNSCallAttr(CmseNSCallAttr *A) {
2698   if (!getDerived().VisitAttr(A))
2699     return false;
2700   if (!getDerived().VisitCmseNSCallAttr(A))
2701     return false;
2702   return true;
2703 }
2704 
2705 template <typename Derived>
2706 bool VISITORCLASS<Derived>::TraverseCmseNSEntryAttr(CmseNSEntryAttr *A) {
2707   if (!getDerived().VisitAttr(A))
2708     return false;
2709   if (!getDerived().VisitCmseNSEntryAttr(A))
2710     return false;
2711   return true;
2712 }
2713 
2714 template <typename Derived>
2715 bool VISITORCLASS<Derived>::TraverseCodeAlignAttr(CodeAlignAttr *A) {
2716   if (!getDerived().VisitAttr(A))
2717     return false;
2718   if (!getDerived().VisitCodeAlignAttr(A))
2719     return false;
2720   if (!getDerived().TraverseStmt(A->getAlignment()))
2721     return false;
2722   return true;
2723 }
2724 
2725 template <typename Derived>
2726 bool VISITORCLASS<Derived>::TraverseCodeModelAttr(CodeModelAttr *A) {
2727   if (!getDerived().VisitAttr(A))
2728     return false;
2729   if (!getDerived().VisitCodeModelAttr(A))
2730     return false;
2731   return true;
2732 }
2733 
2734 template <typename Derived>
2735 bool VISITORCLASS<Derived>::TraverseCodeSegAttr(CodeSegAttr *A) {
2736   if (!getDerived().VisitAttr(A))
2737     return false;
2738   if (!getDerived().VisitCodeSegAttr(A))
2739     return false;
2740   return true;
2741 }
2742 
2743 template <typename Derived>
2744 bool VISITORCLASS<Derived>::TraverseColdAttr(ColdAttr *A) {
2745   if (!getDerived().VisitAttr(A))
2746     return false;
2747   if (!getDerived().VisitColdAttr(A))
2748     return false;
2749   return true;
2750 }
2751 
2752 template <typename Derived>
2753 bool VISITORCLASS<Derived>::TraverseCommonAttr(CommonAttr *A) {
2754   if (!getDerived().VisitAttr(A))
2755     return false;
2756   if (!getDerived().VisitCommonAttr(A))
2757     return false;
2758   return true;
2759 }
2760 
2761 template <typename Derived>
2762 bool VISITORCLASS<Derived>::TraverseConstAttr(ConstAttr *A) {
2763   if (!getDerived().VisitAttr(A))
2764     return false;
2765   if (!getDerived().VisitConstAttr(A))
2766     return false;
2767   return true;
2768 }
2769 
2770 template <typename Derived>
2771 bool VISITORCLASS<Derived>::TraverseConstInitAttr(ConstInitAttr *A) {
2772   if (!getDerived().VisitAttr(A))
2773     return false;
2774   if (!getDerived().VisitConstInitAttr(A))
2775     return false;
2776   return true;
2777 }
2778 
2779 template <typename Derived>
2780 bool VISITORCLASS<Derived>::TraverseConstructorAttr(ConstructorAttr *A) {
2781   if (!getDerived().VisitAttr(A))
2782     return false;
2783   if (!getDerived().VisitConstructorAttr(A))
2784     return false;
2785   return true;
2786 }
2787 
2788 template <typename Derived>
2789 bool VISITORCLASS<Derived>::TraverseConsumableAttr(ConsumableAttr *A) {
2790   if (!getDerived().VisitAttr(A))
2791     return false;
2792   if (!getDerived().VisitConsumableAttr(A))
2793     return false;
2794   return true;
2795 }
2796 
2797 template <typename Derived>
2798 bool VISITORCLASS<Derived>::TraverseConsumableAutoCastAttr(ConsumableAutoCastAttr *A) {
2799   if (!getDerived().VisitAttr(A))
2800     return false;
2801   if (!getDerived().VisitConsumableAutoCastAttr(A))
2802     return false;
2803   return true;
2804 }
2805 
2806 template <typename Derived>
2807 bool VISITORCLASS<Derived>::TraverseConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A) {
2808   if (!getDerived().VisitAttr(A))
2809     return false;
2810   if (!getDerived().VisitConsumableSetOnReadAttr(A))
2811     return false;
2812   return true;
2813 }
2814 
2815 template <typename Derived>
2816 bool VISITORCLASS<Derived>::TraverseConvergentAttr(ConvergentAttr *A) {
2817   if (!getDerived().VisitAttr(A))
2818     return false;
2819   if (!getDerived().VisitConvergentAttr(A))
2820     return false;
2821   return true;
2822 }
2823 
2824 template <typename Derived>
2825 bool VISITORCLASS<Derived>::TraverseCoroAwaitElidableAttr(CoroAwaitElidableAttr *A) {
2826   if (!getDerived().VisitAttr(A))
2827     return false;
2828   if (!getDerived().VisitCoroAwaitElidableAttr(A))
2829     return false;
2830   return true;
2831 }
2832 
2833 template <typename Derived>
2834 bool VISITORCLASS<Derived>::TraverseCoroAwaitElidableArgumentAttr(CoroAwaitElidableArgumentAttr *A) {
2835   if (!getDerived().VisitAttr(A))
2836     return false;
2837   if (!getDerived().VisitCoroAwaitElidableArgumentAttr(A))
2838     return false;
2839   return true;
2840 }
2841 
2842 template <typename Derived>
2843 bool VISITORCLASS<Derived>::TraverseCoroDisableLifetimeBoundAttr(CoroDisableLifetimeBoundAttr *A) {
2844   if (!getDerived().VisitAttr(A))
2845     return false;
2846   if (!getDerived().VisitCoroDisableLifetimeBoundAttr(A))
2847     return false;
2848   return true;
2849 }
2850 
2851 template <typename Derived>
2852 bool VISITORCLASS<Derived>::TraverseCoroLifetimeBoundAttr(CoroLifetimeBoundAttr *A) {
2853   if (!getDerived().VisitAttr(A))
2854     return false;
2855   if (!getDerived().VisitCoroLifetimeBoundAttr(A))
2856     return false;
2857   return true;
2858 }
2859 
2860 template <typename Derived>
2861 bool VISITORCLASS<Derived>::TraverseCoroOnlyDestroyWhenCompleteAttr(CoroOnlyDestroyWhenCompleteAttr *A) {
2862   if (!getDerived().VisitAttr(A))
2863     return false;
2864   if (!getDerived().VisitCoroOnlyDestroyWhenCompleteAttr(A))
2865     return false;
2866   return true;
2867 }
2868 
2869 template <typename Derived>
2870 bool VISITORCLASS<Derived>::TraverseCoroReturnTypeAttr(CoroReturnTypeAttr *A) {
2871   if (!getDerived().VisitAttr(A))
2872     return false;
2873   if (!getDerived().VisitCoroReturnTypeAttr(A))
2874     return false;
2875   return true;
2876 }
2877 
2878 template <typename Derived>
2879 bool VISITORCLASS<Derived>::TraverseCoroWrapperAttr(CoroWrapperAttr *A) {
2880   if (!getDerived().VisitAttr(A))
2881     return false;
2882   if (!getDerived().VisitCoroWrapperAttr(A))
2883     return false;
2884   return true;
2885 }
2886 
2887 template <typename Derived>
2888 bool VISITORCLASS<Derived>::TraverseCountedByAttr(CountedByAttr *A) {
2889   if (!getDerived().VisitAttr(A))
2890     return false;
2891   if (!getDerived().VisitCountedByAttr(A))
2892     return false;
2893   if (!getDerived().TraverseStmt(A->getCount()))
2894     return false;
2895   return true;
2896 }
2897 
2898 template <typename Derived>
2899 bool VISITORCLASS<Derived>::TraverseCountedByOrNullAttr(CountedByOrNullAttr *A) {
2900   if (!getDerived().VisitAttr(A))
2901     return false;
2902   if (!getDerived().VisitCountedByOrNullAttr(A))
2903     return false;
2904   if (!getDerived().TraverseStmt(A->getCount()))
2905     return false;
2906   return true;
2907 }
2908 
2909 template <typename Derived>
2910 bool VISITORCLASS<Derived>::TraverseDLLExportAttr(DLLExportAttr *A) {
2911   if (!getDerived().VisitAttr(A))
2912     return false;
2913   if (!getDerived().VisitDLLExportAttr(A))
2914     return false;
2915   return true;
2916 }
2917 
2918 template <typename Derived>
2919 bool VISITORCLASS<Derived>::TraverseDLLExportStaticLocalAttr(DLLExportStaticLocalAttr *A) {
2920   if (!getDerived().VisitAttr(A))
2921     return false;
2922   if (!getDerived().VisitDLLExportStaticLocalAttr(A))
2923     return false;
2924   return true;
2925 }
2926 
2927 template <typename Derived>
2928 bool VISITORCLASS<Derived>::TraverseDLLImportAttr(DLLImportAttr *A) {
2929   if (!getDerived().VisitAttr(A))
2930     return false;
2931   if (!getDerived().VisitDLLImportAttr(A))
2932     return false;
2933   return true;
2934 }
2935 
2936 template <typename Derived>
2937 bool VISITORCLASS<Derived>::TraverseDLLImportStaticLocalAttr(DLLImportStaticLocalAttr *A) {
2938   if (!getDerived().VisitAttr(A))
2939     return false;
2940   if (!getDerived().VisitDLLImportStaticLocalAttr(A))
2941     return false;
2942   return true;
2943 }
2944 
2945 template <typename Derived>
2946 bool VISITORCLASS<Derived>::TraverseDeprecatedAttr(DeprecatedAttr *A) {
2947   if (!getDerived().VisitAttr(A))
2948     return false;
2949   if (!getDerived().VisitDeprecatedAttr(A))
2950     return false;
2951   return true;
2952 }
2953 
2954 template <typename Derived>
2955 bool VISITORCLASS<Derived>::TraverseDestructorAttr(DestructorAttr *A) {
2956   if (!getDerived().VisitAttr(A))
2957     return false;
2958   if (!getDerived().VisitDestructorAttr(A))
2959     return false;
2960   return true;
2961 }
2962 
2963 template <typename Derived>
2964 bool VISITORCLASS<Derived>::TraverseDiagnoseAsBuiltinAttr(DiagnoseAsBuiltinAttr *A) {
2965   if (!getDerived().VisitAttr(A))
2966     return false;
2967   if (!getDerived().VisitDiagnoseAsBuiltinAttr(A))
2968     return false;
2969   return true;
2970 }
2971 
2972 template <typename Derived>
2973 bool VISITORCLASS<Derived>::TraverseDiagnoseIfAttr(DiagnoseIfAttr *A) {
2974   if (!getDerived().VisitAttr(A))
2975     return false;
2976   if (!getDerived().VisitDiagnoseIfAttr(A))
2977     return false;
2978   if (!getDerived().TraverseStmt(A->getCond()))
2979     return false;
2980   return true;
2981 }
2982 
2983 template <typename Derived>
2984 bool VISITORCLASS<Derived>::TraverseDisableSanitizerInstrumentationAttr(DisableSanitizerInstrumentationAttr *A) {
2985   if (!getDerived().VisitAttr(A))
2986     return false;
2987   if (!getDerived().VisitDisableSanitizerInstrumentationAttr(A))
2988     return false;
2989   return true;
2990 }
2991 
2992 template <typename Derived>
2993 bool VISITORCLASS<Derived>::TraverseDisableTailCallsAttr(DisableTailCallsAttr *A) {
2994   if (!getDerived().VisitAttr(A))
2995     return false;
2996   if (!getDerived().VisitDisableTailCallsAttr(A))
2997     return false;
2998   return true;
2999 }
3000 
3001 template <typename Derived>
3002 bool VISITORCLASS<Derived>::TraverseEmptyBasesAttr(EmptyBasesAttr *A) {
3003   if (!getDerived().VisitAttr(A))
3004     return false;
3005   if (!getDerived().VisitEmptyBasesAttr(A))
3006     return false;
3007   return true;
3008 }
3009 
3010 template <typename Derived>
3011 bool VISITORCLASS<Derived>::TraverseEnableIfAttr(EnableIfAttr *A) {
3012   if (!getDerived().VisitAttr(A))
3013     return false;
3014   if (!getDerived().VisitEnableIfAttr(A))
3015     return false;
3016   if (!getDerived().TraverseStmt(A->getCond()))
3017     return false;
3018   return true;
3019 }
3020 
3021 template <typename Derived>
3022 bool VISITORCLASS<Derived>::TraverseEnforceTCBAttr(EnforceTCBAttr *A) {
3023   if (!getDerived().VisitAttr(A))
3024     return false;
3025   if (!getDerived().VisitEnforceTCBAttr(A))
3026     return false;
3027   return true;
3028 }
3029 
3030 template <typename Derived>
3031 bool VISITORCLASS<Derived>::TraverseEnforceTCBLeafAttr(EnforceTCBLeafAttr *A) {
3032   if (!getDerived().VisitAttr(A))
3033     return false;
3034   if (!getDerived().VisitEnforceTCBLeafAttr(A))
3035     return false;
3036   return true;
3037 }
3038 
3039 template <typename Derived>
3040 bool VISITORCLASS<Derived>::TraverseEnumExtensibilityAttr(EnumExtensibilityAttr *A) {
3041   if (!getDerived().VisitAttr(A))
3042     return false;
3043   if (!getDerived().VisitEnumExtensibilityAttr(A))
3044     return false;
3045   return true;
3046 }
3047 
3048 template <typename Derived>
3049 bool VISITORCLASS<Derived>::TraverseErrorAttr(ErrorAttr *A) {
3050   if (!getDerived().VisitAttr(A))
3051     return false;
3052   if (!getDerived().VisitErrorAttr(A))
3053     return false;
3054   return true;
3055 }
3056 
3057 template <typename Derived>
3058 bool VISITORCLASS<Derived>::TraverseExcludeFromExplicitInstantiationAttr(ExcludeFromExplicitInstantiationAttr *A) {
3059   if (!getDerived().VisitAttr(A))
3060     return false;
3061   if (!getDerived().VisitExcludeFromExplicitInstantiationAttr(A))
3062     return false;
3063   return true;
3064 }
3065 
3066 template <typename Derived>
3067 bool VISITORCLASS<Derived>::TraverseExclusiveTrylockFunctionAttr(ExclusiveTrylockFunctionAttr *A) {
3068   if (!getDerived().VisitAttr(A))
3069     return false;
3070   if (!getDerived().VisitExclusiveTrylockFunctionAttr(A))
3071     return false;
3072   if (!getDerived().TraverseStmt(A->getSuccessValue()))
3073     return false;
3074   {
3075     Expr * *I = A->args_begin();
3076     Expr * *E = A->args_end();
3077     for (; I != E; ++I) {
3078       if (!getDerived().TraverseStmt(*I))
3079         return false;
3080     }
3081   }
3082   return true;
3083 }
3084 
3085 template <typename Derived>
3086 bool VISITORCLASS<Derived>::TraverseExplicitInitAttr(ExplicitInitAttr *A) {
3087   if (!getDerived().VisitAttr(A))
3088     return false;
3089   if (!getDerived().VisitExplicitInitAttr(A))
3090     return false;
3091   return true;
3092 }
3093 
3094 template <typename Derived>
3095 bool VISITORCLASS<Derived>::TraverseExternalSourceSymbolAttr(ExternalSourceSymbolAttr *A) {
3096   if (!getDerived().VisitAttr(A))
3097     return false;
3098   if (!getDerived().VisitExternalSourceSymbolAttr(A))
3099     return false;
3100   return true;
3101 }
3102 
3103 template <typename Derived>
3104 bool VISITORCLASS<Derived>::TraverseFallThroughAttr(FallThroughAttr *A) {
3105   if (!getDerived().VisitAttr(A))
3106     return false;
3107   if (!getDerived().VisitFallThroughAttr(A))
3108     return false;
3109   return true;
3110 }
3111 
3112 template <typename Derived>
3113 bool VISITORCLASS<Derived>::TraverseFastCallAttr(FastCallAttr *A) {
3114   if (!getDerived().VisitAttr(A))
3115     return false;
3116   if (!getDerived().VisitFastCallAttr(A))
3117     return false;
3118   return true;
3119 }
3120 
3121 template <typename Derived>
3122 bool VISITORCLASS<Derived>::TraverseFinalAttr(FinalAttr *A) {
3123   if (!getDerived().VisitAttr(A))
3124     return false;
3125   if (!getDerived().VisitFinalAttr(A))
3126     return false;
3127   return true;
3128 }
3129 
3130 template <typename Derived>
3131 bool VISITORCLASS<Derived>::TraverseFlagEnumAttr(FlagEnumAttr *A) {
3132   if (!getDerived().VisitAttr(A))
3133     return false;
3134   if (!getDerived().VisitFlagEnumAttr(A))
3135     return false;
3136   return true;
3137 }
3138 
3139 template <typename Derived>
3140 bool VISITORCLASS<Derived>::TraverseFlattenAttr(FlattenAttr *A) {
3141   if (!getDerived().VisitAttr(A))
3142     return false;
3143   if (!getDerived().VisitFlattenAttr(A))
3144     return false;
3145   return true;
3146 }
3147 
3148 template <typename Derived>
3149 bool VISITORCLASS<Derived>::TraverseFormatAttr(FormatAttr *A) {
3150   if (!getDerived().VisitAttr(A))
3151     return false;
3152   if (!getDerived().VisitFormatAttr(A))
3153     return false;
3154   return true;
3155 }
3156 
3157 template <typename Derived>
3158 bool VISITORCLASS<Derived>::TraverseFormatArgAttr(FormatArgAttr *A) {
3159   if (!getDerived().VisitAttr(A))
3160     return false;
3161   if (!getDerived().VisitFormatArgAttr(A))
3162     return false;
3163   return true;
3164 }
3165 
3166 template <typename Derived>
3167 bool VISITORCLASS<Derived>::TraverseFunctionReturnThunksAttr(FunctionReturnThunksAttr *A) {
3168   if (!getDerived().VisitAttr(A))
3169     return false;
3170   if (!getDerived().VisitFunctionReturnThunksAttr(A))
3171     return false;
3172   return true;
3173 }
3174 
3175 template <typename Derived>
3176 bool VISITORCLASS<Derived>::TraverseGNUInlineAttr(GNUInlineAttr *A) {
3177   if (!getDerived().VisitAttr(A))
3178     return false;
3179   if (!getDerived().VisitGNUInlineAttr(A))
3180     return false;
3181   return true;
3182 }
3183 
3184 template <typename Derived>
3185 bool VISITORCLASS<Derived>::TraverseGuardedByAttr(GuardedByAttr *A) {
3186   if (!getDerived().VisitAttr(A))
3187     return false;
3188   if (!getDerived().VisitGuardedByAttr(A))
3189     return false;
3190   if (!getDerived().TraverseStmt(A->getArg()))
3191     return false;
3192   return true;
3193 }
3194 
3195 template <typename Derived>
3196 bool VISITORCLASS<Derived>::TraverseGuardedVarAttr(GuardedVarAttr *A) {
3197   if (!getDerived().VisitAttr(A))
3198     return false;
3199   if (!getDerived().VisitGuardedVarAttr(A))
3200     return false;
3201   return true;
3202 }
3203 
3204 template <typename Derived>
3205 bool VISITORCLASS<Derived>::TraverseHIPManagedAttr(HIPManagedAttr *A) {
3206   if (!getDerived().VisitAttr(A))
3207     return false;
3208   if (!getDerived().VisitHIPManagedAttr(A))
3209     return false;
3210   return true;
3211 }
3212 
3213 template <typename Derived>
3214 bool VISITORCLASS<Derived>::TraverseHLSLContainedTypeAttr(HLSLContainedTypeAttr *A) {
3215   if (!getDerived().VisitAttr(A))
3216     return false;
3217   if (!getDerived().VisitHLSLContainedTypeAttr(A))
3218     return false;
3219   if (auto *TSI = A->getTypeLoc())
3220     if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
3221       return false;
3222   return true;
3223 }
3224 
3225 template <typename Derived>
3226 bool VISITORCLASS<Derived>::TraverseHLSLControlFlowHintAttr(HLSLControlFlowHintAttr *A) {
3227   if (!getDerived().VisitAttr(A))
3228     return false;
3229   if (!getDerived().VisitHLSLControlFlowHintAttr(A))
3230     return false;
3231   return true;
3232 }
3233 
3234 template <typename Derived>
3235 bool VISITORCLASS<Derived>::TraverseHLSLGroupSharedAddressSpaceAttr(HLSLGroupSharedAddressSpaceAttr *A) {
3236   if (!getDerived().VisitAttr(A))
3237     return false;
3238   if (!getDerived().VisitHLSLGroupSharedAddressSpaceAttr(A))
3239     return false;
3240   return true;
3241 }
3242 
3243 template <typename Derived>
3244 bool VISITORCLASS<Derived>::TraverseHLSLLoopHintAttr(HLSLLoopHintAttr *A) {
3245   if (!getDerived().VisitAttr(A))
3246     return false;
3247   if (!getDerived().VisitHLSLLoopHintAttr(A))
3248     return false;
3249   return true;
3250 }
3251 
3252 template <typename Derived>
3253 bool VISITORCLASS<Derived>::TraverseHLSLNumThreadsAttr(HLSLNumThreadsAttr *A) {
3254   if (!getDerived().VisitAttr(A))
3255     return false;
3256   if (!getDerived().VisitHLSLNumThreadsAttr(A))
3257     return false;
3258   return true;
3259 }
3260 
3261 template <typename Derived>
3262 bool VISITORCLASS<Derived>::TraverseHLSLPackOffsetAttr(HLSLPackOffsetAttr *A) {
3263   if (!getDerived().VisitAttr(A))
3264     return false;
3265   if (!getDerived().VisitHLSLPackOffsetAttr(A))
3266     return false;
3267   return true;
3268 }
3269 
3270 template <typename Derived>
3271 bool VISITORCLASS<Derived>::TraverseHLSLParamModifierAttr(HLSLParamModifierAttr *A) {
3272   if (!getDerived().VisitAttr(A))
3273     return false;
3274   if (!getDerived().VisitHLSLParamModifierAttr(A))
3275     return false;
3276   return true;
3277 }
3278 
3279 template <typename Derived>
3280 bool VISITORCLASS<Derived>::TraverseHLSLROVAttr(HLSLROVAttr *A) {
3281   if (!getDerived().VisitAttr(A))
3282     return false;
3283   if (!getDerived().VisitHLSLROVAttr(A))
3284     return false;
3285   return true;
3286 }
3287 
3288 template <typename Derived>
3289 bool VISITORCLASS<Derived>::TraverseHLSLRawBufferAttr(HLSLRawBufferAttr *A) {
3290   if (!getDerived().VisitAttr(A))
3291     return false;
3292   if (!getDerived().VisitHLSLRawBufferAttr(A))
3293     return false;
3294   return true;
3295 }
3296 
3297 template <typename Derived>
3298 bool VISITORCLASS<Derived>::TraverseHLSLResourceAttr(HLSLResourceAttr *A) {
3299   if (!getDerived().VisitAttr(A))
3300     return false;
3301   if (!getDerived().VisitHLSLResourceAttr(A))
3302     return false;
3303   return true;
3304 }
3305 
3306 template <typename Derived>
3307 bool VISITORCLASS<Derived>::TraverseHLSLResourceBindingAttr(HLSLResourceBindingAttr *A) {
3308   if (!getDerived().VisitAttr(A))
3309     return false;
3310   if (!getDerived().VisitHLSLResourceBindingAttr(A))
3311     return false;
3312   return true;
3313 }
3314 
3315 template <typename Derived>
3316 bool VISITORCLASS<Derived>::TraverseHLSLResourceClassAttr(HLSLResourceClassAttr *A) {
3317   if (!getDerived().VisitAttr(A))
3318     return false;
3319   if (!getDerived().VisitHLSLResourceClassAttr(A))
3320     return false;
3321   return true;
3322 }
3323 
3324 template <typename Derived>
3325 bool VISITORCLASS<Derived>::TraverseHLSLSV_DispatchThreadIDAttr(HLSLSV_DispatchThreadIDAttr *A) {
3326   if (!getDerived().VisitAttr(A))
3327     return false;
3328   if (!getDerived().VisitHLSLSV_DispatchThreadIDAttr(A))
3329     return false;
3330   return true;
3331 }
3332 
3333 template <typename Derived>
3334 bool VISITORCLASS<Derived>::TraverseHLSLSV_GroupIDAttr(HLSLSV_GroupIDAttr *A) {
3335   if (!getDerived().VisitAttr(A))
3336     return false;
3337   if (!getDerived().VisitHLSLSV_GroupIDAttr(A))
3338     return false;
3339   return true;
3340 }
3341 
3342 template <typename Derived>
3343 bool VISITORCLASS<Derived>::TraverseHLSLSV_GroupIndexAttr(HLSLSV_GroupIndexAttr *A) {
3344   if (!getDerived().VisitAttr(A))
3345     return false;
3346   if (!getDerived().VisitHLSLSV_GroupIndexAttr(A))
3347     return false;
3348   return true;
3349 }
3350 
3351 template <typename Derived>
3352 bool VISITORCLASS<Derived>::TraverseHLSLSV_GroupThreadIDAttr(HLSLSV_GroupThreadIDAttr *A) {
3353   if (!getDerived().VisitAttr(A))
3354     return false;
3355   if (!getDerived().VisitHLSLSV_GroupThreadIDAttr(A))
3356     return false;
3357   return true;
3358 }
3359 
3360 template <typename Derived>
3361 bool VISITORCLASS<Derived>::TraverseHLSLShaderAttr(HLSLShaderAttr *A) {
3362   if (!getDerived().VisitAttr(A))
3363     return false;
3364   if (!getDerived().VisitHLSLShaderAttr(A))
3365     return false;
3366   return true;
3367 }
3368 
3369 template <typename Derived>
3370 bool VISITORCLASS<Derived>::TraverseHLSLWaveSizeAttr(HLSLWaveSizeAttr *A) {
3371   if (!getDerived().VisitAttr(A))
3372     return false;
3373   if (!getDerived().VisitHLSLWaveSizeAttr(A))
3374     return false;
3375   return true;
3376 }
3377 
3378 template <typename Derived>
3379 bool VISITORCLASS<Derived>::TraverseHotAttr(HotAttr *A) {
3380   if (!getDerived().VisitAttr(A))
3381     return false;
3382   if (!getDerived().VisitHotAttr(A))
3383     return false;
3384   return true;
3385 }
3386 
3387 template <typename Derived>
3388 bool VISITORCLASS<Derived>::TraverseHybridPatchableAttr(HybridPatchableAttr *A) {
3389   if (!getDerived().VisitAttr(A))
3390     return false;
3391   if (!getDerived().VisitHybridPatchableAttr(A))
3392     return false;
3393   return true;
3394 }
3395 
3396 template <typename Derived>
3397 bool VISITORCLASS<Derived>::TraverseIBActionAttr(IBActionAttr *A) {
3398   if (!getDerived().VisitAttr(A))
3399     return false;
3400   if (!getDerived().VisitIBActionAttr(A))
3401     return false;
3402   return true;
3403 }
3404 
3405 template <typename Derived>
3406 bool VISITORCLASS<Derived>::TraverseIBOutletAttr(IBOutletAttr *A) {
3407   if (!getDerived().VisitAttr(A))
3408     return false;
3409   if (!getDerived().VisitIBOutletAttr(A))
3410     return false;
3411   return true;
3412 }
3413 
3414 template <typename Derived>
3415 bool VISITORCLASS<Derived>::TraverseIBOutletCollectionAttr(IBOutletCollectionAttr *A) {
3416   if (!getDerived().VisitAttr(A))
3417     return false;
3418   if (!getDerived().VisitIBOutletCollectionAttr(A))
3419     return false;
3420   if (auto *TSI = A->getInterfaceLoc())
3421     if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
3422       return false;
3423   return true;
3424 }
3425 
3426 template <typename Derived>
3427 bool VISITORCLASS<Derived>::TraverseIFuncAttr(IFuncAttr *A) {
3428   if (!getDerived().VisitAttr(A))
3429     return false;
3430   if (!getDerived().VisitIFuncAttr(A))
3431     return false;
3432   return true;
3433 }
3434 
3435 template <typename Derived>
3436 bool VISITORCLASS<Derived>::TraverseInitPriorityAttr(InitPriorityAttr *A) {
3437   if (!getDerived().VisitAttr(A))
3438     return false;
3439   if (!getDerived().VisitInitPriorityAttr(A))
3440     return false;
3441   return true;
3442 }
3443 
3444 template <typename Derived>
3445 bool VISITORCLASS<Derived>::TraverseInitSegAttr(InitSegAttr *A) {
3446   if (!getDerived().VisitAttr(A))
3447     return false;
3448   if (!getDerived().VisitInitSegAttr(A))
3449     return false;
3450   return true;
3451 }
3452 
3453 template <typename Derived>
3454 bool VISITORCLASS<Derived>::TraverseIntelOclBiccAttr(IntelOclBiccAttr *A) {
3455   if (!getDerived().VisitAttr(A))
3456     return false;
3457   if (!getDerived().VisitIntelOclBiccAttr(A))
3458     return false;
3459   return true;
3460 }
3461 
3462 template <typename Derived>
3463 bool VISITORCLASS<Derived>::TraverseInternalLinkageAttr(InternalLinkageAttr *A) {
3464   if (!getDerived().VisitAttr(A))
3465     return false;
3466   if (!getDerived().VisitInternalLinkageAttr(A))
3467     return false;
3468   return true;
3469 }
3470 
3471 template <typename Derived>
3472 bool VISITORCLASS<Derived>::TraverseLTOVisibilityPublicAttr(LTOVisibilityPublicAttr *A) {
3473   if (!getDerived().VisitAttr(A))
3474     return false;
3475   if (!getDerived().VisitLTOVisibilityPublicAttr(A))
3476     return false;
3477   return true;
3478 }
3479 
3480 template <typename Derived>
3481 bool VISITORCLASS<Derived>::TraverseLayoutVersionAttr(LayoutVersionAttr *A) {
3482   if (!getDerived().VisitAttr(A))
3483     return false;
3484   if (!getDerived().VisitLayoutVersionAttr(A))
3485     return false;
3486   return true;
3487 }
3488 
3489 template <typename Derived>
3490 bool VISITORCLASS<Derived>::TraverseLeafAttr(LeafAttr *A) {
3491   if (!getDerived().VisitAttr(A))
3492     return false;
3493   if (!getDerived().VisitLeafAttr(A))
3494     return false;
3495   return true;
3496 }
3497 
3498 template <typename Derived>
3499 bool VISITORCLASS<Derived>::TraverseLifetimeBoundAttr(LifetimeBoundAttr *A) {
3500   if (!getDerived().VisitAttr(A))
3501     return false;
3502   if (!getDerived().VisitLifetimeBoundAttr(A))
3503     return false;
3504   return true;
3505 }
3506 
3507 template <typename Derived>
3508 bool VISITORCLASS<Derived>::TraverseLifetimeCaptureByAttr(LifetimeCaptureByAttr *A) {
3509   if (!getDerived().VisitAttr(A))
3510     return false;
3511   if (!getDerived().VisitLifetimeCaptureByAttr(A))
3512     return false;
3513   return true;
3514 }
3515 
3516 template <typename Derived>
3517 bool VISITORCLASS<Derived>::TraverseLikelyAttr(LikelyAttr *A) {
3518   if (!getDerived().VisitAttr(A))
3519     return false;
3520   if (!getDerived().VisitLikelyAttr(A))
3521     return false;
3522   return true;
3523 }
3524 
3525 template <typename Derived>
3526 bool VISITORCLASS<Derived>::TraverseLoaderUninitializedAttr(LoaderUninitializedAttr *A) {
3527   if (!getDerived().VisitAttr(A))
3528     return false;
3529   if (!getDerived().VisitLoaderUninitializedAttr(A))
3530     return false;
3531   return true;
3532 }
3533 
3534 template <typename Derived>
3535 bool VISITORCLASS<Derived>::TraverseLockReturnedAttr(LockReturnedAttr *A) {
3536   if (!getDerived().VisitAttr(A))
3537     return false;
3538   if (!getDerived().VisitLockReturnedAttr(A))
3539     return false;
3540   if (!getDerived().TraverseStmt(A->getArg()))
3541     return false;
3542   return true;
3543 }
3544 
3545 template <typename Derived>
3546 bool VISITORCLASS<Derived>::TraverseLocksExcludedAttr(LocksExcludedAttr *A) {
3547   if (!getDerived().VisitAttr(A))
3548     return false;
3549   if (!getDerived().VisitLocksExcludedAttr(A))
3550     return false;
3551   {
3552     Expr * *I = A->args_begin();
3553     Expr * *E = A->args_end();
3554     for (; I != E; ++I) {
3555       if (!getDerived().TraverseStmt(*I))
3556         return false;
3557     }
3558   }
3559   return true;
3560 }
3561 
3562 template <typename Derived>
3563 bool VISITORCLASS<Derived>::TraverseLoopHintAttr(LoopHintAttr *A) {
3564   if (!getDerived().VisitAttr(A))
3565     return false;
3566   if (!getDerived().VisitLoopHintAttr(A))
3567     return false;
3568   if (!getDerived().TraverseStmt(A->getValue()))
3569     return false;
3570   return true;
3571 }
3572 
3573 template <typename Derived>
3574 bool VISITORCLASS<Derived>::TraverseM68kInterruptAttr(M68kInterruptAttr *A) {
3575   if (!getDerived().VisitAttr(A))
3576     return false;
3577   if (!getDerived().VisitM68kInterruptAttr(A))
3578     return false;
3579   return true;
3580 }
3581 
3582 template <typename Derived>
3583 bool VISITORCLASS<Derived>::TraverseM68kRTDAttr(M68kRTDAttr *A) {
3584   if (!getDerived().VisitAttr(A))
3585     return false;
3586   if (!getDerived().VisitM68kRTDAttr(A))
3587     return false;
3588   return true;
3589 }
3590 
3591 template <typename Derived>
3592 bool VISITORCLASS<Derived>::TraverseMIGServerRoutineAttr(MIGServerRoutineAttr *A) {
3593   if (!getDerived().VisitAttr(A))
3594     return false;
3595   if (!getDerived().VisitMIGServerRoutineAttr(A))
3596     return false;
3597   return true;
3598 }
3599 
3600 template <typename Derived>
3601 bool VISITORCLASS<Derived>::TraverseMSABIAttr(MSABIAttr *A) {
3602   if (!getDerived().VisitAttr(A))
3603     return false;
3604   if (!getDerived().VisitMSABIAttr(A))
3605     return false;
3606   return true;
3607 }
3608 
3609 template <typename Derived>
3610 bool VISITORCLASS<Derived>::TraverseMSAllocatorAttr(MSAllocatorAttr *A) {
3611   if (!getDerived().VisitAttr(A))
3612     return false;
3613   if (!getDerived().VisitMSAllocatorAttr(A))
3614     return false;
3615   return true;
3616 }
3617 
3618 template <typename Derived>
3619 bool VISITORCLASS<Derived>::TraverseMSConstexprAttr(MSConstexprAttr *A) {
3620   if (!getDerived().VisitAttr(A))
3621     return false;
3622   if (!getDerived().VisitMSConstexprAttr(A))
3623     return false;
3624   return true;
3625 }
3626 
3627 template <typename Derived>
3628 bool VISITORCLASS<Derived>::TraverseMSInheritanceAttr(MSInheritanceAttr *A) {
3629   if (!getDerived().VisitAttr(A))
3630     return false;
3631   if (!getDerived().VisitMSInheritanceAttr(A))
3632     return false;
3633   return true;
3634 }
3635 
3636 template <typename Derived>
3637 bool VISITORCLASS<Derived>::TraverseMSNoVTableAttr(MSNoVTableAttr *A) {
3638   if (!getDerived().VisitAttr(A))
3639     return false;
3640   if (!getDerived().VisitMSNoVTableAttr(A))
3641     return false;
3642   return true;
3643 }
3644 
3645 template <typename Derived>
3646 bool VISITORCLASS<Derived>::TraverseMSP430InterruptAttr(MSP430InterruptAttr *A) {
3647   if (!getDerived().VisitAttr(A))
3648     return false;
3649   if (!getDerived().VisitMSP430InterruptAttr(A))
3650     return false;
3651   return true;
3652 }
3653 
3654 template <typename Derived>
3655 bool VISITORCLASS<Derived>::TraverseMSStructAttr(MSStructAttr *A) {
3656   if (!getDerived().VisitAttr(A))
3657     return false;
3658   if (!getDerived().VisitMSStructAttr(A))
3659     return false;
3660   return true;
3661 }
3662 
3663 template <typename Derived>
3664 bool VISITORCLASS<Derived>::TraverseMSVtorDispAttr(MSVtorDispAttr *A) {
3665   if (!getDerived().VisitAttr(A))
3666     return false;
3667   if (!getDerived().VisitMSVtorDispAttr(A))
3668     return false;
3669   return true;
3670 }
3671 
3672 template <typename Derived>
3673 bool VISITORCLASS<Derived>::TraverseMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A) {
3674   if (!getDerived().VisitAttr(A))
3675     return false;
3676   if (!getDerived().VisitMaxFieldAlignmentAttr(A))
3677     return false;
3678   return true;
3679 }
3680 
3681 template <typename Derived>
3682 bool VISITORCLASS<Derived>::TraverseMayAliasAttr(MayAliasAttr *A) {
3683   if (!getDerived().VisitAttr(A))
3684     return false;
3685   if (!getDerived().VisitMayAliasAttr(A))
3686     return false;
3687   return true;
3688 }
3689 
3690 template <typename Derived>
3691 bool VISITORCLASS<Derived>::TraverseMaybeUndefAttr(MaybeUndefAttr *A) {
3692   if (!getDerived().VisitAttr(A))
3693     return false;
3694   if (!getDerived().VisitMaybeUndefAttr(A))
3695     return false;
3696   return true;
3697 }
3698 
3699 template <typename Derived>
3700 bool VISITORCLASS<Derived>::TraverseMicroMipsAttr(MicroMipsAttr *A) {
3701   if (!getDerived().VisitAttr(A))
3702     return false;
3703   if (!getDerived().VisitMicroMipsAttr(A))
3704     return false;
3705   return true;
3706 }
3707 
3708 template <typename Derived>
3709 bool VISITORCLASS<Derived>::TraverseMinSizeAttr(MinSizeAttr *A) {
3710   if (!getDerived().VisitAttr(A))
3711     return false;
3712   if (!getDerived().VisitMinSizeAttr(A))
3713     return false;
3714   return true;
3715 }
3716 
3717 template <typename Derived>
3718 bool VISITORCLASS<Derived>::TraverseMinVectorWidthAttr(MinVectorWidthAttr *A) {
3719   if (!getDerived().VisitAttr(A))
3720     return false;
3721   if (!getDerived().VisitMinVectorWidthAttr(A))
3722     return false;
3723   return true;
3724 }
3725 
3726 template <typename Derived>
3727 bool VISITORCLASS<Derived>::TraverseMips16Attr(Mips16Attr *A) {
3728   if (!getDerived().VisitAttr(A))
3729     return false;
3730   if (!getDerived().VisitMips16Attr(A))
3731     return false;
3732   return true;
3733 }
3734 
3735 template <typename Derived>
3736 bool VISITORCLASS<Derived>::TraverseMipsInterruptAttr(MipsInterruptAttr *A) {
3737   if (!getDerived().VisitAttr(A))
3738     return false;
3739   if (!getDerived().VisitMipsInterruptAttr(A))
3740     return false;
3741   return true;
3742 }
3743 
3744 template <typename Derived>
3745 bool VISITORCLASS<Derived>::TraverseMipsLongCallAttr(MipsLongCallAttr *A) {
3746   if (!getDerived().VisitAttr(A))
3747     return false;
3748   if (!getDerived().VisitMipsLongCallAttr(A))
3749     return false;
3750   return true;
3751 }
3752 
3753 template <typename Derived>
3754 bool VISITORCLASS<Derived>::TraverseMipsShortCallAttr(MipsShortCallAttr *A) {
3755   if (!getDerived().VisitAttr(A))
3756     return false;
3757   if (!getDerived().VisitMipsShortCallAttr(A))
3758     return false;
3759   return true;
3760 }
3761 
3762 template <typename Derived>
3763 bool VISITORCLASS<Derived>::TraverseModeAttr(ModeAttr *A) {
3764   if (!getDerived().VisitAttr(A))
3765     return false;
3766   if (!getDerived().VisitModeAttr(A))
3767     return false;
3768   return true;
3769 }
3770 
3771 template <typename Derived>
3772 bool VISITORCLASS<Derived>::TraverseMustTailAttr(MustTailAttr *A) {
3773   if (!getDerived().VisitAttr(A))
3774     return false;
3775   if (!getDerived().VisitMustTailAttr(A))
3776     return false;
3777   return true;
3778 }
3779 
3780 template <typename Derived>
3781 bool VISITORCLASS<Derived>::TraverseNSConsumedAttr(NSConsumedAttr *A) {
3782   if (!getDerived().VisitAttr(A))
3783     return false;
3784   if (!getDerived().VisitNSConsumedAttr(A))
3785     return false;
3786   return true;
3787 }
3788 
3789 template <typename Derived>
3790 bool VISITORCLASS<Derived>::TraverseNSConsumesSelfAttr(NSConsumesSelfAttr *A) {
3791   if (!getDerived().VisitAttr(A))
3792     return false;
3793   if (!getDerived().VisitNSConsumesSelfAttr(A))
3794     return false;
3795   return true;
3796 }
3797 
3798 template <typename Derived>
3799 bool VISITORCLASS<Derived>::TraverseNSErrorDomainAttr(NSErrorDomainAttr *A) {
3800   if (!getDerived().VisitAttr(A))
3801     return false;
3802   if (!getDerived().VisitNSErrorDomainAttr(A))
3803     return false;
3804   return true;
3805 }
3806 
3807 template <typename Derived>
3808 bool VISITORCLASS<Derived>::TraverseNSReturnsAutoreleasedAttr(NSReturnsAutoreleasedAttr *A) {
3809   if (!getDerived().VisitAttr(A))
3810     return false;
3811   if (!getDerived().VisitNSReturnsAutoreleasedAttr(A))
3812     return false;
3813   return true;
3814 }
3815 
3816 template <typename Derived>
3817 bool VISITORCLASS<Derived>::TraverseNSReturnsNotRetainedAttr(NSReturnsNotRetainedAttr *A) {
3818   if (!getDerived().VisitAttr(A))
3819     return false;
3820   if (!getDerived().VisitNSReturnsNotRetainedAttr(A))
3821     return false;
3822   return true;
3823 }
3824 
3825 template <typename Derived>
3826 bool VISITORCLASS<Derived>::TraverseNSReturnsRetainedAttr(NSReturnsRetainedAttr *A) {
3827   if (!getDerived().VisitAttr(A))
3828     return false;
3829   if (!getDerived().VisitNSReturnsRetainedAttr(A))
3830     return false;
3831   return true;
3832 }
3833 
3834 template <typename Derived>
3835 bool VISITORCLASS<Derived>::TraverseNVPTXKernelAttr(NVPTXKernelAttr *A) {
3836   if (!getDerived().VisitAttr(A))
3837     return false;
3838   if (!getDerived().VisitNVPTXKernelAttr(A))
3839     return false;
3840   return true;
3841 }
3842 
3843 template <typename Derived>
3844 bool VISITORCLASS<Derived>::TraverseNakedAttr(NakedAttr *A) {
3845   if (!getDerived().VisitAttr(A))
3846     return false;
3847   if (!getDerived().VisitNakedAttr(A))
3848     return false;
3849   return true;
3850 }
3851 
3852 template <typename Derived>
3853 bool VISITORCLASS<Derived>::TraverseNoAliasAttr(NoAliasAttr *A) {
3854   if (!getDerived().VisitAttr(A))
3855     return false;
3856   if (!getDerived().VisitNoAliasAttr(A))
3857     return false;
3858   return true;
3859 }
3860 
3861 template <typename Derived>
3862 bool VISITORCLASS<Derived>::TraverseNoBuiltinAttr(NoBuiltinAttr *A) {
3863   if (!getDerived().VisitAttr(A))
3864     return false;
3865   if (!getDerived().VisitNoBuiltinAttr(A))
3866     return false;
3867   return true;
3868 }
3869 
3870 template <typename Derived>
3871 bool VISITORCLASS<Derived>::TraverseNoCommonAttr(NoCommonAttr *A) {
3872   if (!getDerived().VisitAttr(A))
3873     return false;
3874   if (!getDerived().VisitNoCommonAttr(A))
3875     return false;
3876   return true;
3877 }
3878 
3879 template <typename Derived>
3880 bool VISITORCLASS<Derived>::TraverseNoConvergentAttr(NoConvergentAttr *A) {
3881   if (!getDerived().VisitAttr(A))
3882     return false;
3883   if (!getDerived().VisitNoConvergentAttr(A))
3884     return false;
3885   return true;
3886 }
3887 
3888 template <typename Derived>
3889 bool VISITORCLASS<Derived>::TraverseNoDebugAttr(NoDebugAttr *A) {
3890   if (!getDerived().VisitAttr(A))
3891     return false;
3892   if (!getDerived().VisitNoDebugAttr(A))
3893     return false;
3894   return true;
3895 }
3896 
3897 template <typename Derived>
3898 bool VISITORCLASS<Derived>::TraverseNoDerefAttr(NoDerefAttr *A) {
3899   if (!getDerived().VisitAttr(A))
3900     return false;
3901   if (!getDerived().VisitNoDerefAttr(A))
3902     return false;
3903   return true;
3904 }
3905 
3906 template <typename Derived>
3907 bool VISITORCLASS<Derived>::TraverseNoDestroyAttr(NoDestroyAttr *A) {
3908   if (!getDerived().VisitAttr(A))
3909     return false;
3910   if (!getDerived().VisitNoDestroyAttr(A))
3911     return false;
3912   return true;
3913 }
3914 
3915 template <typename Derived>
3916 bool VISITORCLASS<Derived>::TraverseNoDuplicateAttr(NoDuplicateAttr *A) {
3917   if (!getDerived().VisitAttr(A))
3918     return false;
3919   if (!getDerived().VisitNoDuplicateAttr(A))
3920     return false;
3921   return true;
3922 }
3923 
3924 template <typename Derived>
3925 bool VISITORCLASS<Derived>::TraverseNoEscapeAttr(NoEscapeAttr *A) {
3926   if (!getDerived().VisitAttr(A))
3927     return false;
3928   if (!getDerived().VisitNoEscapeAttr(A))
3929     return false;
3930   return true;
3931 }
3932 
3933 template <typename Derived>
3934 bool VISITORCLASS<Derived>::TraverseNoInlineAttr(NoInlineAttr *A) {
3935   if (!getDerived().VisitAttr(A))
3936     return false;
3937   if (!getDerived().VisitNoInlineAttr(A))
3938     return false;
3939   return true;
3940 }
3941 
3942 template <typename Derived>
3943 bool VISITORCLASS<Derived>::TraverseNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A) {
3944   if (!getDerived().VisitAttr(A))
3945     return false;
3946   if (!getDerived().VisitNoInstrumentFunctionAttr(A))
3947     return false;
3948   return true;
3949 }
3950 
3951 template <typename Derived>
3952 bool VISITORCLASS<Derived>::TraverseNoMergeAttr(NoMergeAttr *A) {
3953   if (!getDerived().VisitAttr(A))
3954     return false;
3955   if (!getDerived().VisitNoMergeAttr(A))
3956     return false;
3957   return true;
3958 }
3959 
3960 template <typename Derived>
3961 bool VISITORCLASS<Derived>::TraverseNoMicroMipsAttr(NoMicroMipsAttr *A) {
3962   if (!getDerived().VisitAttr(A))
3963     return false;
3964   if (!getDerived().VisitNoMicroMipsAttr(A))
3965     return false;
3966   return true;
3967 }
3968 
3969 template <typename Derived>
3970 bool VISITORCLASS<Derived>::TraverseNoMips16Attr(NoMips16Attr *A) {
3971   if (!getDerived().VisitAttr(A))
3972     return false;
3973   if (!getDerived().VisitNoMips16Attr(A))
3974     return false;
3975   return true;
3976 }
3977 
3978 template <typename Derived>
3979 bool VISITORCLASS<Derived>::TraverseNoProfileFunctionAttr(NoProfileFunctionAttr *A) {
3980   if (!getDerived().VisitAttr(A))
3981     return false;
3982   if (!getDerived().VisitNoProfileFunctionAttr(A))
3983     return false;
3984   return true;
3985 }
3986 
3987 template <typename Derived>
3988 bool VISITORCLASS<Derived>::TraverseNoRandomizeLayoutAttr(NoRandomizeLayoutAttr *A) {
3989   if (!getDerived().VisitAttr(A))
3990     return false;
3991   if (!getDerived().VisitNoRandomizeLayoutAttr(A))
3992     return false;
3993   return true;
3994 }
3995 
3996 template <typename Derived>
3997 bool VISITORCLASS<Derived>::TraverseNoReturnAttr(NoReturnAttr *A) {
3998   if (!getDerived().VisitAttr(A))
3999     return false;
4000   if (!getDerived().VisitNoReturnAttr(A))
4001     return false;
4002   return true;
4003 }
4004 
4005 template <typename Derived>
4006 bool VISITORCLASS<Derived>::TraverseNoSanitizeAttr(NoSanitizeAttr *A) {
4007   if (!getDerived().VisitAttr(A))
4008     return false;
4009   if (!getDerived().VisitNoSanitizeAttr(A))
4010     return false;
4011   return true;
4012 }
4013 
4014 template <typename Derived>
4015 bool VISITORCLASS<Derived>::TraverseNoSpecializationsAttr(NoSpecializationsAttr *A) {
4016   if (!getDerived().VisitAttr(A))
4017     return false;
4018   if (!getDerived().VisitNoSpecializationsAttr(A))
4019     return false;
4020   return true;
4021 }
4022 
4023 template <typename Derived>
4024 bool VISITORCLASS<Derived>::TraverseNoSpeculativeLoadHardeningAttr(NoSpeculativeLoadHardeningAttr *A) {
4025   if (!getDerived().VisitAttr(A))
4026     return false;
4027   if (!getDerived().VisitNoSpeculativeLoadHardeningAttr(A))
4028     return false;
4029   return true;
4030 }
4031 
4032 template <typename Derived>
4033 bool VISITORCLASS<Derived>::TraverseNoSplitStackAttr(NoSplitStackAttr *A) {
4034   if (!getDerived().VisitAttr(A))
4035     return false;
4036   if (!getDerived().VisitNoSplitStackAttr(A))
4037     return false;
4038   return true;
4039 }
4040 
4041 template <typename Derived>
4042 bool VISITORCLASS<Derived>::TraverseNoStackProtectorAttr(NoStackProtectorAttr *A) {
4043   if (!getDerived().VisitAttr(A))
4044     return false;
4045   if (!getDerived().VisitNoStackProtectorAttr(A))
4046     return false;
4047   return true;
4048 }
4049 
4050 template <typename Derived>
4051 bool VISITORCLASS<Derived>::TraverseNoThreadSafetyAnalysisAttr(NoThreadSafetyAnalysisAttr *A) {
4052   if (!getDerived().VisitAttr(A))
4053     return false;
4054   if (!getDerived().VisitNoThreadSafetyAnalysisAttr(A))
4055     return false;
4056   return true;
4057 }
4058 
4059 template <typename Derived>
4060 bool VISITORCLASS<Derived>::TraverseNoThrowAttr(NoThrowAttr *A) {
4061   if (!getDerived().VisitAttr(A))
4062     return false;
4063   if (!getDerived().VisitNoThrowAttr(A))
4064     return false;
4065   return true;
4066 }
4067 
4068 template <typename Derived>
4069 bool VISITORCLASS<Derived>::TraverseNoTrivialAutoVarInitAttr(NoTrivialAutoVarInitAttr *A) {
4070   if (!getDerived().VisitAttr(A))
4071     return false;
4072   if (!getDerived().VisitNoTrivialAutoVarInitAttr(A))
4073     return false;
4074   return true;
4075 }
4076 
4077 template <typename Derived>
4078 bool VISITORCLASS<Derived>::TraverseNoUniqueAddressAttr(NoUniqueAddressAttr *A) {
4079   if (!getDerived().VisitAttr(A))
4080     return false;
4081   if (!getDerived().VisitNoUniqueAddressAttr(A))
4082     return false;
4083   return true;
4084 }
4085 
4086 template <typename Derived>
4087 bool VISITORCLASS<Derived>::TraverseNoUwtableAttr(NoUwtableAttr *A) {
4088   if (!getDerived().VisitAttr(A))
4089     return false;
4090   if (!getDerived().VisitNoUwtableAttr(A))
4091     return false;
4092   return true;
4093 }
4094 
4095 template <typename Derived>
4096 bool VISITORCLASS<Derived>::TraverseNonAllocatingAttr(NonAllocatingAttr *A) {
4097   if (!getDerived().VisitAttr(A))
4098     return false;
4099   if (!getDerived().VisitNonAllocatingAttr(A))
4100     return false;
4101   if (!getDerived().TraverseStmt(A->getCond()))
4102     return false;
4103   return true;
4104 }
4105 
4106 template <typename Derived>
4107 bool VISITORCLASS<Derived>::TraverseNonBlockingAttr(NonBlockingAttr *A) {
4108   if (!getDerived().VisitAttr(A))
4109     return false;
4110   if (!getDerived().VisitNonBlockingAttr(A))
4111     return false;
4112   if (!getDerived().TraverseStmt(A->getCond()))
4113     return false;
4114   return true;
4115 }
4116 
4117 template <typename Derived>
4118 bool VISITORCLASS<Derived>::TraverseNonNullAttr(NonNullAttr *A) {
4119   if (!getDerived().VisitAttr(A))
4120     return false;
4121   if (!getDerived().VisitNonNullAttr(A))
4122     return false;
4123   return true;
4124 }
4125 
4126 template <typename Derived>
4127 bool VISITORCLASS<Derived>::TraverseNotTailCalledAttr(NotTailCalledAttr *A) {
4128   if (!getDerived().VisitAttr(A))
4129     return false;
4130   if (!getDerived().VisitNotTailCalledAttr(A))
4131     return false;
4132   return true;
4133 }
4134 
4135 template <typename Derived>
4136 bool VISITORCLASS<Derived>::TraverseOMPAllocateDeclAttr(OMPAllocateDeclAttr *A) {
4137   if (!getDerived().VisitAttr(A))
4138     return false;
4139   if (!getDerived().VisitOMPAllocateDeclAttr(A))
4140     return false;
4141   if (!getDerived().TraverseStmt(A->getAllocator()))
4142     return false;
4143   if (!getDerived().TraverseStmt(A->getAlignment()))
4144     return false;
4145   return true;
4146 }
4147 
4148 template <typename Derived>
4149 bool VISITORCLASS<Derived>::TraverseOMPAssumeAttr(OMPAssumeAttr *A) {
4150   if (!getDerived().VisitAttr(A))
4151     return false;
4152   if (!getDerived().VisitOMPAssumeAttr(A))
4153     return false;
4154   return true;
4155 }
4156 
4157 template <typename Derived>
4158 bool VISITORCLASS<Derived>::TraverseOMPCaptureKindAttr(OMPCaptureKindAttr *A) {
4159   if (!getDerived().VisitAttr(A))
4160     return false;
4161   if (!getDerived().VisitOMPCaptureKindAttr(A))
4162     return false;
4163   return true;
4164 }
4165 
4166 template <typename Derived>
4167 bool VISITORCLASS<Derived>::TraverseOMPCaptureNoInitAttr(OMPCaptureNoInitAttr *A) {
4168   if (!getDerived().VisitAttr(A))
4169     return false;
4170   if (!getDerived().VisitOMPCaptureNoInitAttr(A))
4171     return false;
4172   return true;
4173 }
4174 
4175 template <typename Derived>
4176 bool VISITORCLASS<Derived>::TraverseOMPDeclareSimdDeclAttr(OMPDeclareSimdDeclAttr *A) {
4177   if (!getDerived().VisitAttr(A))
4178     return false;
4179   if (!getDerived().VisitOMPDeclareSimdDeclAttr(A))
4180     return false;
4181   if (!getDerived().TraverseStmt(A->getSimdlen()))
4182     return false;
4183   {
4184     Expr * *I = A->uniforms_begin();
4185     Expr * *E = A->uniforms_end();
4186     for (; I != E; ++I) {
4187       if (!getDerived().TraverseStmt(*I))
4188         return false;
4189     }
4190   }
4191   {
4192     Expr * *I = A->aligneds_begin();
4193     Expr * *E = A->aligneds_end();
4194     for (; I != E; ++I) {
4195       if (!getDerived().TraverseStmt(*I))
4196         return false;
4197     }
4198   }
4199   {
4200     Expr * *I = A->alignments_begin();
4201     Expr * *E = A->alignments_end();
4202     for (; I != E; ++I) {
4203       if (!getDerived().TraverseStmt(*I))
4204         return false;
4205     }
4206   }
4207   {
4208     Expr * *I = A->linears_begin();
4209     Expr * *E = A->linears_end();
4210     for (; I != E; ++I) {
4211       if (!getDerived().TraverseStmt(*I))
4212         return false;
4213     }
4214   }
4215   {
4216     Expr * *I = A->steps_begin();
4217     Expr * *E = A->steps_end();
4218     for (; I != E; ++I) {
4219       if (!getDerived().TraverseStmt(*I))
4220         return false;
4221     }
4222   }
4223   return true;
4224 }
4225 
4226 template <typename Derived>
4227 bool VISITORCLASS<Derived>::TraverseOMPDeclareTargetDeclAttr(OMPDeclareTargetDeclAttr *A) {
4228   if (!getDerived().VisitAttr(A))
4229     return false;
4230   if (!getDerived().VisitOMPDeclareTargetDeclAttr(A))
4231     return false;
4232   if (!getDerived().TraverseStmt(A->getIndirectExpr()))
4233     return false;
4234   return true;
4235 }
4236 
4237 template <typename Derived>
4238 bool VISITORCLASS<Derived>::TraverseOMPDeclareVariantAttr(OMPDeclareVariantAttr *A) {
4239   if (!getDerived().VisitAttr(A))
4240     return false;
4241   if (!getDerived().VisitOMPDeclareVariantAttr(A))
4242     return false;
4243   if (!getDerived().TraverseStmt(A->getVariantFuncRef()))
4244     return false;
4245   {
4246     Expr * *I = A->adjustArgsNothing_begin();
4247     Expr * *E = A->adjustArgsNothing_end();
4248     for (; I != E; ++I) {
4249       if (!getDerived().TraverseStmt(*I))
4250         return false;
4251     }
4252   }
4253   {
4254     Expr * *I = A->adjustArgsNeedDevicePtr_begin();
4255     Expr * *E = A->adjustArgsNeedDevicePtr_end();
4256     for (; I != E; ++I) {
4257       if (!getDerived().TraverseStmt(*I))
4258         return false;
4259     }
4260   }
4261   return true;
4262 }
4263 
4264 template <typename Derived>
4265 bool VISITORCLASS<Derived>::TraverseOMPReferencedVarAttr(OMPReferencedVarAttr *A) {
4266   if (!getDerived().VisitAttr(A))
4267     return false;
4268   if (!getDerived().VisitOMPReferencedVarAttr(A))
4269     return false;
4270   if (!getDerived().TraverseStmt(A->getRef()))
4271     return false;
4272   return true;
4273 }
4274 
4275 template <typename Derived>
4276 bool VISITORCLASS<Derived>::TraverseOMPThreadPrivateDeclAttr(OMPThreadPrivateDeclAttr *A) {
4277   if (!getDerived().VisitAttr(A))
4278     return false;
4279   if (!getDerived().VisitOMPThreadPrivateDeclAttr(A))
4280     return false;
4281   return true;
4282 }
4283 
4284 template <typename Derived>
4285 bool VISITORCLASS<Derived>::TraverseOSConsumedAttr(OSConsumedAttr *A) {
4286   if (!getDerived().VisitAttr(A))
4287     return false;
4288   if (!getDerived().VisitOSConsumedAttr(A))
4289     return false;
4290   return true;
4291 }
4292 
4293 template <typename Derived>
4294 bool VISITORCLASS<Derived>::TraverseOSConsumesThisAttr(OSConsumesThisAttr *A) {
4295   if (!getDerived().VisitAttr(A))
4296     return false;
4297   if (!getDerived().VisitOSConsumesThisAttr(A))
4298     return false;
4299   return true;
4300 }
4301 
4302 template <typename Derived>
4303 bool VISITORCLASS<Derived>::TraverseOSReturnsNotRetainedAttr(OSReturnsNotRetainedAttr *A) {
4304   if (!getDerived().VisitAttr(A))
4305     return false;
4306   if (!getDerived().VisitOSReturnsNotRetainedAttr(A))
4307     return false;
4308   return true;
4309 }
4310 
4311 template <typename Derived>
4312 bool VISITORCLASS<Derived>::TraverseOSReturnsRetainedAttr(OSReturnsRetainedAttr *A) {
4313   if (!getDerived().VisitAttr(A))
4314     return false;
4315   if (!getDerived().VisitOSReturnsRetainedAttr(A))
4316     return false;
4317   return true;
4318 }
4319 
4320 template <typename Derived>
4321 bool VISITORCLASS<Derived>::TraverseOSReturnsRetainedOnNonZeroAttr(OSReturnsRetainedOnNonZeroAttr *A) {
4322   if (!getDerived().VisitAttr(A))
4323     return false;
4324   if (!getDerived().VisitOSReturnsRetainedOnNonZeroAttr(A))
4325     return false;
4326   return true;
4327 }
4328 
4329 template <typename Derived>
4330 bool VISITORCLASS<Derived>::TraverseOSReturnsRetainedOnZeroAttr(OSReturnsRetainedOnZeroAttr *A) {
4331   if (!getDerived().VisitAttr(A))
4332     return false;
4333   if (!getDerived().VisitOSReturnsRetainedOnZeroAttr(A))
4334     return false;
4335   return true;
4336 }
4337 
4338 template <typename Derived>
4339 bool VISITORCLASS<Derived>::TraverseObjCBoxableAttr(ObjCBoxableAttr *A) {
4340   if (!getDerived().VisitAttr(A))
4341     return false;
4342   if (!getDerived().VisitObjCBoxableAttr(A))
4343     return false;
4344   return true;
4345 }
4346 
4347 template <typename Derived>
4348 bool VISITORCLASS<Derived>::TraverseObjCBridgeAttr(ObjCBridgeAttr *A) {
4349   if (!getDerived().VisitAttr(A))
4350     return false;
4351   if (!getDerived().VisitObjCBridgeAttr(A))
4352     return false;
4353   return true;
4354 }
4355 
4356 template <typename Derived>
4357 bool VISITORCLASS<Derived>::TraverseObjCBridgeMutableAttr(ObjCBridgeMutableAttr *A) {
4358   if (!getDerived().VisitAttr(A))
4359     return false;
4360   if (!getDerived().VisitObjCBridgeMutableAttr(A))
4361     return false;
4362   return true;
4363 }
4364 
4365 template <typename Derived>
4366 bool VISITORCLASS<Derived>::TraverseObjCBridgeRelatedAttr(ObjCBridgeRelatedAttr *A) {
4367   if (!getDerived().VisitAttr(A))
4368     return false;
4369   if (!getDerived().VisitObjCBridgeRelatedAttr(A))
4370     return false;
4371   return true;
4372 }
4373 
4374 template <typename Derived>
4375 bool VISITORCLASS<Derived>::TraverseObjCClassStubAttr(ObjCClassStubAttr *A) {
4376   if (!getDerived().VisitAttr(A))
4377     return false;
4378   if (!getDerived().VisitObjCClassStubAttr(A))
4379     return false;
4380   return true;
4381 }
4382 
4383 template <typename Derived>
4384 bool VISITORCLASS<Derived>::TraverseObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A) {
4385   if (!getDerived().VisitAttr(A))
4386     return false;
4387   if (!getDerived().VisitObjCDesignatedInitializerAttr(A))
4388     return false;
4389   return true;
4390 }
4391 
4392 template <typename Derived>
4393 bool VISITORCLASS<Derived>::TraverseObjCDirectAttr(ObjCDirectAttr *A) {
4394   if (!getDerived().VisitAttr(A))
4395     return false;
4396   if (!getDerived().VisitObjCDirectAttr(A))
4397     return false;
4398   return true;
4399 }
4400 
4401 template <typename Derived>
4402 bool VISITORCLASS<Derived>::TraverseObjCDirectMembersAttr(ObjCDirectMembersAttr *A) {
4403   if (!getDerived().VisitAttr(A))
4404     return false;
4405   if (!getDerived().VisitObjCDirectMembersAttr(A))
4406     return false;
4407   return true;
4408 }
4409 
4410 template <typename Derived>
4411 bool VISITORCLASS<Derived>::TraverseObjCExceptionAttr(ObjCExceptionAttr *A) {
4412   if (!getDerived().VisitAttr(A))
4413     return false;
4414   if (!getDerived().VisitObjCExceptionAttr(A))
4415     return false;
4416   return true;
4417 }
4418 
4419 template <typename Derived>
4420 bool VISITORCLASS<Derived>::TraverseObjCExplicitProtocolImplAttr(ObjCExplicitProtocolImplAttr *A) {
4421   if (!getDerived().VisitAttr(A))
4422     return false;
4423   if (!getDerived().VisitObjCExplicitProtocolImplAttr(A))
4424     return false;
4425   return true;
4426 }
4427 
4428 template <typename Derived>
4429 bool VISITORCLASS<Derived>::TraverseObjCExternallyRetainedAttr(ObjCExternallyRetainedAttr *A) {
4430   if (!getDerived().VisitAttr(A))
4431     return false;
4432   if (!getDerived().VisitObjCExternallyRetainedAttr(A))
4433     return false;
4434   return true;
4435 }
4436 
4437 template <typename Derived>
4438 bool VISITORCLASS<Derived>::TraverseObjCGCAttr(ObjCGCAttr *A) {
4439   if (!getDerived().VisitAttr(A))
4440     return false;
4441   if (!getDerived().VisitObjCGCAttr(A))
4442     return false;
4443   return true;
4444 }
4445 
4446 template <typename Derived>
4447 bool VISITORCLASS<Derived>::TraverseObjCIndependentClassAttr(ObjCIndependentClassAttr *A) {
4448   if (!getDerived().VisitAttr(A))
4449     return false;
4450   if (!getDerived().VisitObjCIndependentClassAttr(A))
4451     return false;
4452   return true;
4453 }
4454 
4455 template <typename Derived>
4456 bool VISITORCLASS<Derived>::TraverseObjCInertUnsafeUnretainedAttr(ObjCInertUnsafeUnretainedAttr *A) {
4457   if (!getDerived().VisitAttr(A))
4458     return false;
4459   if (!getDerived().VisitObjCInertUnsafeUnretainedAttr(A))
4460     return false;
4461   return true;
4462 }
4463 
4464 template <typename Derived>
4465 bool VISITORCLASS<Derived>::TraverseObjCKindOfAttr(ObjCKindOfAttr *A) {
4466   if (!getDerived().VisitAttr(A))
4467     return false;
4468   if (!getDerived().VisitObjCKindOfAttr(A))
4469     return false;
4470   return true;
4471 }
4472 
4473 template <typename Derived>
4474 bool VISITORCLASS<Derived>::TraverseObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A) {
4475   if (!getDerived().VisitAttr(A))
4476     return false;
4477   if (!getDerived().VisitObjCMethodFamilyAttr(A))
4478     return false;
4479   return true;
4480 }
4481 
4482 template <typename Derived>
4483 bool VISITORCLASS<Derived>::TraverseObjCNSObjectAttr(ObjCNSObjectAttr *A) {
4484   if (!getDerived().VisitAttr(A))
4485     return false;
4486   if (!getDerived().VisitObjCNSObjectAttr(A))
4487     return false;
4488   return true;
4489 }
4490 
4491 template <typename Derived>
4492 bool VISITORCLASS<Derived>::TraverseObjCNonLazyClassAttr(ObjCNonLazyClassAttr *A) {
4493   if (!getDerived().VisitAttr(A))
4494     return false;
4495   if (!getDerived().VisitObjCNonLazyClassAttr(A))
4496     return false;
4497   return true;
4498 }
4499 
4500 template <typename Derived>
4501 bool VISITORCLASS<Derived>::TraverseObjCNonRuntimeProtocolAttr(ObjCNonRuntimeProtocolAttr *A) {
4502   if (!getDerived().VisitAttr(A))
4503     return false;
4504   if (!getDerived().VisitObjCNonRuntimeProtocolAttr(A))
4505     return false;
4506   return true;
4507 }
4508 
4509 template <typename Derived>
4510 bool VISITORCLASS<Derived>::TraverseObjCOwnershipAttr(ObjCOwnershipAttr *A) {
4511   if (!getDerived().VisitAttr(A))
4512     return false;
4513   if (!getDerived().VisitObjCOwnershipAttr(A))
4514     return false;
4515   return true;
4516 }
4517 
4518 template <typename Derived>
4519 bool VISITORCLASS<Derived>::TraverseObjCPreciseLifetimeAttr(ObjCPreciseLifetimeAttr *A) {
4520   if (!getDerived().VisitAttr(A))
4521     return false;
4522   if (!getDerived().VisitObjCPreciseLifetimeAttr(A))
4523     return false;
4524   return true;
4525 }
4526 
4527 template <typename Derived>
4528 bool VISITORCLASS<Derived>::TraverseObjCRequiresPropertyDefsAttr(ObjCRequiresPropertyDefsAttr *A) {
4529   if (!getDerived().VisitAttr(A))
4530     return false;
4531   if (!getDerived().VisitObjCRequiresPropertyDefsAttr(A))
4532     return false;
4533   return true;
4534 }
4535 
4536 template <typename Derived>
4537 bool VISITORCLASS<Derived>::TraverseObjCRequiresSuperAttr(ObjCRequiresSuperAttr *A) {
4538   if (!getDerived().VisitAttr(A))
4539     return false;
4540   if (!getDerived().VisitObjCRequiresSuperAttr(A))
4541     return false;
4542   return true;
4543 }
4544 
4545 template <typename Derived>
4546 bool VISITORCLASS<Derived>::TraverseObjCReturnsInnerPointerAttr(ObjCReturnsInnerPointerAttr *A) {
4547   if (!getDerived().VisitAttr(A))
4548     return false;
4549   if (!getDerived().VisitObjCReturnsInnerPointerAttr(A))
4550     return false;
4551   return true;
4552 }
4553 
4554 template <typename Derived>
4555 bool VISITORCLASS<Derived>::TraverseObjCRootClassAttr(ObjCRootClassAttr *A) {
4556   if (!getDerived().VisitAttr(A))
4557     return false;
4558   if (!getDerived().VisitObjCRootClassAttr(A))
4559     return false;
4560   return true;
4561 }
4562 
4563 template <typename Derived>
4564 bool VISITORCLASS<Derived>::TraverseObjCRuntimeNameAttr(ObjCRuntimeNameAttr *A) {
4565   if (!getDerived().VisitAttr(A))
4566     return false;
4567   if (!getDerived().VisitObjCRuntimeNameAttr(A))
4568     return false;
4569   return true;
4570 }
4571 
4572 template <typename Derived>
4573 bool VISITORCLASS<Derived>::TraverseObjCRuntimeVisibleAttr(ObjCRuntimeVisibleAttr *A) {
4574   if (!getDerived().VisitAttr(A))
4575     return false;
4576   if (!getDerived().VisitObjCRuntimeVisibleAttr(A))
4577     return false;
4578   return true;
4579 }
4580 
4581 template <typename Derived>
4582 bool VISITORCLASS<Derived>::TraverseObjCSubclassingRestrictedAttr(ObjCSubclassingRestrictedAttr *A) {
4583   if (!getDerived().VisitAttr(A))
4584     return false;
4585   if (!getDerived().VisitObjCSubclassingRestrictedAttr(A))
4586     return false;
4587   return true;
4588 }
4589 
4590 template <typename Derived>
4591 bool VISITORCLASS<Derived>::TraverseOpenCLAccessAttr(OpenCLAccessAttr *A) {
4592   if (!getDerived().VisitAttr(A))
4593     return false;
4594   if (!getDerived().VisitOpenCLAccessAttr(A))
4595     return false;
4596   return true;
4597 }
4598 
4599 template <typename Derived>
4600 bool VISITORCLASS<Derived>::TraverseOpenCLConstantAddressSpaceAttr(OpenCLConstantAddressSpaceAttr *A) {
4601   if (!getDerived().VisitAttr(A))
4602     return false;
4603   if (!getDerived().VisitOpenCLConstantAddressSpaceAttr(A))
4604     return false;
4605   return true;
4606 }
4607 
4608 template <typename Derived>
4609 bool VISITORCLASS<Derived>::TraverseOpenCLGenericAddressSpaceAttr(OpenCLGenericAddressSpaceAttr *A) {
4610   if (!getDerived().VisitAttr(A))
4611     return false;
4612   if (!getDerived().VisitOpenCLGenericAddressSpaceAttr(A))
4613     return false;
4614   return true;
4615 }
4616 
4617 template <typename Derived>
4618 bool VISITORCLASS<Derived>::TraverseOpenCLGlobalAddressSpaceAttr(OpenCLGlobalAddressSpaceAttr *A) {
4619   if (!getDerived().VisitAttr(A))
4620     return false;
4621   if (!getDerived().VisitOpenCLGlobalAddressSpaceAttr(A))
4622     return false;
4623   return true;
4624 }
4625 
4626 template <typename Derived>
4627 bool VISITORCLASS<Derived>::TraverseOpenCLGlobalDeviceAddressSpaceAttr(OpenCLGlobalDeviceAddressSpaceAttr *A) {
4628   if (!getDerived().VisitAttr(A))
4629     return false;
4630   if (!getDerived().VisitOpenCLGlobalDeviceAddressSpaceAttr(A))
4631     return false;
4632   return true;
4633 }
4634 
4635 template <typename Derived>
4636 bool VISITORCLASS<Derived>::TraverseOpenCLGlobalHostAddressSpaceAttr(OpenCLGlobalHostAddressSpaceAttr *A) {
4637   if (!getDerived().VisitAttr(A))
4638     return false;
4639   if (!getDerived().VisitOpenCLGlobalHostAddressSpaceAttr(A))
4640     return false;
4641   return true;
4642 }
4643 
4644 template <typename Derived>
4645 bool VISITORCLASS<Derived>::TraverseOpenCLIntelReqdSubGroupSizeAttr(OpenCLIntelReqdSubGroupSizeAttr *A) {
4646   if (!getDerived().VisitAttr(A))
4647     return false;
4648   if (!getDerived().VisitOpenCLIntelReqdSubGroupSizeAttr(A))
4649     return false;
4650   return true;
4651 }
4652 
4653 template <typename Derived>
4654 bool VISITORCLASS<Derived>::TraverseOpenCLKernelAttr(OpenCLKernelAttr *A) {
4655   if (!getDerived().VisitAttr(A))
4656     return false;
4657   if (!getDerived().VisitOpenCLKernelAttr(A))
4658     return false;
4659   return true;
4660 }
4661 
4662 template <typename Derived>
4663 bool VISITORCLASS<Derived>::TraverseOpenCLLocalAddressSpaceAttr(OpenCLLocalAddressSpaceAttr *A) {
4664   if (!getDerived().VisitAttr(A))
4665     return false;
4666   if (!getDerived().VisitOpenCLLocalAddressSpaceAttr(A))
4667     return false;
4668   return true;
4669 }
4670 
4671 template <typename Derived>
4672 bool VISITORCLASS<Derived>::TraverseOpenCLPrivateAddressSpaceAttr(OpenCLPrivateAddressSpaceAttr *A) {
4673   if (!getDerived().VisitAttr(A))
4674     return false;
4675   if (!getDerived().VisitOpenCLPrivateAddressSpaceAttr(A))
4676     return false;
4677   return true;
4678 }
4679 
4680 template <typename Derived>
4681 bool VISITORCLASS<Derived>::TraverseOpenCLUnrollHintAttr(OpenCLUnrollHintAttr *A) {
4682   if (!getDerived().VisitAttr(A))
4683     return false;
4684   if (!getDerived().VisitOpenCLUnrollHintAttr(A))
4685     return false;
4686   return true;
4687 }
4688 
4689 template <typename Derived>
4690 bool VISITORCLASS<Derived>::TraverseOptimizeNoneAttr(OptimizeNoneAttr *A) {
4691   if (!getDerived().VisitAttr(A))
4692     return false;
4693   if (!getDerived().VisitOptimizeNoneAttr(A))
4694     return false;
4695   return true;
4696 }
4697 
4698 template <typename Derived>
4699 bool VISITORCLASS<Derived>::TraverseOverloadableAttr(OverloadableAttr *A) {
4700   if (!getDerived().VisitAttr(A))
4701     return false;
4702   if (!getDerived().VisitOverloadableAttr(A))
4703     return false;
4704   return true;
4705 }
4706 
4707 template <typename Derived>
4708 bool VISITORCLASS<Derived>::TraverseOverrideAttr(OverrideAttr *A) {
4709   if (!getDerived().VisitAttr(A))
4710     return false;
4711   if (!getDerived().VisitOverrideAttr(A))
4712     return false;
4713   return true;
4714 }
4715 
4716 template <typename Derived>
4717 bool VISITORCLASS<Derived>::TraverseOwnerAttr(OwnerAttr *A) {
4718   if (!getDerived().VisitAttr(A))
4719     return false;
4720   if (!getDerived().VisitOwnerAttr(A))
4721     return false;
4722   if (auto *TSI = A->getDerefTypeLoc())
4723     if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
4724       return false;
4725   return true;
4726 }
4727 
4728 template <typename Derived>
4729 bool VISITORCLASS<Derived>::TraverseOwnershipAttr(OwnershipAttr *A) {
4730   if (!getDerived().VisitAttr(A))
4731     return false;
4732   if (!getDerived().VisitOwnershipAttr(A))
4733     return false;
4734   return true;
4735 }
4736 
4737 template <typename Derived>
4738 bool VISITORCLASS<Derived>::TraversePackedAttr(PackedAttr *A) {
4739   if (!getDerived().VisitAttr(A))
4740     return false;
4741   if (!getDerived().VisitPackedAttr(A))
4742     return false;
4743   return true;
4744 }
4745 
4746 template <typename Derived>
4747 bool VISITORCLASS<Derived>::TraverseParamTypestateAttr(ParamTypestateAttr *A) {
4748   if (!getDerived().VisitAttr(A))
4749     return false;
4750   if (!getDerived().VisitParamTypestateAttr(A))
4751     return false;
4752   return true;
4753 }
4754 
4755 template <typename Derived>
4756 bool VISITORCLASS<Derived>::TraversePascalAttr(PascalAttr *A) {
4757   if (!getDerived().VisitAttr(A))
4758     return false;
4759   if (!getDerived().VisitPascalAttr(A))
4760     return false;
4761   return true;
4762 }
4763 
4764 template <typename Derived>
4765 bool VISITORCLASS<Derived>::TraversePassObjectSizeAttr(PassObjectSizeAttr *A) {
4766   if (!getDerived().VisitAttr(A))
4767     return false;
4768   if (!getDerived().VisitPassObjectSizeAttr(A))
4769     return false;
4770   return true;
4771 }
4772 
4773 template <typename Derived>
4774 bool VISITORCLASS<Derived>::TraversePatchableFunctionEntryAttr(PatchableFunctionEntryAttr *A) {
4775   if (!getDerived().VisitAttr(A))
4776     return false;
4777   if (!getDerived().VisitPatchableFunctionEntryAttr(A))
4778     return false;
4779   return true;
4780 }
4781 
4782 template <typename Derived>
4783 bool VISITORCLASS<Derived>::TraversePcsAttr(PcsAttr *A) {
4784   if (!getDerived().VisitAttr(A))
4785     return false;
4786   if (!getDerived().VisitPcsAttr(A))
4787     return false;
4788   return true;
4789 }
4790 
4791 template <typename Derived>
4792 bool VISITORCLASS<Derived>::TraversePointerAttr(PointerAttr *A) {
4793   if (!getDerived().VisitAttr(A))
4794     return false;
4795   if (!getDerived().VisitPointerAttr(A))
4796     return false;
4797   if (auto *TSI = A->getDerefTypeLoc())
4798     if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
4799       return false;
4800   return true;
4801 }
4802 
4803 template <typename Derived>
4804 bool VISITORCLASS<Derived>::TraversePragmaClangBSSSectionAttr(PragmaClangBSSSectionAttr *A) {
4805   if (!getDerived().VisitAttr(A))
4806     return false;
4807   if (!getDerived().VisitPragmaClangBSSSectionAttr(A))
4808     return false;
4809   return true;
4810 }
4811 
4812 template <typename Derived>
4813 bool VISITORCLASS<Derived>::TraversePragmaClangDataSectionAttr(PragmaClangDataSectionAttr *A) {
4814   if (!getDerived().VisitAttr(A))
4815     return false;
4816   if (!getDerived().VisitPragmaClangDataSectionAttr(A))
4817     return false;
4818   return true;
4819 }
4820 
4821 template <typename Derived>
4822 bool VISITORCLASS<Derived>::TraversePragmaClangRelroSectionAttr(PragmaClangRelroSectionAttr *A) {
4823   if (!getDerived().VisitAttr(A))
4824     return false;
4825   if (!getDerived().VisitPragmaClangRelroSectionAttr(A))
4826     return false;
4827   return true;
4828 }
4829 
4830 template <typename Derived>
4831 bool VISITORCLASS<Derived>::TraversePragmaClangRodataSectionAttr(PragmaClangRodataSectionAttr *A) {
4832   if (!getDerived().VisitAttr(A))
4833     return false;
4834   if (!getDerived().VisitPragmaClangRodataSectionAttr(A))
4835     return false;
4836   return true;
4837 }
4838 
4839 template <typename Derived>
4840 bool VISITORCLASS<Derived>::TraversePragmaClangTextSectionAttr(PragmaClangTextSectionAttr *A) {
4841   if (!getDerived().VisitAttr(A))
4842     return false;
4843   if (!getDerived().VisitPragmaClangTextSectionAttr(A))
4844     return false;
4845   return true;
4846 }
4847 
4848 template <typename Derived>
4849 bool VISITORCLASS<Derived>::TraversePreferredNameAttr(PreferredNameAttr *A) {
4850   if (!getDerived().VisitAttr(A))
4851     return false;
4852   if (!getDerived().VisitPreferredNameAttr(A))
4853     return false;
4854   if (auto *TSI = A->getTypedefTypeLoc())
4855     if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
4856       return false;
4857   return true;
4858 }
4859 
4860 template <typename Derived>
4861 bool VISITORCLASS<Derived>::TraversePreferredTypeAttr(PreferredTypeAttr *A) {
4862   if (!getDerived().VisitAttr(A))
4863     return false;
4864   if (!getDerived().VisitPreferredTypeAttr(A))
4865     return false;
4866   if (auto *TSI = A->getTypeLoc())
4867     if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
4868       return false;
4869   return true;
4870 }
4871 
4872 template <typename Derived>
4873 bool VISITORCLASS<Derived>::TraversePreserveAllAttr(PreserveAllAttr *A) {
4874   if (!getDerived().VisitAttr(A))
4875     return false;
4876   if (!getDerived().VisitPreserveAllAttr(A))
4877     return false;
4878   return true;
4879 }
4880 
4881 template <typename Derived>
4882 bool VISITORCLASS<Derived>::TraversePreserveMostAttr(PreserveMostAttr *A) {
4883   if (!getDerived().VisitAttr(A))
4884     return false;
4885   if (!getDerived().VisitPreserveMostAttr(A))
4886     return false;
4887   return true;
4888 }
4889 
4890 template <typename Derived>
4891 bool VISITORCLASS<Derived>::TraversePreserveNoneAttr(PreserveNoneAttr *A) {
4892   if (!getDerived().VisitAttr(A))
4893     return false;
4894   if (!getDerived().VisitPreserveNoneAttr(A))
4895     return false;
4896   return true;
4897 }
4898 
4899 template <typename Derived>
4900 bool VISITORCLASS<Derived>::TraversePtGuardedByAttr(PtGuardedByAttr *A) {
4901   if (!getDerived().VisitAttr(A))
4902     return false;
4903   if (!getDerived().VisitPtGuardedByAttr(A))
4904     return false;
4905   if (!getDerived().TraverseStmt(A->getArg()))
4906     return false;
4907   return true;
4908 }
4909 
4910 template <typename Derived>
4911 bool VISITORCLASS<Derived>::TraversePtGuardedVarAttr(PtGuardedVarAttr *A) {
4912   if (!getDerived().VisitAttr(A))
4913     return false;
4914   if (!getDerived().VisitPtGuardedVarAttr(A))
4915     return false;
4916   return true;
4917 }
4918 
4919 template <typename Derived>
4920 bool VISITORCLASS<Derived>::TraversePtr32Attr(Ptr32Attr *A) {
4921   if (!getDerived().VisitAttr(A))
4922     return false;
4923   if (!getDerived().VisitPtr32Attr(A))
4924     return false;
4925   return true;
4926 }
4927 
4928 template <typename Derived>
4929 bool VISITORCLASS<Derived>::TraversePtr64Attr(Ptr64Attr *A) {
4930   if (!getDerived().VisitAttr(A))
4931     return false;
4932   if (!getDerived().VisitPtr64Attr(A))
4933     return false;
4934   return true;
4935 }
4936 
4937 template <typename Derived>
4938 bool VISITORCLASS<Derived>::TraversePureAttr(PureAttr *A) {
4939   if (!getDerived().VisitAttr(A))
4940     return false;
4941   if (!getDerived().VisitPureAttr(A))
4942     return false;
4943   return true;
4944 }
4945 
4946 template <typename Derived>
4947 bool VISITORCLASS<Derived>::TraverseRISCVInterruptAttr(RISCVInterruptAttr *A) {
4948   if (!getDerived().VisitAttr(A))
4949     return false;
4950   if (!getDerived().VisitRISCVInterruptAttr(A))
4951     return false;
4952   return true;
4953 }
4954 
4955 template <typename Derived>
4956 bool VISITORCLASS<Derived>::TraverseRISCVVectorCCAttr(RISCVVectorCCAttr *A) {
4957   if (!getDerived().VisitAttr(A))
4958     return false;
4959   if (!getDerived().VisitRISCVVectorCCAttr(A))
4960     return false;
4961   return true;
4962 }
4963 
4964 template <typename Derived>
4965 bool VISITORCLASS<Derived>::TraverseRandomizeLayoutAttr(RandomizeLayoutAttr *A) {
4966   if (!getDerived().VisitAttr(A))
4967     return false;
4968   if (!getDerived().VisitRandomizeLayoutAttr(A))
4969     return false;
4970   return true;
4971 }
4972 
4973 template <typename Derived>
4974 bool VISITORCLASS<Derived>::TraverseReadOnlyPlacementAttr(ReadOnlyPlacementAttr *A) {
4975   if (!getDerived().VisitAttr(A))
4976     return false;
4977   if (!getDerived().VisitReadOnlyPlacementAttr(A))
4978     return false;
4979   return true;
4980 }
4981 
4982 template <typename Derived>
4983 bool VISITORCLASS<Derived>::TraverseRegCallAttr(RegCallAttr *A) {
4984   if (!getDerived().VisitAttr(A))
4985     return false;
4986   if (!getDerived().VisitRegCallAttr(A))
4987     return false;
4988   return true;
4989 }
4990 
4991 template <typename Derived>
4992 bool VISITORCLASS<Derived>::TraverseReinitializesAttr(ReinitializesAttr *A) {
4993   if (!getDerived().VisitAttr(A))
4994     return false;
4995   if (!getDerived().VisitReinitializesAttr(A))
4996     return false;
4997   return true;
4998 }
4999 
5000 template <typename Derived>
5001 bool VISITORCLASS<Derived>::TraverseReleaseCapabilityAttr(ReleaseCapabilityAttr *A) {
5002   if (!getDerived().VisitAttr(A))
5003     return false;
5004   if (!getDerived().VisitReleaseCapabilityAttr(A))
5005     return false;
5006   {
5007     Expr * *I = A->args_begin();
5008     Expr * *E = A->args_end();
5009     for (; I != E; ++I) {
5010       if (!getDerived().TraverseStmt(*I))
5011         return false;
5012     }
5013   }
5014   return true;
5015 }
5016 
5017 template <typename Derived>
5018 bool VISITORCLASS<Derived>::TraverseReleaseHandleAttr(ReleaseHandleAttr *A) {
5019   if (!getDerived().VisitAttr(A))
5020     return false;
5021   if (!getDerived().VisitReleaseHandleAttr(A))
5022     return false;
5023   return true;
5024 }
5025 
5026 template <typename Derived>
5027 bool VISITORCLASS<Derived>::TraverseReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A) {
5028   if (!getDerived().VisitAttr(A))
5029     return false;
5030   if (!getDerived().VisitReqdWorkGroupSizeAttr(A))
5031     return false;
5032   return true;
5033 }
5034 
5035 template <typename Derived>
5036 bool VISITORCLASS<Derived>::TraverseRequiresCapabilityAttr(RequiresCapabilityAttr *A) {
5037   if (!getDerived().VisitAttr(A))
5038     return false;
5039   if (!getDerived().VisitRequiresCapabilityAttr(A))
5040     return false;
5041   {
5042     Expr * *I = A->args_begin();
5043     Expr * *E = A->args_end();
5044     for (; I != E; ++I) {
5045       if (!getDerived().TraverseStmt(*I))
5046         return false;
5047     }
5048   }
5049   return true;
5050 }
5051 
5052 template <typename Derived>
5053 bool VISITORCLASS<Derived>::TraverseRestrictAttr(RestrictAttr *A) {
5054   if (!getDerived().VisitAttr(A))
5055     return false;
5056   if (!getDerived().VisitRestrictAttr(A))
5057     return false;
5058   return true;
5059 }
5060 
5061 template <typename Derived>
5062 bool VISITORCLASS<Derived>::TraverseRetainAttr(RetainAttr *A) {
5063   if (!getDerived().VisitAttr(A))
5064     return false;
5065   if (!getDerived().VisitRetainAttr(A))
5066     return false;
5067   return true;
5068 }
5069 
5070 template <typename Derived>
5071 bool VISITORCLASS<Derived>::TraverseReturnTypestateAttr(ReturnTypestateAttr *A) {
5072   if (!getDerived().VisitAttr(A))
5073     return false;
5074   if (!getDerived().VisitReturnTypestateAttr(A))
5075     return false;
5076   return true;
5077 }
5078 
5079 template <typename Derived>
5080 bool VISITORCLASS<Derived>::TraverseReturnsNonNullAttr(ReturnsNonNullAttr *A) {
5081   if (!getDerived().VisitAttr(A))
5082     return false;
5083   if (!getDerived().VisitReturnsNonNullAttr(A))
5084     return false;
5085   return true;
5086 }
5087 
5088 template <typename Derived>
5089 bool VISITORCLASS<Derived>::TraverseReturnsTwiceAttr(ReturnsTwiceAttr *A) {
5090   if (!getDerived().VisitAttr(A))
5091     return false;
5092   if (!getDerived().VisitReturnsTwiceAttr(A))
5093     return false;
5094   return true;
5095 }
5096 
5097 template <typename Derived>
5098 bool VISITORCLASS<Derived>::TraverseSPtrAttr(SPtrAttr *A) {
5099   if (!getDerived().VisitAttr(A))
5100     return false;
5101   if (!getDerived().VisitSPtrAttr(A))
5102     return false;
5103   return true;
5104 }
5105 
5106 template <typename Derived>
5107 bool VISITORCLASS<Derived>::TraverseSYCLKernelAttr(SYCLKernelAttr *A) {
5108   if (!getDerived().VisitAttr(A))
5109     return false;
5110   if (!getDerived().VisitSYCLKernelAttr(A))
5111     return false;
5112   return true;
5113 }
5114 
5115 template <typename Derived>
5116 bool VISITORCLASS<Derived>::TraverseSYCLKernelEntryPointAttr(SYCLKernelEntryPointAttr *A) {
5117   if (!getDerived().VisitAttr(A))
5118     return false;
5119   if (!getDerived().VisitSYCLKernelEntryPointAttr(A))
5120     return false;
5121   if (auto *TSI = A->getKernelNameLoc())
5122     if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
5123       return false;
5124   return true;
5125 }
5126 
5127 template <typename Derived>
5128 bool VISITORCLASS<Derived>::TraverseSYCLSpecialClassAttr(SYCLSpecialClassAttr *A) {
5129   if (!getDerived().VisitAttr(A))
5130     return false;
5131   if (!getDerived().VisitSYCLSpecialClassAttr(A))
5132     return false;
5133   return true;
5134 }
5135 
5136 template <typename Derived>
5137 bool VISITORCLASS<Derived>::TraverseScopedLockableAttr(ScopedLockableAttr *A) {
5138   if (!getDerived().VisitAttr(A))
5139     return false;
5140   if (!getDerived().VisitScopedLockableAttr(A))
5141     return false;
5142   return true;
5143 }
5144 
5145 template <typename Derived>
5146 bool VISITORCLASS<Derived>::TraverseSectionAttr(SectionAttr *A) {
5147   if (!getDerived().VisitAttr(A))
5148     return false;
5149   if (!getDerived().VisitSectionAttr(A))
5150     return false;
5151   return true;
5152 }
5153 
5154 template <typename Derived>
5155 bool VISITORCLASS<Derived>::TraverseSelectAnyAttr(SelectAnyAttr *A) {
5156   if (!getDerived().VisitAttr(A))
5157     return false;
5158   if (!getDerived().VisitSelectAnyAttr(A))
5159     return false;
5160   return true;
5161 }
5162 
5163 template <typename Derived>
5164 bool VISITORCLASS<Derived>::TraverseSentinelAttr(SentinelAttr *A) {
5165   if (!getDerived().VisitAttr(A))
5166     return false;
5167   if (!getDerived().VisitSentinelAttr(A))
5168     return false;
5169   return true;
5170 }
5171 
5172 template <typename Derived>
5173 bool VISITORCLASS<Derived>::TraverseSetTypestateAttr(SetTypestateAttr *A) {
5174   if (!getDerived().VisitAttr(A))
5175     return false;
5176   if (!getDerived().VisitSetTypestateAttr(A))
5177     return false;
5178   return true;
5179 }
5180 
5181 template <typename Derived>
5182 bool VISITORCLASS<Derived>::TraverseSharedTrylockFunctionAttr(SharedTrylockFunctionAttr *A) {
5183   if (!getDerived().VisitAttr(A))
5184     return false;
5185   if (!getDerived().VisitSharedTrylockFunctionAttr(A))
5186     return false;
5187   if (!getDerived().TraverseStmt(A->getSuccessValue()))
5188     return false;
5189   {
5190     Expr * *I = A->args_begin();
5191     Expr * *E = A->args_end();
5192     for (; I != E; ++I) {
5193       if (!getDerived().TraverseStmt(*I))
5194         return false;
5195     }
5196   }
5197   return true;
5198 }
5199 
5200 template <typename Derived>
5201 bool VISITORCLASS<Derived>::TraverseSizedByAttr(SizedByAttr *A) {
5202   if (!getDerived().VisitAttr(A))
5203     return false;
5204   if (!getDerived().VisitSizedByAttr(A))
5205     return false;
5206   if (!getDerived().TraverseStmt(A->getSize()))
5207     return false;
5208   return true;
5209 }
5210 
5211 template <typename Derived>
5212 bool VISITORCLASS<Derived>::TraverseSizedByOrNullAttr(SizedByOrNullAttr *A) {
5213   if (!getDerived().VisitAttr(A))
5214     return false;
5215   if (!getDerived().VisitSizedByOrNullAttr(A))
5216     return false;
5217   if (!getDerived().TraverseStmt(A->getSize()))
5218     return false;
5219   return true;
5220 }
5221 
5222 template <typename Derived>
5223 bool VISITORCLASS<Derived>::TraverseSpeculativeLoadHardeningAttr(SpeculativeLoadHardeningAttr *A) {
5224   if (!getDerived().VisitAttr(A))
5225     return false;
5226   if (!getDerived().VisitSpeculativeLoadHardeningAttr(A))
5227     return false;
5228   return true;
5229 }
5230 
5231 template <typename Derived>
5232 bool VISITORCLASS<Derived>::TraverseStandaloneDebugAttr(StandaloneDebugAttr *A) {
5233   if (!getDerived().VisitAttr(A))
5234     return false;
5235   if (!getDerived().VisitStandaloneDebugAttr(A))
5236     return false;
5237   return true;
5238 }
5239 
5240 template <typename Derived>
5241 bool VISITORCLASS<Derived>::TraverseStdCallAttr(StdCallAttr *A) {
5242   if (!getDerived().VisitAttr(A))
5243     return false;
5244   if (!getDerived().VisitStdCallAttr(A))
5245     return false;
5246   return true;
5247 }
5248 
5249 template <typename Derived>
5250 bool VISITORCLASS<Derived>::TraverseStrictFPAttr(StrictFPAttr *A) {
5251   if (!getDerived().VisitAttr(A))
5252     return false;
5253   if (!getDerived().VisitStrictFPAttr(A))
5254     return false;
5255   return true;
5256 }
5257 
5258 template <typename Derived>
5259 bool VISITORCLASS<Derived>::TraverseStrictGuardStackCheckAttr(StrictGuardStackCheckAttr *A) {
5260   if (!getDerived().VisitAttr(A))
5261     return false;
5262   if (!getDerived().VisitStrictGuardStackCheckAttr(A))
5263     return false;
5264   return true;
5265 }
5266 
5267 template <typename Derived>
5268 bool VISITORCLASS<Derived>::TraverseSuppressAttr(SuppressAttr *A) {
5269   if (!getDerived().VisitAttr(A))
5270     return false;
5271   if (!getDerived().VisitSuppressAttr(A))
5272     return false;
5273   return true;
5274 }
5275 
5276 template <typename Derived>
5277 bool VISITORCLASS<Derived>::TraverseSwiftAsyncAttr(SwiftAsyncAttr *A) {
5278   if (!getDerived().VisitAttr(A))
5279     return false;
5280   if (!getDerived().VisitSwiftAsyncAttr(A))
5281     return false;
5282   return true;
5283 }
5284 
5285 template <typename Derived>
5286 bool VISITORCLASS<Derived>::TraverseSwiftAsyncCallAttr(SwiftAsyncCallAttr *A) {
5287   if (!getDerived().VisitAttr(A))
5288     return false;
5289   if (!getDerived().VisitSwiftAsyncCallAttr(A))
5290     return false;
5291   return true;
5292 }
5293 
5294 template <typename Derived>
5295 bool VISITORCLASS<Derived>::TraverseSwiftAsyncContextAttr(SwiftAsyncContextAttr *A) {
5296   if (!getDerived().VisitAttr(A))
5297     return false;
5298   if (!getDerived().VisitSwiftAsyncContextAttr(A))
5299     return false;
5300   return true;
5301 }
5302 
5303 template <typename Derived>
5304 bool VISITORCLASS<Derived>::TraverseSwiftAsyncErrorAttr(SwiftAsyncErrorAttr *A) {
5305   if (!getDerived().VisitAttr(A))
5306     return false;
5307   if (!getDerived().VisitSwiftAsyncErrorAttr(A))
5308     return false;
5309   return true;
5310 }
5311 
5312 template <typename Derived>
5313 bool VISITORCLASS<Derived>::TraverseSwiftAsyncNameAttr(SwiftAsyncNameAttr *A) {
5314   if (!getDerived().VisitAttr(A))
5315     return false;
5316   if (!getDerived().VisitSwiftAsyncNameAttr(A))
5317     return false;
5318   return true;
5319 }
5320 
5321 template <typename Derived>
5322 bool VISITORCLASS<Derived>::TraverseSwiftAttrAttr(SwiftAttrAttr *A) {
5323   if (!getDerived().VisitAttr(A))
5324     return false;
5325   if (!getDerived().VisitSwiftAttrAttr(A))
5326     return false;
5327   return true;
5328 }
5329 
5330 template <typename Derived>
5331 bool VISITORCLASS<Derived>::TraverseSwiftBridgeAttr(SwiftBridgeAttr *A) {
5332   if (!getDerived().VisitAttr(A))
5333     return false;
5334   if (!getDerived().VisitSwiftBridgeAttr(A))
5335     return false;
5336   return true;
5337 }
5338 
5339 template <typename Derived>
5340 bool VISITORCLASS<Derived>::TraverseSwiftBridgedTypedefAttr(SwiftBridgedTypedefAttr *A) {
5341   if (!getDerived().VisitAttr(A))
5342     return false;
5343   if (!getDerived().VisitSwiftBridgedTypedefAttr(A))
5344     return false;
5345   return true;
5346 }
5347 
5348 template <typename Derived>
5349 bool VISITORCLASS<Derived>::TraverseSwiftCallAttr(SwiftCallAttr *A) {
5350   if (!getDerived().VisitAttr(A))
5351     return false;
5352   if (!getDerived().VisitSwiftCallAttr(A))
5353     return false;
5354   return true;
5355 }
5356 
5357 template <typename Derived>
5358 bool VISITORCLASS<Derived>::TraverseSwiftContextAttr(SwiftContextAttr *A) {
5359   if (!getDerived().VisitAttr(A))
5360     return false;
5361   if (!getDerived().VisitSwiftContextAttr(A))
5362     return false;
5363   return true;
5364 }
5365 
5366 template <typename Derived>
5367 bool VISITORCLASS<Derived>::TraverseSwiftErrorAttr(SwiftErrorAttr *A) {
5368   if (!getDerived().VisitAttr(A))
5369     return false;
5370   if (!getDerived().VisitSwiftErrorAttr(A))
5371     return false;
5372   return true;
5373 }
5374 
5375 template <typename Derived>
5376 bool VISITORCLASS<Derived>::TraverseSwiftErrorResultAttr(SwiftErrorResultAttr *A) {
5377   if (!getDerived().VisitAttr(A))
5378     return false;
5379   if (!getDerived().VisitSwiftErrorResultAttr(A))
5380     return false;
5381   return true;
5382 }
5383 
5384 template <typename Derived>
5385 bool VISITORCLASS<Derived>::TraverseSwiftImportAsNonGenericAttr(SwiftImportAsNonGenericAttr *A) {
5386   if (!getDerived().VisitAttr(A))
5387     return false;
5388   if (!getDerived().VisitSwiftImportAsNonGenericAttr(A))
5389     return false;
5390   return true;
5391 }
5392 
5393 template <typename Derived>
5394 bool VISITORCLASS<Derived>::TraverseSwiftImportPropertyAsAccessorsAttr(SwiftImportPropertyAsAccessorsAttr *A) {
5395   if (!getDerived().VisitAttr(A))
5396     return false;
5397   if (!getDerived().VisitSwiftImportPropertyAsAccessorsAttr(A))
5398     return false;
5399   return true;
5400 }
5401 
5402 template <typename Derived>
5403 bool VISITORCLASS<Derived>::TraverseSwiftIndirectResultAttr(SwiftIndirectResultAttr *A) {
5404   if (!getDerived().VisitAttr(A))
5405     return false;
5406   if (!getDerived().VisitSwiftIndirectResultAttr(A))
5407     return false;
5408   return true;
5409 }
5410 
5411 template <typename Derived>
5412 bool VISITORCLASS<Derived>::TraverseSwiftNameAttr(SwiftNameAttr *A) {
5413   if (!getDerived().VisitAttr(A))
5414     return false;
5415   if (!getDerived().VisitSwiftNameAttr(A))
5416     return false;
5417   return true;
5418 }
5419 
5420 template <typename Derived>
5421 bool VISITORCLASS<Derived>::TraverseSwiftNewTypeAttr(SwiftNewTypeAttr *A) {
5422   if (!getDerived().VisitAttr(A))
5423     return false;
5424   if (!getDerived().VisitSwiftNewTypeAttr(A))
5425     return false;
5426   return true;
5427 }
5428 
5429 template <typename Derived>
5430 bool VISITORCLASS<Derived>::TraverseSwiftObjCMembersAttr(SwiftObjCMembersAttr *A) {
5431   if (!getDerived().VisitAttr(A))
5432     return false;
5433   if (!getDerived().VisitSwiftObjCMembersAttr(A))
5434     return false;
5435   return true;
5436 }
5437 
5438 template <typename Derived>
5439 bool VISITORCLASS<Derived>::TraverseSwiftPrivateAttr(SwiftPrivateAttr *A) {
5440   if (!getDerived().VisitAttr(A))
5441     return false;
5442   if (!getDerived().VisitSwiftPrivateAttr(A))
5443     return false;
5444   return true;
5445 }
5446 
5447 template <typename Derived>
5448 bool VISITORCLASS<Derived>::TraverseSwiftVersionedAdditionAttr(SwiftVersionedAdditionAttr *A) {
5449   if (!getDerived().VisitAttr(A))
5450     return false;
5451   if (!getDerived().VisitSwiftVersionedAdditionAttr(A))
5452     return false;
5453   return true;
5454 }
5455 
5456 template <typename Derived>
5457 bool VISITORCLASS<Derived>::TraverseSwiftVersionedRemovalAttr(SwiftVersionedRemovalAttr *A) {
5458   if (!getDerived().VisitAttr(A))
5459     return false;
5460   if (!getDerived().VisitSwiftVersionedRemovalAttr(A))
5461     return false;
5462   return true;
5463 }
5464 
5465 template <typename Derived>
5466 bool VISITORCLASS<Derived>::TraverseSysVABIAttr(SysVABIAttr *A) {
5467   if (!getDerived().VisitAttr(A))
5468     return false;
5469   if (!getDerived().VisitSysVABIAttr(A))
5470     return false;
5471   return true;
5472 }
5473 
5474 template <typename Derived>
5475 bool VISITORCLASS<Derived>::TraverseTLSModelAttr(TLSModelAttr *A) {
5476   if (!getDerived().VisitAttr(A))
5477     return false;
5478   if (!getDerived().VisitTLSModelAttr(A))
5479     return false;
5480   return true;
5481 }
5482 
5483 template <typename Derived>
5484 bool VISITORCLASS<Derived>::TraverseTargetAttr(TargetAttr *A) {
5485   if (!getDerived().VisitAttr(A))
5486     return false;
5487   if (!getDerived().VisitTargetAttr(A))
5488     return false;
5489   return true;
5490 }
5491 
5492 template <typename Derived>
5493 bool VISITORCLASS<Derived>::TraverseTargetClonesAttr(TargetClonesAttr *A) {
5494   if (!getDerived().VisitAttr(A))
5495     return false;
5496   if (!getDerived().VisitTargetClonesAttr(A))
5497     return false;
5498   return true;
5499 }
5500 
5501 template <typename Derived>
5502 bool VISITORCLASS<Derived>::TraverseTargetVersionAttr(TargetVersionAttr *A) {
5503   if (!getDerived().VisitAttr(A))
5504     return false;
5505   if (!getDerived().VisitTargetVersionAttr(A))
5506     return false;
5507   return true;
5508 }
5509 
5510 template <typename Derived>
5511 bool VISITORCLASS<Derived>::TraverseTestTypestateAttr(TestTypestateAttr *A) {
5512   if (!getDerived().VisitAttr(A))
5513     return false;
5514   if (!getDerived().VisitTestTypestateAttr(A))
5515     return false;
5516   return true;
5517 }
5518 
5519 template <typename Derived>
5520 bool VISITORCLASS<Derived>::TraverseThisCallAttr(ThisCallAttr *A) {
5521   if (!getDerived().VisitAttr(A))
5522     return false;
5523   if (!getDerived().VisitThisCallAttr(A))
5524     return false;
5525   return true;
5526 }
5527 
5528 template <typename Derived>
5529 bool VISITORCLASS<Derived>::TraverseThreadAttr(ThreadAttr *A) {
5530   if (!getDerived().VisitAttr(A))
5531     return false;
5532   if (!getDerived().VisitThreadAttr(A))
5533     return false;
5534   return true;
5535 }
5536 
5537 template <typename Derived>
5538 bool VISITORCLASS<Derived>::TraverseTransparentUnionAttr(TransparentUnionAttr *A) {
5539   if (!getDerived().VisitAttr(A))
5540     return false;
5541   if (!getDerived().VisitTransparentUnionAttr(A))
5542     return false;
5543   return true;
5544 }
5545 
5546 template <typename Derived>
5547 bool VISITORCLASS<Derived>::TraverseTrivialABIAttr(TrivialABIAttr *A) {
5548   if (!getDerived().VisitAttr(A))
5549     return false;
5550   if (!getDerived().VisitTrivialABIAttr(A))
5551     return false;
5552   return true;
5553 }
5554 
5555 template <typename Derived>
5556 bool VISITORCLASS<Derived>::TraverseTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A) {
5557   if (!getDerived().VisitAttr(A))
5558     return false;
5559   if (!getDerived().VisitTryAcquireCapabilityAttr(A))
5560     return false;
5561   if (!getDerived().TraverseStmt(A->getSuccessValue()))
5562     return false;
5563   {
5564     Expr * *I = A->args_begin();
5565     Expr * *E = A->args_end();
5566     for (; I != E; ++I) {
5567       if (!getDerived().TraverseStmt(*I))
5568         return false;
5569     }
5570   }
5571   return true;
5572 }
5573 
5574 template <typename Derived>
5575 bool VISITORCLASS<Derived>::TraverseTypeNonNullAttr(TypeNonNullAttr *A) {
5576   if (!getDerived().VisitAttr(A))
5577     return false;
5578   if (!getDerived().VisitTypeNonNullAttr(A))
5579     return false;
5580   return true;
5581 }
5582 
5583 template <typename Derived>
5584 bool VISITORCLASS<Derived>::TraverseTypeNullUnspecifiedAttr(TypeNullUnspecifiedAttr *A) {
5585   if (!getDerived().VisitAttr(A))
5586     return false;
5587   if (!getDerived().VisitTypeNullUnspecifiedAttr(A))
5588     return false;
5589   return true;
5590 }
5591 
5592 template <typename Derived>
5593 bool VISITORCLASS<Derived>::TraverseTypeNullableAttr(TypeNullableAttr *A) {
5594   if (!getDerived().VisitAttr(A))
5595     return false;
5596   if (!getDerived().VisitTypeNullableAttr(A))
5597     return false;
5598   return true;
5599 }
5600 
5601 template <typename Derived>
5602 bool VISITORCLASS<Derived>::TraverseTypeNullableResultAttr(TypeNullableResultAttr *A) {
5603   if (!getDerived().VisitAttr(A))
5604     return false;
5605   if (!getDerived().VisitTypeNullableResultAttr(A))
5606     return false;
5607   return true;
5608 }
5609 
5610 template <typename Derived>
5611 bool VISITORCLASS<Derived>::TraverseTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A) {
5612   if (!getDerived().VisitAttr(A))
5613     return false;
5614   if (!getDerived().VisitTypeTagForDatatypeAttr(A))
5615     return false;
5616   if (auto *TSI = A->getMatchingCTypeLoc())
5617     if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
5618       return false;
5619   return true;
5620 }
5621 
5622 template <typename Derived>
5623 bool VISITORCLASS<Derived>::TraverseTypeVisibilityAttr(TypeVisibilityAttr *A) {
5624   if (!getDerived().VisitAttr(A))
5625     return false;
5626   if (!getDerived().VisitTypeVisibilityAttr(A))
5627     return false;
5628   return true;
5629 }
5630 
5631 template <typename Derived>
5632 bool VISITORCLASS<Derived>::TraverseUPtrAttr(UPtrAttr *A) {
5633   if (!getDerived().VisitAttr(A))
5634     return false;
5635   if (!getDerived().VisitUPtrAttr(A))
5636     return false;
5637   return true;
5638 }
5639 
5640 template <typename Derived>
5641 bool VISITORCLASS<Derived>::TraverseUnavailableAttr(UnavailableAttr *A) {
5642   if (!getDerived().VisitAttr(A))
5643     return false;
5644   if (!getDerived().VisitUnavailableAttr(A))
5645     return false;
5646   return true;
5647 }
5648 
5649 template <typename Derived>
5650 bool VISITORCLASS<Derived>::TraverseUninitializedAttr(UninitializedAttr *A) {
5651   if (!getDerived().VisitAttr(A))
5652     return false;
5653   if (!getDerived().VisitUninitializedAttr(A))
5654     return false;
5655   return true;
5656 }
5657 
5658 template <typename Derived>
5659 bool VISITORCLASS<Derived>::TraverseUnlikelyAttr(UnlikelyAttr *A) {
5660   if (!getDerived().VisitAttr(A))
5661     return false;
5662   if (!getDerived().VisitUnlikelyAttr(A))
5663     return false;
5664   return true;
5665 }
5666 
5667 template <typename Derived>
5668 bool VISITORCLASS<Derived>::TraverseUnsafeBufferUsageAttr(UnsafeBufferUsageAttr *A) {
5669   if (!getDerived().VisitAttr(A))
5670     return false;
5671   if (!getDerived().VisitUnsafeBufferUsageAttr(A))
5672     return false;
5673   return true;
5674 }
5675 
5676 template <typename Derived>
5677 bool VISITORCLASS<Derived>::TraverseUnusedAttr(UnusedAttr *A) {
5678   if (!getDerived().VisitAttr(A))
5679     return false;
5680   if (!getDerived().VisitUnusedAttr(A))
5681     return false;
5682   return true;
5683 }
5684 
5685 template <typename Derived>
5686 bool VISITORCLASS<Derived>::TraverseUseHandleAttr(UseHandleAttr *A) {
5687   if (!getDerived().VisitAttr(A))
5688     return false;
5689   if (!getDerived().VisitUseHandleAttr(A))
5690     return false;
5691   return true;
5692 }
5693 
5694 template <typename Derived>
5695 bool VISITORCLASS<Derived>::TraverseUsedAttr(UsedAttr *A) {
5696   if (!getDerived().VisitAttr(A))
5697     return false;
5698   if (!getDerived().VisitUsedAttr(A))
5699     return false;
5700   return true;
5701 }
5702 
5703 template <typename Derived>
5704 bool VISITORCLASS<Derived>::TraverseUsingIfExistsAttr(UsingIfExistsAttr *A) {
5705   if (!getDerived().VisitAttr(A))
5706     return false;
5707   if (!getDerived().VisitUsingIfExistsAttr(A))
5708     return false;
5709   return true;
5710 }
5711 
5712 template <typename Derived>
5713 bool VISITORCLASS<Derived>::TraverseUuidAttr(UuidAttr *A) {
5714   if (!getDerived().VisitAttr(A))
5715     return false;
5716   if (!getDerived().VisitUuidAttr(A))
5717     return false;
5718   return true;
5719 }
5720 
5721 template <typename Derived>
5722 bool VISITORCLASS<Derived>::TraverseVTablePointerAuthenticationAttr(VTablePointerAuthenticationAttr *A) {
5723   if (!getDerived().VisitAttr(A))
5724     return false;
5725   if (!getDerived().VisitVTablePointerAuthenticationAttr(A))
5726     return false;
5727   return true;
5728 }
5729 
5730 template <typename Derived>
5731 bool VISITORCLASS<Derived>::TraverseVecReturnAttr(VecReturnAttr *A) {
5732   if (!getDerived().VisitAttr(A))
5733     return false;
5734   if (!getDerived().VisitVecReturnAttr(A))
5735     return false;
5736   return true;
5737 }
5738 
5739 template <typename Derived>
5740 bool VISITORCLASS<Derived>::TraverseVecTypeHintAttr(VecTypeHintAttr *A) {
5741   if (!getDerived().VisitAttr(A))
5742     return false;
5743   if (!getDerived().VisitVecTypeHintAttr(A))
5744     return false;
5745   if (auto *TSI = A->getTypeHintLoc())
5746     if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
5747       return false;
5748   return true;
5749 }
5750 
5751 template <typename Derived>
5752 bool VISITORCLASS<Derived>::TraverseVectorCallAttr(VectorCallAttr *A) {
5753   if (!getDerived().VisitAttr(A))
5754     return false;
5755   if (!getDerived().VisitVectorCallAttr(A))
5756     return false;
5757   return true;
5758 }
5759 
5760 template <typename Derived>
5761 bool VISITORCLASS<Derived>::TraverseVisibilityAttr(VisibilityAttr *A) {
5762   if (!getDerived().VisitAttr(A))
5763     return false;
5764   if (!getDerived().VisitVisibilityAttr(A))
5765     return false;
5766   return true;
5767 }
5768 
5769 template <typename Derived>
5770 bool VISITORCLASS<Derived>::TraverseWarnUnusedAttr(WarnUnusedAttr *A) {
5771   if (!getDerived().VisitAttr(A))
5772     return false;
5773   if (!getDerived().VisitWarnUnusedAttr(A))
5774     return false;
5775   return true;
5776 }
5777 
5778 template <typename Derived>
5779 bool VISITORCLASS<Derived>::TraverseWarnUnusedResultAttr(WarnUnusedResultAttr *A) {
5780   if (!getDerived().VisitAttr(A))
5781     return false;
5782   if (!getDerived().VisitWarnUnusedResultAttr(A))
5783     return false;
5784   return true;
5785 }
5786 
5787 template <typename Derived>
5788 bool VISITORCLASS<Derived>::TraverseWeakAttr(WeakAttr *A) {
5789   if (!getDerived().VisitAttr(A))
5790     return false;
5791   if (!getDerived().VisitWeakAttr(A))
5792     return false;
5793   return true;
5794 }
5795 
5796 template <typename Derived>
5797 bool VISITORCLASS<Derived>::TraverseWeakImportAttr(WeakImportAttr *A) {
5798   if (!getDerived().VisitAttr(A))
5799     return false;
5800   if (!getDerived().VisitWeakImportAttr(A))
5801     return false;
5802   return true;
5803 }
5804 
5805 template <typename Derived>
5806 bool VISITORCLASS<Derived>::TraverseWeakRefAttr(WeakRefAttr *A) {
5807   if (!getDerived().VisitAttr(A))
5808     return false;
5809   if (!getDerived().VisitWeakRefAttr(A))
5810     return false;
5811   return true;
5812 }
5813 
5814 template <typename Derived>
5815 bool VISITORCLASS<Derived>::TraverseWebAssemblyExportNameAttr(WebAssemblyExportNameAttr *A) {
5816   if (!getDerived().VisitAttr(A))
5817     return false;
5818   if (!getDerived().VisitWebAssemblyExportNameAttr(A))
5819     return false;
5820   return true;
5821 }
5822 
5823 template <typename Derived>
5824 bool VISITORCLASS<Derived>::TraverseWebAssemblyFuncrefAttr(WebAssemblyFuncrefAttr *A) {
5825   if (!getDerived().VisitAttr(A))
5826     return false;
5827   if (!getDerived().VisitWebAssemblyFuncrefAttr(A))
5828     return false;
5829   return true;
5830 }
5831 
5832 template <typename Derived>
5833 bool VISITORCLASS<Derived>::TraverseWebAssemblyImportModuleAttr(WebAssemblyImportModuleAttr *A) {
5834   if (!getDerived().VisitAttr(A))
5835     return false;
5836   if (!getDerived().VisitWebAssemblyImportModuleAttr(A))
5837     return false;
5838   return true;
5839 }
5840 
5841 template <typename Derived>
5842 bool VISITORCLASS<Derived>::TraverseWebAssemblyImportNameAttr(WebAssemblyImportNameAttr *A) {
5843   if (!getDerived().VisitAttr(A))
5844     return false;
5845   if (!getDerived().VisitWebAssemblyImportNameAttr(A))
5846     return false;
5847   return true;
5848 }
5849 
5850 template <typename Derived>
5851 bool VISITORCLASS<Derived>::TraverseWorkGroupSizeHintAttr(WorkGroupSizeHintAttr *A) {
5852   if (!getDerived().VisitAttr(A))
5853     return false;
5854   if (!getDerived().VisitWorkGroupSizeHintAttr(A))
5855     return false;
5856   return true;
5857 }
5858 
5859 template <typename Derived>
5860 bool VISITORCLASS<Derived>::TraverseX86ForceAlignArgPointerAttr(X86ForceAlignArgPointerAttr *A) {
5861   if (!getDerived().VisitAttr(A))
5862     return false;
5863   if (!getDerived().VisitX86ForceAlignArgPointerAttr(A))
5864     return false;
5865   return true;
5866 }
5867 
5868 template <typename Derived>
5869 bool VISITORCLASS<Derived>::TraverseXRayInstrumentAttr(XRayInstrumentAttr *A) {
5870   if (!getDerived().VisitAttr(A))
5871     return false;
5872   if (!getDerived().VisitXRayInstrumentAttr(A))
5873     return false;
5874   return true;
5875 }
5876 
5877 template <typename Derived>
5878 bool VISITORCLASS<Derived>::TraverseXRayLogArgsAttr(XRayLogArgsAttr *A) {
5879   if (!getDerived().VisitAttr(A))
5880     return false;
5881   if (!getDerived().VisitXRayLogArgsAttr(A))
5882     return false;
5883   return true;
5884 }
5885 
5886 template <typename Derived>
5887 bool VISITORCLASS<Derived>::TraverseZeroCallUsedRegsAttr(ZeroCallUsedRegsAttr *A) {
5888   if (!getDerived().VisitAttr(A))
5889     return false;
5890   if (!getDerived().VisitZeroCallUsedRegsAttr(A))
5891     return false;
5892   return true;
5893 }
5894 
5895 template <typename Derived>
5896 bool VISITORCLASS<Derived>::TraverseAttr(Attr *A) {
5897   if (!A)
5898     return true;
5899 
5900   switch (A->getKind()) {
5901     case attr::AArch64SVEPcs:
5902       return getDerived().TraverseAArch64SVEPcsAttr(cast<AArch64SVEPcsAttr>(A));
5903     case attr::AArch64VectorPcs:
5904       return getDerived().TraverseAArch64VectorPcsAttr(cast<AArch64VectorPcsAttr>(A));
5905     case attr::AMDGPUFlatWorkGroupSize:
5906       return getDerived().TraverseAMDGPUFlatWorkGroupSizeAttr(cast<AMDGPUFlatWorkGroupSizeAttr>(A));
5907     case attr::AMDGPUKernelCall:
5908       return getDerived().TraverseAMDGPUKernelCallAttr(cast<AMDGPUKernelCallAttr>(A));
5909     case attr::AMDGPUMaxNumWorkGroups:
5910       return getDerived().TraverseAMDGPUMaxNumWorkGroupsAttr(cast<AMDGPUMaxNumWorkGroupsAttr>(A));
5911     case attr::AMDGPUNumSGPR:
5912       return getDerived().TraverseAMDGPUNumSGPRAttr(cast<AMDGPUNumSGPRAttr>(A));
5913     case attr::AMDGPUNumVGPR:
5914       return getDerived().TraverseAMDGPUNumVGPRAttr(cast<AMDGPUNumVGPRAttr>(A));
5915     case attr::AMDGPUWavesPerEU:
5916       return getDerived().TraverseAMDGPUWavesPerEUAttr(cast<AMDGPUWavesPerEUAttr>(A));
5917     case attr::ARMInterrupt:
5918       return getDerived().TraverseARMInterruptAttr(cast<ARMInterruptAttr>(A));
5919     case attr::AVRInterrupt:
5920       return getDerived().TraverseAVRInterruptAttr(cast<AVRInterruptAttr>(A));
5921     case attr::AVRSignal:
5922       return getDerived().TraverseAVRSignalAttr(cast<AVRSignalAttr>(A));
5923     case attr::AbiTag:
5924       return getDerived().TraverseAbiTagAttr(cast<AbiTagAttr>(A));
5925     case attr::AcquireCapability:
5926       return getDerived().TraverseAcquireCapabilityAttr(cast<AcquireCapabilityAttr>(A));
5927     case attr::AcquireHandle:
5928       return getDerived().TraverseAcquireHandleAttr(cast<AcquireHandleAttr>(A));
5929     case attr::AcquiredAfter:
5930       return getDerived().TraverseAcquiredAfterAttr(cast<AcquiredAfterAttr>(A));
5931     case attr::AcquiredBefore:
5932       return getDerived().TraverseAcquiredBeforeAttr(cast<AcquiredBeforeAttr>(A));
5933     case attr::AddressSpace:
5934       return getDerived().TraverseAddressSpaceAttr(cast<AddressSpaceAttr>(A));
5935     case attr::Alias:
5936       return getDerived().TraverseAliasAttr(cast<AliasAttr>(A));
5937     case attr::AlignMac68k:
5938       return getDerived().TraverseAlignMac68kAttr(cast<AlignMac68kAttr>(A));
5939     case attr::AlignNatural:
5940       return getDerived().TraverseAlignNaturalAttr(cast<AlignNaturalAttr>(A));
5941     case attr::AlignValue:
5942       return getDerived().TraverseAlignValueAttr(cast<AlignValueAttr>(A));
5943     case attr::Aligned:
5944       return getDerived().TraverseAlignedAttr(cast<AlignedAttr>(A));
5945     case attr::AllocAlign:
5946       return getDerived().TraverseAllocAlignAttr(cast<AllocAlignAttr>(A));
5947     case attr::AllocSize:
5948       return getDerived().TraverseAllocSizeAttr(cast<AllocSizeAttr>(A));
5949     case attr::Allocating:
5950       return getDerived().TraverseAllocatingAttr(cast<AllocatingAttr>(A));
5951     case attr::AlwaysDestroy:
5952       return getDerived().TraverseAlwaysDestroyAttr(cast<AlwaysDestroyAttr>(A));
5953     case attr::AlwaysInline:
5954       return getDerived().TraverseAlwaysInlineAttr(cast<AlwaysInlineAttr>(A));
5955     case attr::AnalyzerNoReturn:
5956       return getDerived().TraverseAnalyzerNoReturnAttr(cast<AnalyzerNoReturnAttr>(A));
5957     case attr::Annotate:
5958       return getDerived().TraverseAnnotateAttr(cast<AnnotateAttr>(A));
5959     case attr::AnnotateType:
5960       return getDerived().TraverseAnnotateTypeAttr(cast<AnnotateTypeAttr>(A));
5961     case attr::AnyX86Interrupt:
5962       return getDerived().TraverseAnyX86InterruptAttr(cast<AnyX86InterruptAttr>(A));
5963     case attr::AnyX86NoCallerSavedRegisters:
5964       return getDerived().TraverseAnyX86NoCallerSavedRegistersAttr(cast<AnyX86NoCallerSavedRegistersAttr>(A));
5965     case attr::AnyX86NoCfCheck:
5966       return getDerived().TraverseAnyX86NoCfCheckAttr(cast<AnyX86NoCfCheckAttr>(A));
5967     case attr::ArcWeakrefUnavailable:
5968       return getDerived().TraverseArcWeakrefUnavailableAttr(cast<ArcWeakrefUnavailableAttr>(A));
5969     case attr::ArgumentWithTypeTag:
5970       return getDerived().TraverseArgumentWithTypeTagAttr(cast<ArgumentWithTypeTagAttr>(A));
5971     case attr::ArmAgnostic:
5972       return getDerived().TraverseArmAgnosticAttr(cast<ArmAgnosticAttr>(A));
5973     case attr::ArmBuiltinAlias:
5974       return getDerived().TraverseArmBuiltinAliasAttr(cast<ArmBuiltinAliasAttr>(A));
5975     case attr::ArmIn:
5976       return getDerived().TraverseArmInAttr(cast<ArmInAttr>(A));
5977     case attr::ArmInOut:
5978       return getDerived().TraverseArmInOutAttr(cast<ArmInOutAttr>(A));
5979     case attr::ArmLocallyStreaming:
5980       return getDerived().TraverseArmLocallyStreamingAttr(cast<ArmLocallyStreamingAttr>(A));
5981     case attr::ArmMveStrictPolymorphism:
5982       return getDerived().TraverseArmMveStrictPolymorphismAttr(cast<ArmMveStrictPolymorphismAttr>(A));
5983     case attr::ArmNew:
5984       return getDerived().TraverseArmNewAttr(cast<ArmNewAttr>(A));
5985     case attr::ArmOut:
5986       return getDerived().TraverseArmOutAttr(cast<ArmOutAttr>(A));
5987     case attr::ArmPreserves:
5988       return getDerived().TraverseArmPreservesAttr(cast<ArmPreservesAttr>(A));
5989     case attr::ArmStreaming:
5990       return getDerived().TraverseArmStreamingAttr(cast<ArmStreamingAttr>(A));
5991     case attr::ArmStreamingCompatible:
5992       return getDerived().TraverseArmStreamingCompatibleAttr(cast<ArmStreamingCompatibleAttr>(A));
5993     case attr::Artificial:
5994       return getDerived().TraverseArtificialAttr(cast<ArtificialAttr>(A));
5995     case attr::AsmLabel:
5996       return getDerived().TraverseAsmLabelAttr(cast<AsmLabelAttr>(A));
5997     case attr::AssertCapability:
5998       return getDerived().TraverseAssertCapabilityAttr(cast<AssertCapabilityAttr>(A));
5999     case attr::AssertExclusiveLock:
6000       return getDerived().TraverseAssertExclusiveLockAttr(cast<AssertExclusiveLockAttr>(A));
6001     case attr::AssertSharedLock:
6002       return getDerived().TraverseAssertSharedLockAttr(cast<AssertSharedLockAttr>(A));
6003     case attr::AssumeAligned:
6004       return getDerived().TraverseAssumeAlignedAttr(cast<AssumeAlignedAttr>(A));
6005     case attr::Availability:
6006       return getDerived().TraverseAvailabilityAttr(cast<AvailabilityAttr>(A));
6007     case attr::AvailableOnlyInDefaultEvalMethod:
6008       return getDerived().TraverseAvailableOnlyInDefaultEvalMethodAttr(cast<AvailableOnlyInDefaultEvalMethodAttr>(A));
6009     case attr::BPFFastCall:
6010       return getDerived().TraverseBPFFastCallAttr(cast<BPFFastCallAttr>(A));
6011     case attr::BPFPreserveAccessIndex:
6012       return getDerived().TraverseBPFPreserveAccessIndexAttr(cast<BPFPreserveAccessIndexAttr>(A));
6013     case attr::BPFPreserveStaticOffset:
6014       return getDerived().TraverseBPFPreserveStaticOffsetAttr(cast<BPFPreserveStaticOffsetAttr>(A));
6015     case attr::BTFDeclTag:
6016       return getDerived().TraverseBTFDeclTagAttr(cast<BTFDeclTagAttr>(A));
6017     case attr::BTFTypeTag:
6018       return getDerived().TraverseBTFTypeTagAttr(cast<BTFTypeTagAttr>(A));
6019     case attr::Blocking:
6020       return getDerived().TraverseBlockingAttr(cast<BlockingAttr>(A));
6021     case attr::Blocks:
6022       return getDerived().TraverseBlocksAttr(cast<BlocksAttr>(A));
6023     case attr::Builtin:
6024       return getDerived().TraverseBuiltinAttr(cast<BuiltinAttr>(A));
6025     case attr::BuiltinAlias:
6026       return getDerived().TraverseBuiltinAliasAttr(cast<BuiltinAliasAttr>(A));
6027     case attr::C11NoReturn:
6028       return getDerived().TraverseC11NoReturnAttr(cast<C11NoReturnAttr>(A));
6029     case attr::CDecl:
6030       return getDerived().TraverseCDeclAttr(cast<CDeclAttr>(A));
6031     case attr::CFAuditedTransfer:
6032       return getDerived().TraverseCFAuditedTransferAttr(cast<CFAuditedTransferAttr>(A));
6033     case attr::CFConsumed:
6034       return getDerived().TraverseCFConsumedAttr(cast<CFConsumedAttr>(A));
6035     case attr::CFGuard:
6036       return getDerived().TraverseCFGuardAttr(cast<CFGuardAttr>(A));
6037     case attr::CFICanonicalJumpTable:
6038       return getDerived().TraverseCFICanonicalJumpTableAttr(cast<CFICanonicalJumpTableAttr>(A));
6039     case attr::CFReturnsNotRetained:
6040       return getDerived().TraverseCFReturnsNotRetainedAttr(cast<CFReturnsNotRetainedAttr>(A));
6041     case attr::CFReturnsRetained:
6042       return getDerived().TraverseCFReturnsRetainedAttr(cast<CFReturnsRetainedAttr>(A));
6043     case attr::CFUnknownTransfer:
6044       return getDerived().TraverseCFUnknownTransferAttr(cast<CFUnknownTransferAttr>(A));
6045     case attr::CPUDispatch:
6046       return getDerived().TraverseCPUDispatchAttr(cast<CPUDispatchAttr>(A));
6047     case attr::CPUSpecific:
6048       return getDerived().TraverseCPUSpecificAttr(cast<CPUSpecificAttr>(A));
6049     case attr::CUDAConstant:
6050       return getDerived().TraverseCUDAConstantAttr(cast<CUDAConstantAttr>(A));
6051     case attr::CUDADevice:
6052       return getDerived().TraverseCUDADeviceAttr(cast<CUDADeviceAttr>(A));
6053     case attr::CUDADeviceBuiltinSurfaceType:
6054       return getDerived().TraverseCUDADeviceBuiltinSurfaceTypeAttr(cast<CUDADeviceBuiltinSurfaceTypeAttr>(A));
6055     case attr::CUDADeviceBuiltinTextureType:
6056       return getDerived().TraverseCUDADeviceBuiltinTextureTypeAttr(cast<CUDADeviceBuiltinTextureTypeAttr>(A));
6057     case attr::CUDAGlobal:
6058       return getDerived().TraverseCUDAGlobalAttr(cast<CUDAGlobalAttr>(A));
6059     case attr::CUDAGridConstant:
6060       return getDerived().TraverseCUDAGridConstantAttr(cast<CUDAGridConstantAttr>(A));
6061     case attr::CUDAHost:
6062       return getDerived().TraverseCUDAHostAttr(cast<CUDAHostAttr>(A));
6063     case attr::CUDAInvalidTarget:
6064       return getDerived().TraverseCUDAInvalidTargetAttr(cast<CUDAInvalidTargetAttr>(A));
6065     case attr::CUDALaunchBounds:
6066       return getDerived().TraverseCUDALaunchBoundsAttr(cast<CUDALaunchBoundsAttr>(A));
6067     case attr::CUDAShared:
6068       return getDerived().TraverseCUDASharedAttr(cast<CUDASharedAttr>(A));
6069     case attr::CXX11NoReturn:
6070       return getDerived().TraverseCXX11NoReturnAttr(cast<CXX11NoReturnAttr>(A));
6071     case attr::CXXAssume:
6072       return getDerived().TraverseCXXAssumeAttr(cast<CXXAssumeAttr>(A));
6073     case attr::CallableWhen:
6074       return getDerived().TraverseCallableWhenAttr(cast<CallableWhenAttr>(A));
6075     case attr::Callback:
6076       return getDerived().TraverseCallbackAttr(cast<CallbackAttr>(A));
6077     case attr::CalledOnce:
6078       return getDerived().TraverseCalledOnceAttr(cast<CalledOnceAttr>(A));
6079     case attr::Capability:
6080       return getDerived().TraverseCapabilityAttr(cast<CapabilityAttr>(A));
6081     case attr::CapturedRecord:
6082       return getDerived().TraverseCapturedRecordAttr(cast<CapturedRecordAttr>(A));
6083     case attr::CarriesDependency:
6084       return getDerived().TraverseCarriesDependencyAttr(cast<CarriesDependencyAttr>(A));
6085     case attr::Cleanup:
6086       return getDerived().TraverseCleanupAttr(cast<CleanupAttr>(A));
6087     case attr::ClspvLibclcBuiltin:
6088       return getDerived().TraverseClspvLibclcBuiltinAttr(cast<ClspvLibclcBuiltinAttr>(A));
6089     case attr::CmseNSCall:
6090       return getDerived().TraverseCmseNSCallAttr(cast<CmseNSCallAttr>(A));
6091     case attr::CmseNSEntry:
6092       return getDerived().TraverseCmseNSEntryAttr(cast<CmseNSEntryAttr>(A));
6093     case attr::CodeAlign:
6094       return getDerived().TraverseCodeAlignAttr(cast<CodeAlignAttr>(A));
6095     case attr::CodeModel:
6096       return getDerived().TraverseCodeModelAttr(cast<CodeModelAttr>(A));
6097     case attr::CodeSeg:
6098       return getDerived().TraverseCodeSegAttr(cast<CodeSegAttr>(A));
6099     case attr::Cold:
6100       return getDerived().TraverseColdAttr(cast<ColdAttr>(A));
6101     case attr::Common:
6102       return getDerived().TraverseCommonAttr(cast<CommonAttr>(A));
6103     case attr::Const:
6104       return getDerived().TraverseConstAttr(cast<ConstAttr>(A));
6105     case attr::ConstInit:
6106       return getDerived().TraverseConstInitAttr(cast<ConstInitAttr>(A));
6107     case attr::Constructor:
6108       return getDerived().TraverseConstructorAttr(cast<ConstructorAttr>(A));
6109     case attr::Consumable:
6110       return getDerived().TraverseConsumableAttr(cast<ConsumableAttr>(A));
6111     case attr::ConsumableAutoCast:
6112       return getDerived().TraverseConsumableAutoCastAttr(cast<ConsumableAutoCastAttr>(A));
6113     case attr::ConsumableSetOnRead:
6114       return getDerived().TraverseConsumableSetOnReadAttr(cast<ConsumableSetOnReadAttr>(A));
6115     case attr::Convergent:
6116       return getDerived().TraverseConvergentAttr(cast<ConvergentAttr>(A));
6117     case attr::CoroAwaitElidable:
6118       return getDerived().TraverseCoroAwaitElidableAttr(cast<CoroAwaitElidableAttr>(A));
6119     case attr::CoroAwaitElidableArgument:
6120       return getDerived().TraverseCoroAwaitElidableArgumentAttr(cast<CoroAwaitElidableArgumentAttr>(A));
6121     case attr::CoroDisableLifetimeBound:
6122       return getDerived().TraverseCoroDisableLifetimeBoundAttr(cast<CoroDisableLifetimeBoundAttr>(A));
6123     case attr::CoroLifetimeBound:
6124       return getDerived().TraverseCoroLifetimeBoundAttr(cast<CoroLifetimeBoundAttr>(A));
6125     case attr::CoroOnlyDestroyWhenComplete:
6126       return getDerived().TraverseCoroOnlyDestroyWhenCompleteAttr(cast<CoroOnlyDestroyWhenCompleteAttr>(A));
6127     case attr::CoroReturnType:
6128       return getDerived().TraverseCoroReturnTypeAttr(cast<CoroReturnTypeAttr>(A));
6129     case attr::CoroWrapper:
6130       return getDerived().TraverseCoroWrapperAttr(cast<CoroWrapperAttr>(A));
6131     case attr::CountedBy:
6132       return getDerived().TraverseCountedByAttr(cast<CountedByAttr>(A));
6133     case attr::CountedByOrNull:
6134       return getDerived().TraverseCountedByOrNullAttr(cast<CountedByOrNullAttr>(A));
6135     case attr::DLLExport:
6136       return getDerived().TraverseDLLExportAttr(cast<DLLExportAttr>(A));
6137     case attr::DLLExportStaticLocal:
6138       return getDerived().TraverseDLLExportStaticLocalAttr(cast<DLLExportStaticLocalAttr>(A));
6139     case attr::DLLImport:
6140       return getDerived().TraverseDLLImportAttr(cast<DLLImportAttr>(A));
6141     case attr::DLLImportStaticLocal:
6142       return getDerived().TraverseDLLImportStaticLocalAttr(cast<DLLImportStaticLocalAttr>(A));
6143     case attr::Deprecated:
6144       return getDerived().TraverseDeprecatedAttr(cast<DeprecatedAttr>(A));
6145     case attr::Destructor:
6146       return getDerived().TraverseDestructorAttr(cast<DestructorAttr>(A));
6147     case attr::DiagnoseAsBuiltin:
6148       return getDerived().TraverseDiagnoseAsBuiltinAttr(cast<DiagnoseAsBuiltinAttr>(A));
6149     case attr::DiagnoseIf:
6150       return getDerived().TraverseDiagnoseIfAttr(cast<DiagnoseIfAttr>(A));
6151     case attr::DisableSanitizerInstrumentation:
6152       return getDerived().TraverseDisableSanitizerInstrumentationAttr(cast<DisableSanitizerInstrumentationAttr>(A));
6153     case attr::DisableTailCalls:
6154       return getDerived().TraverseDisableTailCallsAttr(cast<DisableTailCallsAttr>(A));
6155     case attr::EmptyBases:
6156       return getDerived().TraverseEmptyBasesAttr(cast<EmptyBasesAttr>(A));
6157     case attr::EnableIf:
6158       return getDerived().TraverseEnableIfAttr(cast<EnableIfAttr>(A));
6159     case attr::EnforceTCB:
6160       return getDerived().TraverseEnforceTCBAttr(cast<EnforceTCBAttr>(A));
6161     case attr::EnforceTCBLeaf:
6162       return getDerived().TraverseEnforceTCBLeafAttr(cast<EnforceTCBLeafAttr>(A));
6163     case attr::EnumExtensibility:
6164       return getDerived().TraverseEnumExtensibilityAttr(cast<EnumExtensibilityAttr>(A));
6165     case attr::Error:
6166       return getDerived().TraverseErrorAttr(cast<ErrorAttr>(A));
6167     case attr::ExcludeFromExplicitInstantiation:
6168       return getDerived().TraverseExcludeFromExplicitInstantiationAttr(cast<ExcludeFromExplicitInstantiationAttr>(A));
6169     case attr::ExclusiveTrylockFunction:
6170       return getDerived().TraverseExclusiveTrylockFunctionAttr(cast<ExclusiveTrylockFunctionAttr>(A));
6171     case attr::ExplicitInit:
6172       return getDerived().TraverseExplicitInitAttr(cast<ExplicitInitAttr>(A));
6173     case attr::ExternalSourceSymbol:
6174       return getDerived().TraverseExternalSourceSymbolAttr(cast<ExternalSourceSymbolAttr>(A));
6175     case attr::FallThrough:
6176       return getDerived().TraverseFallThroughAttr(cast<FallThroughAttr>(A));
6177     case attr::FastCall:
6178       return getDerived().TraverseFastCallAttr(cast<FastCallAttr>(A));
6179     case attr::Final:
6180       return getDerived().TraverseFinalAttr(cast<FinalAttr>(A));
6181     case attr::FlagEnum:
6182       return getDerived().TraverseFlagEnumAttr(cast<FlagEnumAttr>(A));
6183     case attr::Flatten:
6184       return getDerived().TraverseFlattenAttr(cast<FlattenAttr>(A));
6185     case attr::Format:
6186       return getDerived().TraverseFormatAttr(cast<FormatAttr>(A));
6187     case attr::FormatArg:
6188       return getDerived().TraverseFormatArgAttr(cast<FormatArgAttr>(A));
6189     case attr::FunctionReturnThunks:
6190       return getDerived().TraverseFunctionReturnThunksAttr(cast<FunctionReturnThunksAttr>(A));
6191     case attr::GNUInline:
6192       return getDerived().TraverseGNUInlineAttr(cast<GNUInlineAttr>(A));
6193     case attr::GuardedBy:
6194       return getDerived().TraverseGuardedByAttr(cast<GuardedByAttr>(A));
6195     case attr::GuardedVar:
6196       return getDerived().TraverseGuardedVarAttr(cast<GuardedVarAttr>(A));
6197     case attr::HIPManaged:
6198       return getDerived().TraverseHIPManagedAttr(cast<HIPManagedAttr>(A));
6199     case attr::HLSLContainedType:
6200       return getDerived().TraverseHLSLContainedTypeAttr(cast<HLSLContainedTypeAttr>(A));
6201     case attr::HLSLControlFlowHint:
6202       return getDerived().TraverseHLSLControlFlowHintAttr(cast<HLSLControlFlowHintAttr>(A));
6203     case attr::HLSLGroupSharedAddressSpace:
6204       return getDerived().TraverseHLSLGroupSharedAddressSpaceAttr(cast<HLSLGroupSharedAddressSpaceAttr>(A));
6205     case attr::HLSLLoopHint:
6206       return getDerived().TraverseHLSLLoopHintAttr(cast<HLSLLoopHintAttr>(A));
6207     case attr::HLSLNumThreads:
6208       return getDerived().TraverseHLSLNumThreadsAttr(cast<HLSLNumThreadsAttr>(A));
6209     case attr::HLSLPackOffset:
6210       return getDerived().TraverseHLSLPackOffsetAttr(cast<HLSLPackOffsetAttr>(A));
6211     case attr::HLSLParamModifier:
6212       return getDerived().TraverseHLSLParamModifierAttr(cast<HLSLParamModifierAttr>(A));
6213     case attr::HLSLROV:
6214       return getDerived().TraverseHLSLROVAttr(cast<HLSLROVAttr>(A));
6215     case attr::HLSLRawBuffer:
6216       return getDerived().TraverseHLSLRawBufferAttr(cast<HLSLRawBufferAttr>(A));
6217     case attr::HLSLResource:
6218       return getDerived().TraverseHLSLResourceAttr(cast<HLSLResourceAttr>(A));
6219     case attr::HLSLResourceBinding:
6220       return getDerived().TraverseHLSLResourceBindingAttr(cast<HLSLResourceBindingAttr>(A));
6221     case attr::HLSLResourceClass:
6222       return getDerived().TraverseHLSLResourceClassAttr(cast<HLSLResourceClassAttr>(A));
6223     case attr::HLSLSV_DispatchThreadID:
6224       return getDerived().TraverseHLSLSV_DispatchThreadIDAttr(cast<HLSLSV_DispatchThreadIDAttr>(A));
6225     case attr::HLSLSV_GroupID:
6226       return getDerived().TraverseHLSLSV_GroupIDAttr(cast<HLSLSV_GroupIDAttr>(A));
6227     case attr::HLSLSV_GroupIndex:
6228       return getDerived().TraverseHLSLSV_GroupIndexAttr(cast<HLSLSV_GroupIndexAttr>(A));
6229     case attr::HLSLSV_GroupThreadID:
6230       return getDerived().TraverseHLSLSV_GroupThreadIDAttr(cast<HLSLSV_GroupThreadIDAttr>(A));
6231     case attr::HLSLShader:
6232       return getDerived().TraverseHLSLShaderAttr(cast<HLSLShaderAttr>(A));
6233     case attr::HLSLWaveSize:
6234       return getDerived().TraverseHLSLWaveSizeAttr(cast<HLSLWaveSizeAttr>(A));
6235     case attr::Hot:
6236       return getDerived().TraverseHotAttr(cast<HotAttr>(A));
6237     case attr::HybridPatchable:
6238       return getDerived().TraverseHybridPatchableAttr(cast<HybridPatchableAttr>(A));
6239     case attr::IBAction:
6240       return getDerived().TraverseIBActionAttr(cast<IBActionAttr>(A));
6241     case attr::IBOutlet:
6242       return getDerived().TraverseIBOutletAttr(cast<IBOutletAttr>(A));
6243     case attr::IBOutletCollection:
6244       return getDerived().TraverseIBOutletCollectionAttr(cast<IBOutletCollectionAttr>(A));
6245     case attr::IFunc:
6246       return getDerived().TraverseIFuncAttr(cast<IFuncAttr>(A));
6247     case attr::InitPriority:
6248       return getDerived().TraverseInitPriorityAttr(cast<InitPriorityAttr>(A));
6249     case attr::InitSeg:
6250       return getDerived().TraverseInitSegAttr(cast<InitSegAttr>(A));
6251     case attr::IntelOclBicc:
6252       return getDerived().TraverseIntelOclBiccAttr(cast<IntelOclBiccAttr>(A));
6253     case attr::InternalLinkage:
6254       return getDerived().TraverseInternalLinkageAttr(cast<InternalLinkageAttr>(A));
6255     case attr::LTOVisibilityPublic:
6256       return getDerived().TraverseLTOVisibilityPublicAttr(cast<LTOVisibilityPublicAttr>(A));
6257     case attr::LayoutVersion:
6258       return getDerived().TraverseLayoutVersionAttr(cast<LayoutVersionAttr>(A));
6259     case attr::Leaf:
6260       return getDerived().TraverseLeafAttr(cast<LeafAttr>(A));
6261     case attr::LifetimeBound:
6262       return getDerived().TraverseLifetimeBoundAttr(cast<LifetimeBoundAttr>(A));
6263     case attr::LifetimeCaptureBy:
6264       return getDerived().TraverseLifetimeCaptureByAttr(cast<LifetimeCaptureByAttr>(A));
6265     case attr::Likely:
6266       return getDerived().TraverseLikelyAttr(cast<LikelyAttr>(A));
6267     case attr::LoaderUninitialized:
6268       return getDerived().TraverseLoaderUninitializedAttr(cast<LoaderUninitializedAttr>(A));
6269     case attr::LockReturned:
6270       return getDerived().TraverseLockReturnedAttr(cast<LockReturnedAttr>(A));
6271     case attr::LocksExcluded:
6272       return getDerived().TraverseLocksExcludedAttr(cast<LocksExcludedAttr>(A));
6273     case attr::LoopHint:
6274       return getDerived().TraverseLoopHintAttr(cast<LoopHintAttr>(A));
6275     case attr::M68kInterrupt:
6276       return getDerived().TraverseM68kInterruptAttr(cast<M68kInterruptAttr>(A));
6277     case attr::M68kRTD:
6278       return getDerived().TraverseM68kRTDAttr(cast<M68kRTDAttr>(A));
6279     case attr::MIGServerRoutine:
6280       return getDerived().TraverseMIGServerRoutineAttr(cast<MIGServerRoutineAttr>(A));
6281     case attr::MSABI:
6282       return getDerived().TraverseMSABIAttr(cast<MSABIAttr>(A));
6283     case attr::MSAllocator:
6284       return getDerived().TraverseMSAllocatorAttr(cast<MSAllocatorAttr>(A));
6285     case attr::MSConstexpr:
6286       return getDerived().TraverseMSConstexprAttr(cast<MSConstexprAttr>(A));
6287     case attr::MSInheritance:
6288       return getDerived().TraverseMSInheritanceAttr(cast<MSInheritanceAttr>(A));
6289     case attr::MSNoVTable:
6290       return getDerived().TraverseMSNoVTableAttr(cast<MSNoVTableAttr>(A));
6291     case attr::MSP430Interrupt:
6292       return getDerived().TraverseMSP430InterruptAttr(cast<MSP430InterruptAttr>(A));
6293     case attr::MSStruct:
6294       return getDerived().TraverseMSStructAttr(cast<MSStructAttr>(A));
6295     case attr::MSVtorDisp:
6296       return getDerived().TraverseMSVtorDispAttr(cast<MSVtorDispAttr>(A));
6297     case attr::MaxFieldAlignment:
6298       return getDerived().TraverseMaxFieldAlignmentAttr(cast<MaxFieldAlignmentAttr>(A));
6299     case attr::MayAlias:
6300       return getDerived().TraverseMayAliasAttr(cast<MayAliasAttr>(A));
6301     case attr::MaybeUndef:
6302       return getDerived().TraverseMaybeUndefAttr(cast<MaybeUndefAttr>(A));
6303     case attr::MicroMips:
6304       return getDerived().TraverseMicroMipsAttr(cast<MicroMipsAttr>(A));
6305     case attr::MinSize:
6306       return getDerived().TraverseMinSizeAttr(cast<MinSizeAttr>(A));
6307     case attr::MinVectorWidth:
6308       return getDerived().TraverseMinVectorWidthAttr(cast<MinVectorWidthAttr>(A));
6309     case attr::Mips16:
6310       return getDerived().TraverseMips16Attr(cast<Mips16Attr>(A));
6311     case attr::MipsInterrupt:
6312       return getDerived().TraverseMipsInterruptAttr(cast<MipsInterruptAttr>(A));
6313     case attr::MipsLongCall:
6314       return getDerived().TraverseMipsLongCallAttr(cast<MipsLongCallAttr>(A));
6315     case attr::MipsShortCall:
6316       return getDerived().TraverseMipsShortCallAttr(cast<MipsShortCallAttr>(A));
6317     case attr::Mode:
6318       return getDerived().TraverseModeAttr(cast<ModeAttr>(A));
6319     case attr::MustTail:
6320       return getDerived().TraverseMustTailAttr(cast<MustTailAttr>(A));
6321     case attr::NSConsumed:
6322       return getDerived().TraverseNSConsumedAttr(cast<NSConsumedAttr>(A));
6323     case attr::NSConsumesSelf:
6324       return getDerived().TraverseNSConsumesSelfAttr(cast<NSConsumesSelfAttr>(A));
6325     case attr::NSErrorDomain:
6326       return getDerived().TraverseNSErrorDomainAttr(cast<NSErrorDomainAttr>(A));
6327     case attr::NSReturnsAutoreleased:
6328       return getDerived().TraverseNSReturnsAutoreleasedAttr(cast<NSReturnsAutoreleasedAttr>(A));
6329     case attr::NSReturnsNotRetained:
6330       return getDerived().TraverseNSReturnsNotRetainedAttr(cast<NSReturnsNotRetainedAttr>(A));
6331     case attr::NSReturnsRetained:
6332       return getDerived().TraverseNSReturnsRetainedAttr(cast<NSReturnsRetainedAttr>(A));
6333     case attr::NVPTXKernel:
6334       return getDerived().TraverseNVPTXKernelAttr(cast<NVPTXKernelAttr>(A));
6335     case attr::Naked:
6336       return getDerived().TraverseNakedAttr(cast<NakedAttr>(A));
6337     case attr::NoAlias:
6338       return getDerived().TraverseNoAliasAttr(cast<NoAliasAttr>(A));
6339     case attr::NoBuiltin:
6340       return getDerived().TraverseNoBuiltinAttr(cast<NoBuiltinAttr>(A));
6341     case attr::NoCommon:
6342       return getDerived().TraverseNoCommonAttr(cast<NoCommonAttr>(A));
6343     case attr::NoConvergent:
6344       return getDerived().TraverseNoConvergentAttr(cast<NoConvergentAttr>(A));
6345     case attr::NoDebug:
6346       return getDerived().TraverseNoDebugAttr(cast<NoDebugAttr>(A));
6347     case attr::NoDeref:
6348       return getDerived().TraverseNoDerefAttr(cast<NoDerefAttr>(A));
6349     case attr::NoDestroy:
6350       return getDerived().TraverseNoDestroyAttr(cast<NoDestroyAttr>(A));
6351     case attr::NoDuplicate:
6352       return getDerived().TraverseNoDuplicateAttr(cast<NoDuplicateAttr>(A));
6353     case attr::NoEscape:
6354       return getDerived().TraverseNoEscapeAttr(cast<NoEscapeAttr>(A));
6355     case attr::NoInline:
6356       return getDerived().TraverseNoInlineAttr(cast<NoInlineAttr>(A));
6357     case attr::NoInstrumentFunction:
6358       return getDerived().TraverseNoInstrumentFunctionAttr(cast<NoInstrumentFunctionAttr>(A));
6359     case attr::NoMerge:
6360       return getDerived().TraverseNoMergeAttr(cast<NoMergeAttr>(A));
6361     case attr::NoMicroMips:
6362       return getDerived().TraverseNoMicroMipsAttr(cast<NoMicroMipsAttr>(A));
6363     case attr::NoMips16:
6364       return getDerived().TraverseNoMips16Attr(cast<NoMips16Attr>(A));
6365     case attr::NoProfileFunction:
6366       return getDerived().TraverseNoProfileFunctionAttr(cast<NoProfileFunctionAttr>(A));
6367     case attr::NoRandomizeLayout:
6368       return getDerived().TraverseNoRandomizeLayoutAttr(cast<NoRandomizeLayoutAttr>(A));
6369     case attr::NoReturn:
6370       return getDerived().TraverseNoReturnAttr(cast<NoReturnAttr>(A));
6371     case attr::NoSanitize:
6372       return getDerived().TraverseNoSanitizeAttr(cast<NoSanitizeAttr>(A));
6373     case attr::NoSpecializations:
6374       return getDerived().TraverseNoSpecializationsAttr(cast<NoSpecializationsAttr>(A));
6375     case attr::NoSpeculativeLoadHardening:
6376       return getDerived().TraverseNoSpeculativeLoadHardeningAttr(cast<NoSpeculativeLoadHardeningAttr>(A));
6377     case attr::NoSplitStack:
6378       return getDerived().TraverseNoSplitStackAttr(cast<NoSplitStackAttr>(A));
6379     case attr::NoStackProtector:
6380       return getDerived().TraverseNoStackProtectorAttr(cast<NoStackProtectorAttr>(A));
6381     case attr::NoThreadSafetyAnalysis:
6382       return getDerived().TraverseNoThreadSafetyAnalysisAttr(cast<NoThreadSafetyAnalysisAttr>(A));
6383     case attr::NoThrow:
6384       return getDerived().TraverseNoThrowAttr(cast<NoThrowAttr>(A));
6385     case attr::NoTrivialAutoVarInit:
6386       return getDerived().TraverseNoTrivialAutoVarInitAttr(cast<NoTrivialAutoVarInitAttr>(A));
6387     case attr::NoUniqueAddress:
6388       return getDerived().TraverseNoUniqueAddressAttr(cast<NoUniqueAddressAttr>(A));
6389     case attr::NoUwtable:
6390       return getDerived().TraverseNoUwtableAttr(cast<NoUwtableAttr>(A));
6391     case attr::NonAllocating:
6392       return getDerived().TraverseNonAllocatingAttr(cast<NonAllocatingAttr>(A));
6393     case attr::NonBlocking:
6394       return getDerived().TraverseNonBlockingAttr(cast<NonBlockingAttr>(A));
6395     case attr::NonNull:
6396       return getDerived().TraverseNonNullAttr(cast<NonNullAttr>(A));
6397     case attr::NotTailCalled:
6398       return getDerived().TraverseNotTailCalledAttr(cast<NotTailCalledAttr>(A));
6399     case attr::OMPAllocateDecl:
6400       return getDerived().TraverseOMPAllocateDeclAttr(cast<OMPAllocateDeclAttr>(A));
6401     case attr::OMPAssume:
6402       return getDerived().TraverseOMPAssumeAttr(cast<OMPAssumeAttr>(A));
6403     case attr::OMPCaptureKind:
6404       return getDerived().TraverseOMPCaptureKindAttr(cast<OMPCaptureKindAttr>(A));
6405     case attr::OMPCaptureNoInit:
6406       return getDerived().TraverseOMPCaptureNoInitAttr(cast<OMPCaptureNoInitAttr>(A));
6407     case attr::OMPDeclareSimdDecl:
6408       return getDerived().TraverseOMPDeclareSimdDeclAttr(cast<OMPDeclareSimdDeclAttr>(A));
6409     case attr::OMPDeclareTargetDecl:
6410       return getDerived().TraverseOMPDeclareTargetDeclAttr(cast<OMPDeclareTargetDeclAttr>(A));
6411     case attr::OMPDeclareVariant:
6412       return getDerived().TraverseOMPDeclareVariantAttr(cast<OMPDeclareVariantAttr>(A));
6413     case attr::OMPReferencedVar:
6414       return getDerived().TraverseOMPReferencedVarAttr(cast<OMPReferencedVarAttr>(A));
6415     case attr::OMPThreadPrivateDecl:
6416       return getDerived().TraverseOMPThreadPrivateDeclAttr(cast<OMPThreadPrivateDeclAttr>(A));
6417     case attr::OSConsumed:
6418       return getDerived().TraverseOSConsumedAttr(cast<OSConsumedAttr>(A));
6419     case attr::OSConsumesThis:
6420       return getDerived().TraverseOSConsumesThisAttr(cast<OSConsumesThisAttr>(A));
6421     case attr::OSReturnsNotRetained:
6422       return getDerived().TraverseOSReturnsNotRetainedAttr(cast<OSReturnsNotRetainedAttr>(A));
6423     case attr::OSReturnsRetained:
6424       return getDerived().TraverseOSReturnsRetainedAttr(cast<OSReturnsRetainedAttr>(A));
6425     case attr::OSReturnsRetainedOnNonZero:
6426       return getDerived().TraverseOSReturnsRetainedOnNonZeroAttr(cast<OSReturnsRetainedOnNonZeroAttr>(A));
6427     case attr::OSReturnsRetainedOnZero:
6428       return getDerived().TraverseOSReturnsRetainedOnZeroAttr(cast<OSReturnsRetainedOnZeroAttr>(A));
6429     case attr::ObjCBoxable:
6430       return getDerived().TraverseObjCBoxableAttr(cast<ObjCBoxableAttr>(A));
6431     case attr::ObjCBridge:
6432       return getDerived().TraverseObjCBridgeAttr(cast<ObjCBridgeAttr>(A));
6433     case attr::ObjCBridgeMutable:
6434       return getDerived().TraverseObjCBridgeMutableAttr(cast<ObjCBridgeMutableAttr>(A));
6435     case attr::ObjCBridgeRelated:
6436       return getDerived().TraverseObjCBridgeRelatedAttr(cast<ObjCBridgeRelatedAttr>(A));
6437     case attr::ObjCClassStub:
6438       return getDerived().TraverseObjCClassStubAttr(cast<ObjCClassStubAttr>(A));
6439     case attr::ObjCDesignatedInitializer:
6440       return getDerived().TraverseObjCDesignatedInitializerAttr(cast<ObjCDesignatedInitializerAttr>(A));
6441     case attr::ObjCDirect:
6442       return getDerived().TraverseObjCDirectAttr(cast<ObjCDirectAttr>(A));
6443     case attr::ObjCDirectMembers:
6444       return getDerived().TraverseObjCDirectMembersAttr(cast<ObjCDirectMembersAttr>(A));
6445     case attr::ObjCException:
6446       return getDerived().TraverseObjCExceptionAttr(cast<ObjCExceptionAttr>(A));
6447     case attr::ObjCExplicitProtocolImpl:
6448       return getDerived().TraverseObjCExplicitProtocolImplAttr(cast<ObjCExplicitProtocolImplAttr>(A));
6449     case attr::ObjCExternallyRetained:
6450       return getDerived().TraverseObjCExternallyRetainedAttr(cast<ObjCExternallyRetainedAttr>(A));
6451     case attr::ObjCGC:
6452       return getDerived().TraverseObjCGCAttr(cast<ObjCGCAttr>(A));
6453     case attr::ObjCIndependentClass:
6454       return getDerived().TraverseObjCIndependentClassAttr(cast<ObjCIndependentClassAttr>(A));
6455     case attr::ObjCInertUnsafeUnretained:
6456       return getDerived().TraverseObjCInertUnsafeUnretainedAttr(cast<ObjCInertUnsafeUnretainedAttr>(A));
6457     case attr::ObjCKindOf:
6458       return getDerived().TraverseObjCKindOfAttr(cast<ObjCKindOfAttr>(A));
6459     case attr::ObjCMethodFamily:
6460       return getDerived().TraverseObjCMethodFamilyAttr(cast<ObjCMethodFamilyAttr>(A));
6461     case attr::ObjCNSObject:
6462       return getDerived().TraverseObjCNSObjectAttr(cast<ObjCNSObjectAttr>(A));
6463     case attr::ObjCNonLazyClass:
6464       return getDerived().TraverseObjCNonLazyClassAttr(cast<ObjCNonLazyClassAttr>(A));
6465     case attr::ObjCNonRuntimeProtocol:
6466       return getDerived().TraverseObjCNonRuntimeProtocolAttr(cast<ObjCNonRuntimeProtocolAttr>(A));
6467     case attr::ObjCOwnership:
6468       return getDerived().TraverseObjCOwnershipAttr(cast<ObjCOwnershipAttr>(A));
6469     case attr::ObjCPreciseLifetime:
6470       return getDerived().TraverseObjCPreciseLifetimeAttr(cast<ObjCPreciseLifetimeAttr>(A));
6471     case attr::ObjCRequiresPropertyDefs:
6472       return getDerived().TraverseObjCRequiresPropertyDefsAttr(cast<ObjCRequiresPropertyDefsAttr>(A));
6473     case attr::ObjCRequiresSuper:
6474       return getDerived().TraverseObjCRequiresSuperAttr(cast<ObjCRequiresSuperAttr>(A));
6475     case attr::ObjCReturnsInnerPointer:
6476       return getDerived().TraverseObjCReturnsInnerPointerAttr(cast<ObjCReturnsInnerPointerAttr>(A));
6477     case attr::ObjCRootClass:
6478       return getDerived().TraverseObjCRootClassAttr(cast<ObjCRootClassAttr>(A));
6479     case attr::ObjCRuntimeName:
6480       return getDerived().TraverseObjCRuntimeNameAttr(cast<ObjCRuntimeNameAttr>(A));
6481     case attr::ObjCRuntimeVisible:
6482       return getDerived().TraverseObjCRuntimeVisibleAttr(cast<ObjCRuntimeVisibleAttr>(A));
6483     case attr::ObjCSubclassingRestricted:
6484       return getDerived().TraverseObjCSubclassingRestrictedAttr(cast<ObjCSubclassingRestrictedAttr>(A));
6485     case attr::OpenCLAccess:
6486       return getDerived().TraverseOpenCLAccessAttr(cast<OpenCLAccessAttr>(A));
6487     case attr::OpenCLConstantAddressSpace:
6488       return getDerived().TraverseOpenCLConstantAddressSpaceAttr(cast<OpenCLConstantAddressSpaceAttr>(A));
6489     case attr::OpenCLGenericAddressSpace:
6490       return getDerived().TraverseOpenCLGenericAddressSpaceAttr(cast<OpenCLGenericAddressSpaceAttr>(A));
6491     case attr::OpenCLGlobalAddressSpace:
6492       return getDerived().TraverseOpenCLGlobalAddressSpaceAttr(cast<OpenCLGlobalAddressSpaceAttr>(A));
6493     case attr::OpenCLGlobalDeviceAddressSpace:
6494       return getDerived().TraverseOpenCLGlobalDeviceAddressSpaceAttr(cast<OpenCLGlobalDeviceAddressSpaceAttr>(A));
6495     case attr::OpenCLGlobalHostAddressSpace:
6496       return getDerived().TraverseOpenCLGlobalHostAddressSpaceAttr(cast<OpenCLGlobalHostAddressSpaceAttr>(A));
6497     case attr::OpenCLIntelReqdSubGroupSize:
6498       return getDerived().TraverseOpenCLIntelReqdSubGroupSizeAttr(cast<OpenCLIntelReqdSubGroupSizeAttr>(A));
6499     case attr::OpenCLKernel:
6500       return getDerived().TraverseOpenCLKernelAttr(cast<OpenCLKernelAttr>(A));
6501     case attr::OpenCLLocalAddressSpace:
6502       return getDerived().TraverseOpenCLLocalAddressSpaceAttr(cast<OpenCLLocalAddressSpaceAttr>(A));
6503     case attr::OpenCLPrivateAddressSpace:
6504       return getDerived().TraverseOpenCLPrivateAddressSpaceAttr(cast<OpenCLPrivateAddressSpaceAttr>(A));
6505     case attr::OpenCLUnrollHint:
6506       return getDerived().TraverseOpenCLUnrollHintAttr(cast<OpenCLUnrollHintAttr>(A));
6507     case attr::OptimizeNone:
6508       return getDerived().TraverseOptimizeNoneAttr(cast<OptimizeNoneAttr>(A));
6509     case attr::Overloadable:
6510       return getDerived().TraverseOverloadableAttr(cast<OverloadableAttr>(A));
6511     case attr::Override:
6512       return getDerived().TraverseOverrideAttr(cast<OverrideAttr>(A));
6513     case attr::Owner:
6514       return getDerived().TraverseOwnerAttr(cast<OwnerAttr>(A));
6515     case attr::Ownership:
6516       return getDerived().TraverseOwnershipAttr(cast<OwnershipAttr>(A));
6517     case attr::Packed:
6518       return getDerived().TraversePackedAttr(cast<PackedAttr>(A));
6519     case attr::ParamTypestate:
6520       return getDerived().TraverseParamTypestateAttr(cast<ParamTypestateAttr>(A));
6521     case attr::Pascal:
6522       return getDerived().TraversePascalAttr(cast<PascalAttr>(A));
6523     case attr::PassObjectSize:
6524       return getDerived().TraversePassObjectSizeAttr(cast<PassObjectSizeAttr>(A));
6525     case attr::PatchableFunctionEntry:
6526       return getDerived().TraversePatchableFunctionEntryAttr(cast<PatchableFunctionEntryAttr>(A));
6527     case attr::Pcs:
6528       return getDerived().TraversePcsAttr(cast<PcsAttr>(A));
6529     case attr::Pointer:
6530       return getDerived().TraversePointerAttr(cast<PointerAttr>(A));
6531     case attr::PragmaClangBSSSection:
6532       return getDerived().TraversePragmaClangBSSSectionAttr(cast<PragmaClangBSSSectionAttr>(A));
6533     case attr::PragmaClangDataSection:
6534       return getDerived().TraversePragmaClangDataSectionAttr(cast<PragmaClangDataSectionAttr>(A));
6535     case attr::PragmaClangRelroSection:
6536       return getDerived().TraversePragmaClangRelroSectionAttr(cast<PragmaClangRelroSectionAttr>(A));
6537     case attr::PragmaClangRodataSection:
6538       return getDerived().TraversePragmaClangRodataSectionAttr(cast<PragmaClangRodataSectionAttr>(A));
6539     case attr::PragmaClangTextSection:
6540       return getDerived().TraversePragmaClangTextSectionAttr(cast<PragmaClangTextSectionAttr>(A));
6541     case attr::PreferredName:
6542       return getDerived().TraversePreferredNameAttr(cast<PreferredNameAttr>(A));
6543     case attr::PreferredType:
6544       return getDerived().TraversePreferredTypeAttr(cast<PreferredTypeAttr>(A));
6545     case attr::PreserveAll:
6546       return getDerived().TraversePreserveAllAttr(cast<PreserveAllAttr>(A));
6547     case attr::PreserveMost:
6548       return getDerived().TraversePreserveMostAttr(cast<PreserveMostAttr>(A));
6549     case attr::PreserveNone:
6550       return getDerived().TraversePreserveNoneAttr(cast<PreserveNoneAttr>(A));
6551     case attr::PtGuardedBy:
6552       return getDerived().TraversePtGuardedByAttr(cast<PtGuardedByAttr>(A));
6553     case attr::PtGuardedVar:
6554       return getDerived().TraversePtGuardedVarAttr(cast<PtGuardedVarAttr>(A));
6555     case attr::Ptr32:
6556       return getDerived().TraversePtr32Attr(cast<Ptr32Attr>(A));
6557     case attr::Ptr64:
6558       return getDerived().TraversePtr64Attr(cast<Ptr64Attr>(A));
6559     case attr::Pure:
6560       return getDerived().TraversePureAttr(cast<PureAttr>(A));
6561     case attr::RISCVInterrupt:
6562       return getDerived().TraverseRISCVInterruptAttr(cast<RISCVInterruptAttr>(A));
6563     case attr::RISCVVectorCC:
6564       return getDerived().TraverseRISCVVectorCCAttr(cast<RISCVVectorCCAttr>(A));
6565     case attr::RandomizeLayout:
6566       return getDerived().TraverseRandomizeLayoutAttr(cast<RandomizeLayoutAttr>(A));
6567     case attr::ReadOnlyPlacement:
6568       return getDerived().TraverseReadOnlyPlacementAttr(cast<ReadOnlyPlacementAttr>(A));
6569     case attr::RegCall:
6570       return getDerived().TraverseRegCallAttr(cast<RegCallAttr>(A));
6571     case attr::Reinitializes:
6572       return getDerived().TraverseReinitializesAttr(cast<ReinitializesAttr>(A));
6573     case attr::ReleaseCapability:
6574       return getDerived().TraverseReleaseCapabilityAttr(cast<ReleaseCapabilityAttr>(A));
6575     case attr::ReleaseHandle:
6576       return getDerived().TraverseReleaseHandleAttr(cast<ReleaseHandleAttr>(A));
6577     case attr::ReqdWorkGroupSize:
6578       return getDerived().TraverseReqdWorkGroupSizeAttr(cast<ReqdWorkGroupSizeAttr>(A));
6579     case attr::RequiresCapability:
6580       return getDerived().TraverseRequiresCapabilityAttr(cast<RequiresCapabilityAttr>(A));
6581     case attr::Restrict:
6582       return getDerived().TraverseRestrictAttr(cast<RestrictAttr>(A));
6583     case attr::Retain:
6584       return getDerived().TraverseRetainAttr(cast<RetainAttr>(A));
6585     case attr::ReturnTypestate:
6586       return getDerived().TraverseReturnTypestateAttr(cast<ReturnTypestateAttr>(A));
6587     case attr::ReturnsNonNull:
6588       return getDerived().TraverseReturnsNonNullAttr(cast<ReturnsNonNullAttr>(A));
6589     case attr::ReturnsTwice:
6590       return getDerived().TraverseReturnsTwiceAttr(cast<ReturnsTwiceAttr>(A));
6591     case attr::SPtr:
6592       return getDerived().TraverseSPtrAttr(cast<SPtrAttr>(A));
6593     case attr::SYCLKernel:
6594       return getDerived().TraverseSYCLKernelAttr(cast<SYCLKernelAttr>(A));
6595     case attr::SYCLKernelEntryPoint:
6596       return getDerived().TraverseSYCLKernelEntryPointAttr(cast<SYCLKernelEntryPointAttr>(A));
6597     case attr::SYCLSpecialClass:
6598       return getDerived().TraverseSYCLSpecialClassAttr(cast<SYCLSpecialClassAttr>(A));
6599     case attr::ScopedLockable:
6600       return getDerived().TraverseScopedLockableAttr(cast<ScopedLockableAttr>(A));
6601     case attr::Section:
6602       return getDerived().TraverseSectionAttr(cast<SectionAttr>(A));
6603     case attr::SelectAny:
6604       return getDerived().TraverseSelectAnyAttr(cast<SelectAnyAttr>(A));
6605     case attr::Sentinel:
6606       return getDerived().TraverseSentinelAttr(cast<SentinelAttr>(A));
6607     case attr::SetTypestate:
6608       return getDerived().TraverseSetTypestateAttr(cast<SetTypestateAttr>(A));
6609     case attr::SharedTrylockFunction:
6610       return getDerived().TraverseSharedTrylockFunctionAttr(cast<SharedTrylockFunctionAttr>(A));
6611     case attr::SizedBy:
6612       return getDerived().TraverseSizedByAttr(cast<SizedByAttr>(A));
6613     case attr::SizedByOrNull:
6614       return getDerived().TraverseSizedByOrNullAttr(cast<SizedByOrNullAttr>(A));
6615     case attr::SpeculativeLoadHardening:
6616       return getDerived().TraverseSpeculativeLoadHardeningAttr(cast<SpeculativeLoadHardeningAttr>(A));
6617     case attr::StandaloneDebug:
6618       return getDerived().TraverseStandaloneDebugAttr(cast<StandaloneDebugAttr>(A));
6619     case attr::StdCall:
6620       return getDerived().TraverseStdCallAttr(cast<StdCallAttr>(A));
6621     case attr::StrictFP:
6622       return getDerived().TraverseStrictFPAttr(cast<StrictFPAttr>(A));
6623     case attr::StrictGuardStackCheck:
6624       return getDerived().TraverseStrictGuardStackCheckAttr(cast<StrictGuardStackCheckAttr>(A));
6625     case attr::Suppress:
6626       return getDerived().TraverseSuppressAttr(cast<SuppressAttr>(A));
6627     case attr::SwiftAsync:
6628       return getDerived().TraverseSwiftAsyncAttr(cast<SwiftAsyncAttr>(A));
6629     case attr::SwiftAsyncCall:
6630       return getDerived().TraverseSwiftAsyncCallAttr(cast<SwiftAsyncCallAttr>(A));
6631     case attr::SwiftAsyncContext:
6632       return getDerived().TraverseSwiftAsyncContextAttr(cast<SwiftAsyncContextAttr>(A));
6633     case attr::SwiftAsyncError:
6634       return getDerived().TraverseSwiftAsyncErrorAttr(cast<SwiftAsyncErrorAttr>(A));
6635     case attr::SwiftAsyncName:
6636       return getDerived().TraverseSwiftAsyncNameAttr(cast<SwiftAsyncNameAttr>(A));
6637     case attr::SwiftAttr:
6638       return getDerived().TraverseSwiftAttrAttr(cast<SwiftAttrAttr>(A));
6639     case attr::SwiftBridge:
6640       return getDerived().TraverseSwiftBridgeAttr(cast<SwiftBridgeAttr>(A));
6641     case attr::SwiftBridgedTypedef:
6642       return getDerived().TraverseSwiftBridgedTypedefAttr(cast<SwiftBridgedTypedefAttr>(A));
6643     case attr::SwiftCall:
6644       return getDerived().TraverseSwiftCallAttr(cast<SwiftCallAttr>(A));
6645     case attr::SwiftContext:
6646       return getDerived().TraverseSwiftContextAttr(cast<SwiftContextAttr>(A));
6647     case attr::SwiftError:
6648       return getDerived().TraverseSwiftErrorAttr(cast<SwiftErrorAttr>(A));
6649     case attr::SwiftErrorResult:
6650       return getDerived().TraverseSwiftErrorResultAttr(cast<SwiftErrorResultAttr>(A));
6651     case attr::SwiftImportAsNonGeneric:
6652       return getDerived().TraverseSwiftImportAsNonGenericAttr(cast<SwiftImportAsNonGenericAttr>(A));
6653     case attr::SwiftImportPropertyAsAccessors:
6654       return getDerived().TraverseSwiftImportPropertyAsAccessorsAttr(cast<SwiftImportPropertyAsAccessorsAttr>(A));
6655     case attr::SwiftIndirectResult:
6656       return getDerived().TraverseSwiftIndirectResultAttr(cast<SwiftIndirectResultAttr>(A));
6657     case attr::SwiftName:
6658       return getDerived().TraverseSwiftNameAttr(cast<SwiftNameAttr>(A));
6659     case attr::SwiftNewType:
6660       return getDerived().TraverseSwiftNewTypeAttr(cast<SwiftNewTypeAttr>(A));
6661     case attr::SwiftObjCMembers:
6662       return getDerived().TraverseSwiftObjCMembersAttr(cast<SwiftObjCMembersAttr>(A));
6663     case attr::SwiftPrivate:
6664       return getDerived().TraverseSwiftPrivateAttr(cast<SwiftPrivateAttr>(A));
6665     case attr::SwiftVersionedAddition:
6666       return getDerived().TraverseSwiftVersionedAdditionAttr(cast<SwiftVersionedAdditionAttr>(A));
6667     case attr::SwiftVersionedRemoval:
6668       return getDerived().TraverseSwiftVersionedRemovalAttr(cast<SwiftVersionedRemovalAttr>(A));
6669     case attr::SysVABI:
6670       return getDerived().TraverseSysVABIAttr(cast<SysVABIAttr>(A));
6671     case attr::TLSModel:
6672       return getDerived().TraverseTLSModelAttr(cast<TLSModelAttr>(A));
6673     case attr::Target:
6674       return getDerived().TraverseTargetAttr(cast<TargetAttr>(A));
6675     case attr::TargetClones:
6676       return getDerived().TraverseTargetClonesAttr(cast<TargetClonesAttr>(A));
6677     case attr::TargetVersion:
6678       return getDerived().TraverseTargetVersionAttr(cast<TargetVersionAttr>(A));
6679     case attr::TestTypestate:
6680       return getDerived().TraverseTestTypestateAttr(cast<TestTypestateAttr>(A));
6681     case attr::ThisCall:
6682       return getDerived().TraverseThisCallAttr(cast<ThisCallAttr>(A));
6683     case attr::Thread:
6684       return getDerived().TraverseThreadAttr(cast<ThreadAttr>(A));
6685     case attr::TransparentUnion:
6686       return getDerived().TraverseTransparentUnionAttr(cast<TransparentUnionAttr>(A));
6687     case attr::TrivialABI:
6688       return getDerived().TraverseTrivialABIAttr(cast<TrivialABIAttr>(A));
6689     case attr::TryAcquireCapability:
6690       return getDerived().TraverseTryAcquireCapabilityAttr(cast<TryAcquireCapabilityAttr>(A));
6691     case attr::TypeNonNull:
6692       return getDerived().TraverseTypeNonNullAttr(cast<TypeNonNullAttr>(A));
6693     case attr::TypeNullUnspecified:
6694       return getDerived().TraverseTypeNullUnspecifiedAttr(cast<TypeNullUnspecifiedAttr>(A));
6695     case attr::TypeNullable:
6696       return getDerived().TraverseTypeNullableAttr(cast<TypeNullableAttr>(A));
6697     case attr::TypeNullableResult:
6698       return getDerived().TraverseTypeNullableResultAttr(cast<TypeNullableResultAttr>(A));
6699     case attr::TypeTagForDatatype:
6700       return getDerived().TraverseTypeTagForDatatypeAttr(cast<TypeTagForDatatypeAttr>(A));
6701     case attr::TypeVisibility:
6702       return getDerived().TraverseTypeVisibilityAttr(cast<TypeVisibilityAttr>(A));
6703     case attr::UPtr:
6704       return getDerived().TraverseUPtrAttr(cast<UPtrAttr>(A));
6705     case attr::Unavailable:
6706       return getDerived().TraverseUnavailableAttr(cast<UnavailableAttr>(A));
6707     case attr::Uninitialized:
6708       return getDerived().TraverseUninitializedAttr(cast<UninitializedAttr>(A));
6709     case attr::Unlikely:
6710       return getDerived().TraverseUnlikelyAttr(cast<UnlikelyAttr>(A));
6711     case attr::UnsafeBufferUsage:
6712       return getDerived().TraverseUnsafeBufferUsageAttr(cast<UnsafeBufferUsageAttr>(A));
6713     case attr::Unused:
6714       return getDerived().TraverseUnusedAttr(cast<UnusedAttr>(A));
6715     case attr::UseHandle:
6716       return getDerived().TraverseUseHandleAttr(cast<UseHandleAttr>(A));
6717     case attr::Used:
6718       return getDerived().TraverseUsedAttr(cast<UsedAttr>(A));
6719     case attr::UsingIfExists:
6720       return getDerived().TraverseUsingIfExistsAttr(cast<UsingIfExistsAttr>(A));
6721     case attr::Uuid:
6722       return getDerived().TraverseUuidAttr(cast<UuidAttr>(A));
6723     case attr::VTablePointerAuthentication:
6724       return getDerived().TraverseVTablePointerAuthenticationAttr(cast<VTablePointerAuthenticationAttr>(A));
6725     case attr::VecReturn:
6726       return getDerived().TraverseVecReturnAttr(cast<VecReturnAttr>(A));
6727     case attr::VecTypeHint:
6728       return getDerived().TraverseVecTypeHintAttr(cast<VecTypeHintAttr>(A));
6729     case attr::VectorCall:
6730       return getDerived().TraverseVectorCallAttr(cast<VectorCallAttr>(A));
6731     case attr::Visibility:
6732       return getDerived().TraverseVisibilityAttr(cast<VisibilityAttr>(A));
6733     case attr::WarnUnused:
6734       return getDerived().TraverseWarnUnusedAttr(cast<WarnUnusedAttr>(A));
6735     case attr::WarnUnusedResult:
6736       return getDerived().TraverseWarnUnusedResultAttr(cast<WarnUnusedResultAttr>(A));
6737     case attr::Weak:
6738       return getDerived().TraverseWeakAttr(cast<WeakAttr>(A));
6739     case attr::WeakImport:
6740       return getDerived().TraverseWeakImportAttr(cast<WeakImportAttr>(A));
6741     case attr::WeakRef:
6742       return getDerived().TraverseWeakRefAttr(cast<WeakRefAttr>(A));
6743     case attr::WebAssemblyExportName:
6744       return getDerived().TraverseWebAssemblyExportNameAttr(cast<WebAssemblyExportNameAttr>(A));
6745     case attr::WebAssemblyFuncref:
6746       return getDerived().TraverseWebAssemblyFuncrefAttr(cast<WebAssemblyFuncrefAttr>(A));
6747     case attr::WebAssemblyImportModule:
6748       return getDerived().TraverseWebAssemblyImportModuleAttr(cast<WebAssemblyImportModuleAttr>(A));
6749     case attr::WebAssemblyImportName:
6750       return getDerived().TraverseWebAssemblyImportNameAttr(cast<WebAssemblyImportNameAttr>(A));
6751     case attr::WorkGroupSizeHint:
6752       return getDerived().TraverseWorkGroupSizeHintAttr(cast<WorkGroupSizeHintAttr>(A));
6753     case attr::X86ForceAlignArgPointer:
6754       return getDerived().TraverseX86ForceAlignArgPointerAttr(cast<X86ForceAlignArgPointerAttr>(A));
6755     case attr::XRayInstrument:
6756       return getDerived().TraverseXRayInstrumentAttr(cast<XRayInstrumentAttr>(A));
6757     case attr::XRayLogArgs:
6758       return getDerived().TraverseXRayLogArgsAttr(cast<XRayLogArgsAttr>(A));
6759     case attr::ZeroCallUsedRegs:
6760       return getDerived().TraverseZeroCallUsedRegsAttr(cast<ZeroCallUsedRegsAttr>(A));
6761   }
6762   llvm_unreachable("bad attribute kind");
6763 }
6764 #endif  // ATTR_VISITOR_DECLS_ONLY
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!