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