WebSVN – QNX 8.QNX8 LLVM/Clang compiler suite – Blame – //llvm-build/x86_64/include/clang/AST/AttrVisitor.inc

Rev	Author	Line No.	Line
14	pmbaty	1	/===- TableGen'erated file -------------------------------------- C++ --===\
		2	\|* *\|
		3	\|* Used by RecursiveASTVisitor to visit attributes. *\|
		4	\|* *\|
		5	\|* Automatically generated file, do not edit! *\|
		6	\|* *\|
		7	\===----------------------------------------------------------------------===/
		8
		9	#ifdef ATTR_VISITOR_DECLS_ONLY
		10
		11	bool TraverseAArch64SVEPcsAttr(AArch64SVEPcsAttr *A);
		12	bool VisitAArch64SVEPcsAttr(AArch64SVEPcsAttr *A) {
		13	return true;
		14	}
		15	bool TraverseAArch64VectorPcsAttr(AArch64VectorPcsAttr *A);
		16	bool VisitAArch64VectorPcsAttr(AArch64VectorPcsAttr *A) {
		17	return true;
		18	}
		19	bool TraverseAMDGPUFlatWorkGroupSizeAttr(AMDGPUFlatWorkGroupSizeAttr *A);
		20	bool VisitAMDGPUFlatWorkGroupSizeAttr(AMDGPUFlatWorkGroupSizeAttr *A) {
		21	return true;
		22	}
		23	bool TraverseAMDGPUKernelCallAttr(AMDGPUKernelCallAttr *A);
		24	bool VisitAMDGPUKernelCallAttr(AMDGPUKernelCallAttr *A) {
		25	return true;
		26	}
		27	bool TraverseAMDGPUNumSGPRAttr(AMDGPUNumSGPRAttr *A);
		28	bool VisitAMDGPUNumSGPRAttr(AMDGPUNumSGPRAttr *A) {
		29	return true;
		30	}
		31	bool TraverseAMDGPUNumVGPRAttr(AMDGPUNumVGPRAttr *A);
		32	bool VisitAMDGPUNumVGPRAttr(AMDGPUNumVGPRAttr *A) {
		33	return true;
		34	}
		35	bool TraverseAMDGPUWavesPerEUAttr(AMDGPUWavesPerEUAttr *A);
		36	bool VisitAMDGPUWavesPerEUAttr(AMDGPUWavesPerEUAttr *A) {
		37	return true;
		38	}
		39	bool TraverseARMInterruptAttr(ARMInterruptAttr *A);
		40	bool VisitARMInterruptAttr(ARMInterruptAttr *A) {
		41	return true;
		42	}
		43	bool TraverseAVRInterruptAttr(AVRInterruptAttr *A);
		44	bool VisitAVRInterruptAttr(AVRInterruptAttr *A) {
		45	return true;
		46	}
		47	bool TraverseAVRSignalAttr(AVRSignalAttr *A);
		48	bool VisitAVRSignalAttr(AVRSignalAttr *A) {
		49	return true;
		50	}
		51	bool TraverseAbiTagAttr(AbiTagAttr *A);
		52	bool VisitAbiTagAttr(AbiTagAttr *A) {
		53	return true;
		54	}
		55	bool TraverseAcquireCapabilityAttr(AcquireCapabilityAttr *A);
		56	bool VisitAcquireCapabilityAttr(AcquireCapabilityAttr *A) {
		57	return true;
		58	}
		59	bool TraverseAcquireHandleAttr(AcquireHandleAttr *A);
		60	bool VisitAcquireHandleAttr(AcquireHandleAttr *A) {
		61	return true;
		62	}
		63	bool TraverseAcquiredAfterAttr(AcquiredAfterAttr *A);
		64	bool VisitAcquiredAfterAttr(AcquiredAfterAttr *A) {
		65	return true;
		66	}
		67	bool TraverseAcquiredBeforeAttr(AcquiredBeforeAttr *A);
		68	bool VisitAcquiredBeforeAttr(AcquiredBeforeAttr *A) {
		69	return true;
		70	}
		71	bool TraverseAddressSpaceAttr(AddressSpaceAttr *A);
		72	bool VisitAddressSpaceAttr(AddressSpaceAttr *A) {
		73	return true;
		74	}
		75	bool TraverseAliasAttr(AliasAttr *A);
		76	bool VisitAliasAttr(AliasAttr *A) {
		77	return true;
		78	}
		79	bool TraverseAlignMac68kAttr(AlignMac68kAttr *A);
		80	bool VisitAlignMac68kAttr(AlignMac68kAttr *A) {
		81	return true;
		82	}
		83	bool TraverseAlignNaturalAttr(AlignNaturalAttr *A);
		84	bool VisitAlignNaturalAttr(AlignNaturalAttr *A) {
		85	return true;
		86	}
		87	bool TraverseAlignValueAttr(AlignValueAttr *A);
		88	bool VisitAlignValueAttr(AlignValueAttr *A) {
		89	return true;
		90	}
		91	bool TraverseAlignedAttr(AlignedAttr *A);
		92	bool VisitAlignedAttr(AlignedAttr *A) {
		93	return true;
		94	}
		95	bool TraverseAllocAlignAttr(AllocAlignAttr *A);
		96	bool VisitAllocAlignAttr(AllocAlignAttr *A) {
		97	return true;
		98	}
		99	bool TraverseAllocSizeAttr(AllocSizeAttr *A);
		100	bool VisitAllocSizeAttr(AllocSizeAttr *A) {
		101	return true;
		102	}
		103	bool TraverseAlwaysDestroyAttr(AlwaysDestroyAttr *A);
		104	bool VisitAlwaysDestroyAttr(AlwaysDestroyAttr *A) {
		105	return true;
		106	}
		107	bool TraverseAlwaysInlineAttr(AlwaysInlineAttr *A);
		108	bool VisitAlwaysInlineAttr(AlwaysInlineAttr *A) {
		109	return true;
		110	}
		111	bool TraverseAnalyzerNoReturnAttr(AnalyzerNoReturnAttr *A);
		112	bool VisitAnalyzerNoReturnAttr(AnalyzerNoReturnAttr *A) {
		113	return true;
		114	}
		115	bool TraverseAnnotateAttr(AnnotateAttr *A);
		116	bool VisitAnnotateAttr(AnnotateAttr *A) {
		117	return true;
		118	}
		119	bool TraverseAnnotateTypeAttr(AnnotateTypeAttr *A);
		120	bool VisitAnnotateTypeAttr(AnnotateTypeAttr *A) {
		121	return true;
		122	}
		123	bool TraverseAnyX86InterruptAttr(AnyX86InterruptAttr *A);
		124	bool VisitAnyX86InterruptAttr(AnyX86InterruptAttr *A) {
		125	return true;
		126	}
		127	bool TraverseAnyX86NoCallerSavedRegistersAttr(AnyX86NoCallerSavedRegistersAttr *A);
		128	bool VisitAnyX86NoCallerSavedRegistersAttr(AnyX86NoCallerSavedRegistersAttr *A) {
		129	return true;
		130	}
		131	bool TraverseAnyX86NoCfCheckAttr(AnyX86NoCfCheckAttr *A);
		132	bool VisitAnyX86NoCfCheckAttr(AnyX86NoCfCheckAttr *A) {
		133	return true;
		134	}
		135	bool TraverseArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A);
		136	bool VisitArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A) {
		137	return true;
		138	}
		139	bool TraverseArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *A);
		140	bool VisitArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *A) {
		141	return true;
		142	}
		143	bool TraverseArmBuiltinAliasAttr(ArmBuiltinAliasAttr *A);
		144	bool VisitArmBuiltinAliasAttr(ArmBuiltinAliasAttr *A) {
		145	return true;
		146	}
		147	bool TraverseArmMveStrictPolymorphismAttr(ArmMveStrictPolymorphismAttr *A);
		148	bool VisitArmMveStrictPolymorphismAttr(ArmMveStrictPolymorphismAttr *A) {
		149	return true;
		150	}
		151	bool TraverseArtificialAttr(ArtificialAttr *A);
		152	bool VisitArtificialAttr(ArtificialAttr *A) {
		153	return true;
		154	}
		155	bool TraverseAsmLabelAttr(AsmLabelAttr *A);
		156	bool VisitAsmLabelAttr(AsmLabelAttr *A) {
		157	return true;
		158	}
		159	bool TraverseAssertCapabilityAttr(AssertCapabilityAttr *A);
		160	bool VisitAssertCapabilityAttr(AssertCapabilityAttr *A) {
		161	return true;
		162	}
		163	bool TraverseAssertExclusiveLockAttr(AssertExclusiveLockAttr *A);
		164	bool VisitAssertExclusiveLockAttr(AssertExclusiveLockAttr *A) {
		165	return true;
		166	}
		167	bool TraverseAssertSharedLockAttr(AssertSharedLockAttr *A);
		168	bool VisitAssertSharedLockAttr(AssertSharedLockAttr *A) {
		169	return true;
		170	}
		171	bool TraverseAssumeAlignedAttr(AssumeAlignedAttr *A);
		172	bool VisitAssumeAlignedAttr(AssumeAlignedAttr *A) {
		173	return true;
		174	}
		175	bool TraverseAssumptionAttr(AssumptionAttr *A);
		176	bool VisitAssumptionAttr(AssumptionAttr *A) {
		177	return true;
		178	}
		179	bool TraverseAvailabilityAttr(AvailabilityAttr *A);
		180	bool VisitAvailabilityAttr(AvailabilityAttr *A) {
		181	return true;
		182	}
		183	bool TraverseBPFPreserveAccessIndexAttr(BPFPreserveAccessIndexAttr *A);
		184	bool VisitBPFPreserveAccessIndexAttr(BPFPreserveAccessIndexAttr *A) {
		185	return true;
		186	}
		187	bool TraverseBTFDeclTagAttr(BTFDeclTagAttr *A);
		188	bool VisitBTFDeclTagAttr(BTFDeclTagAttr *A) {
		189	return true;
		190	}
		191	bool TraverseBTFTypeTagAttr(BTFTypeTagAttr *A);
		192	bool VisitBTFTypeTagAttr(BTFTypeTagAttr *A) {
		193	return true;
		194	}
		195	bool TraverseBlocksAttr(BlocksAttr *A);
		196	bool VisitBlocksAttr(BlocksAttr *A) {
		197	return true;
		198	}
		199	bool TraverseBuiltinAttr(BuiltinAttr *A);
		200	bool VisitBuiltinAttr(BuiltinAttr *A) {
		201	return true;
		202	}
		203	bool TraverseBuiltinAliasAttr(BuiltinAliasAttr *A);
		204	bool VisitBuiltinAliasAttr(BuiltinAliasAttr *A) {
		205	return true;
		206	}
		207	bool TraverseC11NoReturnAttr(C11NoReturnAttr *A);
		208	bool VisitC11NoReturnAttr(C11NoReturnAttr *A) {
		209	return true;
		210	}
		211	bool TraverseCDeclAttr(CDeclAttr *A);
		212	bool VisitCDeclAttr(CDeclAttr *A) {
		213	return true;
		214	}
		215	bool TraverseCFAuditedTransferAttr(CFAuditedTransferAttr *A);
		216	bool VisitCFAuditedTransferAttr(CFAuditedTransferAttr *A) {
		217	return true;
		218	}
		219	bool TraverseCFConsumedAttr(CFConsumedAttr *A);
		220	bool VisitCFConsumedAttr(CFConsumedAttr *A) {
		221	return true;
		222	}
		223	bool TraverseCFGuardAttr(CFGuardAttr *A);
		224	bool VisitCFGuardAttr(CFGuardAttr *A) {
		225	return true;
		226	}
		227	bool TraverseCFICanonicalJumpTableAttr(CFICanonicalJumpTableAttr *A);
		228	bool VisitCFICanonicalJumpTableAttr(CFICanonicalJumpTableAttr *A) {
		229	return true;
		230	}
		231	bool TraverseCFReturnsNotRetainedAttr(CFReturnsNotRetainedAttr *A);
		232	bool VisitCFReturnsNotRetainedAttr(CFReturnsNotRetainedAttr *A) {
		233	return true;
		234	}
		235	bool TraverseCFReturnsRetainedAttr(CFReturnsRetainedAttr *A);
		236	bool VisitCFReturnsRetainedAttr(CFReturnsRetainedAttr *A) {
		237	return true;
		238	}
		239	bool TraverseCFUnknownTransferAttr(CFUnknownTransferAttr *A);
		240	bool VisitCFUnknownTransferAttr(CFUnknownTransferAttr *A) {
		241	return true;
		242	}
		243	bool TraverseCPUDispatchAttr(CPUDispatchAttr *A);
		244	bool VisitCPUDispatchAttr(CPUDispatchAttr *A) {
		245	return true;
		246	}
		247	bool TraverseCPUSpecificAttr(CPUSpecificAttr *A);
		248	bool VisitCPUSpecificAttr(CPUSpecificAttr *A) {
		249	return true;
		250	}
		251	bool TraverseCUDAConstantAttr(CUDAConstantAttr *A);
		252	bool VisitCUDAConstantAttr(CUDAConstantAttr *A) {
		253	return true;
		254	}
		255	bool TraverseCUDADeviceAttr(CUDADeviceAttr *A);
		256	bool VisitCUDADeviceAttr(CUDADeviceAttr *A) {
		257	return true;
		258	}
		259	bool TraverseCUDADeviceBuiltinSurfaceTypeAttr(CUDADeviceBuiltinSurfaceTypeAttr *A);
		260	bool VisitCUDADeviceBuiltinSurfaceTypeAttr(CUDADeviceBuiltinSurfaceTypeAttr *A) {
		261	return true;
		262	}
		263	bool TraverseCUDADeviceBuiltinTextureTypeAttr(CUDADeviceBuiltinTextureTypeAttr *A);
		264	bool VisitCUDADeviceBuiltinTextureTypeAttr(CUDADeviceBuiltinTextureTypeAttr *A) {
		265	return true;
		266	}
		267	bool TraverseCUDAGlobalAttr(CUDAGlobalAttr *A);
		268	bool VisitCUDAGlobalAttr(CUDAGlobalAttr *A) {
		269	return true;
		270	}
		271	bool TraverseCUDAHostAttr(CUDAHostAttr *A);
		272	bool VisitCUDAHostAttr(CUDAHostAttr *A) {
		273	return true;
		274	}
		275	bool TraverseCUDAInvalidTargetAttr(CUDAInvalidTargetAttr *A);
		276	bool VisitCUDAInvalidTargetAttr(CUDAInvalidTargetAttr *A) {
		277	return true;
		278	}
		279	bool TraverseCUDALaunchBoundsAttr(CUDALaunchBoundsAttr *A);
		280	bool VisitCUDALaunchBoundsAttr(CUDALaunchBoundsAttr *A) {
		281	return true;
		282	}
		283	bool TraverseCUDASharedAttr(CUDASharedAttr *A);
		284	bool VisitCUDASharedAttr(CUDASharedAttr *A) {
		285	return true;
		286	}
		287	bool TraverseCXX11NoReturnAttr(CXX11NoReturnAttr *A);
		288	bool VisitCXX11NoReturnAttr(CXX11NoReturnAttr *A) {
		289	return true;
		290	}
		291	bool TraverseCallableWhenAttr(CallableWhenAttr *A);
		292	bool VisitCallableWhenAttr(CallableWhenAttr *A) {
		293	return true;
		294	}
		295	bool TraverseCallbackAttr(CallbackAttr *A);
		296	bool VisitCallbackAttr(CallbackAttr *A) {
		297	return true;
		298	}
		299	bool TraverseCalledOnceAttr(CalledOnceAttr *A);
		300	bool VisitCalledOnceAttr(CalledOnceAttr *A) {
		301	return true;
		302	}
		303	bool TraverseCapabilityAttr(CapabilityAttr *A);
		304	bool VisitCapabilityAttr(CapabilityAttr *A) {
		305	return true;
		306	}
		307	bool TraverseCapturedRecordAttr(CapturedRecordAttr *A);
		308	bool VisitCapturedRecordAttr(CapturedRecordAttr *A) {
		309	return true;
		310	}
		311	bool TraverseCarriesDependencyAttr(CarriesDependencyAttr *A);
		312	bool VisitCarriesDependencyAttr(CarriesDependencyAttr *A) {
		313	return true;
		314	}
		315	bool TraverseCleanupAttr(CleanupAttr *A);
		316	bool VisitCleanupAttr(CleanupAttr *A) {
		317	return true;
		318	}
		319	bool TraverseCmseNSCallAttr(CmseNSCallAttr *A);
		320	bool VisitCmseNSCallAttr(CmseNSCallAttr *A) {
		321	return true;
		322	}
		323	bool TraverseCmseNSEntryAttr(CmseNSEntryAttr *A);
		324	bool VisitCmseNSEntryAttr(CmseNSEntryAttr *A) {
		325	return true;
		326	}
		327	bool TraverseCodeSegAttr(CodeSegAttr *A);
		328	bool VisitCodeSegAttr(CodeSegAttr *A) {
		329	return true;
		330	}
		331	bool TraverseColdAttr(ColdAttr *A);
		332	bool VisitColdAttr(ColdAttr *A) {
		333	return true;
		334	}
		335	bool TraverseCommonAttr(CommonAttr *A);
		336	bool VisitCommonAttr(CommonAttr *A) {
		337	return true;
		338	}
		339	bool TraverseConstAttr(ConstAttr *A);
		340	bool VisitConstAttr(ConstAttr *A) {
		341	return true;
		342	}
		343	bool TraverseConstInitAttr(ConstInitAttr *A);
		344	bool VisitConstInitAttr(ConstInitAttr *A) {
		345	return true;
		346	}
		347	bool TraverseConstructorAttr(ConstructorAttr *A);
		348	bool VisitConstructorAttr(ConstructorAttr *A) {
		349	return true;
		350	}
		351	bool TraverseConsumableAttr(ConsumableAttr *A);
		352	bool VisitConsumableAttr(ConsumableAttr *A) {
		353	return true;
		354	}
		355	bool TraverseConsumableAutoCastAttr(ConsumableAutoCastAttr *A);
		356	bool VisitConsumableAutoCastAttr(ConsumableAutoCastAttr *A) {
		357	return true;
		358	}
		359	bool TraverseConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A);
		360	bool VisitConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A) {
		361	return true;
		362	}
		363	bool TraverseConvergentAttr(ConvergentAttr *A);
		364	bool VisitConvergentAttr(ConvergentAttr *A) {
		365	return true;
		366	}
		367	bool TraverseDLLExportAttr(DLLExportAttr *A);
		368	bool VisitDLLExportAttr(DLLExportAttr *A) {
		369	return true;
		370	}
		371	bool TraverseDLLExportStaticLocalAttr(DLLExportStaticLocalAttr *A);
		372	bool VisitDLLExportStaticLocalAttr(DLLExportStaticLocalAttr *A) {
		373	return true;
		374	}
		375	bool TraverseDLLImportAttr(DLLImportAttr *A);
		376	bool VisitDLLImportAttr(DLLImportAttr *A) {
		377	return true;
		378	}
		379	bool TraverseDLLImportStaticLocalAttr(DLLImportStaticLocalAttr *A);
		380	bool VisitDLLImportStaticLocalAttr(DLLImportStaticLocalAttr *A) {
		381	return true;
		382	}
		383	bool TraverseDeprecatedAttr(DeprecatedAttr *A);
		384	bool VisitDeprecatedAttr(DeprecatedAttr *A) {
		385	return true;
		386	}
		387	bool TraverseDestructorAttr(DestructorAttr *A);
		388	bool VisitDestructorAttr(DestructorAttr *A) {
		389	return true;
		390	}
		391	bool TraverseDiagnoseAsBuiltinAttr(DiagnoseAsBuiltinAttr *A);
		392	bool VisitDiagnoseAsBuiltinAttr(DiagnoseAsBuiltinAttr *A) {
		393	return true;
		394	}
		395	bool TraverseDiagnoseIfAttr(DiagnoseIfAttr *A);
		396	bool VisitDiagnoseIfAttr(DiagnoseIfAttr *A) {
		397	return true;
		398	}
		399	bool TraverseDisableSanitizerInstrumentationAttr(DisableSanitizerInstrumentationAttr *A);
		400	bool VisitDisableSanitizerInstrumentationAttr(DisableSanitizerInstrumentationAttr *A) {
		401	return true;
		402	}
		403	bool TraverseDisableTailCallsAttr(DisableTailCallsAttr *A);
		404	bool VisitDisableTailCallsAttr(DisableTailCallsAttr *A) {
		405	return true;
		406	}
		407	bool TraverseEmptyBasesAttr(EmptyBasesAttr *A);
		408	bool VisitEmptyBasesAttr(EmptyBasesAttr *A) {
		409	return true;
		410	}
		411	bool TraverseEnableIfAttr(EnableIfAttr *A);
		412	bool VisitEnableIfAttr(EnableIfAttr *A) {
		413	return true;
		414	}
		415	bool TraverseEnforceTCBAttr(EnforceTCBAttr *A);
		416	bool VisitEnforceTCBAttr(EnforceTCBAttr *A) {
		417	return true;
		418	}
		419	bool TraverseEnforceTCBLeafAttr(EnforceTCBLeafAttr *A);
		420	bool VisitEnforceTCBLeafAttr(EnforceTCBLeafAttr *A) {
		421	return true;
		422	}
		423	bool TraverseEnumExtensibilityAttr(EnumExtensibilityAttr *A);
		424	bool VisitEnumExtensibilityAttr(EnumExtensibilityAttr *A) {
		425	return true;
		426	}
		427	bool TraverseErrorAttr(ErrorAttr *A);
		428	bool VisitErrorAttr(ErrorAttr *A) {
		429	return true;
		430	}
		431	bool TraverseExcludeFromExplicitInstantiationAttr(ExcludeFromExplicitInstantiationAttr *A);
		432	bool VisitExcludeFromExplicitInstantiationAttr(ExcludeFromExplicitInstantiationAttr *A) {
		433	return true;
		434	}
		435	bool TraverseExclusiveTrylockFunctionAttr(ExclusiveTrylockFunctionAttr *A);
		436	bool VisitExclusiveTrylockFunctionAttr(ExclusiveTrylockFunctionAttr *A) {
		437	return true;
		438	}
		439	bool TraverseExternalSourceSymbolAttr(ExternalSourceSymbolAttr *A);
		440	bool VisitExternalSourceSymbolAttr(ExternalSourceSymbolAttr *A) {
		441	return true;
		442	}
		443	bool TraverseFallThroughAttr(FallThroughAttr *A);
		444	bool VisitFallThroughAttr(FallThroughAttr *A) {
		445	return true;
		446	}
		447	bool TraverseFastCallAttr(FastCallAttr *A);
		448	bool VisitFastCallAttr(FastCallAttr *A) {
		449	return true;
		450	}
		451	bool TraverseFinalAttr(FinalAttr *A);
		452	bool VisitFinalAttr(FinalAttr *A) {
		453	return true;
		454	}
		455	bool TraverseFlagEnumAttr(FlagEnumAttr *A);
		456	bool VisitFlagEnumAttr(FlagEnumAttr *A) {
		457	return true;
		458	}
		459	bool TraverseFlattenAttr(FlattenAttr *A);
		460	bool VisitFlattenAttr(FlattenAttr *A) {
		461	return true;
		462	}
		463	bool TraverseFormatAttr(FormatAttr *A);
		464	bool VisitFormatAttr(FormatAttr *A) {
		465	return true;
		466	}
		467	bool TraverseFormatArgAttr(FormatArgAttr *A);
		468	bool VisitFormatArgAttr(FormatArgAttr *A) {
		469	return true;
		470	}
		471	bool TraverseFunctionReturnThunksAttr(FunctionReturnThunksAttr *A);
		472	bool VisitFunctionReturnThunksAttr(FunctionReturnThunksAttr *A) {
		473	return true;
		474	}
		475	bool TraverseGNUInlineAttr(GNUInlineAttr *A);
		476	bool VisitGNUInlineAttr(GNUInlineAttr *A) {
		477	return true;
		478	}
		479	bool TraverseGuardedByAttr(GuardedByAttr *A);
		480	bool VisitGuardedByAttr(GuardedByAttr *A) {
		481	return true;
		482	}
		483	bool TraverseGuardedVarAttr(GuardedVarAttr *A);
		484	bool VisitGuardedVarAttr(GuardedVarAttr *A) {
		485	return true;
		486	}
		487	bool TraverseHIPManagedAttr(HIPManagedAttr *A);
		488	bool VisitHIPManagedAttr(HIPManagedAttr *A) {
		489	return true;
		490	}
		491	bool TraverseHLSLGroupSharedAddressSpaceAttr(HLSLGroupSharedAddressSpaceAttr *A);
		492	bool VisitHLSLGroupSharedAddressSpaceAttr(HLSLGroupSharedAddressSpaceAttr *A) {
		493	return true;
		494	}
		495	bool TraverseHLSLNumThreadsAttr(HLSLNumThreadsAttr *A);
		496	bool VisitHLSLNumThreadsAttr(HLSLNumThreadsAttr *A) {
		497	return true;
		498	}
		499	bool TraverseHLSLResourceAttr(HLSLResourceAttr *A);
		500	bool VisitHLSLResourceAttr(HLSLResourceAttr *A) {
		501	return true;
		502	}
		503	bool TraverseHLSLResourceBindingAttr(HLSLResourceBindingAttr *A);
		504	bool VisitHLSLResourceBindingAttr(HLSLResourceBindingAttr *A) {
		505	return true;
		506	}
		507	bool TraverseHLSLSV_DispatchThreadIDAttr(HLSLSV_DispatchThreadIDAttr *A);
		508	bool VisitHLSLSV_DispatchThreadIDAttr(HLSLSV_DispatchThreadIDAttr *A) {
		509	return true;
		510	}
		511	bool TraverseHLSLSV_GroupIndexAttr(HLSLSV_GroupIndexAttr *A);
		512	bool VisitHLSLSV_GroupIndexAttr(HLSLSV_GroupIndexAttr *A) {
		513	return true;
		514	}
		515	bool TraverseHLSLShaderAttr(HLSLShaderAttr *A);
		516	bool VisitHLSLShaderAttr(HLSLShaderAttr *A) {
		517	return true;
		518	}
		519	bool TraverseHotAttr(HotAttr *A);
		520	bool VisitHotAttr(HotAttr *A) {
		521	return true;
		522	}
		523	bool TraverseIBActionAttr(IBActionAttr *A);
		524	bool VisitIBActionAttr(IBActionAttr *A) {
		525	return true;
		526	}
		527	bool TraverseIBOutletAttr(IBOutletAttr *A);
		528	bool VisitIBOutletAttr(IBOutletAttr *A) {
		529	return true;
		530	}
		531	bool TraverseIBOutletCollectionAttr(IBOutletCollectionAttr *A);
		532	bool VisitIBOutletCollectionAttr(IBOutletCollectionAttr *A) {
		533	return true;
		534	}
		535	bool TraverseIFuncAttr(IFuncAttr *A);
		536	bool VisitIFuncAttr(IFuncAttr *A) {
		537	return true;
		538	}
		539	bool TraverseInitPriorityAttr(InitPriorityAttr *A);
		540	bool VisitInitPriorityAttr(InitPriorityAttr *A) {
		541	return true;
		542	}
		543	bool TraverseInitSegAttr(InitSegAttr *A);
		544	bool VisitInitSegAttr(InitSegAttr *A) {
		545	return true;
		546	}
		547	bool TraverseIntelOclBiccAttr(IntelOclBiccAttr *A);
		548	bool VisitIntelOclBiccAttr(IntelOclBiccAttr *A) {
		549	return true;
		550	}
		551	bool TraverseInternalLinkageAttr(InternalLinkageAttr *A);
		552	bool VisitInternalLinkageAttr(InternalLinkageAttr *A) {
		553	return true;
		554	}
		555	bool TraverseLTOVisibilityPublicAttr(LTOVisibilityPublicAttr *A);
		556	bool VisitLTOVisibilityPublicAttr(LTOVisibilityPublicAttr *A) {
		557	return true;
		558	}
		559	bool TraverseLayoutVersionAttr(LayoutVersionAttr *A);
		560	bool VisitLayoutVersionAttr(LayoutVersionAttr *A) {
		561	return true;
		562	}
		563	bool TraverseLeafAttr(LeafAttr *A);
		564	bool VisitLeafAttr(LeafAttr *A) {
		565	return true;
		566	}
		567	bool TraverseLifetimeBoundAttr(LifetimeBoundAttr *A);
		568	bool VisitLifetimeBoundAttr(LifetimeBoundAttr *A) {
		569	return true;
		570	}
		571	bool TraverseLikelyAttr(LikelyAttr *A);
		572	bool VisitLikelyAttr(LikelyAttr *A) {
		573	return true;
		574	}
		575	bool TraverseLoaderUninitializedAttr(LoaderUninitializedAttr *A);
		576	bool VisitLoaderUninitializedAttr(LoaderUninitializedAttr *A) {
		577	return true;
		578	}
		579	bool TraverseLockReturnedAttr(LockReturnedAttr *A);
		580	bool VisitLockReturnedAttr(LockReturnedAttr *A) {
		581	return true;
		582	}
		583	bool TraverseLocksExcludedAttr(LocksExcludedAttr *A);
		584	bool VisitLocksExcludedAttr(LocksExcludedAttr *A) {
		585	return true;
		586	}
		587	bool TraverseLoopHintAttr(LoopHintAttr *A);
		588	bool VisitLoopHintAttr(LoopHintAttr *A) {
		589	return true;
		590	}
		591	bool TraverseM68kInterruptAttr(M68kInterruptAttr *A);
		592	bool VisitM68kInterruptAttr(M68kInterruptAttr *A) {
		593	return true;
		594	}
		595	bool TraverseMIGServerRoutineAttr(MIGServerRoutineAttr *A);
		596	bool VisitMIGServerRoutineAttr(MIGServerRoutineAttr *A) {
		597	return true;
		598	}
		599	bool TraverseMSABIAttr(MSABIAttr *A);
		600	bool VisitMSABIAttr(MSABIAttr *A) {
		601	return true;
		602	}
		603	bool TraverseMSAllocatorAttr(MSAllocatorAttr *A);
		604	bool VisitMSAllocatorAttr(MSAllocatorAttr *A) {
		605	return true;
		606	}
		607	bool TraverseMSInheritanceAttr(MSInheritanceAttr *A);
		608	bool VisitMSInheritanceAttr(MSInheritanceAttr *A) {
		609	return true;
		610	}
		611	bool TraverseMSNoVTableAttr(MSNoVTableAttr *A);
		612	bool VisitMSNoVTableAttr(MSNoVTableAttr *A) {
		613	return true;
		614	}
		615	bool TraverseMSP430InterruptAttr(MSP430InterruptAttr *A);
		616	bool VisitMSP430InterruptAttr(MSP430InterruptAttr *A) {
		617	return true;
		618	}
		619	bool TraverseMSStructAttr(MSStructAttr *A);
		620	bool VisitMSStructAttr(MSStructAttr *A) {
		621	return true;
		622	}
		623	bool TraverseMSVtorDispAttr(MSVtorDispAttr *A);
		624	bool VisitMSVtorDispAttr(MSVtorDispAttr *A) {
		625	return true;
		626	}
		627	bool TraverseMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A);
		628	bool VisitMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A) {
		629	return true;
		630	}
		631	bool TraverseMayAliasAttr(MayAliasAttr *A);
		632	bool VisitMayAliasAttr(MayAliasAttr *A) {
		633	return true;
		634	}
		635	bool TraverseMaybeUndefAttr(MaybeUndefAttr *A);
		636	bool VisitMaybeUndefAttr(MaybeUndefAttr *A) {
		637	return true;
		638	}
		639	bool TraverseMicroMipsAttr(MicroMipsAttr *A);
		640	bool VisitMicroMipsAttr(MicroMipsAttr *A) {
		641	return true;
		642	}
		643	bool TraverseMinSizeAttr(MinSizeAttr *A);
		644	bool VisitMinSizeAttr(MinSizeAttr *A) {
		645	return true;
		646	}
		647	bool TraverseMinVectorWidthAttr(MinVectorWidthAttr *A);
		648	bool VisitMinVectorWidthAttr(MinVectorWidthAttr *A) {
		649	return true;
		650	}
		651	bool TraverseMips16Attr(Mips16Attr *A);
		652	bool VisitMips16Attr(Mips16Attr *A) {
		653	return true;
		654	}
		655	bool TraverseMipsInterruptAttr(MipsInterruptAttr *A);
		656	bool VisitMipsInterruptAttr(MipsInterruptAttr *A) {
		657	return true;
		658	}
		659	bool TraverseMipsLongCallAttr(MipsLongCallAttr *A);
		660	bool VisitMipsLongCallAttr(MipsLongCallAttr *A) {
		661	return true;
		662	}
		663	bool TraverseMipsShortCallAttr(MipsShortCallAttr *A);
		664	bool VisitMipsShortCallAttr(MipsShortCallAttr *A) {
		665	return true;
		666	}
		667	bool TraverseModeAttr(ModeAttr *A);
		668	bool VisitModeAttr(ModeAttr *A) {
		669	return true;
		670	}
		671	bool TraverseMustTailAttr(MustTailAttr *A);
		672	bool VisitMustTailAttr(MustTailAttr *A) {
		673	return true;
		674	}
		675	bool TraverseNSConsumedAttr(NSConsumedAttr *A);
		676	bool VisitNSConsumedAttr(NSConsumedAttr *A) {
		677	return true;
		678	}
		679	bool TraverseNSConsumesSelfAttr(NSConsumesSelfAttr *A);
		680	bool VisitNSConsumesSelfAttr(NSConsumesSelfAttr *A) {
		681	return true;
		682	}
		683	bool TraverseNSErrorDomainAttr(NSErrorDomainAttr *A);
		684	bool VisitNSErrorDomainAttr(NSErrorDomainAttr *A) {
		685	return true;
		686	}
		687	bool TraverseNSReturnsAutoreleasedAttr(NSReturnsAutoreleasedAttr *A);
		688	bool VisitNSReturnsAutoreleasedAttr(NSReturnsAutoreleasedAttr *A) {
		689	return true;
		690	}
		691	bool TraverseNSReturnsNotRetainedAttr(NSReturnsNotRetainedAttr *A);
		692	bool VisitNSReturnsNotRetainedAttr(NSReturnsNotRetainedAttr *A) {
		693	return true;
		694	}
		695	bool TraverseNSReturnsRetainedAttr(NSReturnsRetainedAttr *A);
		696	bool VisitNSReturnsRetainedAttr(NSReturnsRetainedAttr *A) {
		697	return true;
		698	}
		699	bool TraverseNakedAttr(NakedAttr *A);
		700	bool VisitNakedAttr(NakedAttr *A) {
		701	return true;
		702	}
		703	bool TraverseNoAliasAttr(NoAliasAttr *A);
		704	bool VisitNoAliasAttr(NoAliasAttr *A) {
		705	return true;
		706	}
		707	bool TraverseNoBuiltinAttr(NoBuiltinAttr *A);
		708	bool VisitNoBuiltinAttr(NoBuiltinAttr *A) {
		709	return true;
		710	}
		711	bool TraverseNoCommonAttr(NoCommonAttr *A);
		712	bool VisitNoCommonAttr(NoCommonAttr *A) {
		713	return true;
		714	}
		715	bool TraverseNoDebugAttr(NoDebugAttr *A);
		716	bool VisitNoDebugAttr(NoDebugAttr *A) {
		717	return true;
		718	}
		719	bool TraverseNoDerefAttr(NoDerefAttr *A);
		720	bool VisitNoDerefAttr(NoDerefAttr *A) {
		721	return true;
		722	}
		723	bool TraverseNoDestroyAttr(NoDestroyAttr *A);
		724	bool VisitNoDestroyAttr(NoDestroyAttr *A) {
		725	return true;
		726	}
		727	bool TraverseNoDuplicateAttr(NoDuplicateAttr *A);
		728	bool VisitNoDuplicateAttr(NoDuplicateAttr *A) {
		729	return true;
		730	}
		731	bool TraverseNoEscapeAttr(NoEscapeAttr *A);
		732	bool VisitNoEscapeAttr(NoEscapeAttr *A) {
		733	return true;
		734	}
		735	bool TraverseNoInlineAttr(NoInlineAttr *A);
		736	bool VisitNoInlineAttr(NoInlineAttr *A) {
		737	return true;
		738	}
		739	bool TraverseNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A);
		740	bool VisitNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A) {
		741	return true;
		742	}
		743	bool TraverseNoMergeAttr(NoMergeAttr *A);
		744	bool VisitNoMergeAttr(NoMergeAttr *A) {
		745	return true;
		746	}
		747	bool TraverseNoMicroMipsAttr(NoMicroMipsAttr *A);
		748	bool VisitNoMicroMipsAttr(NoMicroMipsAttr *A) {
		749	return true;
		750	}
		751	bool TraverseNoMips16Attr(NoMips16Attr *A);
		752	bool VisitNoMips16Attr(NoMips16Attr *A) {
		753	return true;
		754	}
		755	bool TraverseNoProfileFunctionAttr(NoProfileFunctionAttr *A);
		756	bool VisitNoProfileFunctionAttr(NoProfileFunctionAttr *A) {
		757	return true;
		758	}
		759	bool TraverseNoRandomizeLayoutAttr(NoRandomizeLayoutAttr *A);
		760	bool VisitNoRandomizeLayoutAttr(NoRandomizeLayoutAttr *A) {
		761	return true;
		762	}
		763	bool TraverseNoReturnAttr(NoReturnAttr *A);
		764	bool VisitNoReturnAttr(NoReturnAttr *A) {
		765	return true;
		766	}
		767	bool TraverseNoSanitizeAttr(NoSanitizeAttr *A);
		768	bool VisitNoSanitizeAttr(NoSanitizeAttr *A) {
		769	return true;
		770	}
		771	bool TraverseNoSpeculativeLoadHardeningAttr(NoSpeculativeLoadHardeningAttr *A);
		772	bool VisitNoSpeculativeLoadHardeningAttr(NoSpeculativeLoadHardeningAttr *A) {
		773	return true;
		774	}
		775	bool TraverseNoSplitStackAttr(NoSplitStackAttr *A);
		776	bool VisitNoSplitStackAttr(NoSplitStackAttr *A) {
		777	return true;
		778	}
		779	bool TraverseNoStackProtectorAttr(NoStackProtectorAttr *A);
		780	bool VisitNoStackProtectorAttr(NoStackProtectorAttr *A) {
		781	return true;
		782	}
		783	bool TraverseNoThreadSafetyAnalysisAttr(NoThreadSafetyAnalysisAttr *A);
		784	bool VisitNoThreadSafetyAnalysisAttr(NoThreadSafetyAnalysisAttr *A) {
		785	return true;
		786	}
		787	bool TraverseNoThrowAttr(NoThrowAttr *A);
		788	bool VisitNoThrowAttr(NoThrowAttr *A) {
		789	return true;
		790	}
		791	bool TraverseNoUniqueAddressAttr(NoUniqueAddressAttr *A);
		792	bool VisitNoUniqueAddressAttr(NoUniqueAddressAttr *A) {
		793	return true;
		794	}
		795	bool TraverseNoUwtableAttr(NoUwtableAttr *A);
		796	bool VisitNoUwtableAttr(NoUwtableAttr *A) {
		797	return true;
		798	}
		799	bool TraverseNonNullAttr(NonNullAttr *A);
		800	bool VisitNonNullAttr(NonNullAttr *A) {
		801	return true;
		802	}
		803	bool TraverseNotTailCalledAttr(NotTailCalledAttr *A);
		804	bool VisitNotTailCalledAttr(NotTailCalledAttr *A) {
		805	return true;
		806	}
		807	bool TraverseOMPAllocateDeclAttr(OMPAllocateDeclAttr *A);
		808	bool VisitOMPAllocateDeclAttr(OMPAllocateDeclAttr *A) {
		809	return true;
		810	}
		811	bool TraverseOMPCaptureKindAttr(OMPCaptureKindAttr *A);
		812	bool VisitOMPCaptureKindAttr(OMPCaptureKindAttr *A) {
		813	return true;
		814	}
		815	bool TraverseOMPCaptureNoInitAttr(OMPCaptureNoInitAttr *A);
		816	bool VisitOMPCaptureNoInitAttr(OMPCaptureNoInitAttr *A) {
		817	return true;
		818	}
		819	bool TraverseOMPDeclareSimdDeclAttr(OMPDeclareSimdDeclAttr *A);
		820	bool VisitOMPDeclareSimdDeclAttr(OMPDeclareSimdDeclAttr *A) {
		821	return true;
		822	}
		823	bool TraverseOMPDeclareTargetDeclAttr(OMPDeclareTargetDeclAttr *A);
		824	bool VisitOMPDeclareTargetDeclAttr(OMPDeclareTargetDeclAttr *A) {
		825	return true;
		826	}
		827	bool TraverseOMPDeclareVariantAttr(OMPDeclareVariantAttr *A);
		828	bool VisitOMPDeclareVariantAttr(OMPDeclareVariantAttr *A) {
		829	return true;
		830	}
		831	bool TraverseOMPReferencedVarAttr(OMPReferencedVarAttr *A);
		832	bool VisitOMPReferencedVarAttr(OMPReferencedVarAttr *A) {
		833	return true;
		834	}
		835	bool TraverseOMPThreadPrivateDeclAttr(OMPThreadPrivateDeclAttr *A);
		836	bool VisitOMPThreadPrivateDeclAttr(OMPThreadPrivateDeclAttr *A) {
		837	return true;
		838	}
		839	bool TraverseOSConsumedAttr(OSConsumedAttr *A);
		840	bool VisitOSConsumedAttr(OSConsumedAttr *A) {
		841	return true;
		842	}
		843	bool TraverseOSConsumesThisAttr(OSConsumesThisAttr *A);
		844	bool VisitOSConsumesThisAttr(OSConsumesThisAttr *A) {
		845	return true;
		846	}
		847	bool TraverseOSReturnsNotRetainedAttr(OSReturnsNotRetainedAttr *A);
		848	bool VisitOSReturnsNotRetainedAttr(OSReturnsNotRetainedAttr *A) {
		849	return true;
		850	}
		851	bool TraverseOSReturnsRetainedAttr(OSReturnsRetainedAttr *A);
		852	bool VisitOSReturnsRetainedAttr(OSReturnsRetainedAttr *A) {
		853	return true;
		854	}
		855	bool TraverseOSReturnsRetainedOnNonZeroAttr(OSReturnsRetainedOnNonZeroAttr *A);
		856	bool VisitOSReturnsRetainedOnNonZeroAttr(OSReturnsRetainedOnNonZeroAttr *A) {
		857	return true;
		858	}
		859	bool TraverseOSReturnsRetainedOnZeroAttr(OSReturnsRetainedOnZeroAttr *A);
		860	bool VisitOSReturnsRetainedOnZeroAttr(OSReturnsRetainedOnZeroAttr *A) {
		861	return true;
		862	}
		863	bool TraverseObjCBoxableAttr(ObjCBoxableAttr *A);
		864	bool VisitObjCBoxableAttr(ObjCBoxableAttr *A) {
		865	return true;
		866	}
		867	bool TraverseObjCBridgeAttr(ObjCBridgeAttr *A);
		868	bool VisitObjCBridgeAttr(ObjCBridgeAttr *A) {
		869	return true;
		870	}
		871	bool TraverseObjCBridgeMutableAttr(ObjCBridgeMutableAttr *A);
		872	bool VisitObjCBridgeMutableAttr(ObjCBridgeMutableAttr *A) {
		873	return true;
		874	}
		875	bool TraverseObjCBridgeRelatedAttr(ObjCBridgeRelatedAttr *A);
		876	bool VisitObjCBridgeRelatedAttr(ObjCBridgeRelatedAttr *A) {
		877	return true;
		878	}
		879	bool TraverseObjCClassStubAttr(ObjCClassStubAttr *A);
		880	bool VisitObjCClassStubAttr(ObjCClassStubAttr *A) {
		881	return true;
		882	}
		883	bool TraverseObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A);
		884	bool VisitObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A) {
		885	return true;
		886	}
		887	bool TraverseObjCDirectAttr(ObjCDirectAttr *A);
		888	bool VisitObjCDirectAttr(ObjCDirectAttr *A) {
		889	return true;
		890	}
		891	bool TraverseObjCDirectMembersAttr(ObjCDirectMembersAttr *A);
		892	bool VisitObjCDirectMembersAttr(ObjCDirectMembersAttr *A) {
		893	return true;
		894	}
		895	bool TraverseObjCExceptionAttr(ObjCExceptionAttr *A);
		896	bool VisitObjCExceptionAttr(ObjCExceptionAttr *A) {
		897	return true;
		898	}
		899	bool TraverseObjCExplicitProtocolImplAttr(ObjCExplicitProtocolImplAttr *A);
		900	bool VisitObjCExplicitProtocolImplAttr(ObjCExplicitProtocolImplAttr *A) {
		901	return true;
		902	}
		903	bool TraverseObjCExternallyRetainedAttr(ObjCExternallyRetainedAttr *A);
		904	bool VisitObjCExternallyRetainedAttr(ObjCExternallyRetainedAttr *A) {
		905	return true;
		906	}
		907	bool TraverseObjCGCAttr(ObjCGCAttr *A);
		908	bool VisitObjCGCAttr(ObjCGCAttr *A) {
		909	return true;
		910	}
		911	bool TraverseObjCIndependentClassAttr(ObjCIndependentClassAttr *A);
		912	bool VisitObjCIndependentClassAttr(ObjCIndependentClassAttr *A) {
		913	return true;
		914	}
		915	bool TraverseObjCInertUnsafeUnretainedAttr(ObjCInertUnsafeUnretainedAttr *A);
		916	bool VisitObjCInertUnsafeUnretainedAttr(ObjCInertUnsafeUnretainedAttr *A) {
		917	return true;
		918	}
		919	bool TraverseObjCKindOfAttr(ObjCKindOfAttr *A);
		920	bool VisitObjCKindOfAttr(ObjCKindOfAttr *A) {
		921	return true;
		922	}
		923	bool TraverseObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A);
		924	bool VisitObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A) {
		925	return true;
		926	}
		927	bool TraverseObjCNSObjectAttr(ObjCNSObjectAttr *A);
		928	bool VisitObjCNSObjectAttr(ObjCNSObjectAttr *A) {
		929	return true;
		930	}
		931	bool TraverseObjCNonLazyClassAttr(ObjCNonLazyClassAttr *A);
		932	bool VisitObjCNonLazyClassAttr(ObjCNonLazyClassAttr *A) {
		933	return true;
		934	}
		935	bool TraverseObjCNonRuntimeProtocolAttr(ObjCNonRuntimeProtocolAttr *A);
		936	bool VisitObjCNonRuntimeProtocolAttr(ObjCNonRuntimeProtocolAttr *A) {
		937	return true;
		938	}
		939	bool TraverseObjCOwnershipAttr(ObjCOwnershipAttr *A);
		940	bool VisitObjCOwnershipAttr(ObjCOwnershipAttr *A) {
		941	return true;
		942	}
		943	bool TraverseObjCPreciseLifetimeAttr(ObjCPreciseLifetimeAttr *A);
		944	bool VisitObjCPreciseLifetimeAttr(ObjCPreciseLifetimeAttr *A) {
		945	return true;
		946	}
		947	bool TraverseObjCRequiresPropertyDefsAttr(ObjCRequiresPropertyDefsAttr *A);
		948	bool VisitObjCRequiresPropertyDefsAttr(ObjCRequiresPropertyDefsAttr *A) {
		949	return true;
		950	}
		951	bool TraverseObjCRequiresSuperAttr(ObjCRequiresSuperAttr *A);
		952	bool VisitObjCRequiresSuperAttr(ObjCRequiresSuperAttr *A) {
		953	return true;
		954	}
		955	bool TraverseObjCReturnsInnerPointerAttr(ObjCReturnsInnerPointerAttr *A);
		956	bool VisitObjCReturnsInnerPointerAttr(ObjCReturnsInnerPointerAttr *A) {
		957	return true;
		958	}
		959	bool TraverseObjCRootClassAttr(ObjCRootClassAttr *A);
		960	bool VisitObjCRootClassAttr(ObjCRootClassAttr *A) {
		961	return true;
		962	}
		963	bool TraverseObjCRuntimeNameAttr(ObjCRuntimeNameAttr *A);
		964	bool VisitObjCRuntimeNameAttr(ObjCRuntimeNameAttr *A) {
		965	return true;
		966	}
		967	bool TraverseObjCRuntimeVisibleAttr(ObjCRuntimeVisibleAttr *A);
		968	bool VisitObjCRuntimeVisibleAttr(ObjCRuntimeVisibleAttr *A) {
		969	return true;
		970	}
		971	bool TraverseObjCSubclassingRestrictedAttr(ObjCSubclassingRestrictedAttr *A);
		972	bool VisitObjCSubclassingRestrictedAttr(ObjCSubclassingRestrictedAttr *A) {
		973	return true;
		974	}
		975	bool TraverseOpenCLAccessAttr(OpenCLAccessAttr *A);
		976	bool VisitOpenCLAccessAttr(OpenCLAccessAttr *A) {
		977	return true;
		978	}
		979	bool TraverseOpenCLConstantAddressSpaceAttr(OpenCLConstantAddressSpaceAttr *A);
		980	bool VisitOpenCLConstantAddressSpaceAttr(OpenCLConstantAddressSpaceAttr *A) {
		981	return true;
		982	}
		983	bool TraverseOpenCLGenericAddressSpaceAttr(OpenCLGenericAddressSpaceAttr *A);
		984	bool VisitOpenCLGenericAddressSpaceAttr(OpenCLGenericAddressSpaceAttr *A) {
		985	return true;
		986	}
		987	bool TraverseOpenCLGlobalAddressSpaceAttr(OpenCLGlobalAddressSpaceAttr *A);
		988	bool VisitOpenCLGlobalAddressSpaceAttr(OpenCLGlobalAddressSpaceAttr *A) {
		989	return true;
		990	}
		991	bool TraverseOpenCLGlobalDeviceAddressSpaceAttr(OpenCLGlobalDeviceAddressSpaceAttr *A);
		992	bool VisitOpenCLGlobalDeviceAddressSpaceAttr(OpenCLGlobalDeviceAddressSpaceAttr *A) {
		993	return true;
		994	}
		995	bool TraverseOpenCLGlobalHostAddressSpaceAttr(OpenCLGlobalHostAddressSpaceAttr *A);
		996	bool VisitOpenCLGlobalHostAddressSpaceAttr(OpenCLGlobalHostAddressSpaceAttr *A) {
		997	return true;
		998	}
		999	bool TraverseOpenCLIntelReqdSubGroupSizeAttr(OpenCLIntelReqdSubGroupSizeAttr *A);
		1000	bool VisitOpenCLIntelReqdSubGroupSizeAttr(OpenCLIntelReqdSubGroupSizeAttr *A) {
		1001	return true;
		1002	}
		1003	bool TraverseOpenCLKernelAttr(OpenCLKernelAttr *A);
		1004	bool VisitOpenCLKernelAttr(OpenCLKernelAttr *A) {
		1005	return true;
		1006	}
		1007	bool TraverseOpenCLLocalAddressSpaceAttr(OpenCLLocalAddressSpaceAttr *A);
		1008	bool VisitOpenCLLocalAddressSpaceAttr(OpenCLLocalAddressSpaceAttr *A) {
		1009	return true;
		1010	}
		1011	bool TraverseOpenCLPrivateAddressSpaceAttr(OpenCLPrivateAddressSpaceAttr *A);
		1012	bool VisitOpenCLPrivateAddressSpaceAttr(OpenCLPrivateAddressSpaceAttr *A) {
		1013	return true;
		1014	}
		1015	bool TraverseOpenCLUnrollHintAttr(OpenCLUnrollHintAttr *A);
		1016	bool VisitOpenCLUnrollHintAttr(OpenCLUnrollHintAttr *A) {
		1017	return true;
		1018	}
		1019	bool TraverseOptimizeNoneAttr(OptimizeNoneAttr *A);
		1020	bool VisitOptimizeNoneAttr(OptimizeNoneAttr *A) {
		1021	return true;
		1022	}
		1023	bool TraverseOverloadableAttr(OverloadableAttr *A);
		1024	bool VisitOverloadableAttr(OverloadableAttr *A) {
		1025	return true;
		1026	}
		1027	bool TraverseOverrideAttr(OverrideAttr *A);
		1028	bool VisitOverrideAttr(OverrideAttr *A) {
		1029	return true;
		1030	}
		1031	bool TraverseOwnerAttr(OwnerAttr *A);
		1032	bool VisitOwnerAttr(OwnerAttr *A) {
		1033	return true;
		1034	}
		1035	bool TraverseOwnershipAttr(OwnershipAttr *A);
		1036	bool VisitOwnershipAttr(OwnershipAttr *A) {
		1037	return true;
		1038	}
		1039	bool TraversePackedAttr(PackedAttr *A);
		1040	bool VisitPackedAttr(PackedAttr *A) {
		1041	return true;
		1042	}
		1043	bool TraverseParamTypestateAttr(ParamTypestateAttr *A);
		1044	bool VisitParamTypestateAttr(ParamTypestateAttr *A) {
		1045	return true;
		1046	}
		1047	bool TraversePascalAttr(PascalAttr *A);
		1048	bool VisitPascalAttr(PascalAttr *A) {
		1049	return true;
		1050	}
		1051	bool TraversePassObjectSizeAttr(PassObjectSizeAttr *A);
		1052	bool VisitPassObjectSizeAttr(PassObjectSizeAttr *A) {
		1053	return true;
		1054	}
		1055	bool TraversePatchableFunctionEntryAttr(PatchableFunctionEntryAttr *A);
		1056	bool VisitPatchableFunctionEntryAttr(PatchableFunctionEntryAttr *A) {
		1057	return true;
		1058	}
		1059	bool TraversePcsAttr(PcsAttr *A);
		1060	bool VisitPcsAttr(PcsAttr *A) {
		1061	return true;
		1062	}
		1063	bool TraversePointerAttr(PointerAttr *A);
		1064	bool VisitPointerAttr(PointerAttr *A) {
		1065	return true;
		1066	}
		1067	bool TraversePragmaClangBSSSectionAttr(PragmaClangBSSSectionAttr *A);
		1068	bool VisitPragmaClangBSSSectionAttr(PragmaClangBSSSectionAttr *A) {
		1069	return true;
		1070	}
		1071	bool TraversePragmaClangDataSectionAttr(PragmaClangDataSectionAttr *A);
		1072	bool VisitPragmaClangDataSectionAttr(PragmaClangDataSectionAttr *A) {
		1073	return true;
		1074	}
		1075	bool TraversePragmaClangRelroSectionAttr(PragmaClangRelroSectionAttr *A);
		1076	bool VisitPragmaClangRelroSectionAttr(PragmaClangRelroSectionAttr *A) {
		1077	return true;
		1078	}
		1079	bool TraversePragmaClangRodataSectionAttr(PragmaClangRodataSectionAttr *A);
		1080	bool VisitPragmaClangRodataSectionAttr(PragmaClangRodataSectionAttr *A) {
		1081	return true;
		1082	}
		1083	bool TraversePragmaClangTextSectionAttr(PragmaClangTextSectionAttr *A);
		1084	bool VisitPragmaClangTextSectionAttr(PragmaClangTextSectionAttr *A) {
		1085	return true;
		1086	}
		1087	bool TraversePreferredNameAttr(PreferredNameAttr *A);
		1088	bool VisitPreferredNameAttr(PreferredNameAttr *A) {
		1089	return true;
		1090	}
		1091	bool TraversePreserveAllAttr(PreserveAllAttr *A);
		1092	bool VisitPreserveAllAttr(PreserveAllAttr *A) {
		1093	return true;
		1094	}
		1095	bool TraversePreserveMostAttr(PreserveMostAttr *A);
		1096	bool VisitPreserveMostAttr(PreserveMostAttr *A) {
		1097	return true;
		1098	}
		1099	bool TraversePtGuardedByAttr(PtGuardedByAttr *A);
		1100	bool VisitPtGuardedByAttr(PtGuardedByAttr *A) {
		1101	return true;
		1102	}
		1103	bool TraversePtGuardedVarAttr(PtGuardedVarAttr *A);
		1104	bool VisitPtGuardedVarAttr(PtGuardedVarAttr *A) {
		1105	return true;
		1106	}
		1107	bool TraversePtr32Attr(Ptr32Attr *A);
		1108	bool VisitPtr32Attr(Ptr32Attr *A) {
		1109	return true;
		1110	}
		1111	bool TraversePtr64Attr(Ptr64Attr *A);
		1112	bool VisitPtr64Attr(Ptr64Attr *A) {
		1113	return true;
		1114	}
		1115	bool TraversePureAttr(PureAttr *A);
		1116	bool VisitPureAttr(PureAttr *A) {
		1117	return true;
		1118	}
		1119	bool TraverseRISCVInterruptAttr(RISCVInterruptAttr *A);
		1120	bool VisitRISCVInterruptAttr(RISCVInterruptAttr *A) {
		1121	return true;
		1122	}
		1123	bool TraverseRandomizeLayoutAttr(RandomizeLayoutAttr *A);
		1124	bool VisitRandomizeLayoutAttr(RandomizeLayoutAttr *A) {
		1125	return true;
		1126	}
		1127	bool TraverseReadOnlyPlacementAttr(ReadOnlyPlacementAttr *A);
		1128	bool VisitReadOnlyPlacementAttr(ReadOnlyPlacementAttr *A) {
		1129	return true;
		1130	}
		1131	bool TraverseRegCallAttr(RegCallAttr *A);
		1132	bool VisitRegCallAttr(RegCallAttr *A) {
		1133	return true;
		1134	}
		1135	bool TraverseReinitializesAttr(ReinitializesAttr *A);
		1136	bool VisitReinitializesAttr(ReinitializesAttr *A) {
		1137	return true;
		1138	}
		1139	bool TraverseReleaseCapabilityAttr(ReleaseCapabilityAttr *A);
		1140	bool VisitReleaseCapabilityAttr(ReleaseCapabilityAttr *A) {
		1141	return true;
		1142	}
		1143	bool TraverseReleaseHandleAttr(ReleaseHandleAttr *A);
		1144	bool VisitReleaseHandleAttr(ReleaseHandleAttr *A) {
		1145	return true;
		1146	}
		1147	bool TraverseRenderScriptKernelAttr(RenderScriptKernelAttr *A);
		1148	bool VisitRenderScriptKernelAttr(RenderScriptKernelAttr *A) {
		1149	return true;
		1150	}
		1151	bool TraverseReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A);
		1152	bool VisitReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A) {
		1153	return true;
		1154	}
		1155	bool TraverseRequiresCapabilityAttr(RequiresCapabilityAttr *A);
		1156	bool VisitRequiresCapabilityAttr(RequiresCapabilityAttr *A) {
		1157	return true;
		1158	}
		1159	bool TraverseRestrictAttr(RestrictAttr *A);
		1160	bool VisitRestrictAttr(RestrictAttr *A) {
		1161	return true;
		1162	}
		1163	bool TraverseRetainAttr(RetainAttr *A);
		1164	bool VisitRetainAttr(RetainAttr *A) {
		1165	return true;
		1166	}
		1167	bool TraverseReturnTypestateAttr(ReturnTypestateAttr *A);
		1168	bool VisitReturnTypestateAttr(ReturnTypestateAttr *A) {
		1169	return true;
		1170	}
		1171	bool TraverseReturnsNonNullAttr(ReturnsNonNullAttr *A);
		1172	bool VisitReturnsNonNullAttr(ReturnsNonNullAttr *A) {
		1173	return true;
		1174	}
		1175	bool TraverseReturnsTwiceAttr(ReturnsTwiceAttr *A);
		1176	bool VisitReturnsTwiceAttr(ReturnsTwiceAttr *A) {
		1177	return true;
		1178	}
		1179	bool TraverseSPtrAttr(SPtrAttr *A);
		1180	bool VisitSPtrAttr(SPtrAttr *A) {
		1181	return true;
		1182	}
		1183	bool TraverseSYCLKernelAttr(SYCLKernelAttr *A);
		1184	bool VisitSYCLKernelAttr(SYCLKernelAttr *A) {
		1185	return true;
		1186	}
		1187	bool TraverseSYCLSpecialClassAttr(SYCLSpecialClassAttr *A);
		1188	bool VisitSYCLSpecialClassAttr(SYCLSpecialClassAttr *A) {
		1189	return true;
		1190	}
		1191	bool TraverseScopedLockableAttr(ScopedLockableAttr *A);
		1192	bool VisitScopedLockableAttr(ScopedLockableAttr *A) {
		1193	return true;
		1194	}
		1195	bool TraverseSectionAttr(SectionAttr *A);
		1196	bool VisitSectionAttr(SectionAttr *A) {
		1197	return true;
		1198	}
		1199	bool TraverseSelectAnyAttr(SelectAnyAttr *A);
		1200	bool VisitSelectAnyAttr(SelectAnyAttr *A) {
		1201	return true;
		1202	}
		1203	bool TraverseSentinelAttr(SentinelAttr *A);
		1204	bool VisitSentinelAttr(SentinelAttr *A) {
		1205	return true;
		1206	}
		1207	bool TraverseSetTypestateAttr(SetTypestateAttr *A);
		1208	bool VisitSetTypestateAttr(SetTypestateAttr *A) {
		1209	return true;
		1210	}
		1211	bool TraverseSharedTrylockFunctionAttr(SharedTrylockFunctionAttr *A);
		1212	bool VisitSharedTrylockFunctionAttr(SharedTrylockFunctionAttr *A) {
		1213	return true;
		1214	}
		1215	bool TraverseSpeculativeLoadHardeningAttr(SpeculativeLoadHardeningAttr *A);
		1216	bool VisitSpeculativeLoadHardeningAttr(SpeculativeLoadHardeningAttr *A) {
		1217	return true;
		1218	}
		1219	bool TraverseStandaloneDebugAttr(StandaloneDebugAttr *A);
		1220	bool VisitStandaloneDebugAttr(StandaloneDebugAttr *A) {
		1221	return true;
		1222	}
		1223	bool TraverseStdCallAttr(StdCallAttr *A);
		1224	bool VisitStdCallAttr(StdCallAttr *A) {
		1225	return true;
		1226	}
		1227	bool TraverseStrictFPAttr(StrictFPAttr *A);
		1228	bool VisitStrictFPAttr(StrictFPAttr *A) {
		1229	return true;
		1230	}
		1231	bool TraverseStrictGuardStackCheckAttr(StrictGuardStackCheckAttr *A);
		1232	bool VisitStrictGuardStackCheckAttr(StrictGuardStackCheckAttr *A) {
		1233	return true;
		1234	}
		1235	bool TraverseSuppressAttr(SuppressAttr *A);
		1236	bool VisitSuppressAttr(SuppressAttr *A) {
		1237	return true;
		1238	}
		1239	bool TraverseSwiftAsyncAttr(SwiftAsyncAttr *A);
		1240	bool VisitSwiftAsyncAttr(SwiftAsyncAttr *A) {
		1241	return true;
		1242	}
		1243	bool TraverseSwiftAsyncCallAttr(SwiftAsyncCallAttr *A);
		1244	bool VisitSwiftAsyncCallAttr(SwiftAsyncCallAttr *A) {
		1245	return true;
		1246	}
		1247	bool TraverseSwiftAsyncContextAttr(SwiftAsyncContextAttr *A);
		1248	bool VisitSwiftAsyncContextAttr(SwiftAsyncContextAttr *A) {
		1249	return true;
		1250	}
		1251	bool TraverseSwiftAsyncErrorAttr(SwiftAsyncErrorAttr *A);
		1252	bool VisitSwiftAsyncErrorAttr(SwiftAsyncErrorAttr *A) {
		1253	return true;
		1254	}
		1255	bool TraverseSwiftAsyncNameAttr(SwiftAsyncNameAttr *A);
		1256	bool VisitSwiftAsyncNameAttr(SwiftAsyncNameAttr *A) {
		1257	return true;
		1258	}
		1259	bool TraverseSwiftAttrAttr(SwiftAttrAttr *A);
		1260	bool VisitSwiftAttrAttr(SwiftAttrAttr *A) {
		1261	return true;
		1262	}
		1263	bool TraverseSwiftBridgeAttr(SwiftBridgeAttr *A);
		1264	bool VisitSwiftBridgeAttr(SwiftBridgeAttr *A) {
		1265	return true;
		1266	}
		1267	bool TraverseSwiftBridgedTypedefAttr(SwiftBridgedTypedefAttr *A);
		1268	bool VisitSwiftBridgedTypedefAttr(SwiftBridgedTypedefAttr *A) {
		1269	return true;
		1270	}
		1271	bool TraverseSwiftCallAttr(SwiftCallAttr *A);
		1272	bool VisitSwiftCallAttr(SwiftCallAttr *A) {
		1273	return true;
		1274	}
		1275	bool TraverseSwiftContextAttr(SwiftContextAttr *A);
		1276	bool VisitSwiftContextAttr(SwiftContextAttr *A) {
		1277	return true;
		1278	}
		1279	bool TraverseSwiftErrorAttr(SwiftErrorAttr *A);
		1280	bool VisitSwiftErrorAttr(SwiftErrorAttr *A) {
		1281	return true;
		1282	}
		1283	bool TraverseSwiftErrorResultAttr(SwiftErrorResultAttr *A);
		1284	bool VisitSwiftErrorResultAttr(SwiftErrorResultAttr *A) {
		1285	return true;
		1286	}
		1287	bool TraverseSwiftIndirectResultAttr(SwiftIndirectResultAttr *A);
		1288	bool VisitSwiftIndirectResultAttr(SwiftIndirectResultAttr *A) {
		1289	return true;
		1290	}
		1291	bool TraverseSwiftNameAttr(SwiftNameAttr *A);
		1292	bool VisitSwiftNameAttr(SwiftNameAttr *A) {
		1293	return true;
		1294	}
		1295	bool TraverseSwiftNewTypeAttr(SwiftNewTypeAttr *A);
		1296	bool VisitSwiftNewTypeAttr(SwiftNewTypeAttr *A) {
		1297	return true;
		1298	}
		1299	bool TraverseSwiftObjCMembersAttr(SwiftObjCMembersAttr *A);
		1300	bool VisitSwiftObjCMembersAttr(SwiftObjCMembersAttr *A) {
		1301	return true;
		1302	}
		1303	bool TraverseSwiftPrivateAttr(SwiftPrivateAttr *A);
		1304	bool VisitSwiftPrivateAttr(SwiftPrivateAttr *A) {
		1305	return true;
		1306	}
		1307	bool TraverseSysVABIAttr(SysVABIAttr *A);
		1308	bool VisitSysVABIAttr(SysVABIAttr *A) {
		1309	return true;
		1310	}
		1311	bool TraverseTLSModelAttr(TLSModelAttr *A);
		1312	bool VisitTLSModelAttr(TLSModelAttr *A) {
		1313	return true;
		1314	}
		1315	bool TraverseTargetAttr(TargetAttr *A);
		1316	bool VisitTargetAttr(TargetAttr *A) {
		1317	return true;
		1318	}
		1319	bool TraverseTargetClonesAttr(TargetClonesAttr *A);
		1320	bool VisitTargetClonesAttr(TargetClonesAttr *A) {
		1321	return true;
		1322	}
		1323	bool TraverseTargetVersionAttr(TargetVersionAttr *A);
		1324	bool VisitTargetVersionAttr(TargetVersionAttr *A) {
		1325	return true;
		1326	}
		1327	bool TraverseTestTypestateAttr(TestTypestateAttr *A);
		1328	bool VisitTestTypestateAttr(TestTypestateAttr *A) {
		1329	return true;
		1330	}
		1331	bool TraverseThisCallAttr(ThisCallAttr *A);
		1332	bool VisitThisCallAttr(ThisCallAttr *A) {
		1333	return true;
		1334	}
		1335	bool TraverseThreadAttr(ThreadAttr *A);
		1336	bool VisitThreadAttr(ThreadAttr *A) {
		1337	return true;
		1338	}
		1339	bool TraverseTransparentUnionAttr(TransparentUnionAttr *A);
		1340	bool VisitTransparentUnionAttr(TransparentUnionAttr *A) {
		1341	return true;
		1342	}
		1343	bool TraverseTrivialABIAttr(TrivialABIAttr *A);
		1344	bool VisitTrivialABIAttr(TrivialABIAttr *A) {
		1345	return true;
		1346	}
		1347	bool TraverseTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A);
		1348	bool VisitTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A) {
		1349	return true;
		1350	}
		1351	bool TraverseTypeNonNullAttr(TypeNonNullAttr *A);
		1352	bool VisitTypeNonNullAttr(TypeNonNullAttr *A) {
		1353	return true;
		1354	}
		1355	bool TraverseTypeNullUnspecifiedAttr(TypeNullUnspecifiedAttr *A);
		1356	bool VisitTypeNullUnspecifiedAttr(TypeNullUnspecifiedAttr *A) {
		1357	return true;
		1358	}
		1359	bool TraverseTypeNullableAttr(TypeNullableAttr *A);
		1360	bool VisitTypeNullableAttr(TypeNullableAttr *A) {
		1361	return true;
		1362	}
		1363	bool TraverseTypeNullableResultAttr(TypeNullableResultAttr *A);
		1364	bool VisitTypeNullableResultAttr(TypeNullableResultAttr *A) {
		1365	return true;
		1366	}
		1367	bool TraverseTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A);
		1368	bool VisitTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A) {
		1369	return true;
		1370	}
		1371	bool TraverseTypeVisibilityAttr(TypeVisibilityAttr *A);
		1372	bool VisitTypeVisibilityAttr(TypeVisibilityAttr *A) {
		1373	return true;
		1374	}
		1375	bool TraverseUPtrAttr(UPtrAttr *A);
		1376	bool VisitUPtrAttr(UPtrAttr *A) {
		1377	return true;
		1378	}
		1379	bool TraverseUnavailableAttr(UnavailableAttr *A);
		1380	bool VisitUnavailableAttr(UnavailableAttr *A) {
		1381	return true;
		1382	}
		1383	bool TraverseUninitializedAttr(UninitializedAttr *A);
		1384	bool VisitUninitializedAttr(UninitializedAttr *A) {
		1385	return true;
		1386	}
		1387	bool TraverseUnlikelyAttr(UnlikelyAttr *A);
		1388	bool VisitUnlikelyAttr(UnlikelyAttr *A) {
		1389	return true;
		1390	}
		1391	bool TraverseUnusedAttr(UnusedAttr *A);
		1392	bool VisitUnusedAttr(UnusedAttr *A) {
		1393	return true;
		1394	}
		1395	bool TraverseUseHandleAttr(UseHandleAttr *A);
		1396	bool VisitUseHandleAttr(UseHandleAttr *A) {
		1397	return true;
		1398	}
		1399	bool TraverseUsedAttr(UsedAttr *A);
		1400	bool VisitUsedAttr(UsedAttr *A) {
		1401	return true;
		1402	}
		1403	bool TraverseUsingIfExistsAttr(UsingIfExistsAttr *A);
		1404	bool VisitUsingIfExistsAttr(UsingIfExistsAttr *A) {
		1405	return true;
		1406	}
		1407	bool TraverseUuidAttr(UuidAttr *A);
		1408	bool VisitUuidAttr(UuidAttr *A) {
		1409	return true;
		1410	}
		1411	bool TraverseVecReturnAttr(VecReturnAttr *A);
		1412	bool VisitVecReturnAttr(VecReturnAttr *A) {
		1413	return true;
		1414	}
		1415	bool TraverseVecTypeHintAttr(VecTypeHintAttr *A);
		1416	bool VisitVecTypeHintAttr(VecTypeHintAttr *A) {
		1417	return true;
		1418	}
		1419	bool TraverseVectorCallAttr(VectorCallAttr *A);
		1420	bool VisitVectorCallAttr(VectorCallAttr *A) {
		1421	return true;
		1422	}
		1423	bool TraverseVisibilityAttr(VisibilityAttr *A);
		1424	bool VisitVisibilityAttr(VisibilityAttr *A) {
		1425	return true;
		1426	}
		1427	bool TraverseWarnUnusedAttr(WarnUnusedAttr *A);
		1428	bool VisitWarnUnusedAttr(WarnUnusedAttr *A) {
		1429	return true;
		1430	}
		1431	bool TraverseWarnUnusedResultAttr(WarnUnusedResultAttr *A);
		1432	bool VisitWarnUnusedResultAttr(WarnUnusedResultAttr *A) {
		1433	return true;
		1434	}
		1435	bool TraverseWeakAttr(WeakAttr *A);
		1436	bool VisitWeakAttr(WeakAttr *A) {
		1437	return true;
		1438	}
		1439	bool TraverseWeakImportAttr(WeakImportAttr *A);
		1440	bool VisitWeakImportAttr(WeakImportAttr *A) {
		1441	return true;
		1442	}
		1443	bool TraverseWeakRefAttr(WeakRefAttr *A);
		1444	bool VisitWeakRefAttr(WeakRefAttr *A) {
		1445	return true;
		1446	}
		1447	bool TraverseWebAssemblyExportNameAttr(WebAssemblyExportNameAttr *A);
		1448	bool VisitWebAssemblyExportNameAttr(WebAssemblyExportNameAttr *A) {
		1449	return true;
		1450	}
		1451	bool TraverseWebAssemblyImportModuleAttr(WebAssemblyImportModuleAttr *A);
		1452	bool VisitWebAssemblyImportModuleAttr(WebAssemblyImportModuleAttr *A) {
		1453	return true;
		1454	}
		1455	bool TraverseWebAssemblyImportNameAttr(WebAssemblyImportNameAttr *A);
		1456	bool VisitWebAssemblyImportNameAttr(WebAssemblyImportNameAttr *A) {
		1457	return true;
		1458	}
		1459	bool TraverseWorkGroupSizeHintAttr(WorkGroupSizeHintAttr *A);
		1460	bool VisitWorkGroupSizeHintAttr(WorkGroupSizeHintAttr *A) {
		1461	return true;
		1462	}
		1463	bool TraverseX86ForceAlignArgPointerAttr(X86ForceAlignArgPointerAttr *A);
		1464	bool VisitX86ForceAlignArgPointerAttr(X86ForceAlignArgPointerAttr *A) {
		1465	return true;
		1466	}
		1467	bool TraverseXRayInstrumentAttr(XRayInstrumentAttr *A);
		1468	bool VisitXRayInstrumentAttr(XRayInstrumentAttr *A) {
		1469	return true;
		1470	}
		1471	bool TraverseXRayLogArgsAttr(XRayLogArgsAttr *A);
		1472	bool VisitXRayLogArgsAttr(XRayLogArgsAttr *A) {
		1473	return true;
		1474	}
		1475	bool TraverseZeroCallUsedRegsAttr(ZeroCallUsedRegsAttr *A);
		1476	bool VisitZeroCallUsedRegsAttr(ZeroCallUsedRegsAttr *A) {
		1477	return true;
		1478	}
		1479
		1480	#else // ATTR_VISITOR_DECLS_ONLY
		1481
		1482	template <typename Derived>
		1483	bool VISITORCLASS<Derived>::TraverseAArch64SVEPcsAttr(AArch64SVEPcsAttr *A) {
		1484	if (!getDerived().VisitAttr(A))
		1485	return false;
		1486	if (!getDerived().VisitAArch64SVEPcsAttr(A))
		1487	return false;
		1488	return true;
		1489	}
		1490
		1491	template <typename Derived>
		1492	bool VISITORCLASS<Derived>::TraverseAArch64VectorPcsAttr(AArch64VectorPcsAttr *A) {
		1493	if (!getDerived().VisitAttr(A))
		1494	return false;
		1495	if (!getDerived().VisitAArch64VectorPcsAttr(A))
		1496	return false;
		1497	return true;
		1498	}
		1499
		1500	template <typename Derived>
		1501	bool VISITORCLASS<Derived>::TraverseAMDGPUFlatWorkGroupSizeAttr(AMDGPUFlatWorkGroupSizeAttr *A) {
		1502	if (!getDerived().VisitAttr(A))
		1503	return false;
		1504	if (!getDerived().VisitAMDGPUFlatWorkGroupSizeAttr(A))
		1505	return false;
		1506	if (!getDerived().TraverseStmt(A->getMin()))
		1507	return false;
		1508	if (!getDerived().TraverseStmt(A->getMax()))
		1509	return false;
		1510	return true;
		1511	}
		1512
		1513	template <typename Derived>
		1514	bool VISITORCLASS<Derived>::TraverseAMDGPUKernelCallAttr(AMDGPUKernelCallAttr *A) {
		1515	if (!getDerived().VisitAttr(A))
		1516	return false;
		1517	if (!getDerived().VisitAMDGPUKernelCallAttr(A))
		1518	return false;
		1519	return true;
		1520	}
		1521
		1522	template <typename Derived>
		1523	bool VISITORCLASS<Derived>::TraverseAMDGPUNumSGPRAttr(AMDGPUNumSGPRAttr *A) {
		1524	if (!getDerived().VisitAttr(A))
		1525	return false;
		1526	if (!getDerived().VisitAMDGPUNumSGPRAttr(A))
		1527	return false;
		1528	return true;
		1529	}
		1530
		1531	template <typename Derived>
		1532	bool VISITORCLASS<Derived>::TraverseAMDGPUNumVGPRAttr(AMDGPUNumVGPRAttr *A) {
		1533	if (!getDerived().VisitAttr(A))
		1534	return false;
		1535	if (!getDerived().VisitAMDGPUNumVGPRAttr(A))
		1536	return false;
		1537	return true;
		1538	}
		1539
		1540	template <typename Derived>
		1541	bool VISITORCLASS<Derived>::TraverseAMDGPUWavesPerEUAttr(AMDGPUWavesPerEUAttr *A) {
		1542	if (!getDerived().VisitAttr(A))
		1543	return false;
		1544	if (!getDerived().VisitAMDGPUWavesPerEUAttr(A))
		1545	return false;
		1546	if (!getDerived().TraverseStmt(A->getMin()))
		1547	return false;
		1548	if (!getDerived().TraverseStmt(A->getMax()))
		1549	return false;
		1550	return true;
		1551	}
		1552
		1553	template <typename Derived>
		1554	bool VISITORCLASS<Derived>::TraverseARMInterruptAttr(ARMInterruptAttr *A) {
		1555	if (!getDerived().VisitAttr(A))
		1556	return false;
		1557	if (!getDerived().VisitARMInterruptAttr(A))
		1558	return false;
		1559	return true;
		1560	}
		1561
		1562	template <typename Derived>
		1563	bool VISITORCLASS<Derived>::TraverseAVRInterruptAttr(AVRInterruptAttr *A) {
		1564	if (!getDerived().VisitAttr(A))
		1565	return false;
		1566	if (!getDerived().VisitAVRInterruptAttr(A))
		1567	return false;
		1568	return true;
		1569	}
		1570
		1571	template <typename Derived>
		1572	bool VISITORCLASS<Derived>::TraverseAVRSignalAttr(AVRSignalAttr *A) {
		1573	if (!getDerived().VisitAttr(A))
		1574	return false;
		1575	if (!getDerived().VisitAVRSignalAttr(A))
		1576	return false;
		1577	return true;
		1578	}
		1579
		1580	template <typename Derived>
		1581	bool VISITORCLASS<Derived>::TraverseAbiTagAttr(AbiTagAttr *A) {
		1582	if (!getDerived().VisitAttr(A))
		1583	return false;
		1584	if (!getDerived().VisitAbiTagAttr(A))
		1585	return false;
		1586	return true;
		1587	}
		1588
		1589	template <typename Derived>
		1590	bool VISITORCLASS<Derived>::TraverseAcquireCapabilityAttr(AcquireCapabilityAttr *A) {
		1591	if (!getDerived().VisitAttr(A))
		1592	return false;
		1593	if (!getDerived().VisitAcquireCapabilityAttr(A))
		1594	return false;
		1595	{
		1596	Expr * *I = A->args_begin();
		1597	Expr * *E = A->args_end();
		1598	for (; I != E; ++I) {
		1599	if (!getDerived().TraverseStmt(*I))
		1600	return false;
		1601	}
		1602	}
		1603	return true;
		1604	}
		1605
		1606	template <typename Derived>
		1607	bool VISITORCLASS<Derived>::TraverseAcquireHandleAttr(AcquireHandleAttr *A) {
		1608	if (!getDerived().VisitAttr(A))
		1609	return false;
		1610	if (!getDerived().VisitAcquireHandleAttr(A))
		1611	return false;
		1612	return true;
		1613	}
		1614
		1615	template <typename Derived>
		1616	bool VISITORCLASS<Derived>::TraverseAcquiredAfterAttr(AcquiredAfterAttr *A) {
		1617	if (!getDerived().VisitAttr(A))
		1618	return false;
		1619	if (!getDerived().VisitAcquiredAfterAttr(A))
		1620	return false;
		1621	{
		1622	Expr * *I = A->args_begin();
		1623	Expr * *E = A->args_end();
		1624	for (; I != E; ++I) {
		1625	if (!getDerived().TraverseStmt(*I))
		1626	return false;
		1627	}
		1628	}
		1629	return true;
		1630	}
		1631
		1632	template <typename Derived>
		1633	bool VISITORCLASS<Derived>::TraverseAcquiredBeforeAttr(AcquiredBeforeAttr *A) {
		1634	if (!getDerived().VisitAttr(A))
		1635	return false;
		1636	if (!getDerived().VisitAcquiredBeforeAttr(A))
		1637	return false;
		1638	{
		1639	Expr * *I = A->args_begin();
		1640	Expr * *E = A->args_end();
		1641	for (; I != E; ++I) {
		1642	if (!getDerived().TraverseStmt(*I))
		1643	return false;
		1644	}
		1645	}
		1646	return true;
		1647	}
		1648
		1649	template <typename Derived>
		1650	bool VISITORCLASS<Derived>::TraverseAddressSpaceAttr(AddressSpaceAttr *A) {
		1651	if (!getDerived().VisitAttr(A))
		1652	return false;
		1653	if (!getDerived().VisitAddressSpaceAttr(A))
		1654	return false;
		1655	return true;
		1656	}
		1657
		1658	template <typename Derived>
		1659	bool VISITORCLASS<Derived>::TraverseAliasAttr(AliasAttr *A) {
		1660	if (!getDerived().VisitAttr(A))
		1661	return false;
		1662	if (!getDerived().VisitAliasAttr(A))
		1663	return false;
		1664	return true;
		1665	}
		1666
		1667	template <typename Derived>
		1668	bool VISITORCLASS<Derived>::TraverseAlignMac68kAttr(AlignMac68kAttr *A) {
		1669	if (!getDerived().VisitAttr(A))
		1670	return false;
		1671	if (!getDerived().VisitAlignMac68kAttr(A))
		1672	return false;
		1673	return true;
		1674	}
		1675
		1676	template <typename Derived>
		1677	bool VISITORCLASS<Derived>::TraverseAlignNaturalAttr(AlignNaturalAttr *A) {
		1678	if (!getDerived().VisitAttr(A))
		1679	return false;
		1680	if (!getDerived().VisitAlignNaturalAttr(A))
		1681	return false;
		1682	return true;
		1683	}
		1684
		1685	template <typename Derived>
		1686	bool VISITORCLASS<Derived>::TraverseAlignValueAttr(AlignValueAttr *A) {
		1687	if (!getDerived().VisitAttr(A))
		1688	return false;
		1689	if (!getDerived().VisitAlignValueAttr(A))
		1690	return false;
		1691	if (!getDerived().TraverseStmt(A->getAlignment()))
		1692	return false;
		1693	return true;
		1694	}
		1695
		1696	template <typename Derived>
		1697	bool VISITORCLASS<Derived>::TraverseAlignedAttr(AlignedAttr *A) {
		1698	if (!getDerived().VisitAttr(A))
		1699	return false;
		1700	if (!getDerived().VisitAlignedAttr(A))
		1701	return false;
		1702	if (A->isAlignmentExpr()) {
		1703	if (!getDerived().TraverseStmt(A->getAlignmentExpr()))
		1704	return false;
		1705	} else if (auto *TSI = A->getAlignmentType()) {
		1706	if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
		1707	return false;
		1708	}
		1709	return true;
		1710	}
		1711
		1712	template <typename Derived>
		1713	bool VISITORCLASS<Derived>::TraverseAllocAlignAttr(AllocAlignAttr *A) {
		1714	if (!getDerived().VisitAttr(A))
		1715	return false;
		1716	if (!getDerived().VisitAllocAlignAttr(A))
		1717	return false;
		1718	return true;
		1719	}
		1720
		1721	template <typename Derived>
		1722	bool VISITORCLASS<Derived>::TraverseAllocSizeAttr(AllocSizeAttr *A) {
		1723	if (!getDerived().VisitAttr(A))
		1724	return false;
		1725	if (!getDerived().VisitAllocSizeAttr(A))
		1726	return false;
		1727	return true;
		1728	}
		1729
		1730	template <typename Derived>
		1731	bool VISITORCLASS<Derived>::TraverseAlwaysDestroyAttr(AlwaysDestroyAttr *A) {
		1732	if (!getDerived().VisitAttr(A))
		1733	return false;
		1734	if (!getDerived().VisitAlwaysDestroyAttr(A))
		1735	return false;
		1736	return true;
		1737	}
		1738
		1739	template <typename Derived>
		1740	bool VISITORCLASS<Derived>::TraverseAlwaysInlineAttr(AlwaysInlineAttr *A) {
		1741	if (!getDerived().VisitAttr(A))
		1742	return false;
		1743	if (!getDerived().VisitAlwaysInlineAttr(A))
		1744	return false;
		1745	return true;
		1746	}
		1747
		1748	template <typename Derived>
		1749	bool VISITORCLASS<Derived>::TraverseAnalyzerNoReturnAttr(AnalyzerNoReturnAttr *A) {
		1750	if (!getDerived().VisitAttr(A))
		1751	return false;
		1752	if (!getDerived().VisitAnalyzerNoReturnAttr(A))
		1753	return false;
		1754	return true;
		1755	}
		1756
		1757	template <typename Derived>
		1758	bool VISITORCLASS<Derived>::TraverseAnnotateAttr(AnnotateAttr *A) {
		1759	if (!getDerived().VisitAttr(A))
		1760	return false;
		1761	if (!getDerived().VisitAnnotateAttr(A))
		1762	return false;
		1763	{
		1764	Expr * *I = A->args_begin();
		1765	Expr * *E = A->args_end();
		1766	for (; I != E; ++I) {
		1767	if (!getDerived().TraverseStmt(*I))
		1768	return false;
		1769	}
		1770	}
		1771	{
		1772	Expr * *I = A->delayedArgs_begin();
		1773	Expr * *E = A->delayedArgs_end();
		1774	for (; I != E; ++I) {
		1775	if (!getDerived().TraverseStmt(*I))
		1776	return false;
		1777	}
		1778	}
		1779	return true;
		1780	}
		1781
		1782	template <typename Derived>
		1783	bool VISITORCLASS<Derived>::TraverseAnnotateTypeAttr(AnnotateTypeAttr *A) {
		1784	if (!getDerived().VisitAttr(A))
		1785	return false;
		1786	if (!getDerived().VisitAnnotateTypeAttr(A))
		1787	return false;
		1788	{
		1789	Expr * *I = A->args_begin();
		1790	Expr * *E = A->args_end();
		1791	for (; I != E; ++I) {
		1792	if (!getDerived().TraverseStmt(*I))
		1793	return false;
		1794	}
		1795	}
		1796	{
		1797	Expr * *I = A->delayedArgs_begin();
		1798	Expr * *E = A->delayedArgs_end();
		1799	for (; I != E; ++I) {
		1800	if (!getDerived().TraverseStmt(*I))
		1801	return false;
		1802	}
		1803	}
		1804	return true;
		1805	}
		1806
		1807	template <typename Derived>
		1808	bool VISITORCLASS<Derived>::TraverseAnyX86InterruptAttr(AnyX86InterruptAttr *A) {
		1809	if (!getDerived().VisitAttr(A))
		1810	return false;
		1811	if (!getDerived().VisitAnyX86InterruptAttr(A))
		1812	return false;
		1813	return true;
		1814	}
		1815
		1816	template <typename Derived>
		1817	bool VISITORCLASS<Derived>::TraverseAnyX86NoCallerSavedRegistersAttr(AnyX86NoCallerSavedRegistersAttr *A) {
		1818	if (!getDerived().VisitAttr(A))
		1819	return false;
		1820	if (!getDerived().VisitAnyX86NoCallerSavedRegistersAttr(A))
		1821	return false;
		1822	return true;
		1823	}
		1824
		1825	template <typename Derived>
		1826	bool VISITORCLASS<Derived>::TraverseAnyX86NoCfCheckAttr(AnyX86NoCfCheckAttr *A) {
		1827	if (!getDerived().VisitAttr(A))
		1828	return false;
		1829	if (!getDerived().VisitAnyX86NoCfCheckAttr(A))
		1830	return false;
		1831	return true;
		1832	}
		1833
		1834	template <typename Derived>
		1835	bool VISITORCLASS<Derived>::TraverseArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A) {
		1836	if (!getDerived().VisitAttr(A))
		1837	return false;
		1838	if (!getDerived().VisitArcWeakrefUnavailableAttr(A))
		1839	return false;
		1840	return true;
		1841	}
		1842
		1843	template <typename Derived>
		1844	bool VISITORCLASS<Derived>::TraverseArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *A) {
		1845	if (!getDerived().VisitAttr(A))
		1846	return false;
		1847	if (!getDerived().VisitArgumentWithTypeTagAttr(A))
		1848	return false;
		1849	return true;
		1850	}
		1851
		1852	template <typename Derived>
		1853	bool VISITORCLASS<Derived>::TraverseArmBuiltinAliasAttr(ArmBuiltinAliasAttr *A) {
		1854	if (!getDerived().VisitAttr(A))
		1855	return false;
		1856	if (!getDerived().VisitArmBuiltinAliasAttr(A))
		1857	return false;
		1858	return true;
		1859	}
		1860
		1861	template <typename Derived>
		1862	bool VISITORCLASS<Derived>::TraverseArmMveStrictPolymorphismAttr(ArmMveStrictPolymorphismAttr *A) {
		1863	if (!getDerived().VisitAttr(A))
		1864	return false;
		1865	if (!getDerived().VisitArmMveStrictPolymorphismAttr(A))
		1866	return false;
		1867	return true;
		1868	}
		1869
		1870	template <typename Derived>
		1871	bool VISITORCLASS<Derived>::TraverseArtificialAttr(ArtificialAttr *A) {
		1872	if (!getDerived().VisitAttr(A))
		1873	return false;
		1874	if (!getDerived().VisitArtificialAttr(A))
		1875	return false;
		1876	return true;
		1877	}
		1878
		1879	template <typename Derived>
		1880	bool VISITORCLASS<Derived>::TraverseAsmLabelAttr(AsmLabelAttr *A) {
		1881	if (!getDerived().VisitAttr(A))
		1882	return false;
		1883	if (!getDerived().VisitAsmLabelAttr(A))
		1884	return false;
		1885	return true;
		1886	}
		1887
		1888	template <typename Derived>
		1889	bool VISITORCLASS<Derived>::TraverseAssertCapabilityAttr(AssertCapabilityAttr *A) {
		1890	if (!getDerived().VisitAttr(A))
		1891	return false;
		1892	if (!getDerived().VisitAssertCapabilityAttr(A))
		1893	return false;
		1894	{
		1895	Expr * *I = A->args_begin();
		1896	Expr * *E = A->args_end();
		1897	for (; I != E; ++I) {
		1898	if (!getDerived().TraverseStmt(*I))
		1899	return false;
		1900	}
		1901	}
		1902	return true;
		1903	}
		1904
		1905	template <typename Derived>
		1906	bool VISITORCLASS<Derived>::TraverseAssertExclusiveLockAttr(AssertExclusiveLockAttr *A) {
		1907	if (!getDerived().VisitAttr(A))
		1908	return false;
		1909	if (!getDerived().VisitAssertExclusiveLockAttr(A))
		1910	return false;
		1911	{
		1912	Expr * *I = A->args_begin();
		1913	Expr * *E = A->args_end();
		1914	for (; I != E; ++I) {
		1915	if (!getDerived().TraverseStmt(*I))
		1916	return false;
		1917	}
		1918	}
		1919	return true;
		1920	}
		1921
		1922	template <typename Derived>
		1923	bool VISITORCLASS<Derived>::TraverseAssertSharedLockAttr(AssertSharedLockAttr *A) {
		1924	if (!getDerived().VisitAttr(A))
		1925	return false;
		1926	if (!getDerived().VisitAssertSharedLockAttr(A))
		1927	return false;
		1928	{
		1929	Expr * *I = A->args_begin();
		1930	Expr * *E = A->args_end();
		1931	for (; I != E; ++I) {
		1932	if (!getDerived().TraverseStmt(*I))
		1933	return false;
		1934	}
		1935	}
		1936	return true;
		1937	}
		1938
		1939	template <typename Derived>
		1940	bool VISITORCLASS<Derived>::TraverseAssumeAlignedAttr(AssumeAlignedAttr *A) {
		1941	if (!getDerived().VisitAttr(A))
		1942	return false;
		1943	if (!getDerived().VisitAssumeAlignedAttr(A))
		1944	return false;
		1945	if (!getDerived().TraverseStmt(A->getAlignment()))
		1946	return false;
		1947	if (!getDerived().TraverseStmt(A->getOffset()))
		1948	return false;
		1949	return true;
		1950	}
		1951
		1952	template <typename Derived>
		1953	bool VISITORCLASS<Derived>::TraverseAssumptionAttr(AssumptionAttr *A) {
		1954	if (!getDerived().VisitAttr(A))
		1955	return false;
		1956	if (!getDerived().VisitAssumptionAttr(A))
		1957	return false;
		1958	return true;
		1959	}
		1960
		1961	template <typename Derived>
		1962	bool VISITORCLASS<Derived>::TraverseAvailabilityAttr(AvailabilityAttr *A) {
		1963	if (!getDerived().VisitAttr(A))
		1964	return false;
		1965	if (!getDerived().VisitAvailabilityAttr(A))
		1966	return false;
		1967	return true;
		1968	}
		1969
		1970	template <typename Derived>
		1971	bool VISITORCLASS<Derived>::TraverseBPFPreserveAccessIndexAttr(BPFPreserveAccessIndexAttr *A) {
		1972	if (!getDerived().VisitAttr(A))
		1973	return false;
		1974	if (!getDerived().VisitBPFPreserveAccessIndexAttr(A))
		1975	return false;
		1976	return true;
		1977	}
		1978
		1979	template <typename Derived>
		1980	bool VISITORCLASS<Derived>::TraverseBTFDeclTagAttr(BTFDeclTagAttr *A) {
		1981	if (!getDerived().VisitAttr(A))
		1982	return false;
		1983	if (!getDerived().VisitBTFDeclTagAttr(A))
		1984	return false;
		1985	return true;
		1986	}
		1987
		1988	template <typename Derived>
		1989	bool VISITORCLASS<Derived>::TraverseBTFTypeTagAttr(BTFTypeTagAttr *A) {
		1990	if (!getDerived().VisitAttr(A))
		1991	return false;
		1992	if (!getDerived().VisitBTFTypeTagAttr(A))
		1993	return false;
		1994	return true;
		1995	}
		1996
		1997	template <typename Derived>
		1998	bool VISITORCLASS<Derived>::TraverseBlocksAttr(BlocksAttr *A) {
		1999	if (!getDerived().VisitAttr(A))
		2000	return false;
		2001	if (!getDerived().VisitBlocksAttr(A))
		2002	return false;
		2003	return true;
		2004	}
		2005
		2006	template <typename Derived>
		2007	bool VISITORCLASS<Derived>::TraverseBuiltinAttr(BuiltinAttr *A) {
		2008	if (!getDerived().VisitAttr(A))
		2009	return false;
		2010	if (!getDerived().VisitBuiltinAttr(A))
		2011	return false;
		2012	return true;
		2013	}
		2014
		2015	template <typename Derived>
		2016	bool VISITORCLASS<Derived>::TraverseBuiltinAliasAttr(BuiltinAliasAttr *A) {
		2017	if (!getDerived().VisitAttr(A))
		2018	return false;
		2019	if (!getDerived().VisitBuiltinAliasAttr(A))
		2020	return false;
		2021	return true;
		2022	}
		2023
		2024	template <typename Derived>
		2025	bool VISITORCLASS<Derived>::TraverseC11NoReturnAttr(C11NoReturnAttr *A) {
		2026	if (!getDerived().VisitAttr(A))
		2027	return false;
		2028	if (!getDerived().VisitC11NoReturnAttr(A))
		2029	return false;
		2030	return true;
		2031	}
		2032
		2033	template <typename Derived>
		2034	bool VISITORCLASS<Derived>::TraverseCDeclAttr(CDeclAttr *A) {
		2035	if (!getDerived().VisitAttr(A))
		2036	return false;
		2037	if (!getDerived().VisitCDeclAttr(A))
		2038	return false;
		2039	return true;
		2040	}
		2041
		2042	template <typename Derived>
		2043	bool VISITORCLASS<Derived>::TraverseCFAuditedTransferAttr(CFAuditedTransferAttr *A) {
		2044	if (!getDerived().VisitAttr(A))
		2045	return false;
		2046	if (!getDerived().VisitCFAuditedTransferAttr(A))
		2047	return false;
		2048	return true;
		2049	}
		2050
		2051	template <typename Derived>
		2052	bool VISITORCLASS<Derived>::TraverseCFConsumedAttr(CFConsumedAttr *A) {
		2053	if (!getDerived().VisitAttr(A))
		2054	return false;
		2055	if (!getDerived().VisitCFConsumedAttr(A))
		2056	return false;
		2057	return true;
		2058	}
		2059
		2060	template <typename Derived>
		2061	bool VISITORCLASS<Derived>::TraverseCFGuardAttr(CFGuardAttr *A) {
		2062	if (!getDerived().VisitAttr(A))
		2063	return false;
		2064	if (!getDerived().VisitCFGuardAttr(A))
		2065	return false;
		2066	return true;
		2067	}
		2068
		2069	template <typename Derived>
		2070	bool VISITORCLASS<Derived>::TraverseCFICanonicalJumpTableAttr(CFICanonicalJumpTableAttr *A) {
		2071	if (!getDerived().VisitAttr(A))
		2072	return false;
		2073	if (!getDerived().VisitCFICanonicalJumpTableAttr(A))
		2074	return false;
		2075	return true;
		2076	}
		2077
		2078	template <typename Derived>
		2079	bool VISITORCLASS<Derived>::TraverseCFReturnsNotRetainedAttr(CFReturnsNotRetainedAttr *A) {
		2080	if (!getDerived().VisitAttr(A))
		2081	return false;
		2082	if (!getDerived().VisitCFReturnsNotRetainedAttr(A))
		2083	return false;
		2084	return true;
		2085	}
		2086
		2087	template <typename Derived>
		2088	bool VISITORCLASS<Derived>::TraverseCFReturnsRetainedAttr(CFReturnsRetainedAttr *A) {
		2089	if (!getDerived().VisitAttr(A))
		2090	return false;
		2091	if (!getDerived().VisitCFReturnsRetainedAttr(A))
		2092	return false;
		2093	return true;
		2094	}
		2095
		2096	template <typename Derived>
		2097	bool VISITORCLASS<Derived>::TraverseCFUnknownTransferAttr(CFUnknownTransferAttr *A) {
		2098	if (!getDerived().VisitAttr(A))
		2099	return false;
		2100	if (!getDerived().VisitCFUnknownTransferAttr(A))
		2101	return false;
		2102	return true;
		2103	}
		2104
		2105	template <typename Derived>
		2106	bool VISITORCLASS<Derived>::TraverseCPUDispatchAttr(CPUDispatchAttr *A) {
		2107	if (!getDerived().VisitAttr(A))
		2108	return false;
		2109	if (!getDerived().VisitCPUDispatchAttr(A))
		2110	return false;
		2111	return true;
		2112	}
		2113
		2114	template <typename Derived>
		2115	bool VISITORCLASS<Derived>::TraverseCPUSpecificAttr(CPUSpecificAttr *A) {
		2116	if (!getDerived().VisitAttr(A))
		2117	return false;
		2118	if (!getDerived().VisitCPUSpecificAttr(A))
		2119	return false;
		2120	return true;
		2121	}
		2122
		2123	template <typename Derived>
		2124	bool VISITORCLASS<Derived>::TraverseCUDAConstantAttr(CUDAConstantAttr *A) {
		2125	if (!getDerived().VisitAttr(A))
		2126	return false;
		2127	if (!getDerived().VisitCUDAConstantAttr(A))
		2128	return false;
		2129	return true;
		2130	}
		2131
		2132	template <typename Derived>
		2133	bool VISITORCLASS<Derived>::TraverseCUDADeviceAttr(CUDADeviceAttr *A) {
		2134	if (!getDerived().VisitAttr(A))
		2135	return false;
		2136	if (!getDerived().VisitCUDADeviceAttr(A))
		2137	return false;
		2138	return true;
		2139	}
		2140
		2141	template <typename Derived>
		2142	bool VISITORCLASS<Derived>::TraverseCUDADeviceBuiltinSurfaceTypeAttr(CUDADeviceBuiltinSurfaceTypeAttr *A) {
		2143	if (!getDerived().VisitAttr(A))
		2144	return false;
		2145	if (!getDerived().VisitCUDADeviceBuiltinSurfaceTypeAttr(A))
		2146	return false;
		2147	return true;
		2148	}
		2149
		2150	template <typename Derived>
		2151	bool VISITORCLASS<Derived>::TraverseCUDADeviceBuiltinTextureTypeAttr(CUDADeviceBuiltinTextureTypeAttr *A) {
		2152	if (!getDerived().VisitAttr(A))
		2153	return false;
		2154	if (!getDerived().VisitCUDADeviceBuiltinTextureTypeAttr(A))
		2155	return false;
		2156	return true;
		2157	}
		2158
		2159	template <typename Derived>
		2160	bool VISITORCLASS<Derived>::TraverseCUDAGlobalAttr(CUDAGlobalAttr *A) {
		2161	if (!getDerived().VisitAttr(A))
		2162	return false;
		2163	if (!getDerived().VisitCUDAGlobalAttr(A))
		2164	return false;
		2165	return true;
		2166	}
		2167
		2168	template <typename Derived>
		2169	bool VISITORCLASS<Derived>::TraverseCUDAHostAttr(CUDAHostAttr *A) {
		2170	if (!getDerived().VisitAttr(A))
		2171	return false;
		2172	if (!getDerived().VisitCUDAHostAttr(A))
		2173	return false;
		2174	return true;
		2175	}
		2176
		2177	template <typename Derived>
		2178	bool VISITORCLASS<Derived>::TraverseCUDAInvalidTargetAttr(CUDAInvalidTargetAttr *A) {
		2179	if (!getDerived().VisitAttr(A))
		2180	return false;
		2181	if (!getDerived().VisitCUDAInvalidTargetAttr(A))
		2182	return false;
		2183	return true;
		2184	}
		2185
		2186	template <typename Derived>
		2187	bool VISITORCLASS<Derived>::TraverseCUDALaunchBoundsAttr(CUDALaunchBoundsAttr *A) {
		2188	if (!getDerived().VisitAttr(A))
		2189	return false;
		2190	if (!getDerived().VisitCUDALaunchBoundsAttr(A))
		2191	return false;
		2192	if (!getDerived().TraverseStmt(A->getMaxThreads()))
		2193	return false;
		2194	if (!getDerived().TraverseStmt(A->getMinBlocks()))
		2195	return false;
		2196	return true;
		2197	}
		2198
		2199	template <typename Derived>
		2200	bool VISITORCLASS<Derived>::TraverseCUDASharedAttr(CUDASharedAttr *A) {
		2201	if (!getDerived().VisitAttr(A))
		2202	return false;
		2203	if (!getDerived().VisitCUDASharedAttr(A))
		2204	return false;
		2205	return true;
		2206	}
		2207
		2208	template <typename Derived>
		2209	bool VISITORCLASS<Derived>::TraverseCXX11NoReturnAttr(CXX11NoReturnAttr *A) {
		2210	if (!getDerived().VisitAttr(A))
		2211	return false;
		2212	if (!getDerived().VisitCXX11NoReturnAttr(A))
		2213	return false;
		2214	return true;
		2215	}
		2216
		2217	template <typename Derived>
		2218	bool VISITORCLASS<Derived>::TraverseCallableWhenAttr(CallableWhenAttr *A) {
		2219	if (!getDerived().VisitAttr(A))
		2220	return false;
		2221	if (!getDerived().VisitCallableWhenAttr(A))
		2222	return false;
		2223	return true;
		2224	}
		2225
		2226	template <typename Derived>
		2227	bool VISITORCLASS<Derived>::TraverseCallbackAttr(CallbackAttr *A) {
		2228	if (!getDerived().VisitAttr(A))
		2229	return false;
		2230	if (!getDerived().VisitCallbackAttr(A))
		2231	return false;
		2232	return true;
		2233	}
		2234
		2235	template <typename Derived>
		2236	bool VISITORCLASS<Derived>::TraverseCalledOnceAttr(CalledOnceAttr *A) {
		2237	if (!getDerived().VisitAttr(A))
		2238	return false;
		2239	if (!getDerived().VisitCalledOnceAttr(A))
		2240	return false;
		2241	return true;
		2242	}
		2243
		2244	template <typename Derived>
		2245	bool VISITORCLASS<Derived>::TraverseCapabilityAttr(CapabilityAttr *A) {
		2246	if (!getDerived().VisitAttr(A))
		2247	return false;
		2248	if (!getDerived().VisitCapabilityAttr(A))
		2249	return false;
		2250	return true;
		2251	}
		2252
		2253	template <typename Derived>
		2254	bool VISITORCLASS<Derived>::TraverseCapturedRecordAttr(CapturedRecordAttr *A) {
		2255	if (!getDerived().VisitAttr(A))
		2256	return false;
		2257	if (!getDerived().VisitCapturedRecordAttr(A))
		2258	return false;
		2259	return true;
		2260	}
		2261
		2262	template <typename Derived>
		2263	bool VISITORCLASS<Derived>::TraverseCarriesDependencyAttr(CarriesDependencyAttr *A) {
		2264	if (!getDerived().VisitAttr(A))
		2265	return false;
		2266	if (!getDerived().VisitCarriesDependencyAttr(A))
		2267	return false;
		2268	return true;
		2269	}
		2270
		2271	template <typename Derived>
		2272	bool VISITORCLASS<Derived>::TraverseCleanupAttr(CleanupAttr *A) {
		2273	if (!getDerived().VisitAttr(A))
		2274	return false;
		2275	if (!getDerived().VisitCleanupAttr(A))
		2276	return false;
		2277	return true;
		2278	}
		2279
		2280	template <typename Derived>
		2281	bool VISITORCLASS<Derived>::TraverseCmseNSCallAttr(CmseNSCallAttr *A) {
		2282	if (!getDerived().VisitAttr(A))
		2283	return false;
		2284	if (!getDerived().VisitCmseNSCallAttr(A))
		2285	return false;
		2286	return true;
		2287	}
		2288
		2289	template <typename Derived>
		2290	bool VISITORCLASS<Derived>::TraverseCmseNSEntryAttr(CmseNSEntryAttr *A) {
		2291	if (!getDerived().VisitAttr(A))
		2292	return false;
		2293	if (!getDerived().VisitCmseNSEntryAttr(A))
		2294	return false;
		2295	return true;
		2296	}
		2297
		2298	template <typename Derived>
		2299	bool VISITORCLASS<Derived>::TraverseCodeSegAttr(CodeSegAttr *A) {
		2300	if (!getDerived().VisitAttr(A))
		2301	return false;
		2302	if (!getDerived().VisitCodeSegAttr(A))
		2303	return false;
		2304	return true;
		2305	}
		2306
		2307	template <typename Derived>
		2308	bool VISITORCLASS<Derived>::TraverseColdAttr(ColdAttr *A) {
		2309	if (!getDerived().VisitAttr(A))
		2310	return false;
		2311	if (!getDerived().VisitColdAttr(A))
		2312	return false;
		2313	return true;
		2314	}
		2315
		2316	template <typename Derived>
		2317	bool VISITORCLASS<Derived>::TraverseCommonAttr(CommonAttr *A) {
		2318	if (!getDerived().VisitAttr(A))
		2319	return false;
		2320	if (!getDerived().VisitCommonAttr(A))
		2321	return false;
		2322	return true;
		2323	}
		2324
		2325	template <typename Derived>
		2326	bool VISITORCLASS<Derived>::TraverseConstAttr(ConstAttr *A) {
		2327	if (!getDerived().VisitAttr(A))
		2328	return false;
		2329	if (!getDerived().VisitConstAttr(A))
		2330	return false;
		2331	return true;
		2332	}
		2333
		2334	template <typename Derived>
		2335	bool VISITORCLASS<Derived>::TraverseConstInitAttr(ConstInitAttr *A) {
		2336	if (!getDerived().VisitAttr(A))
		2337	return false;
		2338	if (!getDerived().VisitConstInitAttr(A))
		2339	return false;
		2340	return true;
		2341	}
		2342
		2343	template <typename Derived>
		2344	bool VISITORCLASS<Derived>::TraverseConstructorAttr(ConstructorAttr *A) {
		2345	if (!getDerived().VisitAttr(A))
		2346	return false;
		2347	if (!getDerived().VisitConstructorAttr(A))
		2348	return false;
		2349	return true;
		2350	}
		2351
		2352	template <typename Derived>
		2353	bool VISITORCLASS<Derived>::TraverseConsumableAttr(ConsumableAttr *A) {
		2354	if (!getDerived().VisitAttr(A))
		2355	return false;
		2356	if (!getDerived().VisitConsumableAttr(A))
		2357	return false;
		2358	return true;
		2359	}
		2360
		2361	template <typename Derived>
		2362	bool VISITORCLASS<Derived>::TraverseConsumableAutoCastAttr(ConsumableAutoCastAttr *A) {
		2363	if (!getDerived().VisitAttr(A))
		2364	return false;
		2365	if (!getDerived().VisitConsumableAutoCastAttr(A))
		2366	return false;
		2367	return true;
		2368	}
		2369
		2370	template <typename Derived>
		2371	bool VISITORCLASS<Derived>::TraverseConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A) {
		2372	if (!getDerived().VisitAttr(A))
		2373	return false;
		2374	if (!getDerived().VisitConsumableSetOnReadAttr(A))
		2375	return false;
		2376	return true;
		2377	}
		2378
		2379	template <typename Derived>
		2380	bool VISITORCLASS<Derived>::TraverseConvergentAttr(ConvergentAttr *A) {
		2381	if (!getDerived().VisitAttr(A))
		2382	return false;
		2383	if (!getDerived().VisitConvergentAttr(A))
		2384	return false;
		2385	return true;
		2386	}
		2387
		2388	template <typename Derived>
		2389	bool VISITORCLASS<Derived>::TraverseDLLExportAttr(DLLExportAttr *A) {
		2390	if (!getDerived().VisitAttr(A))
		2391	return false;
		2392	if (!getDerived().VisitDLLExportAttr(A))
		2393	return false;
		2394	return true;
		2395	}
		2396
		2397	template <typename Derived>
		2398	bool VISITORCLASS<Derived>::TraverseDLLExportStaticLocalAttr(DLLExportStaticLocalAttr *A) {
		2399	if (!getDerived().VisitAttr(A))
		2400	return false;
		2401	if (!getDerived().VisitDLLExportStaticLocalAttr(A))
		2402	return false;
		2403	return true;
		2404	}
		2405
		2406	template <typename Derived>
		2407	bool VISITORCLASS<Derived>::TraverseDLLImportAttr(DLLImportAttr *A) {
		2408	if (!getDerived().VisitAttr(A))
		2409	return false;
		2410	if (!getDerived().VisitDLLImportAttr(A))
		2411	return false;
		2412	return true;
		2413	}
		2414
		2415	template <typename Derived>
		2416	bool VISITORCLASS<Derived>::TraverseDLLImportStaticLocalAttr(DLLImportStaticLocalAttr *A) {
		2417	if (!getDerived().VisitAttr(A))
		2418	return false;
		2419	if (!getDerived().VisitDLLImportStaticLocalAttr(A))
		2420	return false;
		2421	return true;
		2422	}
		2423
		2424	template <typename Derived>
		2425	bool VISITORCLASS<Derived>::TraverseDeprecatedAttr(DeprecatedAttr *A) {
		2426	if (!getDerived().VisitAttr(A))
		2427	return false;
		2428	if (!getDerived().VisitDeprecatedAttr(A))
		2429	return false;
		2430	return true;
		2431	}
		2432
		2433	template <typename Derived>
		2434	bool VISITORCLASS<Derived>::TraverseDestructorAttr(DestructorAttr *A) {
		2435	if (!getDerived().VisitAttr(A))
		2436	return false;
		2437	if (!getDerived().VisitDestructorAttr(A))
		2438	return false;
		2439	return true;
		2440	}
		2441
		2442	template <typename Derived>
		2443	bool VISITORCLASS<Derived>::TraverseDiagnoseAsBuiltinAttr(DiagnoseAsBuiltinAttr *A) {
		2444	if (!getDerived().VisitAttr(A))
		2445	return false;
		2446	if (!getDerived().VisitDiagnoseAsBuiltinAttr(A))
		2447	return false;
		2448	return true;
		2449	}
		2450
		2451	template <typename Derived>
		2452	bool VISITORCLASS<Derived>::TraverseDiagnoseIfAttr(DiagnoseIfAttr *A) {
		2453	if (!getDerived().VisitAttr(A))
		2454	return false;
		2455	if (!getDerived().VisitDiagnoseIfAttr(A))
		2456	return false;
		2457	if (!getDerived().TraverseStmt(A->getCond()))
		2458	return false;
		2459	return true;
		2460	}
		2461
		2462	template <typename Derived>
		2463	bool VISITORCLASS<Derived>::TraverseDisableSanitizerInstrumentationAttr(DisableSanitizerInstrumentationAttr *A) {
		2464	if (!getDerived().VisitAttr(A))
		2465	return false;
		2466	if (!getDerived().VisitDisableSanitizerInstrumentationAttr(A))
		2467	return false;
		2468	return true;
		2469	}
		2470
		2471	template <typename Derived>
		2472	bool VISITORCLASS<Derived>::TraverseDisableTailCallsAttr(DisableTailCallsAttr *A) {
		2473	if (!getDerived().VisitAttr(A))
		2474	return false;
		2475	if (!getDerived().VisitDisableTailCallsAttr(A))
		2476	return false;
		2477	return true;
		2478	}
		2479
		2480	template <typename Derived>
		2481	bool VISITORCLASS<Derived>::TraverseEmptyBasesAttr(EmptyBasesAttr *A) {
		2482	if (!getDerived().VisitAttr(A))
		2483	return false;
		2484	if (!getDerived().VisitEmptyBasesAttr(A))
		2485	return false;
		2486	return true;
		2487	}
		2488
		2489	template <typename Derived>
		2490	bool VISITORCLASS<Derived>::TraverseEnableIfAttr(EnableIfAttr *A) {
		2491	if (!getDerived().VisitAttr(A))
		2492	return false;
		2493	if (!getDerived().VisitEnableIfAttr(A))
		2494	return false;
		2495	if (!getDerived().TraverseStmt(A->getCond()))
		2496	return false;
		2497	return true;
		2498	}
		2499
		2500	template <typename Derived>
		2501	bool VISITORCLASS<Derived>::TraverseEnforceTCBAttr(EnforceTCBAttr *A) {
		2502	if (!getDerived().VisitAttr(A))
		2503	return false;
		2504	if (!getDerived().VisitEnforceTCBAttr(A))
		2505	return false;
		2506	return true;
		2507	}
		2508
		2509	template <typename Derived>
		2510	bool VISITORCLASS<Derived>::TraverseEnforceTCBLeafAttr(EnforceTCBLeafAttr *A) {
		2511	if (!getDerived().VisitAttr(A))
		2512	return false;
		2513	if (!getDerived().VisitEnforceTCBLeafAttr(A))
		2514	return false;
		2515	return true;
		2516	}
		2517
		2518	template <typename Derived>
		2519	bool VISITORCLASS<Derived>::TraverseEnumExtensibilityAttr(EnumExtensibilityAttr *A) {
		2520	if (!getDerived().VisitAttr(A))
		2521	return false;
		2522	if (!getDerived().VisitEnumExtensibilityAttr(A))
		2523	return false;
		2524	return true;
		2525	}
		2526
		2527	template <typename Derived>
		2528	bool VISITORCLASS<Derived>::TraverseErrorAttr(ErrorAttr *A) {
		2529	if (!getDerived().VisitAttr(A))
		2530	return false;
		2531	if (!getDerived().VisitErrorAttr(A))
		2532	return false;
		2533	return true;
		2534	}
		2535
		2536	template <typename Derived>
		2537	bool VISITORCLASS<Derived>::TraverseExcludeFromExplicitInstantiationAttr(ExcludeFromExplicitInstantiationAttr *A) {
		2538	if (!getDerived().VisitAttr(A))
		2539	return false;
		2540	if (!getDerived().VisitExcludeFromExplicitInstantiationAttr(A))
		2541	return false;
		2542	return true;
		2543	}
		2544
		2545	template <typename Derived>
		2546	bool VISITORCLASS<Derived>::TraverseExclusiveTrylockFunctionAttr(ExclusiveTrylockFunctionAttr *A) {
		2547	if (!getDerived().VisitAttr(A))
		2548	return false;
		2549	if (!getDerived().VisitExclusiveTrylockFunctionAttr(A))
		2550	return false;
		2551	if (!getDerived().TraverseStmt(A->getSuccessValue()))
		2552	return false;
		2553	{
		2554	Expr * *I = A->args_begin();
		2555	Expr * *E = A->args_end();
		2556	for (; I != E; ++I) {
		2557	if (!getDerived().TraverseStmt(*I))
		2558	return false;
		2559	}
		2560	}
		2561	return true;
		2562	}
		2563
		2564	template <typename Derived>
		2565	bool VISITORCLASS<Derived>::TraverseExternalSourceSymbolAttr(ExternalSourceSymbolAttr *A) {
		2566	if (!getDerived().VisitAttr(A))
		2567	return false;
		2568	if (!getDerived().VisitExternalSourceSymbolAttr(A))
		2569	return false;
		2570	return true;
		2571	}
		2572
		2573	template <typename Derived>
		2574	bool VISITORCLASS<Derived>::TraverseFallThroughAttr(FallThroughAttr *A) {
		2575	if (!getDerived().VisitAttr(A))
		2576	return false;
		2577	if (!getDerived().VisitFallThroughAttr(A))
		2578	return false;
		2579	return true;
		2580	}
		2581
		2582	template <typename Derived>
		2583	bool VISITORCLASS<Derived>::TraverseFastCallAttr(FastCallAttr *A) {
		2584	if (!getDerived().VisitAttr(A))
		2585	return false;
		2586	if (!getDerived().VisitFastCallAttr(A))
		2587	return false;
		2588	return true;
		2589	}
		2590
		2591	template <typename Derived>
		2592	bool VISITORCLASS<Derived>::TraverseFinalAttr(FinalAttr *A) {
		2593	if (!getDerived().VisitAttr(A))
		2594	return false;
		2595	if (!getDerived().VisitFinalAttr(A))
		2596	return false;
		2597	return true;
		2598	}
		2599
		2600	template <typename Derived>
		2601	bool VISITORCLASS<Derived>::TraverseFlagEnumAttr(FlagEnumAttr *A) {
		2602	if (!getDerived().VisitAttr(A))
		2603	return false;
		2604	if (!getDerived().VisitFlagEnumAttr(A))
		2605	return false;
		2606	return true;
		2607	}
		2608
		2609	template <typename Derived>
		2610	bool VISITORCLASS<Derived>::TraverseFlattenAttr(FlattenAttr *A) {
		2611	if (!getDerived().VisitAttr(A))
		2612	return false;
		2613	if (!getDerived().VisitFlattenAttr(A))
		2614	return false;
		2615	return true;
		2616	}
		2617
		2618	template <typename Derived>
		2619	bool VISITORCLASS<Derived>::TraverseFormatAttr(FormatAttr *A) {
		2620	if (!getDerived().VisitAttr(A))
		2621	return false;
		2622	if (!getDerived().VisitFormatAttr(A))
		2623	return false;
		2624	return true;
		2625	}
		2626
		2627	template <typename Derived>
		2628	bool VISITORCLASS<Derived>::TraverseFormatArgAttr(FormatArgAttr *A) {
		2629	if (!getDerived().VisitAttr(A))
		2630	return false;
		2631	if (!getDerived().VisitFormatArgAttr(A))
		2632	return false;
		2633	return true;
		2634	}
		2635
		2636	template <typename Derived>
		2637	bool VISITORCLASS<Derived>::TraverseFunctionReturnThunksAttr(FunctionReturnThunksAttr *A) {
		2638	if (!getDerived().VisitAttr(A))
		2639	return false;
		2640	if (!getDerived().VisitFunctionReturnThunksAttr(A))
		2641	return false;
		2642	return true;
		2643	}
		2644
		2645	template <typename Derived>
		2646	bool VISITORCLASS<Derived>::TraverseGNUInlineAttr(GNUInlineAttr *A) {
		2647	if (!getDerived().VisitAttr(A))
		2648	return false;
		2649	if (!getDerived().VisitGNUInlineAttr(A))
		2650	return false;
		2651	return true;
		2652	}
		2653
		2654	template <typename Derived>
		2655	bool VISITORCLASS<Derived>::TraverseGuardedByAttr(GuardedByAttr *A) {
		2656	if (!getDerived().VisitAttr(A))
		2657	return false;
		2658	if (!getDerived().VisitGuardedByAttr(A))
		2659	return false;
		2660	if (!getDerived().TraverseStmt(A->getArg()))
		2661	return false;
		2662	return true;
		2663	}
		2664
		2665	template <typename Derived>
		2666	bool VISITORCLASS<Derived>::TraverseGuardedVarAttr(GuardedVarAttr *A) {
		2667	if (!getDerived().VisitAttr(A))
		2668	return false;
		2669	if (!getDerived().VisitGuardedVarAttr(A))
		2670	return false;
		2671	return true;
		2672	}
		2673
		2674	template <typename Derived>
		2675	bool VISITORCLASS<Derived>::TraverseHIPManagedAttr(HIPManagedAttr *A) {
		2676	if (!getDerived().VisitAttr(A))
		2677	return false;
		2678	if (!getDerived().VisitHIPManagedAttr(A))
		2679	return false;
		2680	return true;
		2681	}
		2682
		2683	template <typename Derived>
		2684	bool VISITORCLASS<Derived>::TraverseHLSLGroupSharedAddressSpaceAttr(HLSLGroupSharedAddressSpaceAttr *A) {
		2685	if (!getDerived().VisitAttr(A))
		2686	return false;
		2687	if (!getDerived().VisitHLSLGroupSharedAddressSpaceAttr(A))
		2688	return false;
		2689	return true;
		2690	}
		2691
		2692	template <typename Derived>
		2693	bool VISITORCLASS<Derived>::TraverseHLSLNumThreadsAttr(HLSLNumThreadsAttr *A) {
		2694	if (!getDerived().VisitAttr(A))
		2695	return false;
		2696	if (!getDerived().VisitHLSLNumThreadsAttr(A))
		2697	return false;
		2698	return true;
		2699	}
		2700
		2701	template <typename Derived>
		2702	bool VISITORCLASS<Derived>::TraverseHLSLResourceAttr(HLSLResourceAttr *A) {
		2703	if (!getDerived().VisitAttr(A))
		2704	return false;
		2705	if (!getDerived().VisitHLSLResourceAttr(A))
		2706	return false;
		2707	return true;
		2708	}
		2709
		2710	template <typename Derived>
		2711	bool VISITORCLASS<Derived>::TraverseHLSLResourceBindingAttr(HLSLResourceBindingAttr *A) {
		2712	if (!getDerived().VisitAttr(A))
		2713	return false;
		2714	if (!getDerived().VisitHLSLResourceBindingAttr(A))
		2715	return false;
		2716	return true;
		2717	}
		2718
		2719	template <typename Derived>
		2720	bool VISITORCLASS<Derived>::TraverseHLSLSV_DispatchThreadIDAttr(HLSLSV_DispatchThreadIDAttr *A) {
		2721	if (!getDerived().VisitAttr(A))
		2722	return false;
		2723	if (!getDerived().VisitHLSLSV_DispatchThreadIDAttr(A))
		2724	return false;
		2725	return true;
		2726	}
		2727
		2728	template <typename Derived>
		2729	bool VISITORCLASS<Derived>::TraverseHLSLSV_GroupIndexAttr(HLSLSV_GroupIndexAttr *A) {
		2730	if (!getDerived().VisitAttr(A))
		2731	return false;
		2732	if (!getDerived().VisitHLSLSV_GroupIndexAttr(A))
		2733	return false;
		2734	return true;
		2735	}
		2736
		2737	template <typename Derived>
		2738	bool VISITORCLASS<Derived>::TraverseHLSLShaderAttr(HLSLShaderAttr *A) {
		2739	if (!getDerived().VisitAttr(A))
		2740	return false;
		2741	if (!getDerived().VisitHLSLShaderAttr(A))
		2742	return false;
		2743	return true;
		2744	}
		2745
		2746	template <typename Derived>
		2747	bool VISITORCLASS<Derived>::TraverseHotAttr(HotAttr *A) {
		2748	if (!getDerived().VisitAttr(A))
		2749	return false;
		2750	if (!getDerived().VisitHotAttr(A))
		2751	return false;
		2752	return true;
		2753	}
		2754
		2755	template <typename Derived>
		2756	bool VISITORCLASS<Derived>::TraverseIBActionAttr(IBActionAttr *A) {
		2757	if (!getDerived().VisitAttr(A))
		2758	return false;
		2759	if (!getDerived().VisitIBActionAttr(A))
		2760	return false;
		2761	return true;
		2762	}
		2763
		2764	template <typename Derived>
		2765	bool VISITORCLASS<Derived>::TraverseIBOutletAttr(IBOutletAttr *A) {
		2766	if (!getDerived().VisitAttr(A))
		2767	return false;
		2768	if (!getDerived().VisitIBOutletAttr(A))
		2769	return false;
		2770	return true;
		2771	}
		2772
		2773	template <typename Derived>
		2774	bool VISITORCLASS<Derived>::TraverseIBOutletCollectionAttr(IBOutletCollectionAttr *A) {
		2775	if (!getDerived().VisitAttr(A))
		2776	return false;
		2777	if (!getDerived().VisitIBOutletCollectionAttr(A))
		2778	return false;
		2779	if (auto *TSI = A->getInterfaceLoc())
		2780	if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
		2781	return false;
		2782	return true;
		2783	}
		2784
		2785	template <typename Derived>
		2786	bool VISITORCLASS<Derived>::TraverseIFuncAttr(IFuncAttr *A) {
		2787	if (!getDerived().VisitAttr(A))
		2788	return false;
		2789	if (!getDerived().VisitIFuncAttr(A))
		2790	return false;
		2791	return true;
		2792	}
		2793
		2794	template <typename Derived>
		2795	bool VISITORCLASS<Derived>::TraverseInitPriorityAttr(InitPriorityAttr *A) {
		2796	if (!getDerived().VisitAttr(A))
		2797	return false;
		2798	if (!getDerived().VisitInitPriorityAttr(A))
		2799	return false;
		2800	return true;
		2801	}
		2802
		2803	template <typename Derived>
		2804	bool VISITORCLASS<Derived>::TraverseInitSegAttr(InitSegAttr *A) {
		2805	if (!getDerived().VisitAttr(A))
		2806	return false;
		2807	if (!getDerived().VisitInitSegAttr(A))
		2808	return false;
		2809	return true;
		2810	}
		2811
		2812	template <typename Derived>
		2813	bool VISITORCLASS<Derived>::TraverseIntelOclBiccAttr(IntelOclBiccAttr *A) {
		2814	if (!getDerived().VisitAttr(A))
		2815	return false;
		2816	if (!getDerived().VisitIntelOclBiccAttr(A))
		2817	return false;
		2818	return true;
		2819	}
		2820
		2821	template <typename Derived>
		2822	bool VISITORCLASS<Derived>::TraverseInternalLinkageAttr(InternalLinkageAttr *A) {
		2823	if (!getDerived().VisitAttr(A))
		2824	return false;
		2825	if (!getDerived().VisitInternalLinkageAttr(A))
		2826	return false;
		2827	return true;
		2828	}
		2829
		2830	template <typename Derived>
		2831	bool VISITORCLASS<Derived>::TraverseLTOVisibilityPublicAttr(LTOVisibilityPublicAttr *A) {
		2832	if (!getDerived().VisitAttr(A))
		2833	return false;
		2834	if (!getDerived().VisitLTOVisibilityPublicAttr(A))
		2835	return false;
		2836	return true;
		2837	}
		2838
		2839	template <typename Derived>
		2840	bool VISITORCLASS<Derived>::TraverseLayoutVersionAttr(LayoutVersionAttr *A) {
		2841	if (!getDerived().VisitAttr(A))
		2842	return false;
		2843	if (!getDerived().VisitLayoutVersionAttr(A))
		2844	return false;
		2845	return true;
		2846	}
		2847
		2848	template <typename Derived>
		2849	bool VISITORCLASS<Derived>::TraverseLeafAttr(LeafAttr *A) {
		2850	if (!getDerived().VisitAttr(A))
		2851	return false;
		2852	if (!getDerived().VisitLeafAttr(A))
		2853	return false;
		2854	return true;
		2855	}
		2856
		2857	template <typename Derived>
		2858	bool VISITORCLASS<Derived>::TraverseLifetimeBoundAttr(LifetimeBoundAttr *A) {
		2859	if (!getDerived().VisitAttr(A))
		2860	return false;
		2861	if (!getDerived().VisitLifetimeBoundAttr(A))
		2862	return false;
		2863	return true;
		2864	}
		2865
		2866	template <typename Derived>
		2867	bool VISITORCLASS<Derived>::TraverseLikelyAttr(LikelyAttr *A) {
		2868	if (!getDerived().VisitAttr(A))
		2869	return false;
		2870	if (!getDerived().VisitLikelyAttr(A))
		2871	return false;
		2872	return true;
		2873	}
		2874
		2875	template <typename Derived>
		2876	bool VISITORCLASS<Derived>::TraverseLoaderUninitializedAttr(LoaderUninitializedAttr *A) {
		2877	if (!getDerived().VisitAttr(A))
		2878	return false;
		2879	if (!getDerived().VisitLoaderUninitializedAttr(A))
		2880	return false;
		2881	return true;
		2882	}
		2883
		2884	template <typename Derived>
		2885	bool VISITORCLASS<Derived>::TraverseLockReturnedAttr(LockReturnedAttr *A) {
		2886	if (!getDerived().VisitAttr(A))
		2887	return false;
		2888	if (!getDerived().VisitLockReturnedAttr(A))
		2889	return false;
		2890	if (!getDerived().TraverseStmt(A->getArg()))
		2891	return false;
		2892	return true;
		2893	}
		2894
		2895	template <typename Derived>
		2896	bool VISITORCLASS<Derived>::TraverseLocksExcludedAttr(LocksExcludedAttr *A) {
		2897	if (!getDerived().VisitAttr(A))
		2898	return false;
		2899	if (!getDerived().VisitLocksExcludedAttr(A))
		2900	return false;
		2901	{
		2902	Expr * *I = A->args_begin();
		2903	Expr * *E = A->args_end();
		2904	for (; I != E; ++I) {
		2905	if (!getDerived().TraverseStmt(*I))
		2906	return false;
		2907	}
		2908	}
		2909	return true;
		2910	}
		2911
		2912	template <typename Derived>
		2913	bool VISITORCLASS<Derived>::TraverseLoopHintAttr(LoopHintAttr *A) {
		2914	if (!getDerived().VisitAttr(A))
		2915	return false;
		2916	if (!getDerived().VisitLoopHintAttr(A))
		2917	return false;
		2918	if (!getDerived().TraverseStmt(A->getValue()))
		2919	return false;
		2920	return true;
		2921	}
		2922
		2923	template <typename Derived>
		2924	bool VISITORCLASS<Derived>::TraverseM68kInterruptAttr(M68kInterruptAttr *A) {
		2925	if (!getDerived().VisitAttr(A))
		2926	return false;
		2927	if (!getDerived().VisitM68kInterruptAttr(A))
		2928	return false;
		2929	return true;
		2930	}
		2931
		2932	template <typename Derived>
		2933	bool VISITORCLASS<Derived>::TraverseMIGServerRoutineAttr(MIGServerRoutineAttr *A) {
		2934	if (!getDerived().VisitAttr(A))
		2935	return false;
		2936	if (!getDerived().VisitMIGServerRoutineAttr(A))
		2937	return false;
		2938	return true;
		2939	}
		2940
		2941	template <typename Derived>
		2942	bool VISITORCLASS<Derived>::TraverseMSABIAttr(MSABIAttr *A) {
		2943	if (!getDerived().VisitAttr(A))
		2944	return false;
		2945	if (!getDerived().VisitMSABIAttr(A))
		2946	return false;
		2947	return true;
		2948	}
		2949
		2950	template <typename Derived>
		2951	bool VISITORCLASS<Derived>::TraverseMSAllocatorAttr(MSAllocatorAttr *A) {
		2952	if (!getDerived().VisitAttr(A))
		2953	return false;
		2954	if (!getDerived().VisitMSAllocatorAttr(A))
		2955	return false;
		2956	return true;
		2957	}
		2958
		2959	template <typename Derived>
		2960	bool VISITORCLASS<Derived>::TraverseMSInheritanceAttr(MSInheritanceAttr *A) {
		2961	if (!getDerived().VisitAttr(A))
		2962	return false;
		2963	if (!getDerived().VisitMSInheritanceAttr(A))
		2964	return false;
		2965	return true;
		2966	}
		2967
		2968	template <typename Derived>
		2969	bool VISITORCLASS<Derived>::TraverseMSNoVTableAttr(MSNoVTableAttr *A) {
		2970	if (!getDerived().VisitAttr(A))
		2971	return false;
		2972	if (!getDerived().VisitMSNoVTableAttr(A))
		2973	return false;
		2974	return true;
		2975	}
		2976
		2977	template <typename Derived>
		2978	bool VISITORCLASS<Derived>::TraverseMSP430InterruptAttr(MSP430InterruptAttr *A) {
		2979	if (!getDerived().VisitAttr(A))
		2980	return false;
		2981	if (!getDerived().VisitMSP430InterruptAttr(A))
		2982	return false;
		2983	return true;
		2984	}
		2985
		2986	template <typename Derived>
		2987	bool VISITORCLASS<Derived>::TraverseMSStructAttr(MSStructAttr *A) {
		2988	if (!getDerived().VisitAttr(A))
		2989	return false;
		2990	if (!getDerived().VisitMSStructAttr(A))
		2991	return false;
		2992	return true;
		2993	}
		2994
		2995	template <typename Derived>
		2996	bool VISITORCLASS<Derived>::TraverseMSVtorDispAttr(MSVtorDispAttr *A) {
		2997	if (!getDerived().VisitAttr(A))
		2998	return false;
		2999	if (!getDerived().VisitMSVtorDispAttr(A))
		3000	return false;
		3001	return true;
		3002	}
		3003
		3004	template <typename Derived>
		3005	bool VISITORCLASS<Derived>::TraverseMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A) {
		3006	if (!getDerived().VisitAttr(A))
		3007	return false;
		3008	if (!getDerived().VisitMaxFieldAlignmentAttr(A))
		3009	return false;
		3010	return true;
		3011	}
		3012
		3013	template <typename Derived>
		3014	bool VISITORCLASS<Derived>::TraverseMayAliasAttr(MayAliasAttr *A) {
		3015	if (!getDerived().VisitAttr(A))
		3016	return false;
		3017	if (!getDerived().VisitMayAliasAttr(A))
		3018	return false;
		3019	return true;
		3020	}
		3021
		3022	template <typename Derived>
		3023	bool VISITORCLASS<Derived>::TraverseMaybeUndefAttr(MaybeUndefAttr *A) {
		3024	if (!getDerived().VisitAttr(A))
		3025	return false;
		3026	if (!getDerived().VisitMaybeUndefAttr(A))
		3027	return false;
		3028	return true;
		3029	}
		3030
		3031	template <typename Derived>
		3032	bool VISITORCLASS<Derived>::TraverseMicroMipsAttr(MicroMipsAttr *A) {
		3033	if (!getDerived().VisitAttr(A))
		3034	return false;
		3035	if (!getDerived().VisitMicroMipsAttr(A))
		3036	return false;
		3037	return true;
		3038	}
		3039
		3040	template <typename Derived>
		3041	bool VISITORCLASS<Derived>::TraverseMinSizeAttr(MinSizeAttr *A) {
		3042	if (!getDerived().VisitAttr(A))
		3043	return false;
		3044	if (!getDerived().VisitMinSizeAttr(A))
		3045	return false;
		3046	return true;
		3047	}
		3048
		3049	template <typename Derived>
		3050	bool VISITORCLASS<Derived>::TraverseMinVectorWidthAttr(MinVectorWidthAttr *A) {
		3051	if (!getDerived().VisitAttr(A))
		3052	return false;
		3053	if (!getDerived().VisitMinVectorWidthAttr(A))
		3054	return false;
		3055	return true;
		3056	}
		3057
		3058	template <typename Derived>
		3059	bool VISITORCLASS<Derived>::TraverseMips16Attr(Mips16Attr *A) {
		3060	if (!getDerived().VisitAttr(A))
		3061	return false;
		3062	if (!getDerived().VisitMips16Attr(A))
		3063	return false;
		3064	return true;
		3065	}
		3066
		3067	template <typename Derived>
		3068	bool VISITORCLASS<Derived>::TraverseMipsInterruptAttr(MipsInterruptAttr *A) {
		3069	if (!getDerived().VisitAttr(A))
		3070	return false;
		3071	if (!getDerived().VisitMipsInterruptAttr(A))
		3072	return false;
		3073	return true;
		3074	}
		3075
		3076	template <typename Derived>
		3077	bool VISITORCLASS<Derived>::TraverseMipsLongCallAttr(MipsLongCallAttr *A) {
		3078	if (!getDerived().VisitAttr(A))
		3079	return false;
		3080	if (!getDerived().VisitMipsLongCallAttr(A))
		3081	return false;
		3082	return true;
		3083	}
		3084
		3085	template <typename Derived>
		3086	bool VISITORCLASS<Derived>::TraverseMipsShortCallAttr(MipsShortCallAttr *A) {
		3087	if (!getDerived().VisitAttr(A))
		3088	return false;
		3089	if (!getDerived().VisitMipsShortCallAttr(A))
		3090	return false;
		3091	return true;
		3092	}
		3093
		3094	template <typename Derived>
		3095	bool VISITORCLASS<Derived>::TraverseModeAttr(ModeAttr *A) {
		3096	if (!getDerived().VisitAttr(A))
		3097	return false;
		3098	if (!getDerived().VisitModeAttr(A))
		3099	return false;
		3100	return true;
		3101	}
		3102
		3103	template <typename Derived>
		3104	bool VISITORCLASS<Derived>::TraverseMustTailAttr(MustTailAttr *A) {
		3105	if (!getDerived().VisitAttr(A))
		3106	return false;
		3107	if (!getDerived().VisitMustTailAttr(A))
		3108	return false;
		3109	return true;
		3110	}
		3111
		3112	template <typename Derived>
		3113	bool VISITORCLASS<Derived>::TraverseNSConsumedAttr(NSConsumedAttr *A) {
		3114	if (!getDerived().VisitAttr(A))
		3115	return false;
		3116	if (!getDerived().VisitNSConsumedAttr(A))
		3117	return false;
		3118	return true;
		3119	}
		3120
		3121	template <typename Derived>
		3122	bool VISITORCLASS<Derived>::TraverseNSConsumesSelfAttr(NSConsumesSelfAttr *A) {
		3123	if (!getDerived().VisitAttr(A))
		3124	return false;
		3125	if (!getDerived().VisitNSConsumesSelfAttr(A))
		3126	return false;
		3127	return true;
		3128	}
		3129
		3130	template <typename Derived>
		3131	bool VISITORCLASS<Derived>::TraverseNSErrorDomainAttr(NSErrorDomainAttr *A) {
		3132	if (!getDerived().VisitAttr(A))
		3133	return false;
		3134	if (!getDerived().VisitNSErrorDomainAttr(A))
		3135	return false;
		3136	return true;
		3137	}
		3138
		3139	template <typename Derived>
		3140	bool VISITORCLASS<Derived>::TraverseNSReturnsAutoreleasedAttr(NSReturnsAutoreleasedAttr *A) {
		3141	if (!getDerived().VisitAttr(A))
		3142	return false;
		3143	if (!getDerived().VisitNSReturnsAutoreleasedAttr(A))
		3144	return false;
		3145	return true;
		3146	}
		3147
		3148	template <typename Derived>
		3149	bool VISITORCLASS<Derived>::TraverseNSReturnsNotRetainedAttr(NSReturnsNotRetainedAttr *A) {
		3150	if (!getDerived().VisitAttr(A))
		3151	return false;
		3152	if (!getDerived().VisitNSReturnsNotRetainedAttr(A))
		3153	return false;
		3154	return true;
		3155	}
		3156
		3157	template <typename Derived>
		3158	bool VISITORCLASS<Derived>::TraverseNSReturnsRetainedAttr(NSReturnsRetainedAttr *A) {
		3159	if (!getDerived().VisitAttr(A))
		3160	return false;
		3161	if (!getDerived().VisitNSReturnsRetainedAttr(A))
		3162	return false;
		3163	return true;
		3164	}
		3165
		3166	template <typename Derived>
		3167	bool VISITORCLASS<Derived>::TraverseNakedAttr(NakedAttr *A) {
		3168	if (!getDerived().VisitAttr(A))
		3169	return false;
		3170	if (!getDerived().VisitNakedAttr(A))
		3171	return false;
		3172	return true;
		3173	}
		3174
		3175	template <typename Derived>
		3176	bool VISITORCLASS<Derived>::TraverseNoAliasAttr(NoAliasAttr *A) {
		3177	if (!getDerived().VisitAttr(A))
		3178	return false;
		3179	if (!getDerived().VisitNoAliasAttr(A))
		3180	return false;
		3181	return true;
		3182	}
		3183
		3184	template <typename Derived>
		3185	bool VISITORCLASS<Derived>::TraverseNoBuiltinAttr(NoBuiltinAttr *A) {
		3186	if (!getDerived().VisitAttr(A))
		3187	return false;
		3188	if (!getDerived().VisitNoBuiltinAttr(A))
		3189	return false;
		3190	return true;
		3191	}
		3192
		3193	template <typename Derived>
		3194	bool VISITORCLASS<Derived>::TraverseNoCommonAttr(NoCommonAttr *A) {
		3195	if (!getDerived().VisitAttr(A))
		3196	return false;
		3197	if (!getDerived().VisitNoCommonAttr(A))
		3198	return false;
		3199	return true;
		3200	}
		3201
		3202	template <typename Derived>
		3203	bool VISITORCLASS<Derived>::TraverseNoDebugAttr(NoDebugAttr *A) {
		3204	if (!getDerived().VisitAttr(A))
		3205	return false;
		3206	if (!getDerived().VisitNoDebugAttr(A))
		3207	return false;
		3208	return true;
		3209	}
		3210
		3211	template <typename Derived>
		3212	bool VISITORCLASS<Derived>::TraverseNoDerefAttr(NoDerefAttr *A) {
		3213	if (!getDerived().VisitAttr(A))
		3214	return false;
		3215	if (!getDerived().VisitNoDerefAttr(A))
		3216	return false;
		3217	return true;
		3218	}
		3219
		3220	template <typename Derived>
		3221	bool VISITORCLASS<Derived>::TraverseNoDestroyAttr(NoDestroyAttr *A) {
		3222	if (!getDerived().VisitAttr(A))
		3223	return false;
		3224	if (!getDerived().VisitNoDestroyAttr(A))
		3225	return false;
		3226	return true;
		3227	}
		3228
		3229	template <typename Derived>
		3230	bool VISITORCLASS<Derived>::TraverseNoDuplicateAttr(NoDuplicateAttr *A) {
		3231	if (!getDerived().VisitAttr(A))
		3232	return false;
		3233	if (!getDerived().VisitNoDuplicateAttr(A))
		3234	return false;
		3235	return true;
		3236	}
		3237
		3238	template <typename Derived>
		3239	bool VISITORCLASS<Derived>::TraverseNoEscapeAttr(NoEscapeAttr *A) {
		3240	if (!getDerived().VisitAttr(A))
		3241	return false;
		3242	if (!getDerived().VisitNoEscapeAttr(A))
		3243	return false;
		3244	return true;
		3245	}
		3246
		3247	template <typename Derived>
		3248	bool VISITORCLASS<Derived>::TraverseNoInlineAttr(NoInlineAttr *A) {
		3249	if (!getDerived().VisitAttr(A))
		3250	return false;
		3251	if (!getDerived().VisitNoInlineAttr(A))
		3252	return false;
		3253	return true;
		3254	}
		3255
		3256	template <typename Derived>
		3257	bool VISITORCLASS<Derived>::TraverseNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A) {
		3258	if (!getDerived().VisitAttr(A))
		3259	return false;
		3260	if (!getDerived().VisitNoInstrumentFunctionAttr(A))
		3261	return false;
		3262	return true;
		3263	}
		3264
		3265	template <typename Derived>
		3266	bool VISITORCLASS<Derived>::TraverseNoMergeAttr(NoMergeAttr *A) {
		3267	if (!getDerived().VisitAttr(A))
		3268	return false;
		3269	if (!getDerived().VisitNoMergeAttr(A))
		3270	return false;
		3271	return true;
		3272	}
		3273
		3274	template <typename Derived>
		3275	bool VISITORCLASS<Derived>::TraverseNoMicroMipsAttr(NoMicroMipsAttr *A) {
		3276	if (!getDerived().VisitAttr(A))
		3277	return false;
		3278	if (!getDerived().VisitNoMicroMipsAttr(A))
		3279	return false;
		3280	return true;
		3281	}
		3282
		3283	template <typename Derived>
		3284	bool VISITORCLASS<Derived>::TraverseNoMips16Attr(NoMips16Attr *A) {
		3285	if (!getDerived().VisitAttr(A))
		3286	return false;
		3287	if (!getDerived().VisitNoMips16Attr(A))
		3288	return false;
		3289	return true;
		3290	}
		3291
		3292	template <typename Derived>
		3293	bool VISITORCLASS<Derived>::TraverseNoProfileFunctionAttr(NoProfileFunctionAttr *A) {
		3294	if (!getDerived().VisitAttr(A))
		3295	return false;
		3296	if (!getDerived().VisitNoProfileFunctionAttr(A))
		3297	return false;
		3298	return true;
		3299	}
		3300
		3301	template <typename Derived>
		3302	bool VISITORCLASS<Derived>::TraverseNoRandomizeLayoutAttr(NoRandomizeLayoutAttr *A) {
		3303	if (!getDerived().VisitAttr(A))
		3304	return false;
		3305	if (!getDerived().VisitNoRandomizeLayoutAttr(A))
		3306	return false;
		3307	return true;
		3308	}
		3309
		3310	template <typename Derived>
		3311	bool VISITORCLASS<Derived>::TraverseNoReturnAttr(NoReturnAttr *A) {
		3312	if (!getDerived().VisitAttr(A))
		3313	return false;
		3314	if (!getDerived().VisitNoReturnAttr(A))
		3315	return false;
		3316	return true;
		3317	}
		3318
		3319	template <typename Derived>
		3320	bool VISITORCLASS<Derived>::TraverseNoSanitizeAttr(NoSanitizeAttr *A) {
		3321	if (!getDerived().VisitAttr(A))
		3322	return false;
		3323	if (!getDerived().VisitNoSanitizeAttr(A))
		3324	return false;
		3325	return true;
		3326	}
		3327
		3328	template <typename Derived>
		3329	bool VISITORCLASS<Derived>::TraverseNoSpeculativeLoadHardeningAttr(NoSpeculativeLoadHardeningAttr *A) {
		3330	if (!getDerived().VisitAttr(A))
		3331	return false;
		3332	if (!getDerived().VisitNoSpeculativeLoadHardeningAttr(A))
		3333	return false;
		3334	return true;
		3335	}
		3336
		3337	template <typename Derived>
		3338	bool VISITORCLASS<Derived>::TraverseNoSplitStackAttr(NoSplitStackAttr *A) {
		3339	if (!getDerived().VisitAttr(A))
		3340	return false;
		3341	if (!getDerived().VisitNoSplitStackAttr(A))
		3342	return false;
		3343	return true;
		3344	}
		3345
		3346	template <typename Derived>
		3347	bool VISITORCLASS<Derived>::TraverseNoStackProtectorAttr(NoStackProtectorAttr *A) {
		3348	if (!getDerived().VisitAttr(A))
		3349	return false;
		3350	if (!getDerived().VisitNoStackProtectorAttr(A))
		3351	return false;
		3352	return true;
		3353	}
		3354
		3355	template <typename Derived>
		3356	bool VISITORCLASS<Derived>::TraverseNoThreadSafetyAnalysisAttr(NoThreadSafetyAnalysisAttr *A) {
		3357	if (!getDerived().VisitAttr(A))
		3358	return false;
		3359	if (!getDerived().VisitNoThreadSafetyAnalysisAttr(A))
		3360	return false;
		3361	return true;
		3362	}
		3363
		3364	template <typename Derived>
		3365	bool VISITORCLASS<Derived>::TraverseNoThrowAttr(NoThrowAttr *A) {
		3366	if (!getDerived().VisitAttr(A))
		3367	return false;
		3368	if (!getDerived().VisitNoThrowAttr(A))
		3369	return false;
		3370	return true;
		3371	}
		3372
		3373	template <typename Derived>
		3374	bool VISITORCLASS<Derived>::TraverseNoUniqueAddressAttr(NoUniqueAddressAttr *A) {
		3375	if (!getDerived().VisitAttr(A))
		3376	return false;
		3377	if (!getDerived().VisitNoUniqueAddressAttr(A))
		3378	return false;
		3379	return true;
		3380	}
		3381
		3382	template <typename Derived>
		3383	bool VISITORCLASS<Derived>::TraverseNoUwtableAttr(NoUwtableAttr *A) {
		3384	if (!getDerived().VisitAttr(A))
		3385	return false;
		3386	if (!getDerived().VisitNoUwtableAttr(A))
		3387	return false;
		3388	return true;
		3389	}
		3390
		3391	template <typename Derived>
		3392	bool VISITORCLASS<Derived>::TraverseNonNullAttr(NonNullAttr *A) {
		3393	if (!getDerived().VisitAttr(A))
		3394	return false;
		3395	if (!getDerived().VisitNonNullAttr(A))
		3396	return false;
		3397	return true;
		3398	}
		3399
		3400	template <typename Derived>
		3401	bool VISITORCLASS<Derived>::TraverseNotTailCalledAttr(NotTailCalledAttr *A) {
		3402	if (!getDerived().VisitAttr(A))
		3403	return false;
		3404	if (!getDerived().VisitNotTailCalledAttr(A))
		3405	return false;
		3406	return true;
		3407	}
		3408
		3409	template <typename Derived>
		3410	bool VISITORCLASS<Derived>::TraverseOMPAllocateDeclAttr(OMPAllocateDeclAttr *A) {
		3411	if (!getDerived().VisitAttr(A))
		3412	return false;
		3413	if (!getDerived().VisitOMPAllocateDeclAttr(A))
		3414	return false;
		3415	if (!getDerived().TraverseStmt(A->getAllocator()))
		3416	return false;
		3417	if (!getDerived().TraverseStmt(A->getAlignment()))
		3418	return false;
		3419	return true;
		3420	}
		3421
		3422	template <typename Derived>
		3423	bool VISITORCLASS<Derived>::TraverseOMPCaptureKindAttr(OMPCaptureKindAttr *A) {
		3424	if (!getDerived().VisitAttr(A))
		3425	return false;
		3426	if (!getDerived().VisitOMPCaptureKindAttr(A))
		3427	return false;
		3428	return true;
		3429	}
		3430
		3431	template <typename Derived>
		3432	bool VISITORCLASS<Derived>::TraverseOMPCaptureNoInitAttr(OMPCaptureNoInitAttr *A) {
		3433	if (!getDerived().VisitAttr(A))
		3434	return false;
		3435	if (!getDerived().VisitOMPCaptureNoInitAttr(A))
		3436	return false;
		3437	return true;
		3438	}
		3439
		3440	template <typename Derived>
		3441	bool VISITORCLASS<Derived>::TraverseOMPDeclareSimdDeclAttr(OMPDeclareSimdDeclAttr *A) {
		3442	if (!getDerived().VisitAttr(A))
		3443	return false;
		3444	if (!getDerived().VisitOMPDeclareSimdDeclAttr(A))
		3445	return false;
		3446	if (!getDerived().TraverseStmt(A->getSimdlen()))
		3447	return false;
		3448	{
		3449	Expr * *I = A->uniforms_begin();
		3450	Expr * *E = A->uniforms_end();
		3451	for (; I != E; ++I) {
		3452	if (!getDerived().TraverseStmt(*I))
		3453	return false;
		3454	}
		3455	}
		3456	{
		3457	Expr * *I = A->aligneds_begin();
		3458	Expr * *E = A->aligneds_end();
		3459	for (; I != E; ++I) {
		3460	if (!getDerived().TraverseStmt(*I))
		3461	return false;
		3462	}
		3463	}
		3464	{
		3465	Expr * *I = A->alignments_begin();
		3466	Expr * *E = A->alignments_end();
		3467	for (; I != E; ++I) {
		3468	if (!getDerived().TraverseStmt(*I))
		3469	return false;
		3470	}
		3471	}
		3472	{
		3473	Expr * *I = A->linears_begin();
		3474	Expr * *E = A->linears_end();
		3475	for (; I != E; ++I) {
		3476	if (!getDerived().TraverseStmt(*I))
		3477	return false;
		3478	}
		3479	}
		3480	{
		3481	Expr * *I = A->steps_begin();
		3482	Expr * *E = A->steps_end();
		3483	for (; I != E; ++I) {
		3484	if (!getDerived().TraverseStmt(*I))
		3485	return false;
		3486	}
		3487	}
		3488	return true;
		3489	}
		3490
		3491	template <typename Derived>
		3492	bool VISITORCLASS<Derived>::TraverseOMPDeclareTargetDeclAttr(OMPDeclareTargetDeclAttr *A) {
		3493	if (!getDerived().VisitAttr(A))
		3494	return false;
		3495	if (!getDerived().VisitOMPDeclareTargetDeclAttr(A))
		3496	return false;
		3497	if (!getDerived().TraverseStmt(A->getIndirectExpr()))
		3498	return false;
		3499	return true;
		3500	}
		3501
		3502	template <typename Derived>
		3503	bool VISITORCLASS<Derived>::TraverseOMPDeclareVariantAttr(OMPDeclareVariantAttr *A) {
		3504	if (!getDerived().VisitAttr(A))
		3505	return false;
		3506	if (!getDerived().VisitOMPDeclareVariantAttr(A))
		3507	return false;
		3508	if (!getDerived().TraverseStmt(A->getVariantFuncRef()))
		3509	return false;
		3510	{
		3511	Expr * *I = A->adjustArgsNothing_begin();
		3512	Expr * *E = A->adjustArgsNothing_end();
		3513	for (; I != E; ++I) {
		3514	if (!getDerived().TraverseStmt(*I))
		3515	return false;
		3516	}
		3517	}
		3518	{
		3519	Expr * *I = A->adjustArgsNeedDevicePtr_begin();
		3520	Expr * *E = A->adjustArgsNeedDevicePtr_end();
		3521	for (; I != E; ++I) {
		3522	if (!getDerived().TraverseStmt(*I))
		3523	return false;
		3524	}
		3525	}
		3526	return true;
		3527	}
		3528
		3529	template <typename Derived>
		3530	bool VISITORCLASS<Derived>::TraverseOMPReferencedVarAttr(OMPReferencedVarAttr *A) {
		3531	if (!getDerived().VisitAttr(A))
		3532	return false;
		3533	if (!getDerived().VisitOMPReferencedVarAttr(A))
		3534	return false;
		3535	if (!getDerived().TraverseStmt(A->getRef()))
		3536	return false;
		3537	return true;
		3538	}
		3539
		3540	template <typename Derived>
		3541	bool VISITORCLASS<Derived>::TraverseOMPThreadPrivateDeclAttr(OMPThreadPrivateDeclAttr *A) {
		3542	if (!getDerived().VisitAttr(A))
		3543	return false;
		3544	if (!getDerived().VisitOMPThreadPrivateDeclAttr(A))
		3545	return false;
		3546	return true;
		3547	}
		3548
		3549	template <typename Derived>
		3550	bool VISITORCLASS<Derived>::TraverseOSConsumedAttr(OSConsumedAttr *A) {
		3551	if (!getDerived().VisitAttr(A))
		3552	return false;
		3553	if (!getDerived().VisitOSConsumedAttr(A))
		3554	return false;
		3555	return true;
		3556	}
		3557
		3558	template <typename Derived>
		3559	bool VISITORCLASS<Derived>::TraverseOSConsumesThisAttr(OSConsumesThisAttr *A) {
		3560	if (!getDerived().VisitAttr(A))
		3561	return false;
		3562	if (!getDerived().VisitOSConsumesThisAttr(A))
		3563	return false;
		3564	return true;
		3565	}
		3566
		3567	template <typename Derived>
		3568	bool VISITORCLASS<Derived>::TraverseOSReturnsNotRetainedAttr(OSReturnsNotRetainedAttr *A) {
		3569	if (!getDerived().VisitAttr(A))
		3570	return false;
		3571	if (!getDerived().VisitOSReturnsNotRetainedAttr(A))
		3572	return false;
		3573	return true;
		3574	}
		3575
		3576	template <typename Derived>
		3577	bool VISITORCLASS<Derived>::TraverseOSReturnsRetainedAttr(OSReturnsRetainedAttr *A) {
		3578	if (!getDerived().VisitAttr(A))
		3579	return false;
		3580	if (!getDerived().VisitOSReturnsRetainedAttr(A))
		3581	return false;
		3582	return true;
		3583	}
		3584
		3585	template <typename Derived>
		3586	bool VISITORCLASS<Derived>::TraverseOSReturnsRetainedOnNonZeroAttr(OSReturnsRetainedOnNonZeroAttr *A) {
		3587	if (!getDerived().VisitAttr(A))
		3588	return false;
		3589	if (!getDerived().VisitOSReturnsRetainedOnNonZeroAttr(A))
		3590	return false;
		3591	return true;
		3592	}
		3593
		3594	template <typename Derived>
		3595	bool VISITORCLASS<Derived>::TraverseOSReturnsRetainedOnZeroAttr(OSReturnsRetainedOnZeroAttr *A) {
		3596	if (!getDerived().VisitAttr(A))
		3597	return false;
		3598	if (!getDerived().VisitOSReturnsRetainedOnZeroAttr(A))
		3599	return false;
		3600	return true;
		3601	}
		3602
		3603	template <typename Derived>
		3604	bool VISITORCLASS<Derived>::TraverseObjCBoxableAttr(ObjCBoxableAttr *A) {
		3605	if (!getDerived().VisitAttr(A))
		3606	return false;
		3607	if (!getDerived().VisitObjCBoxableAttr(A))
		3608	return false;
		3609	return true;
		3610	}
		3611
		3612	template <typename Derived>
		3613	bool VISITORCLASS<Derived>::TraverseObjCBridgeAttr(ObjCBridgeAttr *A) {
		3614	if (!getDerived().VisitAttr(A))
		3615	return false;
		3616	if (!getDerived().VisitObjCBridgeAttr(A))
		3617	return false;
		3618	return true;
		3619	}
		3620
		3621	template <typename Derived>
		3622	bool VISITORCLASS<Derived>::TraverseObjCBridgeMutableAttr(ObjCBridgeMutableAttr *A) {
		3623	if (!getDerived().VisitAttr(A))
		3624	return false;
		3625	if (!getDerived().VisitObjCBridgeMutableAttr(A))
		3626	return false;
		3627	return true;
		3628	}
		3629
		3630	template <typename Derived>
		3631	bool VISITORCLASS<Derived>::TraverseObjCBridgeRelatedAttr(ObjCBridgeRelatedAttr *A) {
		3632	if (!getDerived().VisitAttr(A))
		3633	return false;
		3634	if (!getDerived().VisitObjCBridgeRelatedAttr(A))
		3635	return false;
		3636	return true;
		3637	}
		3638
		3639	template <typename Derived>
		3640	bool VISITORCLASS<Derived>::TraverseObjCClassStubAttr(ObjCClassStubAttr *A) {
		3641	if (!getDerived().VisitAttr(A))
		3642	return false;
		3643	if (!getDerived().VisitObjCClassStubAttr(A))
		3644	return false;
		3645	return true;
		3646	}
		3647
		3648	template <typename Derived>
		3649	bool VISITORCLASS<Derived>::TraverseObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A) {
		3650	if (!getDerived().VisitAttr(A))
		3651	return false;
		3652	if (!getDerived().VisitObjCDesignatedInitializerAttr(A))
		3653	return false;
		3654	return true;
		3655	}
		3656
		3657	template <typename Derived>
		3658	bool VISITORCLASS<Derived>::TraverseObjCDirectAttr(ObjCDirectAttr *A) {
		3659	if (!getDerived().VisitAttr(A))
		3660	return false;
		3661	if (!getDerived().VisitObjCDirectAttr(A))
		3662	return false;
		3663	return true;
		3664	}
		3665
		3666	template <typename Derived>
		3667	bool VISITORCLASS<Derived>::TraverseObjCDirectMembersAttr(ObjCDirectMembersAttr *A) {
		3668	if (!getDerived().VisitAttr(A))
		3669	return false;
		3670	if (!getDerived().VisitObjCDirectMembersAttr(A))
		3671	return false;
		3672	return true;
		3673	}
		3674
		3675	template <typename Derived>
		3676	bool VISITORCLASS<Derived>::TraverseObjCExceptionAttr(ObjCExceptionAttr *A) {
		3677	if (!getDerived().VisitAttr(A))
		3678	return false;
		3679	if (!getDerived().VisitObjCExceptionAttr(A))
		3680	return false;
		3681	return true;
		3682	}
		3683
		3684	template <typename Derived>
		3685	bool VISITORCLASS<Derived>::TraverseObjCExplicitProtocolImplAttr(ObjCExplicitProtocolImplAttr *A) {
		3686	if (!getDerived().VisitAttr(A))
		3687	return false;
		3688	if (!getDerived().VisitObjCExplicitProtocolImplAttr(A))
		3689	return false;
		3690	return true;
		3691	}
		3692
		3693	template <typename Derived>
		3694	bool VISITORCLASS<Derived>::TraverseObjCExternallyRetainedAttr(ObjCExternallyRetainedAttr *A) {
		3695	if (!getDerived().VisitAttr(A))
		3696	return false;
		3697	if (!getDerived().VisitObjCExternallyRetainedAttr(A))
		3698	return false;
		3699	return true;
		3700	}
		3701
		3702	template <typename Derived>
		3703	bool VISITORCLASS<Derived>::TraverseObjCGCAttr(ObjCGCAttr *A) {
		3704	if (!getDerived().VisitAttr(A))
		3705	return false;
		3706	if (!getDerived().VisitObjCGCAttr(A))
		3707	return false;
		3708	return true;
		3709	}
		3710
		3711	template <typename Derived>
		3712	bool VISITORCLASS<Derived>::TraverseObjCIndependentClassAttr(ObjCIndependentClassAttr *A) {
		3713	if (!getDerived().VisitAttr(A))
		3714	return false;
		3715	if (!getDerived().VisitObjCIndependentClassAttr(A))
		3716	return false;
		3717	return true;
		3718	}
		3719
		3720	template <typename Derived>
		3721	bool VISITORCLASS<Derived>::TraverseObjCInertUnsafeUnretainedAttr(ObjCInertUnsafeUnretainedAttr *A) {
		3722	if (!getDerived().VisitAttr(A))
		3723	return false;
		3724	if (!getDerived().VisitObjCInertUnsafeUnretainedAttr(A))
		3725	return false;
		3726	return true;
		3727	}
		3728
		3729	template <typename Derived>
		3730	bool VISITORCLASS<Derived>::TraverseObjCKindOfAttr(ObjCKindOfAttr *A) {
		3731	if (!getDerived().VisitAttr(A))
		3732	return false;
		3733	if (!getDerived().VisitObjCKindOfAttr(A))
		3734	return false;
		3735	return true;
		3736	}
		3737
		3738	template <typename Derived>
		3739	bool VISITORCLASS<Derived>::TraverseObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A) {
		3740	if (!getDerived().VisitAttr(A))
		3741	return false;
		3742	if (!getDerived().VisitObjCMethodFamilyAttr(A))
		3743	return false;
		3744	return true;
		3745	}
		3746
		3747	template <typename Derived>
		3748	bool VISITORCLASS<Derived>::TraverseObjCNSObjectAttr(ObjCNSObjectAttr *A) {
		3749	if (!getDerived().VisitAttr(A))
		3750	return false;
		3751	if (!getDerived().VisitObjCNSObjectAttr(A))
		3752	return false;
		3753	return true;
		3754	}
		3755
		3756	template <typename Derived>
		3757	bool VISITORCLASS<Derived>::TraverseObjCNonLazyClassAttr(ObjCNonLazyClassAttr *A) {
		3758	if (!getDerived().VisitAttr(A))
		3759	return false;
		3760	if (!getDerived().VisitObjCNonLazyClassAttr(A))
		3761	return false;
		3762	return true;
		3763	}
		3764
		3765	template <typename Derived>
		3766	bool VISITORCLASS<Derived>::TraverseObjCNonRuntimeProtocolAttr(ObjCNonRuntimeProtocolAttr *A) {
		3767	if (!getDerived().VisitAttr(A))
		3768	return false;
		3769	if (!getDerived().VisitObjCNonRuntimeProtocolAttr(A))
		3770	return false;
		3771	return true;
		3772	}
		3773
		3774	template <typename Derived>
		3775	bool VISITORCLASS<Derived>::TraverseObjCOwnershipAttr(ObjCOwnershipAttr *A) {
		3776	if (!getDerived().VisitAttr(A))
		3777	return false;
		3778	if (!getDerived().VisitObjCOwnershipAttr(A))
		3779	return false;
		3780	return true;
		3781	}
		3782
		3783	template <typename Derived>
		3784	bool VISITORCLASS<Derived>::TraverseObjCPreciseLifetimeAttr(ObjCPreciseLifetimeAttr *A) {
		3785	if (!getDerived().VisitAttr(A))
		3786	return false;
		3787	if (!getDerived().VisitObjCPreciseLifetimeAttr(A))
		3788	return false;
		3789	return true;
		3790	}
		3791
		3792	template <typename Derived>
		3793	bool VISITORCLASS<Derived>::TraverseObjCRequiresPropertyDefsAttr(ObjCRequiresPropertyDefsAttr *A) {
		3794	if (!getDerived().VisitAttr(A))
		3795	return false;
		3796	if (!getDerived().VisitObjCRequiresPropertyDefsAttr(A))
		3797	return false;
		3798	return true;
		3799	}
		3800
		3801	template <typename Derived>
		3802	bool VISITORCLASS<Derived>::TraverseObjCRequiresSuperAttr(ObjCRequiresSuperAttr *A) {
		3803	if (!getDerived().VisitAttr(A))
		3804	return false;
		3805	if (!getDerived().VisitObjCRequiresSuperAttr(A))
		3806	return false;
		3807	return true;
		3808	}
		3809
		3810	template <typename Derived>
		3811	bool VISITORCLASS<Derived>::TraverseObjCReturnsInnerPointerAttr(ObjCReturnsInnerPointerAttr *A) {
		3812	if (!getDerived().VisitAttr(A))
		3813	return false;
		3814	if (!getDerived().VisitObjCReturnsInnerPointerAttr(A))
		3815	return false;
		3816	return true;
		3817	}
		3818
		3819	template <typename Derived>
		3820	bool VISITORCLASS<Derived>::TraverseObjCRootClassAttr(ObjCRootClassAttr *A) {
		3821	if (!getDerived().VisitAttr(A))
		3822	return false;
		3823	if (!getDerived().VisitObjCRootClassAttr(A))
		3824	return false;
		3825	return true;
		3826	}
		3827
		3828	template <typename Derived>
		3829	bool VISITORCLASS<Derived>::TraverseObjCRuntimeNameAttr(ObjCRuntimeNameAttr *A) {
		3830	if (!getDerived().VisitAttr(A))
		3831	return false;
		3832	if (!getDerived().VisitObjCRuntimeNameAttr(A))
		3833	return false;
		3834	return true;
		3835	}
		3836
		3837	template <typename Derived>
		3838	bool VISITORCLASS<Derived>::TraverseObjCRuntimeVisibleAttr(ObjCRuntimeVisibleAttr *A) {
		3839	if (!getDerived().VisitAttr(A))
		3840	return false;
		3841	if (!getDerived().VisitObjCRuntimeVisibleAttr(A))
		3842	return false;
		3843	return true;
		3844	}
		3845
		3846	template <typename Derived>
		3847	bool VISITORCLASS<Derived>::TraverseObjCSubclassingRestrictedAttr(ObjCSubclassingRestrictedAttr *A) {
		3848	if (!getDerived().VisitAttr(A))
		3849	return false;
		3850	if (!getDerived().VisitObjCSubclassingRestrictedAttr(A))
		3851	return false;
		3852	return true;
		3853	}
		3854
		3855	template <typename Derived>
		3856	bool VISITORCLASS<Derived>::TraverseOpenCLAccessAttr(OpenCLAccessAttr *A) {
		3857	if (!getDerived().VisitAttr(A))
		3858	return false;
		3859	if (!getDerived().VisitOpenCLAccessAttr(A))
		3860	return false;
		3861	return true;
		3862	}
		3863
		3864	template <typename Derived>
		3865	bool VISITORCLASS<Derived>::TraverseOpenCLConstantAddressSpaceAttr(OpenCLConstantAddressSpaceAttr *A) {
		3866	if (!getDerived().VisitAttr(A))
		3867	return false;
		3868	if (!getDerived().VisitOpenCLConstantAddressSpaceAttr(A))
		3869	return false;
		3870	return true;
		3871	}
		3872
		3873	template <typename Derived>
		3874	bool VISITORCLASS<Derived>::TraverseOpenCLGenericAddressSpaceAttr(OpenCLGenericAddressSpaceAttr *A) {
		3875	if (!getDerived().VisitAttr(A))
		3876	return false;
		3877	if (!getDerived().VisitOpenCLGenericAddressSpaceAttr(A))
		3878	return false;
		3879	return true;
		3880	}
		3881
		3882	template <typename Derived>
		3883	bool VISITORCLASS<Derived>::TraverseOpenCLGlobalAddressSpaceAttr(OpenCLGlobalAddressSpaceAttr *A) {
		3884	if (!getDerived().VisitAttr(A))
		3885	return false;
		3886	if (!getDerived().VisitOpenCLGlobalAddressSpaceAttr(A))
		3887	return false;
		3888	return true;
		3889	}
		3890
		3891	template <typename Derived>
		3892	bool VISITORCLASS<Derived>::TraverseOpenCLGlobalDeviceAddressSpaceAttr(OpenCLGlobalDeviceAddressSpaceAttr *A) {
		3893	if (!getDerived().VisitAttr(A))
		3894	return false;
		3895	if (!getDerived().VisitOpenCLGlobalDeviceAddressSpaceAttr(A))
		3896	return false;
		3897	return true;
		3898	}
		3899
		3900	template <typename Derived>
		3901	bool VISITORCLASS<Derived>::TraverseOpenCLGlobalHostAddressSpaceAttr(OpenCLGlobalHostAddressSpaceAttr *A) {
		3902	if (!getDerived().VisitAttr(A))
		3903	return false;
		3904	if (!getDerived().VisitOpenCLGlobalHostAddressSpaceAttr(A))
		3905	return false;
		3906	return true;
		3907	}
		3908
		3909	template <typename Derived>
		3910	bool VISITORCLASS<Derived>::TraverseOpenCLIntelReqdSubGroupSizeAttr(OpenCLIntelReqdSubGroupSizeAttr *A) {
		3911	if (!getDerived().VisitAttr(A))
		3912	return false;
		3913	if (!getDerived().VisitOpenCLIntelReqdSubGroupSizeAttr(A))
		3914	return false;
		3915	return true;
		3916	}
		3917
		3918	template <typename Derived>
		3919	bool VISITORCLASS<Derived>::TraverseOpenCLKernelAttr(OpenCLKernelAttr *A) {
		3920	if (!getDerived().VisitAttr(A))
		3921	return false;
		3922	if (!getDerived().VisitOpenCLKernelAttr(A))
		3923	return false;
		3924	return true;
		3925	}
		3926
		3927	template <typename Derived>
		3928	bool VISITORCLASS<Derived>::TraverseOpenCLLocalAddressSpaceAttr(OpenCLLocalAddressSpaceAttr *A) {
		3929	if (!getDerived().VisitAttr(A))
		3930	return false;
		3931	if (!getDerived().VisitOpenCLLocalAddressSpaceAttr(A))
		3932	return false;
		3933	return true;
		3934	}
		3935
		3936	template <typename Derived>
		3937	bool VISITORCLASS<Derived>::TraverseOpenCLPrivateAddressSpaceAttr(OpenCLPrivateAddressSpaceAttr *A) {
		3938	if (!getDerived().VisitAttr(A))
		3939	return false;
		3940	if (!getDerived().VisitOpenCLPrivateAddressSpaceAttr(A))
		3941	return false;
		3942	return true;
		3943	}
		3944
		3945	template <typename Derived>
		3946	bool VISITORCLASS<Derived>::TraverseOpenCLUnrollHintAttr(OpenCLUnrollHintAttr *A) {
		3947	if (!getDerived().VisitAttr(A))
		3948	return false;
		3949	if (!getDerived().VisitOpenCLUnrollHintAttr(A))
		3950	return false;
		3951	return true;
		3952	}
		3953
		3954	template <typename Derived>
		3955	bool VISITORCLASS<Derived>::TraverseOptimizeNoneAttr(OptimizeNoneAttr *A) {
		3956	if (!getDerived().VisitAttr(A))
		3957	return false;
		3958	if (!getDerived().VisitOptimizeNoneAttr(A))
		3959	return false;
		3960	return true;
		3961	}
		3962
		3963	template <typename Derived>
		3964	bool VISITORCLASS<Derived>::TraverseOverloadableAttr(OverloadableAttr *A) {
		3965	if (!getDerived().VisitAttr(A))
		3966	return false;
		3967	if (!getDerived().VisitOverloadableAttr(A))
		3968	return false;
		3969	return true;
		3970	}
		3971
		3972	template <typename Derived>
		3973	bool VISITORCLASS<Derived>::TraverseOverrideAttr(OverrideAttr *A) {
		3974	if (!getDerived().VisitAttr(A))
		3975	return false;
		3976	if (!getDerived().VisitOverrideAttr(A))
		3977	return false;
		3978	return true;
		3979	}
		3980
		3981	template <typename Derived>
		3982	bool VISITORCLASS<Derived>::TraverseOwnerAttr(OwnerAttr *A) {
		3983	if (!getDerived().VisitAttr(A))
		3984	return false;
		3985	if (!getDerived().VisitOwnerAttr(A))
		3986	return false;
		3987	if (auto *TSI = A->getDerefTypeLoc())
		3988	if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
		3989	return false;
		3990	return true;
		3991	}
		3992
		3993	template <typename Derived>
		3994	bool VISITORCLASS<Derived>::TraverseOwnershipAttr(OwnershipAttr *A) {
		3995	if (!getDerived().VisitAttr(A))
		3996	return false;
		3997	if (!getDerived().VisitOwnershipAttr(A))
		3998	return false;
		3999	return true;
		4000	}
		4001
		4002	template <typename Derived>
		4003	bool VISITORCLASS<Derived>::TraversePackedAttr(PackedAttr *A) {
		4004	if (!getDerived().VisitAttr(A))
		4005	return false;
		4006	if (!getDerived().VisitPackedAttr(A))
		4007	return false;
		4008	return true;
		4009	}
		4010
		4011	template <typename Derived>
		4012	bool VISITORCLASS<Derived>::TraverseParamTypestateAttr(ParamTypestateAttr *A) {
		4013	if (!getDerived().VisitAttr(A))
		4014	return false;
		4015	if (!getDerived().VisitParamTypestateAttr(A))
		4016	return false;
		4017	return true;
		4018	}
		4019
		4020	template <typename Derived>
		4021	bool VISITORCLASS<Derived>::TraversePascalAttr(PascalAttr *A) {
		4022	if (!getDerived().VisitAttr(A))
		4023	return false;
		4024	if (!getDerived().VisitPascalAttr(A))
		4025	return false;
		4026	return true;
		4027	}
		4028
		4029	template <typename Derived>
		4030	bool VISITORCLASS<Derived>::TraversePassObjectSizeAttr(PassObjectSizeAttr *A) {
		4031	if (!getDerived().VisitAttr(A))
		4032	return false;
		4033	if (!getDerived().VisitPassObjectSizeAttr(A))
		4034	return false;
		4035	return true;
		4036	}
		4037
		4038	template <typename Derived>
		4039	bool VISITORCLASS<Derived>::TraversePatchableFunctionEntryAttr(PatchableFunctionEntryAttr *A) {
		4040	if (!getDerived().VisitAttr(A))
		4041	return false;
		4042	if (!getDerived().VisitPatchableFunctionEntryAttr(A))
		4043	return false;
		4044	return true;
		4045	}
		4046
		4047	template <typename Derived>
		4048	bool VISITORCLASS<Derived>::TraversePcsAttr(PcsAttr *A) {
		4049	if (!getDerived().VisitAttr(A))
		4050	return false;
		4051	if (!getDerived().VisitPcsAttr(A))
		4052	return false;
		4053	return true;
		4054	}
		4055
		4056	template <typename Derived>
		4057	bool VISITORCLASS<Derived>::TraversePointerAttr(PointerAttr *A) {
		4058	if (!getDerived().VisitAttr(A))
		4059	return false;
		4060	if (!getDerived().VisitPointerAttr(A))
		4061	return false;
		4062	if (auto *TSI = A->getDerefTypeLoc())
		4063	if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
		4064	return false;
		4065	return true;
		4066	}
		4067
		4068	template <typename Derived>
		4069	bool VISITORCLASS<Derived>::TraversePragmaClangBSSSectionAttr(PragmaClangBSSSectionAttr *A) {
		4070	if (!getDerived().VisitAttr(A))
		4071	return false;
		4072	if (!getDerived().VisitPragmaClangBSSSectionAttr(A))
		4073	return false;
		4074	return true;
		4075	}
		4076
		4077	template <typename Derived>
		4078	bool VISITORCLASS<Derived>::TraversePragmaClangDataSectionAttr(PragmaClangDataSectionAttr *A) {
		4079	if (!getDerived().VisitAttr(A))
		4080	return false;
		4081	if (!getDerived().VisitPragmaClangDataSectionAttr(A))
		4082	return false;
		4083	return true;
		4084	}
		4085
		4086	template <typename Derived>
		4087	bool VISITORCLASS<Derived>::TraversePragmaClangRelroSectionAttr(PragmaClangRelroSectionAttr *A) {
		4088	if (!getDerived().VisitAttr(A))
		4089	return false;
		4090	if (!getDerived().VisitPragmaClangRelroSectionAttr(A))
		4091	return false;
		4092	return true;
		4093	}
		4094
		4095	template <typename Derived>
		4096	bool VISITORCLASS<Derived>::TraversePragmaClangRodataSectionAttr(PragmaClangRodataSectionAttr *A) {
		4097	if (!getDerived().VisitAttr(A))
		4098	return false;
		4099	if (!getDerived().VisitPragmaClangRodataSectionAttr(A))
		4100	return false;
		4101	return true;
		4102	}
		4103
		4104	template <typename Derived>
		4105	bool VISITORCLASS<Derived>::TraversePragmaClangTextSectionAttr(PragmaClangTextSectionAttr *A) {
		4106	if (!getDerived().VisitAttr(A))
		4107	return false;
		4108	if (!getDerived().VisitPragmaClangTextSectionAttr(A))
		4109	return false;
		4110	return true;
		4111	}
		4112
		4113	template <typename Derived>
		4114	bool VISITORCLASS<Derived>::TraversePreferredNameAttr(PreferredNameAttr *A) {
		4115	if (!getDerived().VisitAttr(A))
		4116	return false;
		4117	if (!getDerived().VisitPreferredNameAttr(A))
		4118	return false;
		4119	if (auto *TSI = A->getTypedefTypeLoc())
		4120	if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
		4121	return false;
		4122	return true;
		4123	}
		4124
		4125	template <typename Derived>
		4126	bool VISITORCLASS<Derived>::TraversePreserveAllAttr(PreserveAllAttr *A) {
		4127	if (!getDerived().VisitAttr(A))
		4128	return false;
		4129	if (!getDerived().VisitPreserveAllAttr(A))
		4130	return false;
		4131	return true;
		4132	}
		4133
		4134	template <typename Derived>
		4135	bool VISITORCLASS<Derived>::TraversePreserveMostAttr(PreserveMostAttr *A) {
		4136	if (!getDerived().VisitAttr(A))
		4137	return false;
		4138	if (!getDerived().VisitPreserveMostAttr(A))
		4139	return false;
		4140	return true;
		4141	}
		4142
		4143	template <typename Derived>
		4144	bool VISITORCLASS<Derived>::TraversePtGuardedByAttr(PtGuardedByAttr *A) {
		4145	if (!getDerived().VisitAttr(A))
		4146	return false;
		4147	if (!getDerived().VisitPtGuardedByAttr(A))
		4148	return false;
		4149	if (!getDerived().TraverseStmt(A->getArg()))
		4150	return false;
		4151	return true;
		4152	}
		4153
		4154	template <typename Derived>
		4155	bool VISITORCLASS<Derived>::TraversePtGuardedVarAttr(PtGuardedVarAttr *A) {
		4156	if (!getDerived().VisitAttr(A))
		4157	return false;
		4158	if (!getDerived().VisitPtGuardedVarAttr(A))
		4159	return false;
		4160	return true;
		4161	}
		4162
		4163	template <typename Derived>
		4164	bool VISITORCLASS<Derived>::TraversePtr32Attr(Ptr32Attr *A) {
		4165	if (!getDerived().VisitAttr(A))
		4166	return false;
		4167	if (!getDerived().VisitPtr32Attr(A))
		4168	return false;
		4169	return true;
		4170	}
		4171
		4172	template <typename Derived>
		4173	bool VISITORCLASS<Derived>::TraversePtr64Attr(Ptr64Attr *A) {
		4174	if (!getDerived().VisitAttr(A))
		4175	return false;
		4176	if (!getDerived().VisitPtr64Attr(A))
		4177	return false;
		4178	return true;
		4179	}
		4180
		4181	template <typename Derived>
		4182	bool VISITORCLASS<Derived>::TraversePureAttr(PureAttr *A) {
		4183	if (!getDerived().VisitAttr(A))
		4184	return false;
		4185	if (!getDerived().VisitPureAttr(A))
		4186	return false;
		4187	return true;
		4188	}
		4189
		4190	template <typename Derived>
		4191	bool VISITORCLASS<Derived>::TraverseRISCVInterruptAttr(RISCVInterruptAttr *A) {
		4192	if (!getDerived().VisitAttr(A))
		4193	return false;
		4194	if (!getDerived().VisitRISCVInterruptAttr(A))
		4195	return false;
		4196	return true;
		4197	}
		4198
		4199	template <typename Derived>
		4200	bool VISITORCLASS<Derived>::TraverseRandomizeLayoutAttr(RandomizeLayoutAttr *A) {
		4201	if (!getDerived().VisitAttr(A))
		4202	return false;
		4203	if (!getDerived().VisitRandomizeLayoutAttr(A))
		4204	return false;
		4205	return true;
		4206	}
		4207
		4208	template <typename Derived>
		4209	bool VISITORCLASS<Derived>::TraverseReadOnlyPlacementAttr(ReadOnlyPlacementAttr *A) {
		4210	if (!getDerived().VisitAttr(A))
		4211	return false;
		4212	if (!getDerived().VisitReadOnlyPlacementAttr(A))
		4213	return false;
		4214	return true;
		4215	}
		4216
		4217	template <typename Derived>
		4218	bool VISITORCLASS<Derived>::TraverseRegCallAttr(RegCallAttr *A) {
		4219	if (!getDerived().VisitAttr(A))
		4220	return false;
		4221	if (!getDerived().VisitRegCallAttr(A))
		4222	return false;
		4223	return true;
		4224	}
		4225
		4226	template <typename Derived>
		4227	bool VISITORCLASS<Derived>::TraverseReinitializesAttr(ReinitializesAttr *A) {
		4228	if (!getDerived().VisitAttr(A))
		4229	return false;
		4230	if (!getDerived().VisitReinitializesAttr(A))
		4231	return false;
		4232	return true;
		4233	}
		4234
		4235	template <typename Derived>
		4236	bool VISITORCLASS<Derived>::TraverseReleaseCapabilityAttr(ReleaseCapabilityAttr *A) {
		4237	if (!getDerived().VisitAttr(A))
		4238	return false;
		4239	if (!getDerived().VisitReleaseCapabilityAttr(A))
		4240	return false;
		4241	{
		4242	Expr * *I = A->args_begin();
		4243	Expr * *E = A->args_end();
		4244	for (; I != E; ++I) {
		4245	if (!getDerived().TraverseStmt(*I))
		4246	return false;
		4247	}
		4248	}
		4249	return true;
		4250	}
		4251
		4252	template <typename Derived>
		4253	bool VISITORCLASS<Derived>::TraverseReleaseHandleAttr(ReleaseHandleAttr *A) {
		4254	if (!getDerived().VisitAttr(A))
		4255	return false;
		4256	if (!getDerived().VisitReleaseHandleAttr(A))
		4257	return false;
		4258	return true;
		4259	}
		4260
		4261	template <typename Derived>
		4262	bool VISITORCLASS<Derived>::TraverseRenderScriptKernelAttr(RenderScriptKernelAttr *A) {
		4263	if (!getDerived().VisitAttr(A))
		4264	return false;
		4265	if (!getDerived().VisitRenderScriptKernelAttr(A))
		4266	return false;
		4267	return true;
		4268	}
		4269
		4270	template <typename Derived>
		4271	bool VISITORCLASS<Derived>::TraverseReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A) {
		4272	if (!getDerived().VisitAttr(A))
		4273	return false;
		4274	if (!getDerived().VisitReqdWorkGroupSizeAttr(A))
		4275	return false;
		4276	return true;
		4277	}
		4278
		4279	template <typename Derived>
		4280	bool VISITORCLASS<Derived>::TraverseRequiresCapabilityAttr(RequiresCapabilityAttr *A) {
		4281	if (!getDerived().VisitAttr(A))
		4282	return false;
		4283	if (!getDerived().VisitRequiresCapabilityAttr(A))
		4284	return false;
		4285	{
		4286	Expr * *I = A->args_begin();
		4287	Expr * *E = A->args_end();
		4288	for (; I != E; ++I) {
		4289	if (!getDerived().TraverseStmt(*I))
		4290	return false;
		4291	}
		4292	}
		4293	return true;
		4294	}
		4295
		4296	template <typename Derived>
		4297	bool VISITORCLASS<Derived>::TraverseRestrictAttr(RestrictAttr *A) {
		4298	if (!getDerived().VisitAttr(A))
		4299	return false;
		4300	if (!getDerived().VisitRestrictAttr(A))
		4301	return false;
		4302	return true;
		4303	}
		4304
		4305	template <typename Derived>
		4306	bool VISITORCLASS<Derived>::TraverseRetainAttr(RetainAttr *A) {
		4307	if (!getDerived().VisitAttr(A))
		4308	return false;
		4309	if (!getDerived().VisitRetainAttr(A))
		4310	return false;
		4311	return true;
		4312	}
		4313
		4314	template <typename Derived>
		4315	bool VISITORCLASS<Derived>::TraverseReturnTypestateAttr(ReturnTypestateAttr *A) {
		4316	if (!getDerived().VisitAttr(A))
		4317	return false;
		4318	if (!getDerived().VisitReturnTypestateAttr(A))
		4319	return false;
		4320	return true;
		4321	}
		4322
		4323	template <typename Derived>
		4324	bool VISITORCLASS<Derived>::TraverseReturnsNonNullAttr(ReturnsNonNullAttr *A) {
		4325	if (!getDerived().VisitAttr(A))
		4326	return false;
		4327	if (!getDerived().VisitReturnsNonNullAttr(A))
		4328	return false;
		4329	return true;
		4330	}
		4331
		4332	template <typename Derived>
		4333	bool VISITORCLASS<Derived>::TraverseReturnsTwiceAttr(ReturnsTwiceAttr *A) {
		4334	if (!getDerived().VisitAttr(A))
		4335	return false;
		4336	if (!getDerived().VisitReturnsTwiceAttr(A))
		4337	return false;
		4338	return true;
		4339	}
		4340
		4341	template <typename Derived>
		4342	bool VISITORCLASS<Derived>::TraverseSPtrAttr(SPtrAttr *A) {
		4343	if (!getDerived().VisitAttr(A))
		4344	return false;
		4345	if (!getDerived().VisitSPtrAttr(A))
		4346	return false;
		4347	return true;
		4348	}
		4349
		4350	template <typename Derived>
		4351	bool VISITORCLASS<Derived>::TraverseSYCLKernelAttr(SYCLKernelAttr *A) {
		4352	if (!getDerived().VisitAttr(A))
		4353	return false;
		4354	if (!getDerived().VisitSYCLKernelAttr(A))
		4355	return false;
		4356	return true;
		4357	}
		4358
		4359	template <typename Derived>
		4360	bool VISITORCLASS<Derived>::TraverseSYCLSpecialClassAttr(SYCLSpecialClassAttr *A) {
		4361	if (!getDerived().VisitAttr(A))
		4362	return false;
		4363	if (!getDerived().VisitSYCLSpecialClassAttr(A))
		4364	return false;
		4365	return true;
		4366	}
		4367
		4368	template <typename Derived>
		4369	bool VISITORCLASS<Derived>::TraverseScopedLockableAttr(ScopedLockableAttr *A) {
		4370	if (!getDerived().VisitAttr(A))
		4371	return false;
		4372	if (!getDerived().VisitScopedLockableAttr(A))
		4373	return false;
		4374	return true;
		4375	}
		4376
		4377	template <typename Derived>
		4378	bool VISITORCLASS<Derived>::TraverseSectionAttr(SectionAttr *A) {
		4379	if (!getDerived().VisitAttr(A))
		4380	return false;
		4381	if (!getDerived().VisitSectionAttr(A))
		4382	return false;
		4383	return true;
		4384	}
		4385
		4386	template <typename Derived>
		4387	bool VISITORCLASS<Derived>::TraverseSelectAnyAttr(SelectAnyAttr *A) {
		4388	if (!getDerived().VisitAttr(A))
		4389	return false;
		4390	if (!getDerived().VisitSelectAnyAttr(A))
		4391	return false;
		4392	return true;
		4393	}
		4394
		4395	template <typename Derived>
		4396	bool VISITORCLASS<Derived>::TraverseSentinelAttr(SentinelAttr *A) {
		4397	if (!getDerived().VisitAttr(A))
		4398	return false;
		4399	if (!getDerived().VisitSentinelAttr(A))
		4400	return false;
		4401	return true;
		4402	}
		4403
		4404	template <typename Derived>
		4405	bool VISITORCLASS<Derived>::TraverseSetTypestateAttr(SetTypestateAttr *A) {
		4406	if (!getDerived().VisitAttr(A))
		4407	return false;
		4408	if (!getDerived().VisitSetTypestateAttr(A))
		4409	return false;
		4410	return true;
		4411	}
		4412
		4413	template <typename Derived>
		4414	bool VISITORCLASS<Derived>::TraverseSharedTrylockFunctionAttr(SharedTrylockFunctionAttr *A) {
		4415	if (!getDerived().VisitAttr(A))
		4416	return false;
		4417	if (!getDerived().VisitSharedTrylockFunctionAttr(A))
		4418	return false;
		4419	if (!getDerived().TraverseStmt(A->getSuccessValue()))
		4420	return false;
		4421	{
		4422	Expr * *I = A->args_begin();
		4423	Expr * *E = A->args_end();
		4424	for (; I != E; ++I) {
		4425	if (!getDerived().TraverseStmt(*I))
		4426	return false;
		4427	}
		4428	}
		4429	return true;
		4430	}
		4431
		4432	template <typename Derived>
		4433	bool VISITORCLASS<Derived>::TraverseSpeculativeLoadHardeningAttr(SpeculativeLoadHardeningAttr *A) {
		4434	if (!getDerived().VisitAttr(A))
		4435	return false;
		4436	if (!getDerived().VisitSpeculativeLoadHardeningAttr(A))
		4437	return false;
		4438	return true;
		4439	}
		4440
		4441	template <typename Derived>
		4442	bool VISITORCLASS<Derived>::TraverseStandaloneDebugAttr(StandaloneDebugAttr *A) {
		4443	if (!getDerived().VisitAttr(A))
		4444	return false;
		4445	if (!getDerived().VisitStandaloneDebugAttr(A))
		4446	return false;
		4447	return true;
		4448	}
		4449
		4450	template <typename Derived>
		4451	bool VISITORCLASS<Derived>::TraverseStdCallAttr(StdCallAttr *A) {
		4452	if (!getDerived().VisitAttr(A))
		4453	return false;
		4454	if (!getDerived().VisitStdCallAttr(A))
		4455	return false;
		4456	return true;
		4457	}
		4458
		4459	template <typename Derived>
		4460	bool VISITORCLASS<Derived>::TraverseStrictFPAttr(StrictFPAttr *A) {
		4461	if (!getDerived().VisitAttr(A))
		4462	return false;
		4463	if (!getDerived().VisitStrictFPAttr(A))
		4464	return false;
		4465	return true;
		4466	}
		4467
		4468	template <typename Derived>
		4469	bool VISITORCLASS<Derived>::TraverseStrictGuardStackCheckAttr(StrictGuardStackCheckAttr *A) {
		4470	if (!getDerived().VisitAttr(A))
		4471	return false;
		4472	if (!getDerived().VisitStrictGuardStackCheckAttr(A))
		4473	return false;
		4474	return true;
		4475	}
		4476
		4477	template <typename Derived>
		4478	bool VISITORCLASS<Derived>::TraverseSuppressAttr(SuppressAttr *A) {
		4479	if (!getDerived().VisitAttr(A))
		4480	return false;
		4481	if (!getDerived().VisitSuppressAttr(A))
		4482	return false;
		4483	return true;
		4484	}
		4485
		4486	template <typename Derived>
		4487	bool VISITORCLASS<Derived>::TraverseSwiftAsyncAttr(SwiftAsyncAttr *A) {
		4488	if (!getDerived().VisitAttr(A))
		4489	return false;
		4490	if (!getDerived().VisitSwiftAsyncAttr(A))
		4491	return false;
		4492	return true;
		4493	}
		4494
		4495	template <typename Derived>
		4496	bool VISITORCLASS<Derived>::TraverseSwiftAsyncCallAttr(SwiftAsyncCallAttr *A) {
		4497	if (!getDerived().VisitAttr(A))
		4498	return false;
		4499	if (!getDerived().VisitSwiftAsyncCallAttr(A))
		4500	return false;
		4501	return true;
		4502	}
		4503
		4504	template <typename Derived>
		4505	bool VISITORCLASS<Derived>::TraverseSwiftAsyncContextAttr(SwiftAsyncContextAttr *A) {
		4506	if (!getDerived().VisitAttr(A))
		4507	return false;
		4508	if (!getDerived().VisitSwiftAsyncContextAttr(A))
		4509	return false;
		4510	return true;
		4511	}
		4512
		4513	template <typename Derived>
		4514	bool VISITORCLASS<Derived>::TraverseSwiftAsyncErrorAttr(SwiftAsyncErrorAttr *A) {
		4515	if (!getDerived().VisitAttr(A))
		4516	return false;
		4517	if (!getDerived().VisitSwiftAsyncErrorAttr(A))
		4518	return false;
		4519	return true;
		4520	}
		4521
		4522	template <typename Derived>
		4523	bool VISITORCLASS<Derived>::TraverseSwiftAsyncNameAttr(SwiftAsyncNameAttr *A) {
		4524	if (!getDerived().VisitAttr(A))
		4525	return false;
		4526	if (!getDerived().VisitSwiftAsyncNameAttr(A))
		4527	return false;
		4528	return true;
		4529	}
		4530
		4531	template <typename Derived>
		4532	bool VISITORCLASS<Derived>::TraverseSwiftAttrAttr(SwiftAttrAttr *A) {
		4533	if (!getDerived().VisitAttr(A))
		4534	return false;
		4535	if (!getDerived().VisitSwiftAttrAttr(A))
		4536	return false;
		4537	return true;
		4538	}
		4539
		4540	template <typename Derived>
		4541	bool VISITORCLASS<Derived>::TraverseSwiftBridgeAttr(SwiftBridgeAttr *A) {
		4542	if (!getDerived().VisitAttr(A))
		4543	return false;
		4544	if (!getDerived().VisitSwiftBridgeAttr(A))
		4545	return false;
		4546	return true;
		4547	}
		4548
		4549	template <typename Derived>
		4550	bool VISITORCLASS<Derived>::TraverseSwiftBridgedTypedefAttr(SwiftBridgedTypedefAttr *A) {
		4551	if (!getDerived().VisitAttr(A))
		4552	return false;
		4553	if (!getDerived().VisitSwiftBridgedTypedefAttr(A))
		4554	return false;
		4555	return true;
		4556	}
		4557
		4558	template <typename Derived>
		4559	bool VISITORCLASS<Derived>::TraverseSwiftCallAttr(SwiftCallAttr *A) {
		4560	if (!getDerived().VisitAttr(A))
		4561	return false;
		4562	if (!getDerived().VisitSwiftCallAttr(A))
		4563	return false;
		4564	return true;
		4565	}
		4566
		4567	template <typename Derived>
		4568	bool VISITORCLASS<Derived>::TraverseSwiftContextAttr(SwiftContextAttr *A) {
		4569	if (!getDerived().VisitAttr(A))
		4570	return false;
		4571	if (!getDerived().VisitSwiftContextAttr(A))
		4572	return false;
		4573	return true;
		4574	}
		4575
		4576	template <typename Derived>
		4577	bool VISITORCLASS<Derived>::TraverseSwiftErrorAttr(SwiftErrorAttr *A) {
		4578	if (!getDerived().VisitAttr(A))
		4579	return false;
		4580	if (!getDerived().VisitSwiftErrorAttr(A))
		4581	return false;
		4582	return true;
		4583	}
		4584
		4585	template <typename Derived>
		4586	bool VISITORCLASS<Derived>::TraverseSwiftErrorResultAttr(SwiftErrorResultAttr *A) {
		4587	if (!getDerived().VisitAttr(A))
		4588	return false;
		4589	if (!getDerived().VisitSwiftErrorResultAttr(A))
		4590	return false;
		4591	return true;
		4592	}
		4593
		4594	template <typename Derived>
		4595	bool VISITORCLASS<Derived>::TraverseSwiftIndirectResultAttr(SwiftIndirectResultAttr *A) {
		4596	if (!getDerived().VisitAttr(A))
		4597	return false;
		4598	if (!getDerived().VisitSwiftIndirectResultAttr(A))
		4599	return false;
		4600	return true;
		4601	}
		4602
		4603	template <typename Derived>
		4604	bool VISITORCLASS<Derived>::TraverseSwiftNameAttr(SwiftNameAttr *A) {
		4605	if (!getDerived().VisitAttr(A))
		4606	return false;
		4607	if (!getDerived().VisitSwiftNameAttr(A))
		4608	return false;
		4609	return true;
		4610	}
		4611
		4612	template <typename Derived>
		4613	bool VISITORCLASS<Derived>::TraverseSwiftNewTypeAttr(SwiftNewTypeAttr *A) {
		4614	if (!getDerived().VisitAttr(A))
		4615	return false;
		4616	if (!getDerived().VisitSwiftNewTypeAttr(A))
		4617	return false;
		4618	return true;
		4619	}
		4620
		4621	template <typename Derived>
		4622	bool VISITORCLASS<Derived>::TraverseSwiftObjCMembersAttr(SwiftObjCMembersAttr *A) {
		4623	if (!getDerived().VisitAttr(A))
		4624	return false;
		4625	if (!getDerived().VisitSwiftObjCMembersAttr(A))
		4626	return false;
		4627	return true;
		4628	}
		4629
		4630	template <typename Derived>
		4631	bool VISITORCLASS<Derived>::TraverseSwiftPrivateAttr(SwiftPrivateAttr *A) {
		4632	if (!getDerived().VisitAttr(A))
		4633	return false;
		4634	if (!getDerived().VisitSwiftPrivateAttr(A))
		4635	return false;
		4636	return true;
		4637	}
		4638
		4639	template <typename Derived>
		4640	bool VISITORCLASS<Derived>::TraverseSysVABIAttr(SysVABIAttr *A) {
		4641	if (!getDerived().VisitAttr(A))
		4642	return false;
		4643	if (!getDerived().VisitSysVABIAttr(A))
		4644	return false;
		4645	return true;
		4646	}
		4647
		4648	template <typename Derived>
		4649	bool VISITORCLASS<Derived>::TraverseTLSModelAttr(TLSModelAttr *A) {
		4650	if (!getDerived().VisitAttr(A))
		4651	return false;
		4652	if (!getDerived().VisitTLSModelAttr(A))
		4653	return false;
		4654	return true;
		4655	}
		4656
		4657	template <typename Derived>
		4658	bool VISITORCLASS<Derived>::TraverseTargetAttr(TargetAttr *A) {
		4659	if (!getDerived().VisitAttr(A))
		4660	return false;
		4661	if (!getDerived().VisitTargetAttr(A))
		4662	return false;
		4663	return true;
		4664	}
		4665
		4666	template <typename Derived>
		4667	bool VISITORCLASS<Derived>::TraverseTargetClonesAttr(TargetClonesAttr *A) {
		4668	if (!getDerived().VisitAttr(A))
		4669	return false;
		4670	if (!getDerived().VisitTargetClonesAttr(A))
		4671	return false;
		4672	return true;
		4673	}
		4674
		4675	template <typename Derived>
		4676	bool VISITORCLASS<Derived>::TraverseTargetVersionAttr(TargetVersionAttr *A) {
		4677	if (!getDerived().VisitAttr(A))
		4678	return false;
		4679	if (!getDerived().VisitTargetVersionAttr(A))
		4680	return false;
		4681	return true;
		4682	}
		4683
		4684	template <typename Derived>
		4685	bool VISITORCLASS<Derived>::TraverseTestTypestateAttr(TestTypestateAttr *A) {
		4686	if (!getDerived().VisitAttr(A))
		4687	return false;
		4688	if (!getDerived().VisitTestTypestateAttr(A))
		4689	return false;
		4690	return true;
		4691	}
		4692
		4693	template <typename Derived>
		4694	bool VISITORCLASS<Derived>::TraverseThisCallAttr(ThisCallAttr *A) {
		4695	if (!getDerived().VisitAttr(A))
		4696	return false;
		4697	if (!getDerived().VisitThisCallAttr(A))
		4698	return false;
		4699	return true;
		4700	}
		4701
		4702	template <typename Derived>
		4703	bool VISITORCLASS<Derived>::TraverseThreadAttr(ThreadAttr *A) {
		4704	if (!getDerived().VisitAttr(A))
		4705	return false;
		4706	if (!getDerived().VisitThreadAttr(A))
		4707	return false;
		4708	return true;
		4709	}
		4710
		4711	template <typename Derived>
		4712	bool VISITORCLASS<Derived>::TraverseTransparentUnionAttr(TransparentUnionAttr *A) {
		4713	if (!getDerived().VisitAttr(A))
		4714	return false;
		4715	if (!getDerived().VisitTransparentUnionAttr(A))
		4716	return false;
		4717	return true;
		4718	}
		4719
		4720	template <typename Derived>
		4721	bool VISITORCLASS<Derived>::TraverseTrivialABIAttr(TrivialABIAttr *A) {
		4722	if (!getDerived().VisitAttr(A))
		4723	return false;
		4724	if (!getDerived().VisitTrivialABIAttr(A))
		4725	return false;
		4726	return true;
		4727	}
		4728
		4729	template <typename Derived>
		4730	bool VISITORCLASS<Derived>::TraverseTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A) {
		4731	if (!getDerived().VisitAttr(A))
		4732	return false;
		4733	if (!getDerived().VisitTryAcquireCapabilityAttr(A))
		4734	return false;
		4735	if (!getDerived().TraverseStmt(A->getSuccessValue()))
		4736	return false;
		4737	{
		4738	Expr * *I = A->args_begin();
		4739	Expr * *E = A->args_end();
		4740	for (; I != E; ++I) {
		4741	if (!getDerived().TraverseStmt(*I))
		4742	return false;
		4743	}
		4744	}
		4745	return true;
		4746	}
		4747
		4748	template <typename Derived>
		4749	bool VISITORCLASS<Derived>::TraverseTypeNonNullAttr(TypeNonNullAttr *A) {
		4750	if (!getDerived().VisitAttr(A))
		4751	return false;
		4752	if (!getDerived().VisitTypeNonNullAttr(A))
		4753	return false;
		4754	return true;
		4755	}
		4756
		4757	template <typename Derived>
		4758	bool VISITORCLASS<Derived>::TraverseTypeNullUnspecifiedAttr(TypeNullUnspecifiedAttr *A) {
		4759	if (!getDerived().VisitAttr(A))
		4760	return false;
		4761	if (!getDerived().VisitTypeNullUnspecifiedAttr(A))
		4762	return false;
		4763	return true;
		4764	}
		4765
		4766	template <typename Derived>
		4767	bool VISITORCLASS<Derived>::TraverseTypeNullableAttr(TypeNullableAttr *A) {
		4768	if (!getDerived().VisitAttr(A))
		4769	return false;
		4770	if (!getDerived().VisitTypeNullableAttr(A))
		4771	return false;
		4772	return true;
		4773	}
		4774
		4775	template <typename Derived>
		4776	bool VISITORCLASS<Derived>::TraverseTypeNullableResultAttr(TypeNullableResultAttr *A) {
		4777	if (!getDerived().VisitAttr(A))
		4778	return false;
		4779	if (!getDerived().VisitTypeNullableResultAttr(A))
		4780	return false;
		4781	return true;
		4782	}
		4783
		4784	template <typename Derived>
		4785	bool VISITORCLASS<Derived>::TraverseTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A) {
		4786	if (!getDerived().VisitAttr(A))
		4787	return false;
		4788	if (!getDerived().VisitTypeTagForDatatypeAttr(A))
		4789	return false;
		4790	if (auto *TSI = A->getMatchingCTypeLoc())
		4791	if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
		4792	return false;
		4793	return true;
		4794	}
		4795
		4796	template <typename Derived>
		4797	bool VISITORCLASS<Derived>::TraverseTypeVisibilityAttr(TypeVisibilityAttr *A) {
		4798	if (!getDerived().VisitAttr(A))
		4799	return false;
		4800	if (!getDerived().VisitTypeVisibilityAttr(A))
		4801	return false;
		4802	return true;
		4803	}
		4804
		4805	template <typename Derived>
		4806	bool VISITORCLASS<Derived>::TraverseUPtrAttr(UPtrAttr *A) {
		4807	if (!getDerived().VisitAttr(A))
		4808	return false;
		4809	if (!getDerived().VisitUPtrAttr(A))
		4810	return false;
		4811	return true;
		4812	}
		4813
		4814	template <typename Derived>
		4815	bool VISITORCLASS<Derived>::TraverseUnavailableAttr(UnavailableAttr *A) {
		4816	if (!getDerived().VisitAttr(A))
		4817	return false;
		4818	if (!getDerived().VisitUnavailableAttr(A))
		4819	return false;
		4820	return true;
		4821	}
		4822
		4823	template <typename Derived>
		4824	bool VISITORCLASS<Derived>::TraverseUninitializedAttr(UninitializedAttr *A) {
		4825	if (!getDerived().VisitAttr(A))
		4826	return false;
		4827	if (!getDerived().VisitUninitializedAttr(A))
		4828	return false;
		4829	return true;
		4830	}
		4831
		4832	template <typename Derived>
		4833	bool VISITORCLASS<Derived>::TraverseUnlikelyAttr(UnlikelyAttr *A) {
		4834	if (!getDerived().VisitAttr(A))
		4835	return false;
		4836	if (!getDerived().VisitUnlikelyAttr(A))
		4837	return false;
		4838	return true;
		4839	}
		4840
		4841	template <typename Derived>
		4842	bool VISITORCLASS<Derived>::TraverseUnusedAttr(UnusedAttr *A) {
		4843	if (!getDerived().VisitAttr(A))
		4844	return false;
		4845	if (!getDerived().VisitUnusedAttr(A))
		4846	return false;
		4847	return true;
		4848	}
		4849
		4850	template <typename Derived>
		4851	bool VISITORCLASS<Derived>::TraverseUseHandleAttr(UseHandleAttr *A) {
		4852	if (!getDerived().VisitAttr(A))
		4853	return false;
		4854	if (!getDerived().VisitUseHandleAttr(A))
		4855	return false;
		4856	return true;
		4857	}
		4858
		4859	template <typename Derived>
		4860	bool VISITORCLASS<Derived>::TraverseUsedAttr(UsedAttr *A) {
		4861	if (!getDerived().VisitAttr(A))
		4862	return false;
		4863	if (!getDerived().VisitUsedAttr(A))
		4864	return false;
		4865	return true;
		4866	}
		4867
		4868	template <typename Derived>
		4869	bool VISITORCLASS<Derived>::TraverseUsingIfExistsAttr(UsingIfExistsAttr *A) {
		4870	if (!getDerived().VisitAttr(A))
		4871	return false;
		4872	if (!getDerived().VisitUsingIfExistsAttr(A))
		4873	return false;
		4874	return true;
		4875	}
		4876
		4877	template <typename Derived>
		4878	bool VISITORCLASS<Derived>::TraverseUuidAttr(UuidAttr *A) {
		4879	if (!getDerived().VisitAttr(A))
		4880	return false;
		4881	if (!getDerived().VisitUuidAttr(A))
		4882	return false;
		4883	return true;
		4884	}
		4885
		4886	template <typename Derived>
		4887	bool VISITORCLASS<Derived>::TraverseVecReturnAttr(VecReturnAttr *A) {
		4888	if (!getDerived().VisitAttr(A))
		4889	return false;
		4890	if (!getDerived().VisitVecReturnAttr(A))
		4891	return false;
		4892	return true;
		4893	}
		4894
		4895	template <typename Derived>
		4896	bool VISITORCLASS<Derived>::TraverseVecTypeHintAttr(VecTypeHintAttr *A) {
		4897	if (!getDerived().VisitAttr(A))
		4898	return false;
		4899	if (!getDerived().VisitVecTypeHintAttr(A))
		4900	return false;
		4901	if (auto *TSI = A->getTypeHintLoc())
		4902	if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))
		4903	return false;
		4904	return true;
		4905	}
		4906
		4907	template <typename Derived>
		4908	bool VISITORCLASS<Derived>::TraverseVectorCallAttr(VectorCallAttr *A) {
		4909	if (!getDerived().VisitAttr(A))
		4910	return false;
		4911	if (!getDerived().VisitVectorCallAttr(A))
		4912	return false;
		4913	return true;
		4914	}
		4915
		4916	template <typename Derived>
		4917	bool VISITORCLASS<Derived>::TraverseVisibilityAttr(VisibilityAttr *A) {
		4918	if (!getDerived().VisitAttr(A))
		4919	return false;
		4920	if (!getDerived().VisitVisibilityAttr(A))
		4921	return false;
		4922	return true;
		4923	}
		4924
		4925	template <typename Derived>
		4926	bool VISITORCLASS<Derived>::TraverseWarnUnusedAttr(WarnUnusedAttr *A) {
		4927	if (!getDerived().VisitAttr(A))
		4928	return false;
		4929	if (!getDerived().VisitWarnUnusedAttr(A))
		4930	return false;
		4931	return true;
		4932	}
		4933
		4934	template <typename Derived>
		4935	bool VISITORCLASS<Derived>::TraverseWarnUnusedResultAttr(WarnUnusedResultAttr *A) {
		4936	if (!getDerived().VisitAttr(A))
		4937	return false;
		4938	if (!getDerived().VisitWarnUnusedResultAttr(A))
		4939	return false;
		4940	return true;
		4941	}
		4942
		4943	template <typename Derived>
		4944	bool VISITORCLASS<Derived>::TraverseWeakAttr(WeakAttr *A) {
		4945	if (!getDerived().VisitAttr(A))
		4946	return false;
		4947	if (!getDerived().VisitWeakAttr(A))
		4948	return false;
		4949	return true;
		4950	}
		4951
		4952	template <typename Derived>
		4953	bool VISITORCLASS<Derived>::TraverseWeakImportAttr(WeakImportAttr *A) {
		4954	if (!getDerived().VisitAttr(A))
		4955	return false;
		4956	if (!getDerived().VisitWeakImportAttr(A))
		4957	return false;
		4958	return true;
		4959	}
		4960
		4961	template <typename Derived>
		4962	bool VISITORCLASS<Derived>::TraverseWeakRefAttr(WeakRefAttr *A) {
		4963	if (!getDerived().VisitAttr(A))
		4964	return false;
		4965	if (!getDerived().VisitWeakRefAttr(A))
		4966	return false;
		4967	return true;
		4968	}
		4969
		4970	template <typename Derived>
		4971	bool VISITORCLASS<Derived>::TraverseWebAssemblyExportNameAttr(WebAssemblyExportNameAttr *A) {
		4972	if (!getDerived().VisitAttr(A))
		4973	return false;
		4974	if (!getDerived().VisitWebAssemblyExportNameAttr(A))
		4975	return false;
		4976	return true;
		4977	}
		4978
		4979	template <typename Derived>
		4980	bool VISITORCLASS<Derived>::TraverseWebAssemblyImportModuleAttr(WebAssemblyImportModuleAttr *A) {
		4981	if (!getDerived().VisitAttr(A))
		4982	return false;
		4983	if (!getDerived().VisitWebAssemblyImportModuleAttr(A))
		4984	return false;
		4985	return true;
		4986	}
		4987
		4988	template <typename Derived>
		4989	bool VISITORCLASS<Derived>::TraverseWebAssemblyImportNameAttr(WebAssemblyImportNameAttr *A) {
		4990	if (!getDerived().VisitAttr(A))
		4991	return false;
		4992	if (!getDerived().VisitWebAssemblyImportNameAttr(A))
		4993	return false;
		4994	return true;
		4995	}
		4996
		4997	template <typename Derived>
		4998	bool VISITORCLASS<Derived>::TraverseWorkGroupSizeHintAttr(WorkGroupSizeHintAttr *A) {
		4999	if (!getDerived().VisitAttr(A))
		5000	return false;
		5001	if (!getDerived().VisitWorkGroupSizeHintAttr(A))
		5002	return false;
		5003	return true;
		5004	}
		5005
		5006	template <typename Derived>
		5007	bool VISITORCLASS<Derived>::TraverseX86ForceAlignArgPointerAttr(X86ForceAlignArgPointerAttr *A) {
		5008	if (!getDerived().VisitAttr(A))
		5009	return false;
		5010	if (!getDerived().VisitX86ForceAlignArgPointerAttr(A))
		5011	return false;
		5012	return true;
		5013	}
		5014
		5015	template <typename Derived>
		5016	bool VISITORCLASS<Derived>::TraverseXRayInstrumentAttr(XRayInstrumentAttr *A) {
		5017	if (!getDerived().VisitAttr(A))
		5018	return false;
		5019	if (!getDerived().VisitXRayInstrumentAttr(A))
		5020	return false;
		5021	return true;
		5022	}
		5023
		5024	template <typename Derived>
		5025	bool VISITORCLASS<Derived>::TraverseXRayLogArgsAttr(XRayLogArgsAttr *A) {
		5026	if (!getDerived().VisitAttr(A))
		5027	return false;
		5028	if (!getDerived().VisitXRayLogArgsAttr(A))
		5029	return false;
		5030	return true;
		5031	}
		5032
		5033	template <typename Derived>
		5034	bool VISITORCLASS<Derived>::TraverseZeroCallUsedRegsAttr(ZeroCallUsedRegsAttr *A) {
		5035	if (!getDerived().VisitAttr(A))
		5036	return false;
		5037	if (!getDerived().VisitZeroCallUsedRegsAttr(A))
		5038	return false;
		5039	return true;
		5040	}
		5041
		5042	template <typename Derived>
		5043	bool VISITORCLASS<Derived>::TraverseAttr(Attr *A) {
		5044	if (!A)
		5045	return true;
		5046
		5047	switch (A->getKind()) {
		5048	case attr::AArch64SVEPcs:
		5049	return getDerived().TraverseAArch64SVEPcsAttr(cast<AArch64SVEPcsAttr>(A));
		5050	case attr::AArch64VectorPcs:
		5051	return getDerived().TraverseAArch64VectorPcsAttr(cast<AArch64VectorPcsAttr>(A));
		5052	case attr::AMDGPUFlatWorkGroupSize:
		5053	return getDerived().TraverseAMDGPUFlatWorkGroupSizeAttr(cast<AMDGPUFlatWorkGroupSizeAttr>(A));
		5054	case attr::AMDGPUKernelCall:
		5055	return getDerived().TraverseAMDGPUKernelCallAttr(cast<AMDGPUKernelCallAttr>(A));
		5056	case attr::AMDGPUNumSGPR:
		5057	return getDerived().TraverseAMDGPUNumSGPRAttr(cast<AMDGPUNumSGPRAttr>(A));
		5058	case attr::AMDGPUNumVGPR:
		5059	return getDerived().TraverseAMDGPUNumVGPRAttr(cast<AMDGPUNumVGPRAttr>(A));
		5060	case attr::AMDGPUWavesPerEU:
		5061	return getDerived().TraverseAMDGPUWavesPerEUAttr(cast<AMDGPUWavesPerEUAttr>(A));
		5062	case attr::ARMInterrupt:
		5063	return getDerived().TraverseARMInterruptAttr(cast<ARMInterruptAttr>(A));
		5064	case attr::AVRInterrupt:
		5065	return getDerived().TraverseAVRInterruptAttr(cast<AVRInterruptAttr>(A));
		5066	case attr::AVRSignal:
		5067	return getDerived().TraverseAVRSignalAttr(cast<AVRSignalAttr>(A));
		5068	case attr::AbiTag:
		5069	return getDerived().TraverseAbiTagAttr(cast<AbiTagAttr>(A));
		5070	case attr::AcquireCapability:
		5071	return getDerived().TraverseAcquireCapabilityAttr(cast<AcquireCapabilityAttr>(A));
		5072	case attr::AcquireHandle:
		5073	return getDerived().TraverseAcquireHandleAttr(cast<AcquireHandleAttr>(A));
		5074	case attr::AcquiredAfter:
		5075	return getDerived().TraverseAcquiredAfterAttr(cast<AcquiredAfterAttr>(A));
		5076	case attr::AcquiredBefore:
		5077	return getDerived().TraverseAcquiredBeforeAttr(cast<AcquiredBeforeAttr>(A));
		5078	case attr::AddressSpace:
		5079	return getDerived().TraverseAddressSpaceAttr(cast<AddressSpaceAttr>(A));
		5080	case attr::Alias:
		5081	return getDerived().TraverseAliasAttr(cast<AliasAttr>(A));
		5082	case attr::AlignMac68k:
		5083	return getDerived().TraverseAlignMac68kAttr(cast<AlignMac68kAttr>(A));
		5084	case attr::AlignNatural:
		5085	return getDerived().TraverseAlignNaturalAttr(cast<AlignNaturalAttr>(A));
		5086	case attr::AlignValue:
		5087	return getDerived().TraverseAlignValueAttr(cast<AlignValueAttr>(A));
		5088	case attr::Aligned:
		5089	return getDerived().TraverseAlignedAttr(cast<AlignedAttr>(A));
		5090	case attr::AllocAlign:
		5091	return getDerived().TraverseAllocAlignAttr(cast<AllocAlignAttr>(A));
		5092	case attr::AllocSize:
		5093	return getDerived().TraverseAllocSizeAttr(cast<AllocSizeAttr>(A));
		5094	case attr::AlwaysDestroy:
		5095	return getDerived().TraverseAlwaysDestroyAttr(cast<AlwaysDestroyAttr>(A));
		5096	case attr::AlwaysInline:
		5097	return getDerived().TraverseAlwaysInlineAttr(cast<AlwaysInlineAttr>(A));
		5098	case attr::AnalyzerNoReturn:
		5099	return getDerived().TraverseAnalyzerNoReturnAttr(cast<AnalyzerNoReturnAttr>(A));
		5100	case attr::Annotate:
		5101	return getDerived().TraverseAnnotateAttr(cast<AnnotateAttr>(A));
		5102	case attr::AnnotateType:
		5103	return getDerived().TraverseAnnotateTypeAttr(cast<AnnotateTypeAttr>(A));
		5104	case attr::AnyX86Interrupt:
		5105	return getDerived().TraverseAnyX86InterruptAttr(cast<AnyX86InterruptAttr>(A));
		5106	case attr::AnyX86NoCallerSavedRegisters:
		5107	return getDerived().TraverseAnyX86NoCallerSavedRegistersAttr(cast<AnyX86NoCallerSavedRegistersAttr>(A));
		5108	case attr::AnyX86NoCfCheck:
		5109	return getDerived().TraverseAnyX86NoCfCheckAttr(cast<AnyX86NoCfCheckAttr>(A));
		5110	case attr::ArcWeakrefUnavailable:
		5111	return getDerived().TraverseArcWeakrefUnavailableAttr(cast<ArcWeakrefUnavailableAttr>(A));
		5112	case attr::ArgumentWithTypeTag:
		5113	return getDerived().TraverseArgumentWithTypeTagAttr(cast<ArgumentWithTypeTagAttr>(A));
		5114	case attr::ArmBuiltinAlias:
		5115	return getDerived().TraverseArmBuiltinAliasAttr(cast<ArmBuiltinAliasAttr>(A));
		5116	case attr::ArmMveStrictPolymorphism:
		5117	return getDerived().TraverseArmMveStrictPolymorphismAttr(cast<ArmMveStrictPolymorphismAttr>(A));
		5118	case attr::Artificial:
		5119	return getDerived().TraverseArtificialAttr(cast<ArtificialAttr>(A));
		5120	case attr::AsmLabel:
		5121	return getDerived().TraverseAsmLabelAttr(cast<AsmLabelAttr>(A));
		5122	case attr::AssertCapability:
		5123	return getDerived().TraverseAssertCapabilityAttr(cast<AssertCapabilityAttr>(A));
		5124	case attr::AssertExclusiveLock:
		5125	return getDerived().TraverseAssertExclusiveLockAttr(cast<AssertExclusiveLockAttr>(A));
		5126	case attr::AssertSharedLock:
		5127	return getDerived().TraverseAssertSharedLockAttr(cast<AssertSharedLockAttr>(A));
		5128	case attr::AssumeAligned:
		5129	return getDerived().TraverseAssumeAlignedAttr(cast<AssumeAlignedAttr>(A));
		5130	case attr::Assumption:
		5131	return getDerived().TraverseAssumptionAttr(cast<AssumptionAttr>(A));
		5132	case attr::Availability:
		5133	return getDerived().TraverseAvailabilityAttr(cast<AvailabilityAttr>(A));
		5134	case attr::BPFPreserveAccessIndex:
		5135	return getDerived().TraverseBPFPreserveAccessIndexAttr(cast<BPFPreserveAccessIndexAttr>(A));
		5136	case attr::BTFDeclTag:
		5137	return getDerived().TraverseBTFDeclTagAttr(cast<BTFDeclTagAttr>(A));
		5138	case attr::BTFTypeTag:
		5139	return getDerived().TraverseBTFTypeTagAttr(cast<BTFTypeTagAttr>(A));
		5140	case attr::Blocks:
		5141	return getDerived().TraverseBlocksAttr(cast<BlocksAttr>(A));
		5142	case attr::Builtin:
		5143	return getDerived().TraverseBuiltinAttr(cast<BuiltinAttr>(A));
		5144	case attr::BuiltinAlias:
		5145	return getDerived().TraverseBuiltinAliasAttr(cast<BuiltinAliasAttr>(A));
		5146	case attr::C11NoReturn:
		5147	return getDerived().TraverseC11NoReturnAttr(cast<C11NoReturnAttr>(A));
		5148	case attr::CDecl:
		5149	return getDerived().TraverseCDeclAttr(cast<CDeclAttr>(A));
		5150	case attr::CFAuditedTransfer:
		5151	return getDerived().TraverseCFAuditedTransferAttr(cast<CFAuditedTransferAttr>(A));
		5152	case attr::CFConsumed:
		5153	return getDerived().TraverseCFConsumedAttr(cast<CFConsumedAttr>(A));
		5154	case attr::CFGuard:
		5155	return getDerived().TraverseCFGuardAttr(cast<CFGuardAttr>(A));
		5156	case attr::CFICanonicalJumpTable:
		5157	return getDerived().TraverseCFICanonicalJumpTableAttr(cast<CFICanonicalJumpTableAttr>(A));
		5158	case attr::CFReturnsNotRetained:
		5159	return getDerived().TraverseCFReturnsNotRetainedAttr(cast<CFReturnsNotRetainedAttr>(A));
		5160	case attr::CFReturnsRetained:
		5161	return getDerived().TraverseCFReturnsRetainedAttr(cast<CFReturnsRetainedAttr>(A));
		5162	case attr::CFUnknownTransfer:
		5163	return getDerived().TraverseCFUnknownTransferAttr(cast<CFUnknownTransferAttr>(A));
		5164	case attr::CPUDispatch:
		5165	return getDerived().TraverseCPUDispatchAttr(cast<CPUDispatchAttr>(A));
		5166	case attr::CPUSpecific:
		5167	return getDerived().TraverseCPUSpecificAttr(cast<CPUSpecificAttr>(A));
		5168	case attr::CUDAConstant:
		5169	return getDerived().TraverseCUDAConstantAttr(cast<CUDAConstantAttr>(A));
		5170	case attr::CUDADevice:
		5171	return getDerived().TraverseCUDADeviceAttr(cast<CUDADeviceAttr>(A));
		5172	case attr::CUDADeviceBuiltinSurfaceType:
		5173	return getDerived().TraverseCUDADeviceBuiltinSurfaceTypeAttr(cast<CUDADeviceBuiltinSurfaceTypeAttr>(A));
		5174	case attr::CUDADeviceBuiltinTextureType:
		5175	return getDerived().TraverseCUDADeviceBuiltinTextureTypeAttr(cast<CUDADeviceBuiltinTextureTypeAttr>(A));
		5176	case attr::CUDAGlobal:
		5177	return getDerived().TraverseCUDAGlobalAttr(cast<CUDAGlobalAttr>(A));
		5178	case attr::CUDAHost:
		5179	return getDerived().TraverseCUDAHostAttr(cast<CUDAHostAttr>(A));
		5180	case attr::CUDAInvalidTarget:
		5181	return getDerived().TraverseCUDAInvalidTargetAttr(cast<CUDAInvalidTargetAttr>(A));
		5182	case attr::CUDALaunchBounds:
		5183	return getDerived().TraverseCUDALaunchBoundsAttr(cast<CUDALaunchBoundsAttr>(A));
		5184	case attr::CUDAShared:
		5185	return getDerived().TraverseCUDASharedAttr(cast<CUDASharedAttr>(A));
		5186	case attr::CXX11NoReturn:
		5187	return getDerived().TraverseCXX11NoReturnAttr(cast<CXX11NoReturnAttr>(A));
		5188	case attr::CallableWhen:
		5189	return getDerived().TraverseCallableWhenAttr(cast<CallableWhenAttr>(A));
		5190	case attr::Callback:
		5191	return getDerived().TraverseCallbackAttr(cast<CallbackAttr>(A));
		5192	case attr::CalledOnce:
		5193	return getDerived().TraverseCalledOnceAttr(cast<CalledOnceAttr>(A));
		5194	case attr::Capability:
		5195	return getDerived().TraverseCapabilityAttr(cast<CapabilityAttr>(A));
		5196	case attr::CapturedRecord:
		5197	return getDerived().TraverseCapturedRecordAttr(cast<CapturedRecordAttr>(A));
		5198	case attr::CarriesDependency:
		5199	return getDerived().TraverseCarriesDependencyAttr(cast<CarriesDependencyAttr>(A));
		5200	case attr::Cleanup:
		5201	return getDerived().TraverseCleanupAttr(cast<CleanupAttr>(A));
		5202	case attr::CmseNSCall:
		5203	return getDerived().TraverseCmseNSCallAttr(cast<CmseNSCallAttr>(A));
		5204	case attr::CmseNSEntry:
		5205	return getDerived().TraverseCmseNSEntryAttr(cast<CmseNSEntryAttr>(A));
		5206	case attr::CodeSeg:
		5207	return getDerived().TraverseCodeSegAttr(cast<CodeSegAttr>(A));
		5208	case attr::Cold:
		5209	return getDerived().TraverseColdAttr(cast<ColdAttr>(A));
		5210	case attr::Common:
		5211	return getDerived().TraverseCommonAttr(cast<CommonAttr>(A));
		5212	case attr::Const:
		5213	return getDerived().TraverseConstAttr(cast<ConstAttr>(A));
		5214	case attr::ConstInit:
		5215	return getDerived().TraverseConstInitAttr(cast<ConstInitAttr>(A));
		5216	case attr::Constructor:
		5217	return getDerived().TraverseConstructorAttr(cast<ConstructorAttr>(A));
		5218	case attr::Consumable:
		5219	return getDerived().TraverseConsumableAttr(cast<ConsumableAttr>(A));
		5220	case attr::ConsumableAutoCast:
		5221	return getDerived().TraverseConsumableAutoCastAttr(cast<ConsumableAutoCastAttr>(A));
		5222	case attr::ConsumableSetOnRead:
		5223	return getDerived().TraverseConsumableSetOnReadAttr(cast<ConsumableSetOnReadAttr>(A));
		5224	case attr::Convergent:
		5225	return getDerived().TraverseConvergentAttr(cast<ConvergentAttr>(A));
		5226	case attr::DLLExport:
		5227	return getDerived().TraverseDLLExportAttr(cast<DLLExportAttr>(A));
		5228	case attr::DLLExportStaticLocal:
		5229	return getDerived().TraverseDLLExportStaticLocalAttr(cast<DLLExportStaticLocalAttr>(A));
		5230	case attr::DLLImport:
		5231	return getDerived().TraverseDLLImportAttr(cast<DLLImportAttr>(A));
		5232	case attr::DLLImportStaticLocal:
		5233	return getDerived().TraverseDLLImportStaticLocalAttr(cast<DLLImportStaticLocalAttr>(A));
		5234	case attr::Deprecated:
		5235	return getDerived().TraverseDeprecatedAttr(cast<DeprecatedAttr>(A));
		5236	case attr::Destructor:
		5237	return getDerived().TraverseDestructorAttr(cast<DestructorAttr>(A));
		5238	case attr::DiagnoseAsBuiltin:
		5239	return getDerived().TraverseDiagnoseAsBuiltinAttr(cast<DiagnoseAsBuiltinAttr>(A));
		5240	case attr::DiagnoseIf:
		5241	return getDerived().TraverseDiagnoseIfAttr(cast<DiagnoseIfAttr>(A));
		5242	case attr::DisableSanitizerInstrumentation:
		5243	return getDerived().TraverseDisableSanitizerInstrumentationAttr(cast<DisableSanitizerInstrumentationAttr>(A));
		5244	case attr::DisableTailCalls:
		5245	return getDerived().TraverseDisableTailCallsAttr(cast<DisableTailCallsAttr>(A));
		5246	case attr::EmptyBases:
		5247	return getDerived().TraverseEmptyBasesAttr(cast<EmptyBasesAttr>(A));
		5248	case attr::EnableIf:
		5249	return getDerived().TraverseEnableIfAttr(cast<EnableIfAttr>(A));
		5250	case attr::EnforceTCB:
		5251	return getDerived().TraverseEnforceTCBAttr(cast<EnforceTCBAttr>(A));
		5252	case attr::EnforceTCBLeaf:
		5253	return getDerived().TraverseEnforceTCBLeafAttr(cast<EnforceTCBLeafAttr>(A));
		5254	case attr::EnumExtensibility:
		5255	return getDerived().TraverseEnumExtensibilityAttr(cast<EnumExtensibilityAttr>(A));
		5256	case attr::Error:
		5257	return getDerived().TraverseErrorAttr(cast<ErrorAttr>(A));
		5258	case attr::ExcludeFromExplicitInstantiation:
		5259	return getDerived().TraverseExcludeFromExplicitInstantiationAttr(cast<ExcludeFromExplicitInstantiationAttr>(A));
		5260	case attr::ExclusiveTrylockFunction:
		5261	return getDerived().TraverseExclusiveTrylockFunctionAttr(cast<ExclusiveTrylockFunctionAttr>(A));
		5262	case attr::ExternalSourceSymbol:
		5263	return getDerived().TraverseExternalSourceSymbolAttr(cast<ExternalSourceSymbolAttr>(A));
		5264	case attr::FallThrough:
		5265	return getDerived().TraverseFallThroughAttr(cast<FallThroughAttr>(A));
		5266	case attr::FastCall:
		5267	return getDerived().TraverseFastCallAttr(cast<FastCallAttr>(A));
		5268	case attr::Final:
		5269	return getDerived().TraverseFinalAttr(cast<FinalAttr>(A));
		5270	case attr::FlagEnum:
		5271	return getDerived().TraverseFlagEnumAttr(cast<FlagEnumAttr>(A));
		5272	case attr::Flatten:
		5273	return getDerived().TraverseFlattenAttr(cast<FlattenAttr>(A));
		5274	case attr::Format:
		5275	return getDerived().TraverseFormatAttr(cast<FormatAttr>(A));
		5276	case attr::FormatArg:
		5277	return getDerived().TraverseFormatArgAttr(cast<FormatArgAttr>(A));
		5278	case attr::FunctionReturnThunks:
		5279	return getDerived().TraverseFunctionReturnThunksAttr(cast<FunctionReturnThunksAttr>(A));
		5280	case attr::GNUInline:
		5281	return getDerived().TraverseGNUInlineAttr(cast<GNUInlineAttr>(A));
		5282	case attr::GuardedBy:
		5283	return getDerived().TraverseGuardedByAttr(cast<GuardedByAttr>(A));
		5284	case attr::GuardedVar:
		5285	return getDerived().TraverseGuardedVarAttr(cast<GuardedVarAttr>(A));
		5286	case attr::HIPManaged:
		5287	return getDerived().TraverseHIPManagedAttr(cast<HIPManagedAttr>(A));
		5288	case attr::HLSLGroupSharedAddressSpace:
		5289	return getDerived().TraverseHLSLGroupSharedAddressSpaceAttr(cast<HLSLGroupSharedAddressSpaceAttr>(A));
		5290	case attr::HLSLNumThreads:
		5291	return getDerived().TraverseHLSLNumThreadsAttr(cast<HLSLNumThreadsAttr>(A));
		5292	case attr::HLSLResource:
		5293	return getDerived().TraverseHLSLResourceAttr(cast<HLSLResourceAttr>(A));
		5294	case attr::HLSLResourceBinding:
		5295	return getDerived().TraverseHLSLResourceBindingAttr(cast<HLSLResourceBindingAttr>(A));
		5296	case attr::HLSLSV_DispatchThreadID:
		5297	return getDerived().TraverseHLSLSV_DispatchThreadIDAttr(cast<HLSLSV_DispatchThreadIDAttr>(A));
		5298	case attr::HLSLSV_GroupIndex:
		5299	return getDerived().TraverseHLSLSV_GroupIndexAttr(cast<HLSLSV_GroupIndexAttr>(A));
		5300	case attr::HLSLShader:
		5301	return getDerived().TraverseHLSLShaderAttr(cast<HLSLShaderAttr>(A));
		5302	case attr::Hot:
		5303	return getDerived().TraverseHotAttr(cast<HotAttr>(A));
		5304	case attr::IBAction:
		5305	return getDerived().TraverseIBActionAttr(cast<IBActionAttr>(A));
		5306	case attr::IBOutlet:
		5307	return getDerived().TraverseIBOutletAttr(cast<IBOutletAttr>(A));
		5308	case attr::IBOutletCollection:
		5309	return getDerived().TraverseIBOutletCollectionAttr(cast<IBOutletCollectionAttr>(A));
		5310	case attr::IFunc:
		5311	return getDerived().TraverseIFuncAttr(cast<IFuncAttr>(A));
		5312	case attr::InitPriority:
		5313	return getDerived().TraverseInitPriorityAttr(cast<InitPriorityAttr>(A));
		5314	case attr::InitSeg:
		5315	return getDerived().TraverseInitSegAttr(cast<InitSegAttr>(A));
		5316	case attr::IntelOclBicc:
		5317	return getDerived().TraverseIntelOclBiccAttr(cast<IntelOclBiccAttr>(A));
		5318	case attr::InternalLinkage:
		5319	return getDerived().TraverseInternalLinkageAttr(cast<InternalLinkageAttr>(A));
		5320	case attr::LTOVisibilityPublic:
		5321	return getDerived().TraverseLTOVisibilityPublicAttr(cast<LTOVisibilityPublicAttr>(A));
		5322	case attr::LayoutVersion:
		5323	return getDerived().TraverseLayoutVersionAttr(cast<LayoutVersionAttr>(A));
		5324	case attr::Leaf:
		5325	return getDerived().TraverseLeafAttr(cast<LeafAttr>(A));
		5326	case attr::LifetimeBound:
		5327	return getDerived().TraverseLifetimeBoundAttr(cast<LifetimeBoundAttr>(A));
		5328	case attr::Likely:
		5329	return getDerived().TraverseLikelyAttr(cast<LikelyAttr>(A));
		5330	case attr::LoaderUninitialized:
		5331	return getDerived().TraverseLoaderUninitializedAttr(cast<LoaderUninitializedAttr>(A));
		5332	case attr::LockReturned:
		5333	return getDerived().TraverseLockReturnedAttr(cast<LockReturnedAttr>(A));
		5334	case attr::LocksExcluded:
		5335	return getDerived().TraverseLocksExcludedAttr(cast<LocksExcludedAttr>(A));
		5336	case attr::LoopHint:
		5337	return getDerived().TraverseLoopHintAttr(cast<LoopHintAttr>(A));
		5338	case attr::M68kInterrupt:
		5339	return getDerived().TraverseM68kInterruptAttr(cast<M68kInterruptAttr>(A));
		5340	case attr::MIGServerRoutine:
		5341	return getDerived().TraverseMIGServerRoutineAttr(cast<MIGServerRoutineAttr>(A));
		5342	case attr::MSABI:
		5343	return getDerived().TraverseMSABIAttr(cast<MSABIAttr>(A));
		5344	case attr::MSAllocator:
		5345	return getDerived().TraverseMSAllocatorAttr(cast<MSAllocatorAttr>(A));
		5346	case attr::MSInheritance:
		5347	return getDerived().TraverseMSInheritanceAttr(cast<MSInheritanceAttr>(A));
		5348	case attr::MSNoVTable:
		5349	return getDerived().TraverseMSNoVTableAttr(cast<MSNoVTableAttr>(A));
		5350	case attr::MSP430Interrupt:
		5351	return getDerived().TraverseMSP430InterruptAttr(cast<MSP430InterruptAttr>(A));
		5352	case attr::MSStruct:
		5353	return getDerived().TraverseMSStructAttr(cast<MSStructAttr>(A));
		5354	case attr::MSVtorDisp:
		5355	return getDerived().TraverseMSVtorDispAttr(cast<MSVtorDispAttr>(A));
		5356	case attr::MaxFieldAlignment:
		5357	return getDerived().TraverseMaxFieldAlignmentAttr(cast<MaxFieldAlignmentAttr>(A));
		5358	case attr::MayAlias:
		5359	return getDerived().TraverseMayAliasAttr(cast<MayAliasAttr>(A));
		5360	case attr::MaybeUndef:
		5361	return getDerived().TraverseMaybeUndefAttr(cast<MaybeUndefAttr>(A));
		5362	case attr::MicroMips:
		5363	return getDerived().TraverseMicroMipsAttr(cast<MicroMipsAttr>(A));
		5364	case attr::MinSize:
		5365	return getDerived().TraverseMinSizeAttr(cast<MinSizeAttr>(A));
		5366	case attr::MinVectorWidth:
		5367	return getDerived().TraverseMinVectorWidthAttr(cast<MinVectorWidthAttr>(A));
		5368	case attr::Mips16:
		5369	return getDerived().TraverseMips16Attr(cast<Mips16Attr>(A));
		5370	case attr::MipsInterrupt:
		5371	return getDerived().TraverseMipsInterruptAttr(cast<MipsInterruptAttr>(A));
		5372	case attr::MipsLongCall:
		5373	return getDerived().TraverseMipsLongCallAttr(cast<MipsLongCallAttr>(A));
		5374	case attr::MipsShortCall:
		5375	return getDerived().TraverseMipsShortCallAttr(cast<MipsShortCallAttr>(A));
		5376	case attr::Mode:
		5377	return getDerived().TraverseModeAttr(cast<ModeAttr>(A));
		5378	case attr::MustTail:
		5379	return getDerived().TraverseMustTailAttr(cast<MustTailAttr>(A));
		5380	case attr::NSConsumed:
		5381	return getDerived().TraverseNSConsumedAttr(cast<NSConsumedAttr>(A));
		5382	case attr::NSConsumesSelf:
		5383	return getDerived().TraverseNSConsumesSelfAttr(cast<NSConsumesSelfAttr>(A));
		5384	case attr::NSErrorDomain:
		5385	return getDerived().TraverseNSErrorDomainAttr(cast<NSErrorDomainAttr>(A));
		5386	case attr::NSReturnsAutoreleased:
		5387	return getDerived().TraverseNSReturnsAutoreleasedAttr(cast<NSReturnsAutoreleasedAttr>(A));
		5388	case attr::NSReturnsNotRetained:
		5389	return getDerived().TraverseNSReturnsNotRetainedAttr(cast<NSReturnsNotRetainedAttr>(A));
		5390	case attr::NSReturnsRetained:
		5391	return getDerived().TraverseNSReturnsRetainedAttr(cast<NSReturnsRetainedAttr>(A));
		5392	case attr::Naked:
		5393	return getDerived().TraverseNakedAttr(cast<NakedAttr>(A));
		5394	case attr::NoAlias:
		5395	return getDerived().TraverseNoAliasAttr(cast<NoAliasAttr>(A));
		5396	case attr::NoBuiltin:
		5397	return getDerived().TraverseNoBuiltinAttr(cast<NoBuiltinAttr>(A));
		5398	case attr::NoCommon:
		5399	return getDerived().TraverseNoCommonAttr(cast<NoCommonAttr>(A));
		5400	case attr::NoDebug:
		5401	return getDerived().TraverseNoDebugAttr(cast<NoDebugAttr>(A));
		5402	case attr::NoDeref:
		5403	return getDerived().TraverseNoDerefAttr(cast<NoDerefAttr>(A));
		5404	case attr::NoDestroy:
		5405	return getDerived().TraverseNoDestroyAttr(cast<NoDestroyAttr>(A));
		5406	case attr::NoDuplicate:
		5407	return getDerived().TraverseNoDuplicateAttr(cast<NoDuplicateAttr>(A));
		5408	case attr::NoEscape:
		5409	return getDerived().TraverseNoEscapeAttr(cast<NoEscapeAttr>(A));
		5410	case attr::NoInline:
		5411	return getDerived().TraverseNoInlineAttr(cast<NoInlineAttr>(A));
		5412	case attr::NoInstrumentFunction:
		5413	return getDerived().TraverseNoInstrumentFunctionAttr(cast<NoInstrumentFunctionAttr>(A));
		5414	case attr::NoMerge:
		5415	return getDerived().TraverseNoMergeAttr(cast<NoMergeAttr>(A));
		5416	case attr::NoMicroMips:
		5417	return getDerived().TraverseNoMicroMipsAttr(cast<NoMicroMipsAttr>(A));
		5418	case attr::NoMips16:
		5419	return getDerived().TraverseNoMips16Attr(cast<NoMips16Attr>(A));
		5420	case attr::NoProfileFunction:
		5421	return getDerived().TraverseNoProfileFunctionAttr(cast<NoProfileFunctionAttr>(A));
		5422	case attr::NoRandomizeLayout:
		5423	return getDerived().TraverseNoRandomizeLayoutAttr(cast<NoRandomizeLayoutAttr>(A));
		5424	case attr::NoReturn:
		5425	return getDerived().TraverseNoReturnAttr(cast<NoReturnAttr>(A));
		5426	case attr::NoSanitize:
		5427	return getDerived().TraverseNoSanitizeAttr(cast<NoSanitizeAttr>(A));
		5428	case attr::NoSpeculativeLoadHardening:
		5429	return getDerived().TraverseNoSpeculativeLoadHardeningAttr(cast<NoSpeculativeLoadHardeningAttr>(A));
		5430	case attr::NoSplitStack:
		5431	return getDerived().TraverseNoSplitStackAttr(cast<NoSplitStackAttr>(A));
		5432	case attr::NoStackProtector:
		5433	return getDerived().TraverseNoStackProtectorAttr(cast<NoStackProtectorAttr>(A));
		5434	case attr::NoThreadSafetyAnalysis:
		5435	return getDerived().TraverseNoThreadSafetyAnalysisAttr(cast<NoThreadSafetyAnalysisAttr>(A));
		5436	case attr::NoThrow:
		5437	return getDerived().TraverseNoThrowAttr(cast<NoThrowAttr>(A));
		5438	case attr::NoUniqueAddress:
		5439	return getDerived().TraverseNoUniqueAddressAttr(cast<NoUniqueAddressAttr>(A));
		5440	case attr::NoUwtable:
		5441	return getDerived().TraverseNoUwtableAttr(cast<NoUwtableAttr>(A));
		5442	case attr::NonNull:
		5443	return getDerived().TraverseNonNullAttr(cast<NonNullAttr>(A));
		5444	case attr::NotTailCalled:
		5445	return getDerived().TraverseNotTailCalledAttr(cast<NotTailCalledAttr>(A));
		5446	case attr::OMPAllocateDecl:
		5447	return getDerived().TraverseOMPAllocateDeclAttr(cast<OMPAllocateDeclAttr>(A));
		5448	case attr::OMPCaptureKind:
		5449	return getDerived().TraverseOMPCaptureKindAttr(cast<OMPCaptureKindAttr>(A));
		5450	case attr::OMPCaptureNoInit:
		5451	return getDerived().TraverseOMPCaptureNoInitAttr(cast<OMPCaptureNoInitAttr>(A));
		5452	case attr::OMPDeclareSimdDecl:
		5453	return getDerived().TraverseOMPDeclareSimdDeclAttr(cast<OMPDeclareSimdDeclAttr>(A));
		5454	case attr::OMPDeclareTargetDecl:
		5455	return getDerived().TraverseOMPDeclareTargetDeclAttr(cast<OMPDeclareTargetDeclAttr>(A));
		5456	case attr::OMPDeclareVariant:
		5457	return getDerived().TraverseOMPDeclareVariantAttr(cast<OMPDeclareVariantAttr>(A));
		5458	case attr::OMPReferencedVar:
		5459	return getDerived().TraverseOMPReferencedVarAttr(cast<OMPReferencedVarAttr>(A));
		5460	case attr::OMPThreadPrivateDecl:
		5461	return getDerived().TraverseOMPThreadPrivateDeclAttr(cast<OMPThreadPrivateDeclAttr>(A));
		5462	case attr::OSConsumed:
		5463	return getDerived().TraverseOSConsumedAttr(cast<OSConsumedAttr>(A));
		5464	case attr::OSConsumesThis:
		5465	return getDerived().TraverseOSConsumesThisAttr(cast<OSConsumesThisAttr>(A));
		5466	case attr::OSReturnsNotRetained:
		5467	return getDerived().TraverseOSReturnsNotRetainedAttr(cast<OSReturnsNotRetainedAttr>(A));
		5468	case attr::OSReturnsRetained:
		5469	return getDerived().TraverseOSReturnsRetainedAttr(cast<OSReturnsRetainedAttr>(A));
		5470	case attr::OSReturnsRetainedOnNonZero:
		5471	return getDerived().TraverseOSReturnsRetainedOnNonZeroAttr(cast<OSReturnsRetainedOnNonZeroAttr>(A));
		5472	case attr::OSReturnsRetainedOnZero:
		5473	return getDerived().TraverseOSReturnsRetainedOnZeroAttr(cast<OSReturnsRetainedOnZeroAttr>(A));
		5474	case attr::ObjCBoxable:
		5475	return getDerived().TraverseObjCBoxableAttr(cast<ObjCBoxableAttr>(A));
		5476	case attr::ObjCBridge:
		5477	return getDerived().TraverseObjCBridgeAttr(cast<ObjCBridgeAttr>(A));
		5478	case attr::ObjCBridgeMutable:
		5479	return getDerived().TraverseObjCBridgeMutableAttr(cast<ObjCBridgeMutableAttr>(A));
		5480	case attr::ObjCBridgeRelated:
		5481	return getDerived().TraverseObjCBridgeRelatedAttr(cast<ObjCBridgeRelatedAttr>(A));
		5482	case attr::ObjCClassStub:
		5483	return getDerived().TraverseObjCClassStubAttr(cast<ObjCClassStubAttr>(A));
		5484	case attr::ObjCDesignatedInitializer:
		5485	return getDerived().TraverseObjCDesignatedInitializerAttr(cast<ObjCDesignatedInitializerAttr>(A));
		5486	case attr::ObjCDirect:
		5487	return getDerived().TraverseObjCDirectAttr(cast<ObjCDirectAttr>(A));
		5488	case attr::ObjCDirectMembers:
		5489	return getDerived().TraverseObjCDirectMembersAttr(cast<ObjCDirectMembersAttr>(A));
		5490	case attr::ObjCException:
		5491	return getDerived().TraverseObjCExceptionAttr(cast<ObjCExceptionAttr>(A));
		5492	case attr::ObjCExplicitProtocolImpl:
		5493	return getDerived().TraverseObjCExplicitProtocolImplAttr(cast<ObjCExplicitProtocolImplAttr>(A));
		5494	case attr::ObjCExternallyRetained:
		5495	return getDerived().TraverseObjCExternallyRetainedAttr(cast<ObjCExternallyRetainedAttr>(A));
		5496	case attr::ObjCGC:
		5497	return getDerived().TraverseObjCGCAttr(cast<ObjCGCAttr>(A));
		5498	case attr::ObjCIndependentClass:
		5499	return getDerived().TraverseObjCIndependentClassAttr(cast<ObjCIndependentClassAttr>(A));
		5500	case attr::ObjCInertUnsafeUnretained:
		5501	return getDerived().TraverseObjCInertUnsafeUnretainedAttr(cast<ObjCInertUnsafeUnretainedAttr>(A));
		5502	case attr::ObjCKindOf:
		5503	return getDerived().TraverseObjCKindOfAttr(cast<ObjCKindOfAttr>(A));
		5504	case attr::ObjCMethodFamily:
		5505	return getDerived().TraverseObjCMethodFamilyAttr(cast<ObjCMethodFamilyAttr>(A));
		5506	case attr::ObjCNSObject:
		5507	return getDerived().TraverseObjCNSObjectAttr(cast<ObjCNSObjectAttr>(A));
		5508	case attr::ObjCNonLazyClass:
		5509	return getDerived().TraverseObjCNonLazyClassAttr(cast<ObjCNonLazyClassAttr>(A));
		5510	case attr::ObjCNonRuntimeProtocol:
		5511	return getDerived().TraverseObjCNonRuntimeProtocolAttr(cast<ObjCNonRuntimeProtocolAttr>(A));
		5512	case attr::ObjCOwnership:
		5513	return getDerived().TraverseObjCOwnershipAttr(cast<ObjCOwnershipAttr>(A));
		5514	case attr::ObjCPreciseLifetime:
		5515	return getDerived().TraverseObjCPreciseLifetimeAttr(cast<ObjCPreciseLifetimeAttr>(A));
		5516	case attr::ObjCRequiresPropertyDefs:
		5517	return getDerived().TraverseObjCRequiresPropertyDefsAttr(cast<ObjCRequiresPropertyDefsAttr>(A));
		5518	case attr::ObjCRequiresSuper:
		5519	return getDerived().TraverseObjCRequiresSuperAttr(cast<ObjCRequiresSuperAttr>(A));
		5520	case attr::ObjCReturnsInnerPointer:
		5521	return getDerived().TraverseObjCReturnsInnerPointerAttr(cast<ObjCReturnsInnerPointerAttr>(A));
		5522	case attr::ObjCRootClass:
		5523	return getDerived().TraverseObjCRootClassAttr(cast<ObjCRootClassAttr>(A));
		5524	case attr::ObjCRuntimeName:
		5525	return getDerived().TraverseObjCRuntimeNameAttr(cast<ObjCRuntimeNameAttr>(A));
		5526	case attr::ObjCRuntimeVisible:
		5527	return getDerived().TraverseObjCRuntimeVisibleAttr(cast<ObjCRuntimeVisibleAttr>(A));
		5528	case attr::ObjCSubclassingRestricted:
		5529	return getDerived().TraverseObjCSubclassingRestrictedAttr(cast<ObjCSubclassingRestrictedAttr>(A));
		5530	case attr::OpenCLAccess:
		5531	return getDerived().TraverseOpenCLAccessAttr(cast<OpenCLAccessAttr>(A));
		5532	case attr::OpenCLConstantAddressSpace:
		5533	return getDerived().TraverseOpenCLConstantAddressSpaceAttr(cast<OpenCLConstantAddressSpaceAttr>(A));
		5534	case attr::OpenCLGenericAddressSpace:
		5535	return getDerived().TraverseOpenCLGenericAddressSpaceAttr(cast<OpenCLGenericAddressSpaceAttr>(A));
		5536	case attr::OpenCLGlobalAddressSpace:
		5537	return getDerived().TraverseOpenCLGlobalAddressSpaceAttr(cast<OpenCLGlobalAddressSpaceAttr>(A));
		5538	case attr::OpenCLGlobalDeviceAddressSpace:
		5539	return getDerived().TraverseOpenCLGlobalDeviceAddressSpaceAttr(cast<OpenCLGlobalDeviceAddressSpaceAttr>(A));
		5540	case attr::OpenCLGlobalHostAddressSpace:
		5541	return getDerived().TraverseOpenCLGlobalHostAddressSpaceAttr(cast<OpenCLGlobalHostAddressSpaceAttr>(A));
		5542	case attr::OpenCLIntelReqdSubGroupSize:
		5543	return getDerived().TraverseOpenCLIntelReqdSubGroupSizeAttr(cast<OpenCLIntelReqdSubGroupSizeAttr>(A));
		5544	case attr::OpenCLKernel:
		5545	return getDerived().TraverseOpenCLKernelAttr(cast<OpenCLKernelAttr>(A));
		5546	case attr::OpenCLLocalAddressSpace:
		5547	return getDerived().TraverseOpenCLLocalAddressSpaceAttr(cast<OpenCLLocalAddressSpaceAttr>(A));
		5548	case attr::OpenCLPrivateAddressSpace:
		5549	return getDerived().TraverseOpenCLPrivateAddressSpaceAttr(cast<OpenCLPrivateAddressSpaceAttr>(A));
		5550	case attr::OpenCLUnrollHint:
		5551	return getDerived().TraverseOpenCLUnrollHintAttr(cast<OpenCLUnrollHintAttr>(A));
		5552	case attr::OptimizeNone:
		5553	return getDerived().TraverseOptimizeNoneAttr(cast<OptimizeNoneAttr>(A));
		5554	case attr::Overloadable:
		5555	return getDerived().TraverseOverloadableAttr(cast<OverloadableAttr>(A));
		5556	case attr::Override:
		5557	return getDerived().TraverseOverrideAttr(cast<OverrideAttr>(A));
		5558	case attr::Owner:
		5559	return getDerived().TraverseOwnerAttr(cast<OwnerAttr>(A));
		5560	case attr::Ownership:
		5561	return getDerived().TraverseOwnershipAttr(cast<OwnershipAttr>(A));
		5562	case attr::Packed:
		5563	return getDerived().TraversePackedAttr(cast<PackedAttr>(A));
		5564	case attr::ParamTypestate:
		5565	return getDerived().TraverseParamTypestateAttr(cast<ParamTypestateAttr>(A));
		5566	case attr::Pascal:
		5567	return getDerived().TraversePascalAttr(cast<PascalAttr>(A));
		5568	case attr::PassObjectSize:
		5569	return getDerived().TraversePassObjectSizeAttr(cast<PassObjectSizeAttr>(A));
		5570	case attr::PatchableFunctionEntry:
		5571	return getDerived().TraversePatchableFunctionEntryAttr(cast<PatchableFunctionEntryAttr>(A));
		5572	case attr::Pcs:
		5573	return getDerived().TraversePcsAttr(cast<PcsAttr>(A));
		5574	case attr::Pointer:
		5575	return getDerived().TraversePointerAttr(cast<PointerAttr>(A));
		5576	case attr::PragmaClangBSSSection:
		5577	return getDerived().TraversePragmaClangBSSSectionAttr(cast<PragmaClangBSSSectionAttr>(A));
		5578	case attr::PragmaClangDataSection:
		5579	return getDerived().TraversePragmaClangDataSectionAttr(cast<PragmaClangDataSectionAttr>(A));
		5580	case attr::PragmaClangRelroSection:
		5581	return getDerived().TraversePragmaClangRelroSectionAttr(cast<PragmaClangRelroSectionAttr>(A));
		5582	case attr::PragmaClangRodataSection:
		5583	return getDerived().TraversePragmaClangRodataSectionAttr(cast<PragmaClangRodataSectionAttr>(A));
		5584	case attr::PragmaClangTextSection:
		5585	return getDerived().TraversePragmaClangTextSectionAttr(cast<PragmaClangTextSectionAttr>(A));
		5586	case attr::PreferredName:
		5587	return getDerived().TraversePreferredNameAttr(cast<PreferredNameAttr>(A));
		5588	case attr::PreserveAll:
		5589	return getDerived().TraversePreserveAllAttr(cast<PreserveAllAttr>(A));
		5590	case attr::PreserveMost:
		5591	return getDerived().TraversePreserveMostAttr(cast<PreserveMostAttr>(A));
		5592	case attr::PtGuardedBy:
		5593	return getDerived().TraversePtGuardedByAttr(cast<PtGuardedByAttr>(A));
		5594	case attr::PtGuardedVar:
		5595	return getDerived().TraversePtGuardedVarAttr(cast<PtGuardedVarAttr>(A));
		5596	case attr::Ptr32:
		5597	return getDerived().TraversePtr32Attr(cast<Ptr32Attr>(A));
		5598	case attr::Ptr64:
		5599	return getDerived().TraversePtr64Attr(cast<Ptr64Attr>(A));
		5600	case attr::Pure:
		5601	return getDerived().TraversePureAttr(cast<PureAttr>(A));
		5602	case attr::RISCVInterrupt:
		5603	return getDerived().TraverseRISCVInterruptAttr(cast<RISCVInterruptAttr>(A));
		5604	case attr::RandomizeLayout:
		5605	return getDerived().TraverseRandomizeLayoutAttr(cast<RandomizeLayoutAttr>(A));
		5606	case attr::ReadOnlyPlacement:
		5607	return getDerived().TraverseReadOnlyPlacementAttr(cast<ReadOnlyPlacementAttr>(A));
		5608	case attr::RegCall:
		5609	return getDerived().TraverseRegCallAttr(cast<RegCallAttr>(A));
		5610	case attr::Reinitializes:
		5611	return getDerived().TraverseReinitializesAttr(cast<ReinitializesAttr>(A));
		5612	case attr::ReleaseCapability:
		5613	return getDerived().TraverseReleaseCapabilityAttr(cast<ReleaseCapabilityAttr>(A));
		5614	case attr::ReleaseHandle:
		5615	return getDerived().TraverseReleaseHandleAttr(cast<ReleaseHandleAttr>(A));
		5616	case attr::RenderScriptKernel:
		5617	return getDerived().TraverseRenderScriptKernelAttr(cast<RenderScriptKernelAttr>(A));
		5618	case attr::ReqdWorkGroupSize:
		5619	return getDerived().TraverseReqdWorkGroupSizeAttr(cast<ReqdWorkGroupSizeAttr>(A));
		5620	case attr::RequiresCapability:
		5621	return getDerived().TraverseRequiresCapabilityAttr(cast<RequiresCapabilityAttr>(A));
		5622	case attr::Restrict:
		5623	return getDerived().TraverseRestrictAttr(cast<RestrictAttr>(A));
		5624	case attr::Retain:
		5625	return getDerived().TraverseRetainAttr(cast<RetainAttr>(A));
		5626	case attr::ReturnTypestate:
		5627	return getDerived().TraverseReturnTypestateAttr(cast<ReturnTypestateAttr>(A));
		5628	case attr::ReturnsNonNull:
		5629	return getDerived().TraverseReturnsNonNullAttr(cast<ReturnsNonNullAttr>(A));
		5630	case attr::ReturnsTwice:
		5631	return getDerived().TraverseReturnsTwiceAttr(cast<ReturnsTwiceAttr>(A));
		5632	case attr::SPtr:
		5633	return getDerived().TraverseSPtrAttr(cast<SPtrAttr>(A));
		5634	case attr::SYCLKernel:
		5635	return getDerived().TraverseSYCLKernelAttr(cast<SYCLKernelAttr>(A));
		5636	case attr::SYCLSpecialClass:
		5637	return getDerived().TraverseSYCLSpecialClassAttr(cast<SYCLSpecialClassAttr>(A));
		5638	case attr::ScopedLockable:
		5639	return getDerived().TraverseScopedLockableAttr(cast<ScopedLockableAttr>(A));
		5640	case attr::Section:
		5641	return getDerived().TraverseSectionAttr(cast<SectionAttr>(A));
		5642	case attr::SelectAny:
		5643	return getDerived().TraverseSelectAnyAttr(cast<SelectAnyAttr>(A));
		5644	case attr::Sentinel:
		5645	return getDerived().TraverseSentinelAttr(cast<SentinelAttr>(A));
		5646	case attr::SetTypestate:
		5647	return getDerived().TraverseSetTypestateAttr(cast<SetTypestateAttr>(A));
		5648	case attr::SharedTrylockFunction:
		5649	return getDerived().TraverseSharedTrylockFunctionAttr(cast<SharedTrylockFunctionAttr>(A));
		5650	case attr::SpeculativeLoadHardening:
		5651	return getDerived().TraverseSpeculativeLoadHardeningAttr(cast<SpeculativeLoadHardeningAttr>(A));
		5652	case attr::StandaloneDebug:
		5653	return getDerived().TraverseStandaloneDebugAttr(cast<StandaloneDebugAttr>(A));
		5654	case attr::StdCall:
		5655	return getDerived().TraverseStdCallAttr(cast<StdCallAttr>(A));
		5656	case attr::StrictFP:
		5657	return getDerived().TraverseStrictFPAttr(cast<StrictFPAttr>(A));
		5658	case attr::StrictGuardStackCheck:
		5659	return getDerived().TraverseStrictGuardStackCheckAttr(cast<StrictGuardStackCheckAttr>(A));
		5660	case attr::Suppress:
		5661	return getDerived().TraverseSuppressAttr(cast<SuppressAttr>(A));
		5662	case attr::SwiftAsync:
		5663	return getDerived().TraverseSwiftAsyncAttr(cast<SwiftAsyncAttr>(A));
		5664	case attr::SwiftAsyncCall:
		5665	return getDerived().TraverseSwiftAsyncCallAttr(cast<SwiftAsyncCallAttr>(A));
		5666	case attr::SwiftAsyncContext:
		5667	return getDerived().TraverseSwiftAsyncContextAttr(cast<SwiftAsyncContextAttr>(A));
		5668	case attr::SwiftAsyncError:
		5669	return getDerived().TraverseSwiftAsyncErrorAttr(cast<SwiftAsyncErrorAttr>(A));
		5670	case attr::SwiftAsyncName:
		5671	return getDerived().TraverseSwiftAsyncNameAttr(cast<SwiftAsyncNameAttr>(A));
		5672	case attr::SwiftAttr:
		5673	return getDerived().TraverseSwiftAttrAttr(cast<SwiftAttrAttr>(A));
		5674	case attr::SwiftBridge:
		5675	return getDerived().TraverseSwiftBridgeAttr(cast<SwiftBridgeAttr>(A));
		5676	case attr::SwiftBridgedTypedef:
		5677	return getDerived().TraverseSwiftBridgedTypedefAttr(cast<SwiftBridgedTypedefAttr>(A));
		5678	case attr::SwiftCall:
		5679	return getDerived().TraverseSwiftCallAttr(cast<SwiftCallAttr>(A));
		5680	case attr::SwiftContext:
		5681	return getDerived().TraverseSwiftContextAttr(cast<SwiftContextAttr>(A));
		5682	case attr::SwiftError:
		5683	return getDerived().TraverseSwiftErrorAttr(cast<SwiftErrorAttr>(A));
		5684	case attr::SwiftErrorResult:
		5685	return getDerived().TraverseSwiftErrorResultAttr(cast<SwiftErrorResultAttr>(A));
		5686	case attr::SwiftIndirectResult:
		5687	return getDerived().TraverseSwiftIndirectResultAttr(cast<SwiftIndirectResultAttr>(A));
		5688	case attr::SwiftName:
		5689	return getDerived().TraverseSwiftNameAttr(cast<SwiftNameAttr>(A));
		5690	case attr::SwiftNewType:
		5691	return getDerived().TraverseSwiftNewTypeAttr(cast<SwiftNewTypeAttr>(A));
		5692	case attr::SwiftObjCMembers:
		5693	return getDerived().TraverseSwiftObjCMembersAttr(cast<SwiftObjCMembersAttr>(A));
		5694	case attr::SwiftPrivate:
		5695	return getDerived().TraverseSwiftPrivateAttr(cast<SwiftPrivateAttr>(A));
		5696	case attr::SysVABI:
		5697	return getDerived().TraverseSysVABIAttr(cast<SysVABIAttr>(A));
		5698	case attr::TLSModel:
		5699	return getDerived().TraverseTLSModelAttr(cast<TLSModelAttr>(A));
		5700	case attr::Target:
		5701	return getDerived().TraverseTargetAttr(cast<TargetAttr>(A));
		5702	case attr::TargetClones:
		5703	return getDerived().TraverseTargetClonesAttr(cast<TargetClonesAttr>(A));
		5704	case attr::TargetVersion:
		5705	return getDerived().TraverseTargetVersionAttr(cast<TargetVersionAttr>(A));
		5706	case attr::TestTypestate:
		5707	return getDerived().TraverseTestTypestateAttr(cast<TestTypestateAttr>(A));
		5708	case attr::ThisCall:
		5709	return getDerived().TraverseThisCallAttr(cast<ThisCallAttr>(A));
		5710	case attr::Thread:
		5711	return getDerived().TraverseThreadAttr(cast<ThreadAttr>(A));
		5712	case attr::TransparentUnion:
		5713	return getDerived().TraverseTransparentUnionAttr(cast<TransparentUnionAttr>(A));
		5714	case attr::TrivialABI:
		5715	return getDerived().TraverseTrivialABIAttr(cast<TrivialABIAttr>(A));
		5716	case attr::TryAcquireCapability:
		5717	return getDerived().TraverseTryAcquireCapabilityAttr(cast<TryAcquireCapabilityAttr>(A));
		5718	case attr::TypeNonNull:
		5719	return getDerived().TraverseTypeNonNullAttr(cast<TypeNonNullAttr>(A));
		5720	case attr::TypeNullUnspecified:
		5721	return getDerived().TraverseTypeNullUnspecifiedAttr(cast<TypeNullUnspecifiedAttr>(A));
		5722	case attr::TypeNullable:
		5723	return getDerived().TraverseTypeNullableAttr(cast<TypeNullableAttr>(A));
		5724	case attr::TypeNullableResult:
		5725	return getDerived().TraverseTypeNullableResultAttr(cast<TypeNullableResultAttr>(A));
		5726	case attr::TypeTagForDatatype:
		5727	return getDerived().TraverseTypeTagForDatatypeAttr(cast<TypeTagForDatatypeAttr>(A));
		5728	case attr::TypeVisibility:
		5729	return getDerived().TraverseTypeVisibilityAttr(cast<TypeVisibilityAttr>(A));
		5730	case attr::UPtr:
		5731	return getDerived().TraverseUPtrAttr(cast<UPtrAttr>(A));
		5732	case attr::Unavailable:
		5733	return getDerived().TraverseUnavailableAttr(cast<UnavailableAttr>(A));
		5734	case attr::Uninitialized:
		5735	return getDerived().TraverseUninitializedAttr(cast<UninitializedAttr>(A));
		5736	case attr::Unlikely:
		5737	return getDerived().TraverseUnlikelyAttr(cast<UnlikelyAttr>(A));
		5738	case attr::Unused:
		5739	return getDerived().TraverseUnusedAttr(cast<UnusedAttr>(A));
		5740	case attr::UseHandle:
		5741	return getDerived().TraverseUseHandleAttr(cast<UseHandleAttr>(A));
		5742	case attr::Used:
		5743	return getDerived().TraverseUsedAttr(cast<UsedAttr>(A));
		5744	case attr::UsingIfExists:
		5745	return getDerived().TraverseUsingIfExistsAttr(cast<UsingIfExistsAttr>(A));
		5746	case attr::Uuid:
		5747	return getDerived().TraverseUuidAttr(cast<UuidAttr>(A));
		5748	case attr::VecReturn:
		5749	return getDerived().TraverseVecReturnAttr(cast<VecReturnAttr>(A));
		5750	case attr::VecTypeHint:
		5751	return getDerived().TraverseVecTypeHintAttr(cast<VecTypeHintAttr>(A));
		5752	case attr::VectorCall:
		5753	return getDerived().TraverseVectorCallAttr(cast<VectorCallAttr>(A));
		5754	case attr::Visibility:
		5755	return getDerived().TraverseVisibilityAttr(cast<VisibilityAttr>(A));
		5756	case attr::WarnUnused:
		5757	return getDerived().TraverseWarnUnusedAttr(cast<WarnUnusedAttr>(A));
		5758	case attr::WarnUnusedResult:
		5759	return getDerived().TraverseWarnUnusedResultAttr(cast<WarnUnusedResultAttr>(A));
		5760	case attr::Weak:
		5761	return getDerived().TraverseWeakAttr(cast<WeakAttr>(A));
		5762	case attr::WeakImport:
		5763	return getDerived().TraverseWeakImportAttr(cast<WeakImportAttr>(A));
		5764	case attr::WeakRef:
		5765	return getDerived().TraverseWeakRefAttr(cast<WeakRefAttr>(A));
		5766	case attr::WebAssemblyExportName:
		5767	return getDerived().TraverseWebAssemblyExportNameAttr(cast<WebAssemblyExportNameAttr>(A));
		5768	case attr::WebAssemblyImportModule:
		5769	return getDerived().TraverseWebAssemblyImportModuleAttr(cast<WebAssemblyImportModuleAttr>(A));
		5770	case attr::WebAssemblyImportName:
		5771	return getDerived().TraverseWebAssemblyImportNameAttr(cast<WebAssemblyImportNameAttr>(A));
		5772	case attr::WorkGroupSizeHint:
		5773	return getDerived().TraverseWorkGroupSizeHintAttr(cast<WorkGroupSizeHintAttr>(A));
		5774	case attr::X86ForceAlignArgPointer:
		5775	return getDerived().TraverseX86ForceAlignArgPointerAttr(cast<X86ForceAlignArgPointerAttr>(A));
		5776	case attr::XRayInstrument:
		5777	return getDerived().TraverseXRayInstrumentAttr(cast<XRayInstrumentAttr>(A));
		5778	case attr::XRayLogArgs:
		5779	return getDerived().TraverseXRayLogArgsAttr(cast<XRayLogArgsAttr>(A));
		5780	case attr::ZeroCallUsedRegs:
		5781	return getDerived().TraverseZeroCallUsedRegsAttr(cast<ZeroCallUsedRegsAttr>(A));
		5782	}
		5783	llvm_unreachable("bad attribute kind");
		5784	}
		5785	#endif // ATTR_VISITOR_DECLS_ONLY

Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

QNX 8.QNX8 LLVM/Clang compiler suite//llvm-build/x86_64/include/clang/AST/AttrVisitor.inc – Rev 14