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 TraverseAMDGPUNumSGPRAttr(AMDGPUNumSGPRAttr *A);
12 : bool VisitAMDGPUNumSGPRAttr(AMDGPUNumSGPRAttr *A) {
13 0 : return true;
14 : };
15 : bool TraverseAMDGPUNumVGPRAttr(AMDGPUNumVGPRAttr *A);
16 : bool VisitAMDGPUNumVGPRAttr(AMDGPUNumVGPRAttr *A) {
17 0 : return true;
18 : };
19 : bool TraverseARMInterruptAttr(ARMInterruptAttr *A);
20 : bool VisitARMInterruptAttr(ARMInterruptAttr *A) {
21 0 : return true;
22 : };
23 : bool TraverseAcquireCapabilityAttr(AcquireCapabilityAttr *A);
24 : bool VisitAcquireCapabilityAttr(AcquireCapabilityAttr *A) {
25 0 : return true;
26 : };
27 : bool TraverseAcquiredAfterAttr(AcquiredAfterAttr *A);
28 : bool VisitAcquiredAfterAttr(AcquiredAfterAttr *A) {
29 0 : return true;
30 : };
31 : bool TraverseAcquiredBeforeAttr(AcquiredBeforeAttr *A);
32 : bool VisitAcquiredBeforeAttr(AcquiredBeforeAttr *A) {
33 0 : return true;
34 : };
35 : bool TraverseAliasAttr(AliasAttr *A);
36 : bool VisitAliasAttr(AliasAttr *A) {
37 0 : return true;
38 : };
39 : bool TraverseAlignMac68kAttr(AlignMac68kAttr *A);
40 : bool VisitAlignMac68kAttr(AlignMac68kAttr *A) {
41 0 : return true;
42 : };
43 : bool TraverseAlignValueAttr(AlignValueAttr *A);
44 : bool VisitAlignValueAttr(AlignValueAttr *A) {
45 0 : return true;
46 : };
47 : bool TraverseAlignedAttr(AlignedAttr *A);
48 : bool VisitAlignedAttr(AlignedAttr *A) {
49 0 : return true;
50 : };
51 : bool TraverseAlwaysInlineAttr(AlwaysInlineAttr *A);
52 : bool VisitAlwaysInlineAttr(AlwaysInlineAttr *A) {
53 0 : return true;
54 : };
55 : bool TraverseAnalyzerNoReturnAttr(AnalyzerNoReturnAttr *A);
56 : bool VisitAnalyzerNoReturnAttr(AnalyzerNoReturnAttr *A) {
57 0 : return true;
58 : };
59 : bool TraverseAnnotateAttr(AnnotateAttr *A);
60 : bool VisitAnnotateAttr(AnnotateAttr *A) {
61 0 : return true;
62 : };
63 : bool TraverseArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A);
64 : bool VisitArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A) {
65 0 : return true;
66 : };
67 : bool TraverseArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *A);
68 : bool VisitArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *A) {
69 0 : return true;
70 : };
71 : bool TraverseAsmLabelAttr(AsmLabelAttr *A);
72 : bool VisitAsmLabelAttr(AsmLabelAttr *A) {
73 0 : return true;
74 : };
75 : bool TraverseAssertCapabilityAttr(AssertCapabilityAttr *A);
76 : bool VisitAssertCapabilityAttr(AssertCapabilityAttr *A) {
77 0 : return true;
78 : };
79 : bool TraverseAssertExclusiveLockAttr(AssertExclusiveLockAttr *A);
80 : bool VisitAssertExclusiveLockAttr(AssertExclusiveLockAttr *A) {
81 0 : return true;
82 : };
83 : bool TraverseAssertSharedLockAttr(AssertSharedLockAttr *A);
84 : bool VisitAssertSharedLockAttr(AssertSharedLockAttr *A) {
85 0 : return true;
86 : };
87 : bool TraverseAssumeAlignedAttr(AssumeAlignedAttr *A);
88 : bool VisitAssumeAlignedAttr(AssumeAlignedAttr *A) {
89 0 : return true;
90 : };
91 : bool TraverseAvailabilityAttr(AvailabilityAttr *A);
92 : bool VisitAvailabilityAttr(AvailabilityAttr *A) {
93 0 : return true;
94 : };
95 : bool TraverseBlocksAttr(BlocksAttr *A);
96 : bool VisitBlocksAttr(BlocksAttr *A) {
97 0 : return true;
98 : };
99 : bool TraverseC11NoReturnAttr(C11NoReturnAttr *A);
100 : bool VisitC11NoReturnAttr(C11NoReturnAttr *A) {
101 0 : return true;
102 : };
103 : bool TraverseCDeclAttr(CDeclAttr *A);
104 : bool VisitCDeclAttr(CDeclAttr *A) {
105 0 : return true;
106 : };
107 : bool TraverseCFAuditedTransferAttr(CFAuditedTransferAttr *A);
108 : bool VisitCFAuditedTransferAttr(CFAuditedTransferAttr *A) {
109 0 : return true;
110 : };
111 : bool TraverseCFConsumedAttr(CFConsumedAttr *A);
112 : bool VisitCFConsumedAttr(CFConsumedAttr *A) {
113 0 : return true;
114 : };
115 : bool TraverseCFReturnsNotRetainedAttr(CFReturnsNotRetainedAttr *A);
116 : bool VisitCFReturnsNotRetainedAttr(CFReturnsNotRetainedAttr *A) {
117 0 : return true;
118 : };
119 : bool TraverseCFReturnsRetainedAttr(CFReturnsRetainedAttr *A);
120 : bool VisitCFReturnsRetainedAttr(CFReturnsRetainedAttr *A) {
121 0 : return true;
122 : };
123 : bool TraverseCFUnknownTransferAttr(CFUnknownTransferAttr *A);
124 : bool VisitCFUnknownTransferAttr(CFUnknownTransferAttr *A) {
125 0 : return true;
126 : };
127 : bool TraverseCUDAConstantAttr(CUDAConstantAttr *A);
128 : bool VisitCUDAConstantAttr(CUDAConstantAttr *A) {
129 0 : return true;
130 : };
131 : bool TraverseCUDADeviceAttr(CUDADeviceAttr *A);
132 : bool VisitCUDADeviceAttr(CUDADeviceAttr *A) {
133 0 : return true;
134 : };
135 : bool TraverseCUDAGlobalAttr(CUDAGlobalAttr *A);
136 : bool VisitCUDAGlobalAttr(CUDAGlobalAttr *A) {
137 0 : return true;
138 : };
139 : bool TraverseCUDAHostAttr(CUDAHostAttr *A);
140 : bool VisitCUDAHostAttr(CUDAHostAttr *A) {
141 0 : return true;
142 : };
143 : bool TraverseCUDAInvalidTargetAttr(CUDAInvalidTargetAttr *A);
144 : bool VisitCUDAInvalidTargetAttr(CUDAInvalidTargetAttr *A) {
145 0 : return true;
146 : };
147 : bool TraverseCUDALaunchBoundsAttr(CUDALaunchBoundsAttr *A);
148 : bool VisitCUDALaunchBoundsAttr(CUDALaunchBoundsAttr *A) {
149 0 : return true;
150 : };
151 : bool TraverseCUDASharedAttr(CUDASharedAttr *A);
152 : bool VisitCUDASharedAttr(CUDASharedAttr *A) {
153 0 : return true;
154 : };
155 : bool TraverseCXX11NoReturnAttr(CXX11NoReturnAttr *A);
156 : bool VisitCXX11NoReturnAttr(CXX11NoReturnAttr *A) {
157 0 : return true;
158 : };
159 : bool TraverseCallableWhenAttr(CallableWhenAttr *A);
160 : bool VisitCallableWhenAttr(CallableWhenAttr *A) {
161 0 : return true;
162 : };
163 : bool TraverseCapabilityAttr(CapabilityAttr *A);
164 : bool VisitCapabilityAttr(CapabilityAttr *A) {
165 0 : return true;
166 : };
167 : bool TraverseCapturedRecordAttr(CapturedRecordAttr *A);
168 : bool VisitCapturedRecordAttr(CapturedRecordAttr *A) {
169 0 : return true;
170 : };
171 : bool TraverseCarriesDependencyAttr(CarriesDependencyAttr *A);
172 : bool VisitCarriesDependencyAttr(CarriesDependencyAttr *A) {
173 0 : return true;
174 : };
175 : bool TraverseCleanupAttr(CleanupAttr *A);
176 : bool VisitCleanupAttr(CleanupAttr *A) {
177 0 : return true;
178 : };
179 : bool TraverseColdAttr(ColdAttr *A);
180 : bool VisitColdAttr(ColdAttr *A) {
181 0 : return true;
182 : };
183 : bool TraverseCommonAttr(CommonAttr *A);
184 : bool VisitCommonAttr(CommonAttr *A) {
185 0 : return true;
186 : };
187 : bool TraverseConstAttr(ConstAttr *A);
188 : bool VisitConstAttr(ConstAttr *A) {
189 0 : return true;
190 : };
191 : bool TraverseConstructorAttr(ConstructorAttr *A);
192 : bool VisitConstructorAttr(ConstructorAttr *A) {
193 0 : return true;
194 : };
195 : bool TraverseConsumableAttr(ConsumableAttr *A);
196 : bool VisitConsumableAttr(ConsumableAttr *A) {
197 0 : return true;
198 : };
199 : bool TraverseConsumableAutoCastAttr(ConsumableAutoCastAttr *A);
200 : bool VisitConsumableAutoCastAttr(ConsumableAutoCastAttr *A) {
201 0 : return true;
202 : };
203 : bool TraverseConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A);
204 : bool VisitConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A) {
205 0 : return true;
206 : };
207 : bool TraverseDLLExportAttr(DLLExportAttr *A);
208 : bool VisitDLLExportAttr(DLLExportAttr *A) {
209 0 : return true;
210 : };
211 : bool TraverseDLLImportAttr(DLLImportAttr *A);
212 : bool VisitDLLImportAttr(DLLImportAttr *A) {
213 0 : return true;
214 : };
215 : bool TraverseDeprecatedAttr(DeprecatedAttr *A);
216 : bool VisitDeprecatedAttr(DeprecatedAttr *A) {
217 0 : return true;
218 : };
219 : bool TraverseDestructorAttr(DestructorAttr *A);
220 : bool VisitDestructorAttr(DestructorAttr *A) {
221 0 : return true;
222 : };
223 : bool TraverseEnableIfAttr(EnableIfAttr *A);
224 : bool VisitEnableIfAttr(EnableIfAttr *A) {
225 0 : return true;
226 : };
227 : bool TraverseExclusiveTrylockFunctionAttr(ExclusiveTrylockFunctionAttr *A);
228 : bool VisitExclusiveTrylockFunctionAttr(ExclusiveTrylockFunctionAttr *A) {
229 0 : return true;
230 : };
231 : bool TraverseFallThroughAttr(FallThroughAttr *A);
232 : bool VisitFallThroughAttr(FallThroughAttr *A) {
233 0 : return true;
234 : };
235 : bool TraverseFastCallAttr(FastCallAttr *A);
236 : bool VisitFastCallAttr(FastCallAttr *A) {
237 0 : return true;
238 : };
239 : bool TraverseFinalAttr(FinalAttr *A);
240 : bool VisitFinalAttr(FinalAttr *A) {
241 0 : return true;
242 : };
243 : bool TraverseFlagEnumAttr(FlagEnumAttr *A);
244 : bool VisitFlagEnumAttr(FlagEnumAttr *A) {
245 0 : return true;
246 : };
247 : bool TraverseFlattenAttr(FlattenAttr *A);
248 : bool VisitFlattenAttr(FlattenAttr *A) {
249 0 : return true;
250 : };
251 : bool TraverseFormatAttr(FormatAttr *A);
252 : bool VisitFormatAttr(FormatAttr *A) {
253 0 : return true;
254 : };
255 : bool TraverseFormatArgAttr(FormatArgAttr *A);
256 : bool VisitFormatArgAttr(FormatArgAttr *A) {
257 0 : return true;
258 : };
259 : bool TraverseGNUInlineAttr(GNUInlineAttr *A);
260 : bool VisitGNUInlineAttr(GNUInlineAttr *A) {
261 0 : return true;
262 : };
263 : bool TraverseGuardedByAttr(GuardedByAttr *A);
264 : bool VisitGuardedByAttr(GuardedByAttr *A) {
265 0 : return true;
266 : };
267 : bool TraverseGuardedVarAttr(GuardedVarAttr *A);
268 : bool VisitGuardedVarAttr(GuardedVarAttr *A) {
269 0 : return true;
270 : };
271 : bool TraverseHotAttr(HotAttr *A);
272 : bool VisitHotAttr(HotAttr *A) {
273 0 : return true;
274 : };
275 : bool TraverseIBActionAttr(IBActionAttr *A);
276 : bool VisitIBActionAttr(IBActionAttr *A) {
277 0 : return true;
278 : };
279 : bool TraverseIBOutletAttr(IBOutletAttr *A);
280 : bool VisitIBOutletAttr(IBOutletAttr *A) {
281 0 : return true;
282 : };
283 : bool TraverseIBOutletCollectionAttr(IBOutletCollectionAttr *A);
284 : bool VisitIBOutletCollectionAttr(IBOutletCollectionAttr *A) {
285 0 : return true;
286 : };
287 : bool TraverseInitPriorityAttr(InitPriorityAttr *A);
288 : bool VisitInitPriorityAttr(InitPriorityAttr *A) {
289 0 : return true;
290 : };
291 : bool TraverseInitSegAttr(InitSegAttr *A);
292 : bool VisitInitSegAttr(InitSegAttr *A) {
293 0 : return true;
294 : };
295 : bool TraverseIntelOclBiccAttr(IntelOclBiccAttr *A);
296 : bool VisitIntelOclBiccAttr(IntelOclBiccAttr *A) {
297 0 : return true;
298 : };
299 : bool TraverseLockReturnedAttr(LockReturnedAttr *A);
300 : bool VisitLockReturnedAttr(LockReturnedAttr *A) {
301 0 : return true;
302 : };
303 : bool TraverseLocksExcludedAttr(LocksExcludedAttr *A);
304 : bool VisitLocksExcludedAttr(LocksExcludedAttr *A) {
305 0 : return true;
306 : };
307 : bool TraverseLoopHintAttr(LoopHintAttr *A);
308 : bool VisitLoopHintAttr(LoopHintAttr *A) {
309 0 : return true;
310 : };
311 : bool TraverseMSABIAttr(MSABIAttr *A);
312 : bool VisitMSABIAttr(MSABIAttr *A) {
313 0 : return true;
314 : };
315 : bool TraverseMSInheritanceAttr(MSInheritanceAttr *A);
316 : bool VisitMSInheritanceAttr(MSInheritanceAttr *A) {
317 0 : return true;
318 : };
319 : bool TraverseMSNoVTableAttr(MSNoVTableAttr *A);
320 : bool VisitMSNoVTableAttr(MSNoVTableAttr *A) {
321 0 : return true;
322 : };
323 : bool TraverseMSP430InterruptAttr(MSP430InterruptAttr *A);
324 : bool VisitMSP430InterruptAttr(MSP430InterruptAttr *A) {
325 0 : return true;
326 : };
327 : bool TraverseMSStructAttr(MSStructAttr *A);
328 : bool VisitMSStructAttr(MSStructAttr *A) {
329 0 : return true;
330 : };
331 : bool TraverseMSVtorDispAttr(MSVtorDispAttr *A);
332 : bool VisitMSVtorDispAttr(MSVtorDispAttr *A) {
333 0 : return true;
334 : };
335 : bool TraverseMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A);
336 : bool VisitMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A) {
337 0 : return true;
338 : };
339 : bool TraverseMayAliasAttr(MayAliasAttr *A);
340 : bool VisitMayAliasAttr(MayAliasAttr *A) {
341 0 : return true;
342 : };
343 : bool TraverseMinSizeAttr(MinSizeAttr *A);
344 : bool VisitMinSizeAttr(MinSizeAttr *A) {
345 0 : return true;
346 : };
347 : bool TraverseMips16Attr(Mips16Attr *A);
348 : bool VisitMips16Attr(Mips16Attr *A) {
349 0 : return true;
350 : };
351 : bool TraverseModeAttr(ModeAttr *A);
352 : bool VisitModeAttr(ModeAttr *A) {
353 0 : return true;
354 : };
355 : bool TraverseNSConsumedAttr(NSConsumedAttr *A);
356 : bool VisitNSConsumedAttr(NSConsumedAttr *A) {
357 0 : return true;
358 : };
359 : bool TraverseNSConsumesSelfAttr(NSConsumesSelfAttr *A);
360 : bool VisitNSConsumesSelfAttr(NSConsumesSelfAttr *A) {
361 0 : return true;
362 : };
363 : bool TraverseNSReturnsAutoreleasedAttr(NSReturnsAutoreleasedAttr *A);
364 : bool VisitNSReturnsAutoreleasedAttr(NSReturnsAutoreleasedAttr *A) {
365 0 : return true;
366 : };
367 : bool TraverseNSReturnsNotRetainedAttr(NSReturnsNotRetainedAttr *A);
368 : bool VisitNSReturnsNotRetainedAttr(NSReturnsNotRetainedAttr *A) {
369 0 : return true;
370 : };
371 : bool TraverseNSReturnsRetainedAttr(NSReturnsRetainedAttr *A);
372 : bool VisitNSReturnsRetainedAttr(NSReturnsRetainedAttr *A) {
373 0 : return true;
374 : };
375 : bool TraverseNakedAttr(NakedAttr *A);
376 : bool VisitNakedAttr(NakedAttr *A) {
377 0 : return true;
378 : };
379 : bool TraverseNoCommonAttr(NoCommonAttr *A);
380 : bool VisitNoCommonAttr(NoCommonAttr *A) {
381 0 : return true;
382 : };
383 : bool TraverseNoDebugAttr(NoDebugAttr *A);
384 : bool VisitNoDebugAttr(NoDebugAttr *A) {
385 0 : return true;
386 : };
387 : bool TraverseNoDuplicateAttr(NoDuplicateAttr *A);
388 : bool VisitNoDuplicateAttr(NoDuplicateAttr *A) {
389 0 : return true;
390 : };
391 : bool TraverseNoInlineAttr(NoInlineAttr *A);
392 : bool VisitNoInlineAttr(NoInlineAttr *A) {
393 0 : return true;
394 : };
395 : bool TraverseNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A);
396 : bool VisitNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A) {
397 0 : return true;
398 : };
399 : bool TraverseNoMips16Attr(NoMips16Attr *A);
400 : bool VisitNoMips16Attr(NoMips16Attr *A) {
401 0 : return true;
402 : };
403 : bool TraverseNoReturnAttr(NoReturnAttr *A);
404 : bool VisitNoReturnAttr(NoReturnAttr *A) {
405 0 : return true;
406 : };
407 : bool TraverseNoSanitizeAttr(NoSanitizeAttr *A);
408 : bool VisitNoSanitizeAttr(NoSanitizeAttr *A) {
409 0 : return true;
410 : };
411 : bool TraverseNoSplitStackAttr(NoSplitStackAttr *A);
412 : bool VisitNoSplitStackAttr(NoSplitStackAttr *A) {
413 0 : return true;
414 : };
415 : bool TraverseNoThreadSafetyAnalysisAttr(NoThreadSafetyAnalysisAttr *A);
416 : bool VisitNoThreadSafetyAnalysisAttr(NoThreadSafetyAnalysisAttr *A) {
417 0 : return true;
418 : };
419 : bool TraverseNoThrowAttr(NoThrowAttr *A);
420 : bool VisitNoThrowAttr(NoThrowAttr *A) {
421 0 : return true;
422 : };
423 : bool TraverseNonNullAttr(NonNullAttr *A);
424 : bool VisitNonNullAttr(NonNullAttr *A) {
425 0 : return true;
426 : };
427 : bool TraverseOMPThreadPrivateDeclAttr(OMPThreadPrivateDeclAttr *A);
428 : bool VisitOMPThreadPrivateDeclAttr(OMPThreadPrivateDeclAttr *A) {
429 0 : return true;
430 : };
431 : bool TraverseObjCBoxableAttr(ObjCBoxableAttr *A);
432 : bool VisitObjCBoxableAttr(ObjCBoxableAttr *A) {
433 0 : return true;
434 : };
435 : bool TraverseObjCBridgeAttr(ObjCBridgeAttr *A);
436 : bool VisitObjCBridgeAttr(ObjCBridgeAttr *A) {
437 0 : return true;
438 : };
439 : bool TraverseObjCBridgeMutableAttr(ObjCBridgeMutableAttr *A);
440 : bool VisitObjCBridgeMutableAttr(ObjCBridgeMutableAttr *A) {
441 0 : return true;
442 : };
443 : bool TraverseObjCBridgeRelatedAttr(ObjCBridgeRelatedAttr *A);
444 : bool VisitObjCBridgeRelatedAttr(ObjCBridgeRelatedAttr *A) {
445 0 : return true;
446 : };
447 : bool TraverseObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A);
448 : bool VisitObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A) {
449 0 : return true;
450 : };
451 : bool TraverseObjCExceptionAttr(ObjCExceptionAttr *A);
452 : bool VisitObjCExceptionAttr(ObjCExceptionAttr *A) {
453 0 : return true;
454 : };
455 : bool TraverseObjCExplicitProtocolImplAttr(ObjCExplicitProtocolImplAttr *A);
456 : bool VisitObjCExplicitProtocolImplAttr(ObjCExplicitProtocolImplAttr *A) {
457 0 : return true;
458 : };
459 : bool TraverseObjCIndependentClassAttr(ObjCIndependentClassAttr *A);
460 : bool VisitObjCIndependentClassAttr(ObjCIndependentClassAttr *A) {
461 0 : return true;
462 : };
463 : bool TraverseObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A);
464 : bool VisitObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A) {
465 0 : return true;
466 : };
467 : bool TraverseObjCNSObjectAttr(ObjCNSObjectAttr *A);
468 : bool VisitObjCNSObjectAttr(ObjCNSObjectAttr *A) {
469 0 : return true;
470 : };
471 : bool TraverseObjCPreciseLifetimeAttr(ObjCPreciseLifetimeAttr *A);
472 : bool VisitObjCPreciseLifetimeAttr(ObjCPreciseLifetimeAttr *A) {
473 0 : return true;
474 : };
475 : bool TraverseObjCRequiresPropertyDefsAttr(ObjCRequiresPropertyDefsAttr *A);
476 : bool VisitObjCRequiresPropertyDefsAttr(ObjCRequiresPropertyDefsAttr *A) {
477 0 : return true;
478 : };
479 : bool TraverseObjCRequiresSuperAttr(ObjCRequiresSuperAttr *A);
480 : bool VisitObjCRequiresSuperAttr(ObjCRequiresSuperAttr *A) {
481 0 : return true;
482 : };
483 : bool TraverseObjCReturnsInnerPointerAttr(ObjCReturnsInnerPointerAttr *A);
484 : bool VisitObjCReturnsInnerPointerAttr(ObjCReturnsInnerPointerAttr *A) {
485 0 : return true;
486 : };
487 : bool TraverseObjCRootClassAttr(ObjCRootClassAttr *A);
488 : bool VisitObjCRootClassAttr(ObjCRootClassAttr *A) {
489 0 : return true;
490 : };
491 : bool TraverseObjCRuntimeNameAttr(ObjCRuntimeNameAttr *A);
492 : bool VisitObjCRuntimeNameAttr(ObjCRuntimeNameAttr *A) {
493 0 : return true;
494 : };
495 : bool TraverseOpenCLImageAccessAttr(OpenCLImageAccessAttr *A);
496 : bool VisitOpenCLImageAccessAttr(OpenCLImageAccessAttr *A) {
497 0 : return true;
498 : };
499 : bool TraverseOpenCLKernelAttr(OpenCLKernelAttr *A);
500 : bool VisitOpenCLKernelAttr(OpenCLKernelAttr *A) {
501 0 : return true;
502 : };
503 : bool TraverseOptimizeNoneAttr(OptimizeNoneAttr *A);
504 : bool VisitOptimizeNoneAttr(OptimizeNoneAttr *A) {
505 0 : return true;
506 : };
507 : bool TraverseOverloadableAttr(OverloadableAttr *A);
508 : bool VisitOverloadableAttr(OverloadableAttr *A) {
509 0 : return true;
510 : };
511 : bool TraverseOverrideAttr(OverrideAttr *A);
512 : bool VisitOverrideAttr(OverrideAttr *A) {
513 0 : return true;
514 : };
515 : bool TraverseOwnershipAttr(OwnershipAttr *A);
516 : bool VisitOwnershipAttr(OwnershipAttr *A) {
517 0 : return true;
518 : };
519 : bool TraversePackedAttr(PackedAttr *A);
520 : bool VisitPackedAttr(PackedAttr *A) {
521 0 : return true;
522 : };
523 : bool TraverseParamTypestateAttr(ParamTypestateAttr *A);
524 : bool VisitParamTypestateAttr(ParamTypestateAttr *A) {
525 0 : return true;
526 : };
527 : bool TraversePascalAttr(PascalAttr *A);
528 : bool VisitPascalAttr(PascalAttr *A) {
529 0 : return true;
530 : };
531 : bool TraversePcsAttr(PcsAttr *A);
532 : bool VisitPcsAttr(PcsAttr *A) {
533 0 : return true;
534 : };
535 : bool TraversePtGuardedByAttr(PtGuardedByAttr *A);
536 : bool VisitPtGuardedByAttr(PtGuardedByAttr *A) {
537 0 : return true;
538 : };
539 : bool TraversePtGuardedVarAttr(PtGuardedVarAttr *A);
540 : bool VisitPtGuardedVarAttr(PtGuardedVarAttr *A) {
541 0 : return true;
542 : };
543 : bool TraversePureAttr(PureAttr *A);
544 : bool VisitPureAttr(PureAttr *A) {
545 0 : return true;
546 : };
547 : bool TraverseReleaseCapabilityAttr(ReleaseCapabilityAttr *A);
548 : bool VisitReleaseCapabilityAttr(ReleaseCapabilityAttr *A) {
549 0 : return true;
550 : };
551 : bool TraverseReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A);
552 : bool VisitReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A) {
553 0 : return true;
554 : };
555 : bool TraverseRequiresCapabilityAttr(RequiresCapabilityAttr *A);
556 : bool VisitRequiresCapabilityAttr(RequiresCapabilityAttr *A) {
557 0 : return true;
558 : };
559 : bool TraverseRestrictAttr(RestrictAttr *A);
560 : bool VisitRestrictAttr(RestrictAttr *A) {
561 0 : return true;
562 : };
563 : bool TraverseReturnTypestateAttr(ReturnTypestateAttr *A);
564 : bool VisitReturnTypestateAttr(ReturnTypestateAttr *A) {
565 0 : return true;
566 : };
567 : bool TraverseReturnsNonNullAttr(ReturnsNonNullAttr *A);
568 : bool VisitReturnsNonNullAttr(ReturnsNonNullAttr *A) {
569 0 : return true;
570 : };
571 : bool TraverseReturnsTwiceAttr(ReturnsTwiceAttr *A);
572 : bool VisitReturnsTwiceAttr(ReturnsTwiceAttr *A) {
573 0 : return true;
574 : };
575 : bool TraverseScopedLockableAttr(ScopedLockableAttr *A);
576 : bool VisitScopedLockableAttr(ScopedLockableAttr *A) {
577 0 : return true;
578 : };
579 : bool TraverseSectionAttr(SectionAttr *A);
580 : bool VisitSectionAttr(SectionAttr *A) {
581 0 : return true;
582 : };
583 : bool TraverseSelectAnyAttr(SelectAnyAttr *A);
584 : bool VisitSelectAnyAttr(SelectAnyAttr *A) {
585 0 : return true;
586 : };
587 : bool TraverseSentinelAttr(SentinelAttr *A);
588 : bool VisitSentinelAttr(SentinelAttr *A) {
589 0 : return true;
590 : };
591 : bool TraverseSetTypestateAttr(SetTypestateAttr *A);
592 : bool VisitSetTypestateAttr(SetTypestateAttr *A) {
593 0 : return true;
594 : };
595 : bool TraverseSharedTrylockFunctionAttr(SharedTrylockFunctionAttr *A);
596 : bool VisitSharedTrylockFunctionAttr(SharedTrylockFunctionAttr *A) {
597 0 : return true;
598 : };
599 : bool TraverseStdCallAttr(StdCallAttr *A);
600 : bool VisitStdCallAttr(StdCallAttr *A) {
601 0 : return true;
602 : };
603 : bool TraverseSysVABIAttr(SysVABIAttr *A);
604 : bool VisitSysVABIAttr(SysVABIAttr *A) {
605 0 : return true;
606 : };
607 : bool TraverseTLSModelAttr(TLSModelAttr *A);
608 : bool VisitTLSModelAttr(TLSModelAttr *A) {
609 0 : return true;
610 : };
611 : bool TraverseTargetAttr(TargetAttr *A);
612 : bool VisitTargetAttr(TargetAttr *A) {
613 0 : return true;
614 : };
615 : bool TraverseTestTypestateAttr(TestTypestateAttr *A);
616 : bool VisitTestTypestateAttr(TestTypestateAttr *A) {
617 0 : return true;
618 : };
619 : bool TraverseThisCallAttr(ThisCallAttr *A);
620 : bool VisitThisCallAttr(ThisCallAttr *A) {
621 0 : return true;
622 : };
623 : bool TraverseThreadAttr(ThreadAttr *A);
624 : bool VisitThreadAttr(ThreadAttr *A) {
625 0 : return true;
626 : };
627 : bool TraverseTransparentUnionAttr(TransparentUnionAttr *A);
628 : bool VisitTransparentUnionAttr(TransparentUnionAttr *A) {
629 0 : return true;
630 : };
631 : bool TraverseTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A);
632 : bool VisitTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A) {
633 0 : return true;
634 : };
635 : bool TraverseTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A);
636 : bool VisitTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A) {
637 0 : return true;
638 : };
639 : bool TraverseTypeVisibilityAttr(TypeVisibilityAttr *A);
640 : bool VisitTypeVisibilityAttr(TypeVisibilityAttr *A) {
641 0 : return true;
642 : };
643 : bool TraverseUnavailableAttr(UnavailableAttr *A);
644 : bool VisitUnavailableAttr(UnavailableAttr *A) {
645 0 : return true;
646 : };
647 : bool TraverseUnusedAttr(UnusedAttr *A);
648 : bool VisitUnusedAttr(UnusedAttr *A) {
649 0 : return true;
650 : };
651 : bool TraverseUsedAttr(UsedAttr *A);
652 : bool VisitUsedAttr(UsedAttr *A) {
653 0 : return true;
654 : };
655 : bool TraverseUuidAttr(UuidAttr *A);
656 : bool VisitUuidAttr(UuidAttr *A) {
657 0 : return true;
658 : };
659 : bool TraverseVecReturnAttr(VecReturnAttr *A);
660 : bool VisitVecReturnAttr(VecReturnAttr *A) {
661 0 : return true;
662 : };
663 : bool TraverseVecTypeHintAttr(VecTypeHintAttr *A);
664 : bool VisitVecTypeHintAttr(VecTypeHintAttr *A) {
665 0 : return true;
666 : };
667 : bool TraverseVectorCallAttr(VectorCallAttr *A);
668 : bool VisitVectorCallAttr(VectorCallAttr *A) {
669 0 : return true;
670 : };
671 : bool TraverseVisibilityAttr(VisibilityAttr *A);
672 : bool VisitVisibilityAttr(VisibilityAttr *A) {
673 0 : return true;
674 : };
675 : bool TraverseWarnUnusedAttr(WarnUnusedAttr *A);
676 : bool VisitWarnUnusedAttr(WarnUnusedAttr *A) {
677 0 : return true;
678 : };
679 : bool TraverseWarnUnusedResultAttr(WarnUnusedResultAttr *A);
680 : bool VisitWarnUnusedResultAttr(WarnUnusedResultAttr *A) {
681 0 : return true;
682 : };
683 : bool TraverseWeakAttr(WeakAttr *A);
684 : bool VisitWeakAttr(WeakAttr *A) {
685 0 : return true;
686 : };
687 : bool TraverseWeakImportAttr(WeakImportAttr *A);
688 : bool VisitWeakImportAttr(WeakImportAttr *A) {
689 0 : return true;
690 : };
691 : bool TraverseWeakRefAttr(WeakRefAttr *A);
692 : bool VisitWeakRefAttr(WeakRefAttr *A) {
693 0 : return true;
694 : };
695 : bool TraverseWorkGroupSizeHintAttr(WorkGroupSizeHintAttr *A);
696 : bool VisitWorkGroupSizeHintAttr(WorkGroupSizeHintAttr *A) {
697 0 : return true;
698 : };
699 : bool TraverseX86ForceAlignArgPointerAttr(X86ForceAlignArgPointerAttr *A);
700 : bool VisitX86ForceAlignArgPointerAttr(X86ForceAlignArgPointerAttr *A) {
701 0 : return true;
702 : };
703 :
704 : #else // ATTR_VISITOR_DECLS_ONLY
705 :
706 : template <typename Derived>
707 : bool VISITORCLASS<Derived>::TraverseAMDGPUNumSGPRAttr(AMDGPUNumSGPRAttr *A) {
708 0 : if (!getDerived().VisitAttr(A))
709 0 : return false;
710 0 : if (!getDerived().VisitAMDGPUNumSGPRAttr(A))
711 0 : return false;
712 0 : return true;
713 0 : }
714 :
715 : template <typename Derived>
716 : bool VISITORCLASS<Derived>::TraverseAMDGPUNumVGPRAttr(AMDGPUNumVGPRAttr *A) {
717 0 : if (!getDerived().VisitAttr(A))
718 0 : return false;
719 0 : if (!getDerived().VisitAMDGPUNumVGPRAttr(A))
720 0 : return false;
721 0 : return true;
722 0 : }
723 :
724 : template <typename Derived>
725 : bool VISITORCLASS<Derived>::TraverseARMInterruptAttr(ARMInterruptAttr *A) {
726 0 : if (!getDerived().VisitAttr(A))
727 0 : return false;
728 0 : if (!getDerived().VisitARMInterruptAttr(A))
729 0 : return false;
730 0 : return true;
731 0 : }
732 :
733 : template <typename Derived>
734 : bool VISITORCLASS<Derived>::TraverseAcquireCapabilityAttr(AcquireCapabilityAttr *A) {
735 0 : if (!getDerived().VisitAttr(A))
736 0 : return false;
737 0 : if (!getDerived().VisitAcquireCapabilityAttr(A))
738 0 : return false;
739 : {
740 0 : Expr * *I = A->args_begin();
741 0 : Expr * *E = A->args_end();
742 0 : for (; I != E; ++I) {
743 0 : if (!getDerived().TraverseStmt(*I))
744 0 : return false;
745 0 : }
746 : }
747 0 : return true;
748 0 : }
749 :
750 : template <typename Derived>
751 : bool VISITORCLASS<Derived>::TraverseAcquiredAfterAttr(AcquiredAfterAttr *A) {
752 0 : if (!getDerived().VisitAttr(A))
753 0 : return false;
754 0 : if (!getDerived().VisitAcquiredAfterAttr(A))
755 0 : return false;
756 : {
757 0 : Expr * *I = A->args_begin();
758 0 : Expr * *E = A->args_end();
759 0 : for (; I != E; ++I) {
760 0 : if (!getDerived().TraverseStmt(*I))
761 0 : return false;
762 0 : }
763 : }
764 0 : return true;
765 0 : }
766 :
767 : template <typename Derived>
768 : bool VISITORCLASS<Derived>::TraverseAcquiredBeforeAttr(AcquiredBeforeAttr *A) {
769 0 : if (!getDerived().VisitAttr(A))
770 0 : return false;
771 0 : if (!getDerived().VisitAcquiredBeforeAttr(A))
772 0 : return false;
773 : {
774 0 : Expr * *I = A->args_begin();
775 0 : Expr * *E = A->args_end();
776 0 : for (; I != E; ++I) {
777 0 : if (!getDerived().TraverseStmt(*I))
778 0 : return false;
779 0 : }
780 : }
781 0 : return true;
782 0 : }
783 :
784 : template <typename Derived>
785 : bool VISITORCLASS<Derived>::TraverseAliasAttr(AliasAttr *A) {
786 0 : if (!getDerived().VisitAttr(A))
787 0 : return false;
788 0 : if (!getDerived().VisitAliasAttr(A))
789 0 : return false;
790 0 : return true;
791 0 : }
792 :
793 : template <typename Derived>
794 : bool VISITORCLASS<Derived>::TraverseAlignMac68kAttr(AlignMac68kAttr *A) {
795 0 : if (!getDerived().VisitAttr(A))
796 0 : return false;
797 0 : if (!getDerived().VisitAlignMac68kAttr(A))
798 0 : return false;
799 0 : return true;
800 0 : }
801 :
802 : template <typename Derived>
803 : bool VISITORCLASS<Derived>::TraverseAlignValueAttr(AlignValueAttr *A) {
804 0 : if (!getDerived().VisitAttr(A))
805 0 : return false;
806 0 : if (!getDerived().VisitAlignValueAttr(A))
807 0 : return false;
808 0 : if (!getDerived().TraverseStmt(A->getAlignment()))
809 0 : return false;
810 0 : return true;
811 0 : }
812 :
813 : template <typename Derived>
814 : bool VISITORCLASS<Derived>::TraverseAlignedAttr(AlignedAttr *A) {
815 0 : if (!getDerived().VisitAttr(A))
816 0 : return false;
817 0 : if (!getDerived().VisitAlignedAttr(A))
818 0 : return false;
819 0 : return true;
820 0 : }
821 :
822 : template <typename Derived>
823 : bool VISITORCLASS<Derived>::TraverseAlwaysInlineAttr(AlwaysInlineAttr *A) {
824 0 : if (!getDerived().VisitAttr(A))
825 0 : return false;
826 0 : if (!getDerived().VisitAlwaysInlineAttr(A))
827 0 : return false;
828 0 : return true;
829 0 : }
830 :
831 : template <typename Derived>
832 : bool VISITORCLASS<Derived>::TraverseAnalyzerNoReturnAttr(AnalyzerNoReturnAttr *A) {
833 0 : if (!getDerived().VisitAttr(A))
834 0 : return false;
835 0 : if (!getDerived().VisitAnalyzerNoReturnAttr(A))
836 0 : return false;
837 0 : return true;
838 0 : }
839 :
840 : template <typename Derived>
841 : bool VISITORCLASS<Derived>::TraverseAnnotateAttr(AnnotateAttr *A) {
842 0 : if (!getDerived().VisitAttr(A))
843 0 : return false;
844 0 : if (!getDerived().VisitAnnotateAttr(A))
845 0 : return false;
846 0 : return true;
847 0 : }
848 :
849 : template <typename Derived>
850 : bool VISITORCLASS<Derived>::TraverseArcWeakrefUnavailableAttr(ArcWeakrefUnavailableAttr *A) {
851 0 : if (!getDerived().VisitAttr(A))
852 0 : return false;
853 0 : if (!getDerived().VisitArcWeakrefUnavailableAttr(A))
854 0 : return false;
855 0 : return true;
856 0 : }
857 :
858 : template <typename Derived>
859 : bool VISITORCLASS<Derived>::TraverseArgumentWithTypeTagAttr(ArgumentWithTypeTagAttr *A) {
860 0 : if (!getDerived().VisitAttr(A))
861 0 : return false;
862 0 : if (!getDerived().VisitArgumentWithTypeTagAttr(A))
863 0 : return false;
864 0 : return true;
865 0 : }
866 :
867 : template <typename Derived>
868 : bool VISITORCLASS<Derived>::TraverseAsmLabelAttr(AsmLabelAttr *A) {
869 0 : if (!getDerived().VisitAttr(A))
870 0 : return false;
871 0 : if (!getDerived().VisitAsmLabelAttr(A))
872 0 : return false;
873 0 : return true;
874 0 : }
875 :
876 : template <typename Derived>
877 : bool VISITORCLASS<Derived>::TraverseAssertCapabilityAttr(AssertCapabilityAttr *A) {
878 0 : if (!getDerived().VisitAttr(A))
879 0 : return false;
880 0 : if (!getDerived().VisitAssertCapabilityAttr(A))
881 0 : return false;
882 0 : if (!getDerived().TraverseStmt(A->getExpr()))
883 0 : return false;
884 0 : return true;
885 0 : }
886 :
887 : template <typename Derived>
888 : bool VISITORCLASS<Derived>::TraverseAssertExclusiveLockAttr(AssertExclusiveLockAttr *A) {
889 0 : if (!getDerived().VisitAttr(A))
890 0 : return false;
891 0 : if (!getDerived().VisitAssertExclusiveLockAttr(A))
892 0 : return false;
893 : {
894 0 : Expr * *I = A->args_begin();
895 0 : Expr * *E = A->args_end();
896 0 : for (; I != E; ++I) {
897 0 : if (!getDerived().TraverseStmt(*I))
898 0 : return false;
899 0 : }
900 : }
901 0 : return true;
902 0 : }
903 :
904 : template <typename Derived>
905 : bool VISITORCLASS<Derived>::TraverseAssertSharedLockAttr(AssertSharedLockAttr *A) {
906 0 : if (!getDerived().VisitAttr(A))
907 0 : return false;
908 0 : if (!getDerived().VisitAssertSharedLockAttr(A))
909 0 : return false;
910 : {
911 0 : Expr * *I = A->args_begin();
912 0 : Expr * *E = A->args_end();
913 0 : for (; I != E; ++I) {
914 0 : if (!getDerived().TraverseStmt(*I))
915 0 : return false;
916 0 : }
917 : }
918 0 : return true;
919 0 : }
920 :
921 : template <typename Derived>
922 : bool VISITORCLASS<Derived>::TraverseAssumeAlignedAttr(AssumeAlignedAttr *A) {
923 0 : if (!getDerived().VisitAttr(A))
924 0 : return false;
925 0 : if (!getDerived().VisitAssumeAlignedAttr(A))
926 0 : return false;
927 0 : if (!getDerived().TraverseStmt(A->getAlignment()))
928 0 : return false;
929 0 : if (!getDerived().TraverseStmt(A->getOffset()))
930 0 : return false;
931 0 : return true;
932 0 : }
933 :
934 : template <typename Derived>
935 : bool VISITORCLASS<Derived>::TraverseAvailabilityAttr(AvailabilityAttr *A) {
936 0 : if (!getDerived().VisitAttr(A))
937 0 : return false;
938 0 : if (!getDerived().VisitAvailabilityAttr(A))
939 0 : return false;
940 0 : return true;
941 0 : }
942 :
943 : template <typename Derived>
944 : bool VISITORCLASS<Derived>::TraverseBlocksAttr(BlocksAttr *A) {
945 0 : if (!getDerived().VisitAttr(A))
946 0 : return false;
947 0 : if (!getDerived().VisitBlocksAttr(A))
948 0 : return false;
949 0 : return true;
950 0 : }
951 :
952 : template <typename Derived>
953 : bool VISITORCLASS<Derived>::TraverseC11NoReturnAttr(C11NoReturnAttr *A) {
954 0 : if (!getDerived().VisitAttr(A))
955 0 : return false;
956 0 : if (!getDerived().VisitC11NoReturnAttr(A))
957 0 : return false;
958 0 : return true;
959 0 : }
960 :
961 : template <typename Derived>
962 : bool VISITORCLASS<Derived>::TraverseCDeclAttr(CDeclAttr *A) {
963 0 : if (!getDerived().VisitAttr(A))
964 0 : return false;
965 0 : if (!getDerived().VisitCDeclAttr(A))
966 0 : return false;
967 0 : return true;
968 0 : }
969 :
970 : template <typename Derived>
971 : bool VISITORCLASS<Derived>::TraverseCFAuditedTransferAttr(CFAuditedTransferAttr *A) {
972 0 : if (!getDerived().VisitAttr(A))
973 0 : return false;
974 0 : if (!getDerived().VisitCFAuditedTransferAttr(A))
975 0 : return false;
976 0 : return true;
977 0 : }
978 :
979 : template <typename Derived>
980 : bool VISITORCLASS<Derived>::TraverseCFConsumedAttr(CFConsumedAttr *A) {
981 0 : if (!getDerived().VisitAttr(A))
982 0 : return false;
983 0 : if (!getDerived().VisitCFConsumedAttr(A))
984 0 : return false;
985 0 : return true;
986 0 : }
987 :
988 : template <typename Derived>
989 : bool VISITORCLASS<Derived>::TraverseCFReturnsNotRetainedAttr(CFReturnsNotRetainedAttr *A) {
990 0 : if (!getDerived().VisitAttr(A))
991 0 : return false;
992 0 : if (!getDerived().VisitCFReturnsNotRetainedAttr(A))
993 0 : return false;
994 0 : return true;
995 0 : }
996 :
997 : template <typename Derived>
998 : bool VISITORCLASS<Derived>::TraverseCFReturnsRetainedAttr(CFReturnsRetainedAttr *A) {
999 0 : if (!getDerived().VisitAttr(A))
1000 0 : return false;
1001 0 : if (!getDerived().VisitCFReturnsRetainedAttr(A))
1002 0 : return false;
1003 0 : return true;
1004 0 : }
1005 :
1006 : template <typename Derived>
1007 : bool VISITORCLASS<Derived>::TraverseCFUnknownTransferAttr(CFUnknownTransferAttr *A) {
1008 0 : if (!getDerived().VisitAttr(A))
1009 0 : return false;
1010 0 : if (!getDerived().VisitCFUnknownTransferAttr(A))
1011 0 : return false;
1012 0 : return true;
1013 0 : }
1014 :
1015 : template <typename Derived>
1016 : bool VISITORCLASS<Derived>::TraverseCUDAConstantAttr(CUDAConstantAttr *A) {
1017 0 : if (!getDerived().VisitAttr(A))
1018 0 : return false;
1019 0 : if (!getDerived().VisitCUDAConstantAttr(A))
1020 0 : return false;
1021 0 : return true;
1022 0 : }
1023 :
1024 : template <typename Derived>
1025 : bool VISITORCLASS<Derived>::TraverseCUDADeviceAttr(CUDADeviceAttr *A) {
1026 0 : if (!getDerived().VisitAttr(A))
1027 0 : return false;
1028 0 : if (!getDerived().VisitCUDADeviceAttr(A))
1029 0 : return false;
1030 0 : return true;
1031 0 : }
1032 :
1033 : template <typename Derived>
1034 : bool VISITORCLASS<Derived>::TraverseCUDAGlobalAttr(CUDAGlobalAttr *A) {
1035 0 : if (!getDerived().VisitAttr(A))
1036 0 : return false;
1037 0 : if (!getDerived().VisitCUDAGlobalAttr(A))
1038 0 : return false;
1039 0 : return true;
1040 0 : }
1041 :
1042 : template <typename Derived>
1043 : bool VISITORCLASS<Derived>::TraverseCUDAHostAttr(CUDAHostAttr *A) {
1044 0 : if (!getDerived().VisitAttr(A))
1045 0 : return false;
1046 0 : if (!getDerived().VisitCUDAHostAttr(A))
1047 0 : return false;
1048 0 : return true;
1049 0 : }
1050 :
1051 : template <typename Derived>
1052 : bool VISITORCLASS<Derived>::TraverseCUDAInvalidTargetAttr(CUDAInvalidTargetAttr *A) {
1053 0 : if (!getDerived().VisitAttr(A))
1054 0 : return false;
1055 0 : if (!getDerived().VisitCUDAInvalidTargetAttr(A))
1056 0 : return false;
1057 0 : return true;
1058 0 : }
1059 :
1060 : template <typename Derived>
1061 : bool VISITORCLASS<Derived>::TraverseCUDALaunchBoundsAttr(CUDALaunchBoundsAttr *A) {
1062 0 : if (!getDerived().VisitAttr(A))
1063 0 : return false;
1064 0 : if (!getDerived().VisitCUDALaunchBoundsAttr(A))
1065 0 : return false;
1066 0 : if (!getDerived().TraverseStmt(A->getMaxThreads()))
1067 0 : return false;
1068 0 : if (!getDerived().TraverseStmt(A->getMinBlocks()))
1069 0 : return false;
1070 0 : return true;
1071 0 : }
1072 :
1073 : template <typename Derived>
1074 : bool VISITORCLASS<Derived>::TraverseCUDASharedAttr(CUDASharedAttr *A) {
1075 0 : if (!getDerived().VisitAttr(A))
1076 0 : return false;
1077 0 : if (!getDerived().VisitCUDASharedAttr(A))
1078 0 : return false;
1079 0 : return true;
1080 0 : }
1081 :
1082 : template <typename Derived>
1083 : bool VISITORCLASS<Derived>::TraverseCXX11NoReturnAttr(CXX11NoReturnAttr *A) {
1084 0 : if (!getDerived().VisitAttr(A))
1085 0 : return false;
1086 0 : if (!getDerived().VisitCXX11NoReturnAttr(A))
1087 0 : return false;
1088 0 : return true;
1089 0 : }
1090 :
1091 : template <typename Derived>
1092 : bool VISITORCLASS<Derived>::TraverseCallableWhenAttr(CallableWhenAttr *A) {
1093 0 : if (!getDerived().VisitAttr(A))
1094 0 : return false;
1095 0 : if (!getDerived().VisitCallableWhenAttr(A))
1096 0 : return false;
1097 0 : return true;
1098 0 : }
1099 :
1100 : template <typename Derived>
1101 : bool VISITORCLASS<Derived>::TraverseCapabilityAttr(CapabilityAttr *A) {
1102 0 : if (!getDerived().VisitAttr(A))
1103 0 : return false;
1104 0 : if (!getDerived().VisitCapabilityAttr(A))
1105 0 : return false;
1106 0 : return true;
1107 0 : }
1108 :
1109 : template <typename Derived>
1110 : bool VISITORCLASS<Derived>::TraverseCapturedRecordAttr(CapturedRecordAttr *A) {
1111 0 : if (!getDerived().VisitAttr(A))
1112 0 : return false;
1113 0 : if (!getDerived().VisitCapturedRecordAttr(A))
1114 0 : return false;
1115 0 : return true;
1116 0 : }
1117 :
1118 : template <typename Derived>
1119 : bool VISITORCLASS<Derived>::TraverseCarriesDependencyAttr(CarriesDependencyAttr *A) {
1120 0 : if (!getDerived().VisitAttr(A))
1121 0 : return false;
1122 0 : if (!getDerived().VisitCarriesDependencyAttr(A))
1123 0 : return false;
1124 0 : return true;
1125 0 : }
1126 :
1127 : template <typename Derived>
1128 : bool VISITORCLASS<Derived>::TraverseCleanupAttr(CleanupAttr *A) {
1129 0 : if (!getDerived().VisitAttr(A))
1130 0 : return false;
1131 0 : if (!getDerived().VisitCleanupAttr(A))
1132 0 : return false;
1133 0 : return true;
1134 0 : }
1135 :
1136 : template <typename Derived>
1137 : bool VISITORCLASS<Derived>::TraverseColdAttr(ColdAttr *A) {
1138 0 : if (!getDerived().VisitAttr(A))
1139 0 : return false;
1140 0 : if (!getDerived().VisitColdAttr(A))
1141 0 : return false;
1142 0 : return true;
1143 0 : }
1144 :
1145 : template <typename Derived>
1146 : bool VISITORCLASS<Derived>::TraverseCommonAttr(CommonAttr *A) {
1147 0 : if (!getDerived().VisitAttr(A))
1148 0 : return false;
1149 0 : if (!getDerived().VisitCommonAttr(A))
1150 0 : return false;
1151 0 : return true;
1152 0 : }
1153 :
1154 : template <typename Derived>
1155 : bool VISITORCLASS<Derived>::TraverseConstAttr(ConstAttr *A) {
1156 0 : if (!getDerived().VisitAttr(A))
1157 0 : return false;
1158 0 : if (!getDerived().VisitConstAttr(A))
1159 0 : return false;
1160 0 : return true;
1161 0 : }
1162 :
1163 : template <typename Derived>
1164 : bool VISITORCLASS<Derived>::TraverseConstructorAttr(ConstructorAttr *A) {
1165 0 : if (!getDerived().VisitAttr(A))
1166 0 : return false;
1167 0 : if (!getDerived().VisitConstructorAttr(A))
1168 0 : return false;
1169 0 : return true;
1170 0 : }
1171 :
1172 : template <typename Derived>
1173 : bool VISITORCLASS<Derived>::TraverseConsumableAttr(ConsumableAttr *A) {
1174 0 : if (!getDerived().VisitAttr(A))
1175 0 : return false;
1176 0 : if (!getDerived().VisitConsumableAttr(A))
1177 0 : return false;
1178 0 : return true;
1179 0 : }
1180 :
1181 : template <typename Derived>
1182 : bool VISITORCLASS<Derived>::TraverseConsumableAutoCastAttr(ConsumableAutoCastAttr *A) {
1183 0 : if (!getDerived().VisitAttr(A))
1184 0 : return false;
1185 0 : if (!getDerived().VisitConsumableAutoCastAttr(A))
1186 0 : return false;
1187 0 : return true;
1188 0 : }
1189 :
1190 : template <typename Derived>
1191 : bool VISITORCLASS<Derived>::TraverseConsumableSetOnReadAttr(ConsumableSetOnReadAttr *A) {
1192 0 : if (!getDerived().VisitAttr(A))
1193 0 : return false;
1194 0 : if (!getDerived().VisitConsumableSetOnReadAttr(A))
1195 0 : return false;
1196 0 : return true;
1197 0 : }
1198 :
1199 : template <typename Derived>
1200 : bool VISITORCLASS<Derived>::TraverseDLLExportAttr(DLLExportAttr *A) {
1201 0 : if (!getDerived().VisitAttr(A))
1202 0 : return false;
1203 0 : if (!getDerived().VisitDLLExportAttr(A))
1204 0 : return false;
1205 0 : return true;
1206 0 : }
1207 :
1208 : template <typename Derived>
1209 : bool VISITORCLASS<Derived>::TraverseDLLImportAttr(DLLImportAttr *A) {
1210 0 : if (!getDerived().VisitAttr(A))
1211 0 : return false;
1212 0 : if (!getDerived().VisitDLLImportAttr(A))
1213 0 : return false;
1214 0 : return true;
1215 0 : }
1216 :
1217 : template <typename Derived>
1218 : bool VISITORCLASS<Derived>::TraverseDeprecatedAttr(DeprecatedAttr *A) {
1219 0 : if (!getDerived().VisitAttr(A))
1220 0 : return false;
1221 0 : if (!getDerived().VisitDeprecatedAttr(A))
1222 0 : return false;
1223 0 : return true;
1224 0 : }
1225 :
1226 : template <typename Derived>
1227 : bool VISITORCLASS<Derived>::TraverseDestructorAttr(DestructorAttr *A) {
1228 0 : if (!getDerived().VisitAttr(A))
1229 0 : return false;
1230 0 : if (!getDerived().VisitDestructorAttr(A))
1231 0 : return false;
1232 0 : return true;
1233 0 : }
1234 :
1235 : template <typename Derived>
1236 : bool VISITORCLASS<Derived>::TraverseEnableIfAttr(EnableIfAttr *A) {
1237 0 : if (!getDerived().VisitAttr(A))
1238 0 : return false;
1239 0 : if (!getDerived().VisitEnableIfAttr(A))
1240 0 : return false;
1241 0 : if (!getDerived().TraverseStmt(A->getCond()))
1242 0 : return false;
1243 0 : return true;
1244 0 : }
1245 :
1246 : template <typename Derived>
1247 : bool VISITORCLASS<Derived>::TraverseExclusiveTrylockFunctionAttr(ExclusiveTrylockFunctionAttr *A) {
1248 0 : if (!getDerived().VisitAttr(A))
1249 0 : return false;
1250 0 : if (!getDerived().VisitExclusiveTrylockFunctionAttr(A))
1251 0 : return false;
1252 0 : if (!getDerived().TraverseStmt(A->getSuccessValue()))
1253 0 : return false;
1254 : {
1255 0 : Expr * *I = A->args_begin();
1256 0 : Expr * *E = A->args_end();
1257 0 : for (; I != E; ++I) {
1258 0 : if (!getDerived().TraverseStmt(*I))
1259 0 : return false;
1260 0 : }
1261 : }
1262 0 : return true;
1263 0 : }
1264 :
1265 : template <typename Derived>
1266 : bool VISITORCLASS<Derived>::TraverseFallThroughAttr(FallThroughAttr *A) {
1267 0 : if (!getDerived().VisitAttr(A))
1268 0 : return false;
1269 0 : if (!getDerived().VisitFallThroughAttr(A))
1270 0 : return false;
1271 0 : return true;
1272 0 : }
1273 :
1274 : template <typename Derived>
1275 : bool VISITORCLASS<Derived>::TraverseFastCallAttr(FastCallAttr *A) {
1276 0 : if (!getDerived().VisitAttr(A))
1277 0 : return false;
1278 0 : if (!getDerived().VisitFastCallAttr(A))
1279 0 : return false;
1280 0 : return true;
1281 0 : }
1282 :
1283 : template <typename Derived>
1284 : bool VISITORCLASS<Derived>::TraverseFinalAttr(FinalAttr *A) {
1285 0 : if (!getDerived().VisitAttr(A))
1286 0 : return false;
1287 0 : if (!getDerived().VisitFinalAttr(A))
1288 0 : return false;
1289 0 : return true;
1290 0 : }
1291 :
1292 : template <typename Derived>
1293 : bool VISITORCLASS<Derived>::TraverseFlagEnumAttr(FlagEnumAttr *A) {
1294 0 : if (!getDerived().VisitAttr(A))
1295 0 : return false;
1296 0 : if (!getDerived().VisitFlagEnumAttr(A))
1297 0 : return false;
1298 0 : return true;
1299 0 : }
1300 :
1301 : template <typename Derived>
1302 : bool VISITORCLASS<Derived>::TraverseFlattenAttr(FlattenAttr *A) {
1303 0 : if (!getDerived().VisitAttr(A))
1304 0 : return false;
1305 0 : if (!getDerived().VisitFlattenAttr(A))
1306 0 : return false;
1307 0 : return true;
1308 0 : }
1309 :
1310 : template <typename Derived>
1311 : bool VISITORCLASS<Derived>::TraverseFormatAttr(FormatAttr *A) {
1312 0 : if (!getDerived().VisitAttr(A))
1313 0 : return false;
1314 0 : if (!getDerived().VisitFormatAttr(A))
1315 0 : return false;
1316 0 : return true;
1317 0 : }
1318 :
1319 : template <typename Derived>
1320 : bool VISITORCLASS<Derived>::TraverseFormatArgAttr(FormatArgAttr *A) {
1321 0 : if (!getDerived().VisitAttr(A))
1322 0 : return false;
1323 0 : if (!getDerived().VisitFormatArgAttr(A))
1324 0 : return false;
1325 0 : return true;
1326 0 : }
1327 :
1328 : template <typename Derived>
1329 : bool VISITORCLASS<Derived>::TraverseGNUInlineAttr(GNUInlineAttr *A) {
1330 0 : if (!getDerived().VisitAttr(A))
1331 0 : return false;
1332 0 : if (!getDerived().VisitGNUInlineAttr(A))
1333 0 : return false;
1334 0 : return true;
1335 0 : }
1336 :
1337 : template <typename Derived>
1338 : bool VISITORCLASS<Derived>::TraverseGuardedByAttr(GuardedByAttr *A) {
1339 0 : if (!getDerived().VisitAttr(A))
1340 0 : return false;
1341 0 : if (!getDerived().VisitGuardedByAttr(A))
1342 0 : return false;
1343 0 : if (!getDerived().TraverseStmt(A->getArg()))
1344 0 : return false;
1345 0 : return true;
1346 0 : }
1347 :
1348 : template <typename Derived>
1349 : bool VISITORCLASS<Derived>::TraverseGuardedVarAttr(GuardedVarAttr *A) {
1350 0 : if (!getDerived().VisitAttr(A))
1351 0 : return false;
1352 0 : if (!getDerived().VisitGuardedVarAttr(A))
1353 0 : return false;
1354 0 : return true;
1355 0 : }
1356 :
1357 : template <typename Derived>
1358 : bool VISITORCLASS<Derived>::TraverseHotAttr(HotAttr *A) {
1359 0 : if (!getDerived().VisitAttr(A))
1360 0 : return false;
1361 0 : if (!getDerived().VisitHotAttr(A))
1362 0 : return false;
1363 0 : return true;
1364 0 : }
1365 :
1366 : template <typename Derived>
1367 : bool VISITORCLASS<Derived>::TraverseIBActionAttr(IBActionAttr *A) {
1368 0 : if (!getDerived().VisitAttr(A))
1369 0 : return false;
1370 0 : if (!getDerived().VisitIBActionAttr(A))
1371 0 : return false;
1372 0 : return true;
1373 0 : }
1374 :
1375 : template <typename Derived>
1376 : bool VISITORCLASS<Derived>::TraverseIBOutletAttr(IBOutletAttr *A) {
1377 0 : if (!getDerived().VisitAttr(A))
1378 0 : return false;
1379 0 : if (!getDerived().VisitIBOutletAttr(A))
1380 0 : return false;
1381 0 : return true;
1382 0 : }
1383 :
1384 : template <typename Derived>
1385 : bool VISITORCLASS<Derived>::TraverseIBOutletCollectionAttr(IBOutletCollectionAttr *A) {
1386 0 : if (!getDerived().VisitAttr(A))
1387 0 : return false;
1388 0 : if (!getDerived().VisitIBOutletCollectionAttr(A))
1389 0 : return false;
1390 0 : return true;
1391 0 : }
1392 :
1393 : template <typename Derived>
1394 : bool VISITORCLASS<Derived>::TraverseInitPriorityAttr(InitPriorityAttr *A) {
1395 0 : if (!getDerived().VisitAttr(A))
1396 0 : return false;
1397 0 : if (!getDerived().VisitInitPriorityAttr(A))
1398 0 : return false;
1399 0 : return true;
1400 0 : }
1401 :
1402 : template <typename Derived>
1403 : bool VISITORCLASS<Derived>::TraverseInitSegAttr(InitSegAttr *A) {
1404 0 : if (!getDerived().VisitAttr(A))
1405 0 : return false;
1406 0 : if (!getDerived().VisitInitSegAttr(A))
1407 0 : return false;
1408 0 : return true;
1409 0 : }
1410 :
1411 : template <typename Derived>
1412 : bool VISITORCLASS<Derived>::TraverseIntelOclBiccAttr(IntelOclBiccAttr *A) {
1413 0 : if (!getDerived().VisitAttr(A))
1414 0 : return false;
1415 0 : if (!getDerived().VisitIntelOclBiccAttr(A))
1416 0 : return false;
1417 0 : return true;
1418 0 : }
1419 :
1420 : template <typename Derived>
1421 : bool VISITORCLASS<Derived>::TraverseLockReturnedAttr(LockReturnedAttr *A) {
1422 0 : if (!getDerived().VisitAttr(A))
1423 0 : return false;
1424 0 : if (!getDerived().VisitLockReturnedAttr(A))
1425 0 : return false;
1426 0 : if (!getDerived().TraverseStmt(A->getArg()))
1427 0 : return false;
1428 0 : return true;
1429 0 : }
1430 :
1431 : template <typename Derived>
1432 : bool VISITORCLASS<Derived>::TraverseLocksExcludedAttr(LocksExcludedAttr *A) {
1433 0 : if (!getDerived().VisitAttr(A))
1434 0 : return false;
1435 0 : if (!getDerived().VisitLocksExcludedAttr(A))
1436 0 : return false;
1437 : {
1438 0 : Expr * *I = A->args_begin();
1439 0 : Expr * *E = A->args_end();
1440 0 : for (; I != E; ++I) {
1441 0 : if (!getDerived().TraverseStmt(*I))
1442 0 : return false;
1443 0 : }
1444 : }
1445 0 : return true;
1446 0 : }
1447 :
1448 : template <typename Derived>
1449 : bool VISITORCLASS<Derived>::TraverseLoopHintAttr(LoopHintAttr *A) {
1450 0 : if (!getDerived().VisitAttr(A))
1451 0 : return false;
1452 0 : if (!getDerived().VisitLoopHintAttr(A))
1453 0 : return false;
1454 0 : if (!getDerived().TraverseStmt(A->getValue()))
1455 0 : return false;
1456 0 : return true;
1457 0 : }
1458 :
1459 : template <typename Derived>
1460 : bool VISITORCLASS<Derived>::TraverseMSABIAttr(MSABIAttr *A) {
1461 0 : if (!getDerived().VisitAttr(A))
1462 0 : return false;
1463 0 : if (!getDerived().VisitMSABIAttr(A))
1464 0 : return false;
1465 0 : return true;
1466 0 : }
1467 :
1468 : template <typename Derived>
1469 : bool VISITORCLASS<Derived>::TraverseMSInheritanceAttr(MSInheritanceAttr *A) {
1470 0 : if (!getDerived().VisitAttr(A))
1471 0 : return false;
1472 0 : if (!getDerived().VisitMSInheritanceAttr(A))
1473 0 : return false;
1474 0 : return true;
1475 0 : }
1476 :
1477 : template <typename Derived>
1478 : bool VISITORCLASS<Derived>::TraverseMSNoVTableAttr(MSNoVTableAttr *A) {
1479 0 : if (!getDerived().VisitAttr(A))
1480 0 : return false;
1481 0 : if (!getDerived().VisitMSNoVTableAttr(A))
1482 0 : return false;
1483 0 : return true;
1484 0 : }
1485 :
1486 : template <typename Derived>
1487 : bool VISITORCLASS<Derived>::TraverseMSP430InterruptAttr(MSP430InterruptAttr *A) {
1488 0 : if (!getDerived().VisitAttr(A))
1489 0 : return false;
1490 0 : if (!getDerived().VisitMSP430InterruptAttr(A))
1491 0 : return false;
1492 0 : return true;
1493 0 : }
1494 :
1495 : template <typename Derived>
1496 : bool VISITORCLASS<Derived>::TraverseMSStructAttr(MSStructAttr *A) {
1497 0 : if (!getDerived().VisitAttr(A))
1498 0 : return false;
1499 0 : if (!getDerived().VisitMSStructAttr(A))
1500 0 : return false;
1501 0 : return true;
1502 0 : }
1503 :
1504 : template <typename Derived>
1505 : bool VISITORCLASS<Derived>::TraverseMSVtorDispAttr(MSVtorDispAttr *A) {
1506 0 : if (!getDerived().VisitAttr(A))
1507 0 : return false;
1508 0 : if (!getDerived().VisitMSVtorDispAttr(A))
1509 0 : return false;
1510 0 : return true;
1511 0 : }
1512 :
1513 : template <typename Derived>
1514 : bool VISITORCLASS<Derived>::TraverseMaxFieldAlignmentAttr(MaxFieldAlignmentAttr *A) {
1515 0 : if (!getDerived().VisitAttr(A))
1516 0 : return false;
1517 0 : if (!getDerived().VisitMaxFieldAlignmentAttr(A))
1518 0 : return false;
1519 0 : return true;
1520 0 : }
1521 :
1522 : template <typename Derived>
1523 : bool VISITORCLASS<Derived>::TraverseMayAliasAttr(MayAliasAttr *A) {
1524 0 : if (!getDerived().VisitAttr(A))
1525 0 : return false;
1526 0 : if (!getDerived().VisitMayAliasAttr(A))
1527 0 : return false;
1528 0 : return true;
1529 0 : }
1530 :
1531 : template <typename Derived>
1532 : bool VISITORCLASS<Derived>::TraverseMinSizeAttr(MinSizeAttr *A) {
1533 0 : if (!getDerived().VisitAttr(A))
1534 0 : return false;
1535 0 : if (!getDerived().VisitMinSizeAttr(A))
1536 0 : return false;
1537 0 : return true;
1538 0 : }
1539 :
1540 : template <typename Derived>
1541 : bool VISITORCLASS<Derived>::TraverseMips16Attr(Mips16Attr *A) {
1542 0 : if (!getDerived().VisitAttr(A))
1543 0 : return false;
1544 0 : if (!getDerived().VisitMips16Attr(A))
1545 0 : return false;
1546 0 : return true;
1547 0 : }
1548 :
1549 : template <typename Derived>
1550 : bool VISITORCLASS<Derived>::TraverseModeAttr(ModeAttr *A) {
1551 0 : if (!getDerived().VisitAttr(A))
1552 0 : return false;
1553 0 : if (!getDerived().VisitModeAttr(A))
1554 0 : return false;
1555 0 : return true;
1556 0 : }
1557 :
1558 : template <typename Derived>
1559 : bool VISITORCLASS<Derived>::TraverseNSConsumedAttr(NSConsumedAttr *A) {
1560 0 : if (!getDerived().VisitAttr(A))
1561 0 : return false;
1562 0 : if (!getDerived().VisitNSConsumedAttr(A))
1563 0 : return false;
1564 0 : return true;
1565 0 : }
1566 :
1567 : template <typename Derived>
1568 : bool VISITORCLASS<Derived>::TraverseNSConsumesSelfAttr(NSConsumesSelfAttr *A) {
1569 0 : if (!getDerived().VisitAttr(A))
1570 0 : return false;
1571 0 : if (!getDerived().VisitNSConsumesSelfAttr(A))
1572 0 : return false;
1573 0 : return true;
1574 0 : }
1575 :
1576 : template <typename Derived>
1577 : bool VISITORCLASS<Derived>::TraverseNSReturnsAutoreleasedAttr(NSReturnsAutoreleasedAttr *A) {
1578 0 : if (!getDerived().VisitAttr(A))
1579 0 : return false;
1580 0 : if (!getDerived().VisitNSReturnsAutoreleasedAttr(A))
1581 0 : return false;
1582 0 : return true;
1583 0 : }
1584 :
1585 : template <typename Derived>
1586 : bool VISITORCLASS<Derived>::TraverseNSReturnsNotRetainedAttr(NSReturnsNotRetainedAttr *A) {
1587 0 : if (!getDerived().VisitAttr(A))
1588 0 : return false;
1589 0 : if (!getDerived().VisitNSReturnsNotRetainedAttr(A))
1590 0 : return false;
1591 0 : return true;
1592 0 : }
1593 :
1594 : template <typename Derived>
1595 : bool VISITORCLASS<Derived>::TraverseNSReturnsRetainedAttr(NSReturnsRetainedAttr *A) {
1596 0 : if (!getDerived().VisitAttr(A))
1597 0 : return false;
1598 0 : if (!getDerived().VisitNSReturnsRetainedAttr(A))
1599 0 : return false;
1600 0 : return true;
1601 0 : }
1602 :
1603 : template <typename Derived>
1604 : bool VISITORCLASS<Derived>::TraverseNakedAttr(NakedAttr *A) {
1605 0 : if (!getDerived().VisitAttr(A))
1606 0 : return false;
1607 0 : if (!getDerived().VisitNakedAttr(A))
1608 0 : return false;
1609 0 : return true;
1610 0 : }
1611 :
1612 : template <typename Derived>
1613 : bool VISITORCLASS<Derived>::TraverseNoCommonAttr(NoCommonAttr *A) {
1614 0 : if (!getDerived().VisitAttr(A))
1615 0 : return false;
1616 0 : if (!getDerived().VisitNoCommonAttr(A))
1617 0 : return false;
1618 0 : return true;
1619 0 : }
1620 :
1621 : template <typename Derived>
1622 : bool VISITORCLASS<Derived>::TraverseNoDebugAttr(NoDebugAttr *A) {
1623 0 : if (!getDerived().VisitAttr(A))
1624 0 : return false;
1625 0 : if (!getDerived().VisitNoDebugAttr(A))
1626 0 : return false;
1627 0 : return true;
1628 0 : }
1629 :
1630 : template <typename Derived>
1631 : bool VISITORCLASS<Derived>::TraverseNoDuplicateAttr(NoDuplicateAttr *A) {
1632 0 : if (!getDerived().VisitAttr(A))
1633 0 : return false;
1634 0 : if (!getDerived().VisitNoDuplicateAttr(A))
1635 0 : return false;
1636 0 : return true;
1637 0 : }
1638 :
1639 : template <typename Derived>
1640 : bool VISITORCLASS<Derived>::TraverseNoInlineAttr(NoInlineAttr *A) {
1641 0 : if (!getDerived().VisitAttr(A))
1642 0 : return false;
1643 0 : if (!getDerived().VisitNoInlineAttr(A))
1644 0 : return false;
1645 0 : return true;
1646 0 : }
1647 :
1648 : template <typename Derived>
1649 : bool VISITORCLASS<Derived>::TraverseNoInstrumentFunctionAttr(NoInstrumentFunctionAttr *A) {
1650 0 : if (!getDerived().VisitAttr(A))
1651 0 : return false;
1652 0 : if (!getDerived().VisitNoInstrumentFunctionAttr(A))
1653 0 : return false;
1654 0 : return true;
1655 0 : }
1656 :
1657 : template <typename Derived>
1658 : bool VISITORCLASS<Derived>::TraverseNoMips16Attr(NoMips16Attr *A) {
1659 0 : if (!getDerived().VisitAttr(A))
1660 0 : return false;
1661 0 : if (!getDerived().VisitNoMips16Attr(A))
1662 0 : return false;
1663 0 : return true;
1664 0 : }
1665 :
1666 : template <typename Derived>
1667 : bool VISITORCLASS<Derived>::TraverseNoReturnAttr(NoReturnAttr *A) {
1668 0 : if (!getDerived().VisitAttr(A))
1669 0 : return false;
1670 0 : if (!getDerived().VisitNoReturnAttr(A))
1671 0 : return false;
1672 0 : return true;
1673 0 : }
1674 :
1675 : template <typename Derived>
1676 : bool VISITORCLASS<Derived>::TraverseNoSanitizeAttr(NoSanitizeAttr *A) {
1677 0 : if (!getDerived().VisitAttr(A))
1678 0 : return false;
1679 0 : if (!getDerived().VisitNoSanitizeAttr(A))
1680 0 : return false;
1681 0 : return true;
1682 0 : }
1683 :
1684 : template <typename Derived>
1685 : bool VISITORCLASS<Derived>::TraverseNoSplitStackAttr(NoSplitStackAttr *A) {
1686 0 : if (!getDerived().VisitAttr(A))
1687 0 : return false;
1688 0 : if (!getDerived().VisitNoSplitStackAttr(A))
1689 0 : return false;
1690 0 : return true;
1691 0 : }
1692 :
1693 : template <typename Derived>
1694 : bool VISITORCLASS<Derived>::TraverseNoThreadSafetyAnalysisAttr(NoThreadSafetyAnalysisAttr *A) {
1695 0 : if (!getDerived().VisitAttr(A))
1696 0 : return false;
1697 0 : if (!getDerived().VisitNoThreadSafetyAnalysisAttr(A))
1698 0 : return false;
1699 0 : return true;
1700 0 : }
1701 :
1702 : template <typename Derived>
1703 : bool VISITORCLASS<Derived>::TraverseNoThrowAttr(NoThrowAttr *A) {
1704 0 : if (!getDerived().VisitAttr(A))
1705 0 : return false;
1706 0 : if (!getDerived().VisitNoThrowAttr(A))
1707 0 : return false;
1708 0 : return true;
1709 0 : }
1710 :
1711 : template <typename Derived>
1712 : bool VISITORCLASS<Derived>::TraverseNonNullAttr(NonNullAttr *A) {
1713 0 : if (!getDerived().VisitAttr(A))
1714 0 : return false;
1715 0 : if (!getDerived().VisitNonNullAttr(A))
1716 0 : return false;
1717 0 : return true;
1718 0 : }
1719 :
1720 : template <typename Derived>
1721 : bool VISITORCLASS<Derived>::TraverseOMPThreadPrivateDeclAttr(OMPThreadPrivateDeclAttr *A) {
1722 0 : if (!getDerived().VisitAttr(A))
1723 0 : return false;
1724 0 : if (!getDerived().VisitOMPThreadPrivateDeclAttr(A))
1725 0 : return false;
1726 0 : return true;
1727 0 : }
1728 :
1729 : template <typename Derived>
1730 : bool VISITORCLASS<Derived>::TraverseObjCBoxableAttr(ObjCBoxableAttr *A) {
1731 0 : if (!getDerived().VisitAttr(A))
1732 0 : return false;
1733 0 : if (!getDerived().VisitObjCBoxableAttr(A))
1734 0 : return false;
1735 0 : return true;
1736 0 : }
1737 :
1738 : template <typename Derived>
1739 : bool VISITORCLASS<Derived>::TraverseObjCBridgeAttr(ObjCBridgeAttr *A) {
1740 0 : if (!getDerived().VisitAttr(A))
1741 0 : return false;
1742 0 : if (!getDerived().VisitObjCBridgeAttr(A))
1743 0 : return false;
1744 0 : return true;
1745 0 : }
1746 :
1747 : template <typename Derived>
1748 : bool VISITORCLASS<Derived>::TraverseObjCBridgeMutableAttr(ObjCBridgeMutableAttr *A) {
1749 0 : if (!getDerived().VisitAttr(A))
1750 0 : return false;
1751 0 : if (!getDerived().VisitObjCBridgeMutableAttr(A))
1752 0 : return false;
1753 0 : return true;
1754 0 : }
1755 :
1756 : template <typename Derived>
1757 : bool VISITORCLASS<Derived>::TraverseObjCBridgeRelatedAttr(ObjCBridgeRelatedAttr *A) {
1758 0 : if (!getDerived().VisitAttr(A))
1759 0 : return false;
1760 0 : if (!getDerived().VisitObjCBridgeRelatedAttr(A))
1761 0 : return false;
1762 0 : return true;
1763 0 : }
1764 :
1765 : template <typename Derived>
1766 : bool VISITORCLASS<Derived>::TraverseObjCDesignatedInitializerAttr(ObjCDesignatedInitializerAttr *A) {
1767 0 : if (!getDerived().VisitAttr(A))
1768 0 : return false;
1769 0 : if (!getDerived().VisitObjCDesignatedInitializerAttr(A))
1770 0 : return false;
1771 0 : return true;
1772 0 : }
1773 :
1774 : template <typename Derived>
1775 : bool VISITORCLASS<Derived>::TraverseObjCExceptionAttr(ObjCExceptionAttr *A) {
1776 0 : if (!getDerived().VisitAttr(A))
1777 0 : return false;
1778 0 : if (!getDerived().VisitObjCExceptionAttr(A))
1779 0 : return false;
1780 0 : return true;
1781 0 : }
1782 :
1783 : template <typename Derived>
1784 : bool VISITORCLASS<Derived>::TraverseObjCExplicitProtocolImplAttr(ObjCExplicitProtocolImplAttr *A) {
1785 0 : if (!getDerived().VisitAttr(A))
1786 0 : return false;
1787 0 : if (!getDerived().VisitObjCExplicitProtocolImplAttr(A))
1788 0 : return false;
1789 0 : return true;
1790 0 : }
1791 :
1792 : template <typename Derived>
1793 : bool VISITORCLASS<Derived>::TraverseObjCIndependentClassAttr(ObjCIndependentClassAttr *A) {
1794 0 : if (!getDerived().VisitAttr(A))
1795 0 : return false;
1796 0 : if (!getDerived().VisitObjCIndependentClassAttr(A))
1797 0 : return false;
1798 0 : return true;
1799 0 : }
1800 :
1801 : template <typename Derived>
1802 : bool VISITORCLASS<Derived>::TraverseObjCMethodFamilyAttr(ObjCMethodFamilyAttr *A) {
1803 0 : if (!getDerived().VisitAttr(A))
1804 0 : return false;
1805 0 : if (!getDerived().VisitObjCMethodFamilyAttr(A))
1806 0 : return false;
1807 0 : return true;
1808 0 : }
1809 :
1810 : template <typename Derived>
1811 : bool VISITORCLASS<Derived>::TraverseObjCNSObjectAttr(ObjCNSObjectAttr *A) {
1812 0 : if (!getDerived().VisitAttr(A))
1813 0 : return false;
1814 0 : if (!getDerived().VisitObjCNSObjectAttr(A))
1815 0 : return false;
1816 0 : return true;
1817 0 : }
1818 :
1819 : template <typename Derived>
1820 : bool VISITORCLASS<Derived>::TraverseObjCPreciseLifetimeAttr(ObjCPreciseLifetimeAttr *A) {
1821 0 : if (!getDerived().VisitAttr(A))
1822 0 : return false;
1823 0 : if (!getDerived().VisitObjCPreciseLifetimeAttr(A))
1824 0 : return false;
1825 0 : return true;
1826 0 : }
1827 :
1828 : template <typename Derived>
1829 : bool VISITORCLASS<Derived>::TraverseObjCRequiresPropertyDefsAttr(ObjCRequiresPropertyDefsAttr *A) {
1830 0 : if (!getDerived().VisitAttr(A))
1831 0 : return false;
1832 0 : if (!getDerived().VisitObjCRequiresPropertyDefsAttr(A))
1833 0 : return false;
1834 0 : return true;
1835 0 : }
1836 :
1837 : template <typename Derived>
1838 : bool VISITORCLASS<Derived>::TraverseObjCRequiresSuperAttr(ObjCRequiresSuperAttr *A) {
1839 0 : if (!getDerived().VisitAttr(A))
1840 0 : return false;
1841 0 : if (!getDerived().VisitObjCRequiresSuperAttr(A))
1842 0 : return false;
1843 0 : return true;
1844 0 : }
1845 :
1846 : template <typename Derived>
1847 : bool VISITORCLASS<Derived>::TraverseObjCReturnsInnerPointerAttr(ObjCReturnsInnerPointerAttr *A) {
1848 0 : if (!getDerived().VisitAttr(A))
1849 0 : return false;
1850 0 : if (!getDerived().VisitObjCReturnsInnerPointerAttr(A))
1851 0 : return false;
1852 0 : return true;
1853 0 : }
1854 :
1855 : template <typename Derived>
1856 : bool VISITORCLASS<Derived>::TraverseObjCRootClassAttr(ObjCRootClassAttr *A) {
1857 0 : if (!getDerived().VisitAttr(A))
1858 0 : return false;
1859 0 : if (!getDerived().VisitObjCRootClassAttr(A))
1860 0 : return false;
1861 0 : return true;
1862 0 : }
1863 :
1864 : template <typename Derived>
1865 : bool VISITORCLASS<Derived>::TraverseObjCRuntimeNameAttr(ObjCRuntimeNameAttr *A) {
1866 0 : if (!getDerived().VisitAttr(A))
1867 0 : return false;
1868 0 : if (!getDerived().VisitObjCRuntimeNameAttr(A))
1869 0 : return false;
1870 0 : return true;
1871 0 : }
1872 :
1873 : template <typename Derived>
1874 : bool VISITORCLASS<Derived>::TraverseOpenCLImageAccessAttr(OpenCLImageAccessAttr *A) {
1875 0 : if (!getDerived().VisitAttr(A))
1876 0 : return false;
1877 0 : if (!getDerived().VisitOpenCLImageAccessAttr(A))
1878 0 : return false;
1879 0 : return true;
1880 0 : }
1881 :
1882 : template <typename Derived>
1883 : bool VISITORCLASS<Derived>::TraverseOpenCLKernelAttr(OpenCLKernelAttr *A) {
1884 0 : if (!getDerived().VisitAttr(A))
1885 0 : return false;
1886 0 : if (!getDerived().VisitOpenCLKernelAttr(A))
1887 0 : return false;
1888 0 : return true;
1889 0 : }
1890 :
1891 : template <typename Derived>
1892 : bool VISITORCLASS<Derived>::TraverseOptimizeNoneAttr(OptimizeNoneAttr *A) {
1893 0 : if (!getDerived().VisitAttr(A))
1894 0 : return false;
1895 0 : if (!getDerived().VisitOptimizeNoneAttr(A))
1896 0 : return false;
1897 0 : return true;
1898 0 : }
1899 :
1900 : template <typename Derived>
1901 : bool VISITORCLASS<Derived>::TraverseOverloadableAttr(OverloadableAttr *A) {
1902 0 : if (!getDerived().VisitAttr(A))
1903 0 : return false;
1904 0 : if (!getDerived().VisitOverloadableAttr(A))
1905 0 : return false;
1906 0 : return true;
1907 0 : }
1908 :
1909 : template <typename Derived>
1910 : bool VISITORCLASS<Derived>::TraverseOverrideAttr(OverrideAttr *A) {
1911 0 : if (!getDerived().VisitAttr(A))
1912 0 : return false;
1913 0 : if (!getDerived().VisitOverrideAttr(A))
1914 0 : return false;
1915 0 : return true;
1916 0 : }
1917 :
1918 : template <typename Derived>
1919 : bool VISITORCLASS<Derived>::TraverseOwnershipAttr(OwnershipAttr *A) {
1920 0 : if (!getDerived().VisitAttr(A))
1921 0 : return false;
1922 0 : if (!getDerived().VisitOwnershipAttr(A))
1923 0 : return false;
1924 0 : return true;
1925 0 : }
1926 :
1927 : template <typename Derived>
1928 : bool VISITORCLASS<Derived>::TraversePackedAttr(PackedAttr *A) {
1929 0 : if (!getDerived().VisitAttr(A))
1930 0 : return false;
1931 0 : if (!getDerived().VisitPackedAttr(A))
1932 0 : return false;
1933 0 : return true;
1934 0 : }
1935 :
1936 : template <typename Derived>
1937 : bool VISITORCLASS<Derived>::TraverseParamTypestateAttr(ParamTypestateAttr *A) {
1938 0 : if (!getDerived().VisitAttr(A))
1939 0 : return false;
1940 0 : if (!getDerived().VisitParamTypestateAttr(A))
1941 0 : return false;
1942 0 : return true;
1943 0 : }
1944 :
1945 : template <typename Derived>
1946 : bool VISITORCLASS<Derived>::TraversePascalAttr(PascalAttr *A) {
1947 0 : if (!getDerived().VisitAttr(A))
1948 0 : return false;
1949 0 : if (!getDerived().VisitPascalAttr(A))
1950 0 : return false;
1951 0 : return true;
1952 0 : }
1953 :
1954 : template <typename Derived>
1955 : bool VISITORCLASS<Derived>::TraversePcsAttr(PcsAttr *A) {
1956 0 : if (!getDerived().VisitAttr(A))
1957 0 : return false;
1958 0 : if (!getDerived().VisitPcsAttr(A))
1959 0 : return false;
1960 0 : return true;
1961 0 : }
1962 :
1963 : template <typename Derived>
1964 : bool VISITORCLASS<Derived>::TraversePtGuardedByAttr(PtGuardedByAttr *A) {
1965 0 : if (!getDerived().VisitAttr(A))
1966 0 : return false;
1967 0 : if (!getDerived().VisitPtGuardedByAttr(A))
1968 0 : return false;
1969 0 : if (!getDerived().TraverseStmt(A->getArg()))
1970 0 : return false;
1971 0 : return true;
1972 0 : }
1973 :
1974 : template <typename Derived>
1975 : bool VISITORCLASS<Derived>::TraversePtGuardedVarAttr(PtGuardedVarAttr *A) {
1976 0 : if (!getDerived().VisitAttr(A))
1977 0 : return false;
1978 0 : if (!getDerived().VisitPtGuardedVarAttr(A))
1979 0 : return false;
1980 0 : return true;
1981 0 : }
1982 :
1983 : template <typename Derived>
1984 : bool VISITORCLASS<Derived>::TraversePureAttr(PureAttr *A) {
1985 0 : if (!getDerived().VisitAttr(A))
1986 0 : return false;
1987 0 : if (!getDerived().VisitPureAttr(A))
1988 0 : return false;
1989 0 : return true;
1990 0 : }
1991 :
1992 : template <typename Derived>
1993 : bool VISITORCLASS<Derived>::TraverseReleaseCapabilityAttr(ReleaseCapabilityAttr *A) {
1994 0 : if (!getDerived().VisitAttr(A))
1995 0 : return false;
1996 0 : if (!getDerived().VisitReleaseCapabilityAttr(A))
1997 0 : return false;
1998 : {
1999 0 : Expr * *I = A->args_begin();
2000 0 : Expr * *E = A->args_end();
2001 0 : for (; I != E; ++I) {
2002 0 : if (!getDerived().TraverseStmt(*I))
2003 0 : return false;
2004 0 : }
2005 : }
2006 0 : return true;
2007 0 : }
2008 :
2009 : template <typename Derived>
2010 : bool VISITORCLASS<Derived>::TraverseReqdWorkGroupSizeAttr(ReqdWorkGroupSizeAttr *A) {
2011 0 : if (!getDerived().VisitAttr(A))
2012 0 : return false;
2013 0 : if (!getDerived().VisitReqdWorkGroupSizeAttr(A))
2014 0 : return false;
2015 0 : return true;
2016 0 : }
2017 :
2018 : template <typename Derived>
2019 : bool VISITORCLASS<Derived>::TraverseRequiresCapabilityAttr(RequiresCapabilityAttr *A) {
2020 0 : if (!getDerived().VisitAttr(A))
2021 0 : return false;
2022 0 : if (!getDerived().VisitRequiresCapabilityAttr(A))
2023 0 : return false;
2024 : {
2025 0 : Expr * *I = A->args_begin();
2026 0 : Expr * *E = A->args_end();
2027 0 : for (; I != E; ++I) {
2028 0 : if (!getDerived().TraverseStmt(*I))
2029 0 : return false;
2030 0 : }
2031 : }
2032 0 : return true;
2033 0 : }
2034 :
2035 : template <typename Derived>
2036 : bool VISITORCLASS<Derived>::TraverseRestrictAttr(RestrictAttr *A) {
2037 0 : if (!getDerived().VisitAttr(A))
2038 0 : return false;
2039 0 : if (!getDerived().VisitRestrictAttr(A))
2040 0 : return false;
2041 0 : return true;
2042 0 : }
2043 :
2044 : template <typename Derived>
2045 : bool VISITORCLASS<Derived>::TraverseReturnTypestateAttr(ReturnTypestateAttr *A) {
2046 0 : if (!getDerived().VisitAttr(A))
2047 0 : return false;
2048 0 : if (!getDerived().VisitReturnTypestateAttr(A))
2049 0 : return false;
2050 0 : return true;
2051 0 : }
2052 :
2053 : template <typename Derived>
2054 : bool VISITORCLASS<Derived>::TraverseReturnsNonNullAttr(ReturnsNonNullAttr *A) {
2055 0 : if (!getDerived().VisitAttr(A))
2056 0 : return false;
2057 0 : if (!getDerived().VisitReturnsNonNullAttr(A))
2058 0 : return false;
2059 0 : return true;
2060 0 : }
2061 :
2062 : template <typename Derived>
2063 : bool VISITORCLASS<Derived>::TraverseReturnsTwiceAttr(ReturnsTwiceAttr *A) {
2064 0 : if (!getDerived().VisitAttr(A))
2065 0 : return false;
2066 0 : if (!getDerived().VisitReturnsTwiceAttr(A))
2067 0 : return false;
2068 0 : return true;
2069 0 : }
2070 :
2071 : template <typename Derived>
2072 : bool VISITORCLASS<Derived>::TraverseScopedLockableAttr(ScopedLockableAttr *A) {
2073 0 : if (!getDerived().VisitAttr(A))
2074 0 : return false;
2075 0 : if (!getDerived().VisitScopedLockableAttr(A))
2076 0 : return false;
2077 0 : return true;
2078 0 : }
2079 :
2080 : template <typename Derived>
2081 : bool VISITORCLASS<Derived>::TraverseSectionAttr(SectionAttr *A) {
2082 0 : if (!getDerived().VisitAttr(A))
2083 0 : return false;
2084 0 : if (!getDerived().VisitSectionAttr(A))
2085 0 : return false;
2086 0 : return true;
2087 0 : }
2088 :
2089 : template <typename Derived>
2090 : bool VISITORCLASS<Derived>::TraverseSelectAnyAttr(SelectAnyAttr *A) {
2091 0 : if (!getDerived().VisitAttr(A))
2092 0 : return false;
2093 0 : if (!getDerived().VisitSelectAnyAttr(A))
2094 0 : return false;
2095 0 : return true;
2096 0 : }
2097 :
2098 : template <typename Derived>
2099 : bool VISITORCLASS<Derived>::TraverseSentinelAttr(SentinelAttr *A) {
2100 0 : if (!getDerived().VisitAttr(A))
2101 0 : return false;
2102 0 : if (!getDerived().VisitSentinelAttr(A))
2103 0 : return false;
2104 0 : return true;
2105 0 : }
2106 :
2107 : template <typename Derived>
2108 : bool VISITORCLASS<Derived>::TraverseSetTypestateAttr(SetTypestateAttr *A) {
2109 0 : if (!getDerived().VisitAttr(A))
2110 0 : return false;
2111 0 : if (!getDerived().VisitSetTypestateAttr(A))
2112 0 : return false;
2113 0 : return true;
2114 0 : }
2115 :
2116 : template <typename Derived>
2117 : bool VISITORCLASS<Derived>::TraverseSharedTrylockFunctionAttr(SharedTrylockFunctionAttr *A) {
2118 0 : if (!getDerived().VisitAttr(A))
2119 0 : return false;
2120 0 : if (!getDerived().VisitSharedTrylockFunctionAttr(A))
2121 0 : return false;
2122 0 : if (!getDerived().TraverseStmt(A->getSuccessValue()))
2123 0 : return false;
2124 : {
2125 0 : Expr * *I = A->args_begin();
2126 0 : Expr * *E = A->args_end();
2127 0 : for (; I != E; ++I) {
2128 0 : if (!getDerived().TraverseStmt(*I))
2129 0 : return false;
2130 0 : }
2131 : }
2132 0 : return true;
2133 0 : }
2134 :
2135 : template <typename Derived>
2136 : bool VISITORCLASS<Derived>::TraverseStdCallAttr(StdCallAttr *A) {
2137 0 : if (!getDerived().VisitAttr(A))
2138 0 : return false;
2139 0 : if (!getDerived().VisitStdCallAttr(A))
2140 0 : return false;
2141 0 : return true;
2142 0 : }
2143 :
2144 : template <typename Derived>
2145 : bool VISITORCLASS<Derived>::TraverseSysVABIAttr(SysVABIAttr *A) {
2146 0 : if (!getDerived().VisitAttr(A))
2147 0 : return false;
2148 0 : if (!getDerived().VisitSysVABIAttr(A))
2149 0 : return false;
2150 0 : return true;
2151 0 : }
2152 :
2153 : template <typename Derived>
2154 : bool VISITORCLASS<Derived>::TraverseTLSModelAttr(TLSModelAttr *A) {
2155 0 : if (!getDerived().VisitAttr(A))
2156 0 : return false;
2157 0 : if (!getDerived().VisitTLSModelAttr(A))
2158 0 : return false;
2159 0 : return true;
2160 0 : }
2161 :
2162 : template <typename Derived>
2163 : bool VISITORCLASS<Derived>::TraverseTargetAttr(TargetAttr *A) {
2164 0 : if (!getDerived().VisitAttr(A))
2165 0 : return false;
2166 0 : if (!getDerived().VisitTargetAttr(A))
2167 0 : return false;
2168 0 : return true;
2169 0 : }
2170 :
2171 : template <typename Derived>
2172 : bool VISITORCLASS<Derived>::TraverseTestTypestateAttr(TestTypestateAttr *A) {
2173 0 : if (!getDerived().VisitAttr(A))
2174 0 : return false;
2175 0 : if (!getDerived().VisitTestTypestateAttr(A))
2176 0 : return false;
2177 0 : return true;
2178 0 : }
2179 :
2180 : template <typename Derived>
2181 : bool VISITORCLASS<Derived>::TraverseThisCallAttr(ThisCallAttr *A) {
2182 0 : if (!getDerived().VisitAttr(A))
2183 0 : return false;
2184 0 : if (!getDerived().VisitThisCallAttr(A))
2185 0 : return false;
2186 0 : return true;
2187 0 : }
2188 :
2189 : template <typename Derived>
2190 : bool VISITORCLASS<Derived>::TraverseThreadAttr(ThreadAttr *A) {
2191 0 : if (!getDerived().VisitAttr(A))
2192 0 : return false;
2193 0 : if (!getDerived().VisitThreadAttr(A))
2194 0 : return false;
2195 0 : return true;
2196 0 : }
2197 :
2198 : template <typename Derived>
2199 : bool VISITORCLASS<Derived>::TraverseTransparentUnionAttr(TransparentUnionAttr *A) {
2200 0 : if (!getDerived().VisitAttr(A))
2201 0 : return false;
2202 0 : if (!getDerived().VisitTransparentUnionAttr(A))
2203 0 : return false;
2204 0 : return true;
2205 0 : }
2206 :
2207 : template <typename Derived>
2208 : bool VISITORCLASS<Derived>::TraverseTryAcquireCapabilityAttr(TryAcquireCapabilityAttr *A) {
2209 0 : if (!getDerived().VisitAttr(A))
2210 0 : return false;
2211 0 : if (!getDerived().VisitTryAcquireCapabilityAttr(A))
2212 0 : return false;
2213 0 : if (!getDerived().TraverseStmt(A->getSuccessValue()))
2214 0 : return false;
2215 : {
2216 0 : Expr * *I = A->args_begin();
2217 0 : Expr * *E = A->args_end();
2218 0 : for (; I != E; ++I) {
2219 0 : if (!getDerived().TraverseStmt(*I))
2220 0 : return false;
2221 0 : }
2222 : }
2223 0 : return true;
2224 0 : }
2225 :
2226 : template <typename Derived>
2227 : bool VISITORCLASS<Derived>::TraverseTypeTagForDatatypeAttr(TypeTagForDatatypeAttr *A) {
2228 0 : if (!getDerived().VisitAttr(A))
2229 0 : return false;
2230 0 : if (!getDerived().VisitTypeTagForDatatypeAttr(A))
2231 0 : return false;
2232 0 : return true;
2233 0 : }
2234 :
2235 : template <typename Derived>
2236 : bool VISITORCLASS<Derived>::TraverseTypeVisibilityAttr(TypeVisibilityAttr *A) {
2237 0 : if (!getDerived().VisitAttr(A))
2238 0 : return false;
2239 0 : if (!getDerived().VisitTypeVisibilityAttr(A))
2240 0 : return false;
2241 0 : return true;
2242 0 : }
2243 :
2244 : template <typename Derived>
2245 : bool VISITORCLASS<Derived>::TraverseUnavailableAttr(UnavailableAttr *A) {
2246 0 : if (!getDerived().VisitAttr(A))
2247 0 : return false;
2248 0 : if (!getDerived().VisitUnavailableAttr(A))
2249 0 : return false;
2250 0 : return true;
2251 0 : }
2252 :
2253 : template <typename Derived>
2254 : bool VISITORCLASS<Derived>::TraverseUnusedAttr(UnusedAttr *A) {
2255 0 : if (!getDerived().VisitAttr(A))
2256 0 : return false;
2257 0 : if (!getDerived().VisitUnusedAttr(A))
2258 0 : return false;
2259 0 : return true;
2260 0 : }
2261 :
2262 : template <typename Derived>
2263 : bool VISITORCLASS<Derived>::TraverseUsedAttr(UsedAttr *A) {
2264 0 : if (!getDerived().VisitAttr(A))
2265 0 : return false;
2266 0 : if (!getDerived().VisitUsedAttr(A))
2267 0 : return false;
2268 0 : return true;
2269 0 : }
2270 :
2271 : template <typename Derived>
2272 : bool VISITORCLASS<Derived>::TraverseUuidAttr(UuidAttr *A) {
2273 0 : if (!getDerived().VisitAttr(A))
2274 0 : return false;
2275 0 : if (!getDerived().VisitUuidAttr(A))
2276 0 : return false;
2277 0 : return true;
2278 0 : }
2279 :
2280 : template <typename Derived>
2281 : bool VISITORCLASS<Derived>::TraverseVecReturnAttr(VecReturnAttr *A) {
2282 0 : if (!getDerived().VisitAttr(A))
2283 0 : return false;
2284 0 : if (!getDerived().VisitVecReturnAttr(A))
2285 0 : return false;
2286 0 : return true;
2287 0 : }
2288 :
2289 : template <typename Derived>
2290 : bool VISITORCLASS<Derived>::TraverseVecTypeHintAttr(VecTypeHintAttr *A) {
2291 0 : if (!getDerived().VisitAttr(A))
2292 0 : return false;
2293 0 : if (!getDerived().VisitVecTypeHintAttr(A))
2294 0 : return false;
2295 0 : return true;
2296 0 : }
2297 :
2298 : template <typename Derived>
2299 : bool VISITORCLASS<Derived>::TraverseVectorCallAttr(VectorCallAttr *A) {
2300 0 : if (!getDerived().VisitAttr(A))
2301 0 : return false;
2302 0 : if (!getDerived().VisitVectorCallAttr(A))
2303 0 : return false;
2304 0 : return true;
2305 0 : }
2306 :
2307 : template <typename Derived>
2308 : bool VISITORCLASS<Derived>::TraverseVisibilityAttr(VisibilityAttr *A) {
2309 0 : if (!getDerived().VisitAttr(A))
2310 0 : return false;
2311 0 : if (!getDerived().VisitVisibilityAttr(A))
2312 0 : return false;
2313 0 : return true;
2314 0 : }
2315 :
2316 : template <typename Derived>
2317 : bool VISITORCLASS<Derived>::TraverseWarnUnusedAttr(WarnUnusedAttr *A) {
2318 0 : if (!getDerived().VisitAttr(A))
2319 0 : return false;
2320 0 : if (!getDerived().VisitWarnUnusedAttr(A))
2321 0 : return false;
2322 0 : return true;
2323 0 : }
2324 :
2325 : template <typename Derived>
2326 : bool VISITORCLASS<Derived>::TraverseWarnUnusedResultAttr(WarnUnusedResultAttr *A) {
2327 0 : if (!getDerived().VisitAttr(A))
2328 0 : return false;
2329 0 : if (!getDerived().VisitWarnUnusedResultAttr(A))
2330 0 : return false;
2331 0 : return true;
2332 0 : }
2333 :
2334 : template <typename Derived>
2335 : bool VISITORCLASS<Derived>::TraverseWeakAttr(WeakAttr *A) {
2336 0 : if (!getDerived().VisitAttr(A))
2337 0 : return false;
2338 0 : if (!getDerived().VisitWeakAttr(A))
2339 0 : return false;
2340 0 : return true;
2341 0 : }
2342 :
2343 : template <typename Derived>
2344 : bool VISITORCLASS<Derived>::TraverseWeakImportAttr(WeakImportAttr *A) {
2345 0 : if (!getDerived().VisitAttr(A))
2346 0 : return false;
2347 0 : if (!getDerived().VisitWeakImportAttr(A))
2348 0 : return false;
2349 0 : return true;
2350 0 : }
2351 :
2352 : template <typename Derived>
2353 : bool VISITORCLASS<Derived>::TraverseWeakRefAttr(WeakRefAttr *A) {
2354 0 : if (!getDerived().VisitAttr(A))
2355 0 : return false;
2356 0 : if (!getDerived().VisitWeakRefAttr(A))
2357 0 : return false;
2358 0 : return true;
2359 0 : }
2360 :
2361 : template <typename Derived>
2362 : bool VISITORCLASS<Derived>::TraverseWorkGroupSizeHintAttr(WorkGroupSizeHintAttr *A) {
2363 0 : if (!getDerived().VisitAttr(A))
2364 0 : return false;
2365 0 : if (!getDerived().VisitWorkGroupSizeHintAttr(A))
2366 0 : return false;
2367 0 : return true;
2368 0 : }
2369 :
2370 : template <typename Derived>
2371 : bool VISITORCLASS<Derived>::TraverseX86ForceAlignArgPointerAttr(X86ForceAlignArgPointerAttr *A) {
2372 0 : if (!getDerived().VisitAttr(A))
2373 0 : return false;
2374 0 : if (!getDerived().VisitX86ForceAlignArgPointerAttr(A))
2375 0 : return false;
2376 0 : return true;
2377 0 : }
2378 :
2379 : template <typename Derived>
2380 : bool VISITORCLASS<Derived>::TraverseAttr(Attr *A) {
2381 0 : if (!A)
2382 0 : return true;
2383 :
2384 0 : switch (A->getKind()) {
2385 : default:
2386 0 : return true;
2387 : case attr::AMDGPUNumSGPR:
2388 0 : return getDerived().TraverseAMDGPUNumSGPRAttr(cast<AMDGPUNumSGPRAttr>(A));
2389 : case attr::AMDGPUNumVGPR:
2390 0 : return getDerived().TraverseAMDGPUNumVGPRAttr(cast<AMDGPUNumVGPRAttr>(A));
2391 : case attr::ARMInterrupt:
2392 0 : return getDerived().TraverseARMInterruptAttr(cast<ARMInterruptAttr>(A));
2393 : case attr::AcquireCapability:
2394 0 : return getDerived().TraverseAcquireCapabilityAttr(cast<AcquireCapabilityAttr>(A));
2395 : case attr::AcquiredAfter:
2396 0 : return getDerived().TraverseAcquiredAfterAttr(cast<AcquiredAfterAttr>(A));
2397 : case attr::AcquiredBefore:
2398 0 : return getDerived().TraverseAcquiredBeforeAttr(cast<AcquiredBeforeAttr>(A));
2399 : case attr::Alias:
2400 0 : return getDerived().TraverseAliasAttr(cast<AliasAttr>(A));
2401 : case attr::AlignMac68k:
2402 0 : return getDerived().TraverseAlignMac68kAttr(cast<AlignMac68kAttr>(A));
2403 : case attr::AlignValue:
2404 0 : return getDerived().TraverseAlignValueAttr(cast<AlignValueAttr>(A));
2405 : case attr::Aligned:
2406 0 : return getDerived().TraverseAlignedAttr(cast<AlignedAttr>(A));
2407 : case attr::AlwaysInline:
2408 0 : return getDerived().TraverseAlwaysInlineAttr(cast<AlwaysInlineAttr>(A));
2409 : case attr::AnalyzerNoReturn:
2410 0 : return getDerived().TraverseAnalyzerNoReturnAttr(cast<AnalyzerNoReturnAttr>(A));
2411 : case attr::Annotate:
2412 0 : return getDerived().TraverseAnnotateAttr(cast<AnnotateAttr>(A));
2413 : case attr::ArcWeakrefUnavailable:
2414 0 : return getDerived().TraverseArcWeakrefUnavailableAttr(cast<ArcWeakrefUnavailableAttr>(A));
2415 : case attr::ArgumentWithTypeTag:
2416 0 : return getDerived().TraverseArgumentWithTypeTagAttr(cast<ArgumentWithTypeTagAttr>(A));
2417 : case attr::AsmLabel:
2418 0 : return getDerived().TraverseAsmLabelAttr(cast<AsmLabelAttr>(A));
2419 : case attr::AssertCapability:
2420 0 : return getDerived().TraverseAssertCapabilityAttr(cast<AssertCapabilityAttr>(A));
2421 : case attr::AssertExclusiveLock:
2422 0 : return getDerived().TraverseAssertExclusiveLockAttr(cast<AssertExclusiveLockAttr>(A));
2423 : case attr::AssertSharedLock:
2424 0 : return getDerived().TraverseAssertSharedLockAttr(cast<AssertSharedLockAttr>(A));
2425 : case attr::AssumeAligned:
2426 0 : return getDerived().TraverseAssumeAlignedAttr(cast<AssumeAlignedAttr>(A));
2427 : case attr::Availability:
2428 0 : return getDerived().TraverseAvailabilityAttr(cast<AvailabilityAttr>(A));
2429 : case attr::Blocks:
2430 0 : return getDerived().TraverseBlocksAttr(cast<BlocksAttr>(A));
2431 : case attr::C11NoReturn:
2432 0 : return getDerived().TraverseC11NoReturnAttr(cast<C11NoReturnAttr>(A));
2433 : case attr::CDecl:
2434 0 : return getDerived().TraverseCDeclAttr(cast<CDeclAttr>(A));
2435 : case attr::CFAuditedTransfer:
2436 0 : return getDerived().TraverseCFAuditedTransferAttr(cast<CFAuditedTransferAttr>(A));
2437 : case attr::CFConsumed:
2438 0 : return getDerived().TraverseCFConsumedAttr(cast<CFConsumedAttr>(A));
2439 : case attr::CFReturnsNotRetained:
2440 0 : return getDerived().TraverseCFReturnsNotRetainedAttr(cast<CFReturnsNotRetainedAttr>(A));
2441 : case attr::CFReturnsRetained:
2442 0 : return getDerived().TraverseCFReturnsRetainedAttr(cast<CFReturnsRetainedAttr>(A));
2443 : case attr::CFUnknownTransfer:
2444 0 : return getDerived().TraverseCFUnknownTransferAttr(cast<CFUnknownTransferAttr>(A));
2445 : case attr::CUDAConstant:
2446 0 : return getDerived().TraverseCUDAConstantAttr(cast<CUDAConstantAttr>(A));
2447 : case attr::CUDADevice:
2448 0 : return getDerived().TraverseCUDADeviceAttr(cast<CUDADeviceAttr>(A));
2449 : case attr::CUDAGlobal:
2450 0 : return getDerived().TraverseCUDAGlobalAttr(cast<CUDAGlobalAttr>(A));
2451 : case attr::CUDAHost:
2452 0 : return getDerived().TraverseCUDAHostAttr(cast<CUDAHostAttr>(A));
2453 : case attr::CUDAInvalidTarget:
2454 0 : return getDerived().TraverseCUDAInvalidTargetAttr(cast<CUDAInvalidTargetAttr>(A));
2455 : case attr::CUDALaunchBounds:
2456 0 : return getDerived().TraverseCUDALaunchBoundsAttr(cast<CUDALaunchBoundsAttr>(A));
2457 : case attr::CUDAShared:
2458 0 : return getDerived().TraverseCUDASharedAttr(cast<CUDASharedAttr>(A));
2459 : case attr::CXX11NoReturn:
2460 0 : return getDerived().TraverseCXX11NoReturnAttr(cast<CXX11NoReturnAttr>(A));
2461 : case attr::CallableWhen:
2462 0 : return getDerived().TraverseCallableWhenAttr(cast<CallableWhenAttr>(A));
2463 : case attr::Capability:
2464 0 : return getDerived().TraverseCapabilityAttr(cast<CapabilityAttr>(A));
2465 : case attr::CapturedRecord:
2466 0 : return getDerived().TraverseCapturedRecordAttr(cast<CapturedRecordAttr>(A));
2467 : case attr::CarriesDependency:
2468 0 : return getDerived().TraverseCarriesDependencyAttr(cast<CarriesDependencyAttr>(A));
2469 : case attr::Cleanup:
2470 0 : return getDerived().TraverseCleanupAttr(cast<CleanupAttr>(A));
2471 : case attr::Cold:
2472 0 : return getDerived().TraverseColdAttr(cast<ColdAttr>(A));
2473 : case attr::Common:
2474 0 : return getDerived().TraverseCommonAttr(cast<CommonAttr>(A));
2475 : case attr::Const:
2476 0 : return getDerived().TraverseConstAttr(cast<ConstAttr>(A));
2477 : case attr::Constructor:
2478 0 : return getDerived().TraverseConstructorAttr(cast<ConstructorAttr>(A));
2479 : case attr::Consumable:
2480 0 : return getDerived().TraverseConsumableAttr(cast<ConsumableAttr>(A));
2481 : case attr::ConsumableAutoCast:
2482 0 : return getDerived().TraverseConsumableAutoCastAttr(cast<ConsumableAutoCastAttr>(A));
2483 : case attr::ConsumableSetOnRead:
2484 0 : return getDerived().TraverseConsumableSetOnReadAttr(cast<ConsumableSetOnReadAttr>(A));
2485 : case attr::DLLExport:
2486 0 : return getDerived().TraverseDLLExportAttr(cast<DLLExportAttr>(A));
2487 : case attr::DLLImport:
2488 0 : return getDerived().TraverseDLLImportAttr(cast<DLLImportAttr>(A));
2489 : case attr::Deprecated:
2490 0 : return getDerived().TraverseDeprecatedAttr(cast<DeprecatedAttr>(A));
2491 : case attr::Destructor:
2492 0 : return getDerived().TraverseDestructorAttr(cast<DestructorAttr>(A));
2493 : case attr::EnableIf:
2494 0 : return getDerived().TraverseEnableIfAttr(cast<EnableIfAttr>(A));
2495 : case attr::ExclusiveTrylockFunction:
2496 0 : return getDerived().TraverseExclusiveTrylockFunctionAttr(cast<ExclusiveTrylockFunctionAttr>(A));
2497 : case attr::FallThrough:
2498 0 : return getDerived().TraverseFallThroughAttr(cast<FallThroughAttr>(A));
2499 : case attr::FastCall:
2500 0 : return getDerived().TraverseFastCallAttr(cast<FastCallAttr>(A));
2501 : case attr::Final:
2502 0 : return getDerived().TraverseFinalAttr(cast<FinalAttr>(A));
2503 : case attr::FlagEnum:
2504 0 : return getDerived().TraverseFlagEnumAttr(cast<FlagEnumAttr>(A));
2505 : case attr::Flatten:
2506 0 : return getDerived().TraverseFlattenAttr(cast<FlattenAttr>(A));
2507 : case attr::Format:
2508 0 : return getDerived().TraverseFormatAttr(cast<FormatAttr>(A));
2509 : case attr::FormatArg:
2510 0 : return getDerived().TraverseFormatArgAttr(cast<FormatArgAttr>(A));
2511 : case attr::GNUInline:
2512 0 : return getDerived().TraverseGNUInlineAttr(cast<GNUInlineAttr>(A));
2513 : case attr::GuardedBy:
2514 0 : return getDerived().TraverseGuardedByAttr(cast<GuardedByAttr>(A));
2515 : case attr::GuardedVar:
2516 0 : return getDerived().TraverseGuardedVarAttr(cast<GuardedVarAttr>(A));
2517 : case attr::Hot:
2518 0 : return getDerived().TraverseHotAttr(cast<HotAttr>(A));
2519 : case attr::IBAction:
2520 0 : return getDerived().TraverseIBActionAttr(cast<IBActionAttr>(A));
2521 : case attr::IBOutlet:
2522 0 : return getDerived().TraverseIBOutletAttr(cast<IBOutletAttr>(A));
2523 : case attr::IBOutletCollection:
2524 0 : return getDerived().TraverseIBOutletCollectionAttr(cast<IBOutletCollectionAttr>(A));
2525 : case attr::InitPriority:
2526 0 : return getDerived().TraverseInitPriorityAttr(cast<InitPriorityAttr>(A));
2527 : case attr::InitSeg:
2528 0 : return getDerived().TraverseInitSegAttr(cast<InitSegAttr>(A));
2529 : case attr::IntelOclBicc:
2530 0 : return getDerived().TraverseIntelOclBiccAttr(cast<IntelOclBiccAttr>(A));
2531 : case attr::LockReturned:
2532 0 : return getDerived().TraverseLockReturnedAttr(cast<LockReturnedAttr>(A));
2533 : case attr::LocksExcluded:
2534 0 : return getDerived().TraverseLocksExcludedAttr(cast<LocksExcludedAttr>(A));
2535 : case attr::LoopHint:
2536 0 : return getDerived().TraverseLoopHintAttr(cast<LoopHintAttr>(A));
2537 : case attr::MSABI:
2538 0 : return getDerived().TraverseMSABIAttr(cast<MSABIAttr>(A));
2539 : case attr::MSInheritance:
2540 0 : return getDerived().TraverseMSInheritanceAttr(cast<MSInheritanceAttr>(A));
2541 : case attr::MSNoVTable:
2542 0 : return getDerived().TraverseMSNoVTableAttr(cast<MSNoVTableAttr>(A));
2543 : case attr::MSP430Interrupt:
2544 0 : return getDerived().TraverseMSP430InterruptAttr(cast<MSP430InterruptAttr>(A));
2545 : case attr::MSStruct:
2546 0 : return getDerived().TraverseMSStructAttr(cast<MSStructAttr>(A));
2547 : case attr::MSVtorDisp:
2548 0 : return getDerived().TraverseMSVtorDispAttr(cast<MSVtorDispAttr>(A));
2549 : case attr::MaxFieldAlignment:
2550 0 : return getDerived().TraverseMaxFieldAlignmentAttr(cast<MaxFieldAlignmentAttr>(A));
2551 : case attr::MayAlias:
2552 0 : return getDerived().TraverseMayAliasAttr(cast<MayAliasAttr>(A));
2553 : case attr::MinSize:
2554 0 : return getDerived().TraverseMinSizeAttr(cast<MinSizeAttr>(A));
2555 : case attr::Mips16:
2556 0 : return getDerived().TraverseMips16Attr(cast<Mips16Attr>(A));
2557 : case attr::Mode:
2558 0 : return getDerived().TraverseModeAttr(cast<ModeAttr>(A));
2559 : case attr::NSConsumed:
2560 0 : return getDerived().TraverseNSConsumedAttr(cast<NSConsumedAttr>(A));
2561 : case attr::NSConsumesSelf:
2562 0 : return getDerived().TraverseNSConsumesSelfAttr(cast<NSConsumesSelfAttr>(A));
2563 : case attr::NSReturnsAutoreleased:
2564 0 : return getDerived().TraverseNSReturnsAutoreleasedAttr(cast<NSReturnsAutoreleasedAttr>(A));
2565 : case attr::NSReturnsNotRetained:
2566 0 : return getDerived().TraverseNSReturnsNotRetainedAttr(cast<NSReturnsNotRetainedAttr>(A));
2567 : case attr::NSReturnsRetained:
2568 0 : return getDerived().TraverseNSReturnsRetainedAttr(cast<NSReturnsRetainedAttr>(A));
2569 : case attr::Naked:
2570 0 : return getDerived().TraverseNakedAttr(cast<NakedAttr>(A));
2571 : case attr::NoCommon:
2572 0 : return getDerived().TraverseNoCommonAttr(cast<NoCommonAttr>(A));
2573 : case attr::NoDebug:
2574 0 : return getDerived().TraverseNoDebugAttr(cast<NoDebugAttr>(A));
2575 : case attr::NoDuplicate:
2576 0 : return getDerived().TraverseNoDuplicateAttr(cast<NoDuplicateAttr>(A));
2577 : case attr::NoInline:
2578 0 : return getDerived().TraverseNoInlineAttr(cast<NoInlineAttr>(A));
2579 : case attr::NoInstrumentFunction:
2580 0 : return getDerived().TraverseNoInstrumentFunctionAttr(cast<NoInstrumentFunctionAttr>(A));
2581 : case attr::NoMips16:
2582 0 : return getDerived().TraverseNoMips16Attr(cast<NoMips16Attr>(A));
2583 : case attr::NoReturn:
2584 0 : return getDerived().TraverseNoReturnAttr(cast<NoReturnAttr>(A));
2585 : case attr::NoSanitize:
2586 0 : return getDerived().TraverseNoSanitizeAttr(cast<NoSanitizeAttr>(A));
2587 : case attr::NoSplitStack:
2588 0 : return getDerived().TraverseNoSplitStackAttr(cast<NoSplitStackAttr>(A));
2589 : case attr::NoThreadSafetyAnalysis:
2590 0 : return getDerived().TraverseNoThreadSafetyAnalysisAttr(cast<NoThreadSafetyAnalysisAttr>(A));
2591 : case attr::NoThrow:
2592 0 : return getDerived().TraverseNoThrowAttr(cast<NoThrowAttr>(A));
2593 : case attr::NonNull:
2594 0 : return getDerived().TraverseNonNullAttr(cast<NonNullAttr>(A));
2595 : case attr::OMPThreadPrivateDecl:
2596 0 : return getDerived().TraverseOMPThreadPrivateDeclAttr(cast<OMPThreadPrivateDeclAttr>(A));
2597 : case attr::ObjCBoxable:
2598 0 : return getDerived().TraverseObjCBoxableAttr(cast<ObjCBoxableAttr>(A));
2599 : case attr::ObjCBridge:
2600 0 : return getDerived().TraverseObjCBridgeAttr(cast<ObjCBridgeAttr>(A));
2601 : case attr::ObjCBridgeMutable:
2602 0 : return getDerived().TraverseObjCBridgeMutableAttr(cast<ObjCBridgeMutableAttr>(A));
2603 : case attr::ObjCBridgeRelated:
2604 0 : return getDerived().TraverseObjCBridgeRelatedAttr(cast<ObjCBridgeRelatedAttr>(A));
2605 : case attr::ObjCDesignatedInitializer:
2606 0 : return getDerived().TraverseObjCDesignatedInitializerAttr(cast<ObjCDesignatedInitializerAttr>(A));
2607 : case attr::ObjCException:
2608 0 : return getDerived().TraverseObjCExceptionAttr(cast<ObjCExceptionAttr>(A));
2609 : case attr::ObjCExplicitProtocolImpl:
2610 0 : return getDerived().TraverseObjCExplicitProtocolImplAttr(cast<ObjCExplicitProtocolImplAttr>(A));
2611 : case attr::ObjCIndependentClass:
2612 0 : return getDerived().TraverseObjCIndependentClassAttr(cast<ObjCIndependentClassAttr>(A));
2613 : case attr::ObjCMethodFamily:
2614 0 : return getDerived().TraverseObjCMethodFamilyAttr(cast<ObjCMethodFamilyAttr>(A));
2615 : case attr::ObjCNSObject:
2616 0 : return getDerived().TraverseObjCNSObjectAttr(cast<ObjCNSObjectAttr>(A));
2617 : case attr::ObjCPreciseLifetime:
2618 0 : return getDerived().TraverseObjCPreciseLifetimeAttr(cast<ObjCPreciseLifetimeAttr>(A));
2619 : case attr::ObjCRequiresPropertyDefs:
2620 0 : return getDerived().TraverseObjCRequiresPropertyDefsAttr(cast<ObjCRequiresPropertyDefsAttr>(A));
2621 : case attr::ObjCRequiresSuper:
2622 0 : return getDerived().TraverseObjCRequiresSuperAttr(cast<ObjCRequiresSuperAttr>(A));
2623 : case attr::ObjCReturnsInnerPointer:
2624 0 : return getDerived().TraverseObjCReturnsInnerPointerAttr(cast<ObjCReturnsInnerPointerAttr>(A));
2625 : case attr::ObjCRootClass:
2626 0 : return getDerived().TraverseObjCRootClassAttr(cast<ObjCRootClassAttr>(A));
2627 : case attr::ObjCRuntimeName:
2628 0 : return getDerived().TraverseObjCRuntimeNameAttr(cast<ObjCRuntimeNameAttr>(A));
2629 : case attr::OpenCLImageAccess:
2630 0 : return getDerived().TraverseOpenCLImageAccessAttr(cast<OpenCLImageAccessAttr>(A));
2631 : case attr::OpenCLKernel:
2632 0 : return getDerived().TraverseOpenCLKernelAttr(cast<OpenCLKernelAttr>(A));
2633 : case attr::OptimizeNone:
2634 0 : return getDerived().TraverseOptimizeNoneAttr(cast<OptimizeNoneAttr>(A));
2635 : case attr::Overloadable:
2636 0 : return getDerived().TraverseOverloadableAttr(cast<OverloadableAttr>(A));
2637 : case attr::Override:
2638 0 : return getDerived().TraverseOverrideAttr(cast<OverrideAttr>(A));
2639 : case attr::Ownership:
2640 0 : return getDerived().TraverseOwnershipAttr(cast<OwnershipAttr>(A));
2641 : case attr::Packed:
2642 0 : return getDerived().TraversePackedAttr(cast<PackedAttr>(A));
2643 : case attr::ParamTypestate:
2644 0 : return getDerived().TraverseParamTypestateAttr(cast<ParamTypestateAttr>(A));
2645 : case attr::Pascal:
2646 0 : return getDerived().TraversePascalAttr(cast<PascalAttr>(A));
2647 : case attr::Pcs:
2648 0 : return getDerived().TraversePcsAttr(cast<PcsAttr>(A));
2649 : case attr::PtGuardedBy:
2650 0 : return getDerived().TraversePtGuardedByAttr(cast<PtGuardedByAttr>(A));
2651 : case attr::PtGuardedVar:
2652 0 : return getDerived().TraversePtGuardedVarAttr(cast<PtGuardedVarAttr>(A));
2653 : case attr::Pure:
2654 0 : return getDerived().TraversePureAttr(cast<PureAttr>(A));
2655 : case attr::ReleaseCapability:
2656 0 : return getDerived().TraverseReleaseCapabilityAttr(cast<ReleaseCapabilityAttr>(A));
2657 : case attr::ReqdWorkGroupSize:
2658 0 : return getDerived().TraverseReqdWorkGroupSizeAttr(cast<ReqdWorkGroupSizeAttr>(A));
2659 : case attr::RequiresCapability:
2660 0 : return getDerived().TraverseRequiresCapabilityAttr(cast<RequiresCapabilityAttr>(A));
2661 : case attr::Restrict:
2662 0 : return getDerived().TraverseRestrictAttr(cast<RestrictAttr>(A));
2663 : case attr::ReturnTypestate:
2664 0 : return getDerived().TraverseReturnTypestateAttr(cast<ReturnTypestateAttr>(A));
2665 : case attr::ReturnsNonNull:
2666 0 : return getDerived().TraverseReturnsNonNullAttr(cast<ReturnsNonNullAttr>(A));
2667 : case attr::ReturnsTwice:
2668 0 : return getDerived().TraverseReturnsTwiceAttr(cast<ReturnsTwiceAttr>(A));
2669 : case attr::ScopedLockable:
2670 0 : return getDerived().TraverseScopedLockableAttr(cast<ScopedLockableAttr>(A));
2671 : case attr::Section:
2672 0 : return getDerived().TraverseSectionAttr(cast<SectionAttr>(A));
2673 : case attr::SelectAny:
2674 0 : return getDerived().TraverseSelectAnyAttr(cast<SelectAnyAttr>(A));
2675 : case attr::Sentinel:
2676 0 : return getDerived().TraverseSentinelAttr(cast<SentinelAttr>(A));
2677 : case attr::SetTypestate:
2678 0 : return getDerived().TraverseSetTypestateAttr(cast<SetTypestateAttr>(A));
2679 : case attr::SharedTrylockFunction:
2680 0 : return getDerived().TraverseSharedTrylockFunctionAttr(cast<SharedTrylockFunctionAttr>(A));
2681 : case attr::StdCall:
2682 0 : return getDerived().TraverseStdCallAttr(cast<StdCallAttr>(A));
2683 : case attr::SysVABI:
2684 0 : return getDerived().TraverseSysVABIAttr(cast<SysVABIAttr>(A));
2685 : case attr::TLSModel:
2686 0 : return getDerived().TraverseTLSModelAttr(cast<TLSModelAttr>(A));
2687 : case attr::Target:
2688 0 : return getDerived().TraverseTargetAttr(cast<TargetAttr>(A));
2689 : case attr::TestTypestate:
2690 0 : return getDerived().TraverseTestTypestateAttr(cast<TestTypestateAttr>(A));
2691 : case attr::ThisCall:
2692 0 : return getDerived().TraverseThisCallAttr(cast<ThisCallAttr>(A));
2693 : case attr::Thread:
2694 0 : return getDerived().TraverseThreadAttr(cast<ThreadAttr>(A));
2695 : case attr::TransparentUnion:
2696 0 : return getDerived().TraverseTransparentUnionAttr(cast<TransparentUnionAttr>(A));
2697 : case attr::TryAcquireCapability:
2698 0 : return getDerived().TraverseTryAcquireCapabilityAttr(cast<TryAcquireCapabilityAttr>(A));
2699 : case attr::TypeTagForDatatype:
2700 0 : return getDerived().TraverseTypeTagForDatatypeAttr(cast<TypeTagForDatatypeAttr>(A));
2701 : case attr::TypeVisibility:
2702 0 : return getDerived().TraverseTypeVisibilityAttr(cast<TypeVisibilityAttr>(A));
2703 : case attr::Unavailable:
2704 0 : return getDerived().TraverseUnavailableAttr(cast<UnavailableAttr>(A));
2705 : case attr::Unused:
2706 0 : return getDerived().TraverseUnusedAttr(cast<UnusedAttr>(A));
2707 : case attr::Used:
2708 0 : return getDerived().TraverseUsedAttr(cast<UsedAttr>(A));
2709 : case attr::Uuid:
2710 0 : return getDerived().TraverseUuidAttr(cast<UuidAttr>(A));
2711 : case attr::VecReturn:
2712 0 : return getDerived().TraverseVecReturnAttr(cast<VecReturnAttr>(A));
2713 : case attr::VecTypeHint:
2714 0 : return getDerived().TraverseVecTypeHintAttr(cast<VecTypeHintAttr>(A));
2715 : case attr::VectorCall:
2716 0 : return getDerived().TraverseVectorCallAttr(cast<VectorCallAttr>(A));
2717 : case attr::Visibility:
2718 0 : return getDerived().TraverseVisibilityAttr(cast<VisibilityAttr>(A));
2719 : case attr::WarnUnused:
2720 0 : return getDerived().TraverseWarnUnusedAttr(cast<WarnUnusedAttr>(A));
2721 : case attr::WarnUnusedResult:
2722 0 : return getDerived().TraverseWarnUnusedResultAttr(cast<WarnUnusedResultAttr>(A));
2723 : case attr::Weak:
2724 0 : return getDerived().TraverseWeakAttr(cast<WeakAttr>(A));
2725 : case attr::WeakImport:
2726 0 : return getDerived().TraverseWeakImportAttr(cast<WeakImportAttr>(A));
2727 : case attr::WeakRef:
2728 0 : return getDerived().TraverseWeakRefAttr(cast<WeakRefAttr>(A));
2729 : case attr::WorkGroupSizeHint:
2730 0 : return getDerived().TraverseWorkGroupSizeHintAttr(cast<WorkGroupSizeHintAttr>(A));
2731 : case attr::X86ForceAlignArgPointer:
2732 0 : return getDerived().TraverseX86ForceAlignArgPointerAttr(cast<X86ForceAlignArgPointerAttr>(A));
2733 : }
2734 0 : }
2735 : #endif // ATTR_VISITOR_DECLS_ONLY
|
