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