1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|*                                                                            *|
3|* Template instantiation code for attributes                                 *|
4|*                                                                            *|
5|* Automatically generated file, do not edit!                                 *|
6|*                                                                            *|
7\*===----------------------------------------------------------------------===*/
8
9namespace clang {
10namespace sema {
11
12Attr *instantiateTemplateAttribute(const Attr *At, ASTContext &C, Sema &S,
13        const MultiLevelTemplateArgumentList &TemplateArgs) {
14  switch (At->getKind()) {
15    case attr::AMDGPUFlatWorkGroupSize: {
16      const auto *A = cast<AMDGPUFlatWorkGroupSizeAttr>(At);
17      return A->clone(C);
18    }
19    case attr::AMDGPUNumSGPR: {
20      const auto *A = cast<AMDGPUNumSGPRAttr>(At);
21      return A->clone(C);
22    }
23    case attr::AMDGPUNumVGPR: {
24      const auto *A = cast<AMDGPUNumVGPRAttr>(At);
25      return A->clone(C);
26    }
27    case attr::AMDGPUWavesPerEU: {
28      const auto *A = cast<AMDGPUWavesPerEUAttr>(At);
29      return A->clone(C);
30    }
31    case attr::ARMInterrupt: {
32      const auto *A = cast<ARMInterruptAttr>(At);
33      return A->clone(C);
34    }
35    case attr::AVRInterrupt: {
36      const auto *A = cast<AVRInterruptAttr>(At);
37      return A->clone(C);
38    }
39    case attr::AVRSignal: {
40      const auto *A = cast<AVRSignalAttr>(At);
41      return A->clone(C);
42    }
43    case attr::AbiTag: {
44      const auto *A = cast<AbiTagAttr>(At);
45      return A->clone(C);
46    }
47    case attr::AcquireCapability: {
48      const auto *A = cast<AcquireCapabilityAttr>(At);
49      auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
50      {
51        EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
52        Expr * *TI = tempInstArgs;
53        Expr * *I = A->args_begin();
54        Expr * *E = A->args_end();
55        for (; I != E; ++I, ++TI) {
56          ExprResult Result = S.SubstExpr(*I, TemplateArgs);
57          *TI = Result.getAs<Expr>();
58        }
59      }
60      return new (C) AcquireCapabilityAttr(A->getLocation(), C, tempInstArgs, A->args_size(), A->getSpellingListIndex());
61    }
62    case attr::AcquiredAfter: {
63      const auto *A = cast<AcquiredAfterAttr>(At);
64      auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
65      {
66        EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
67        Expr * *TI = tempInstArgs;
68        Expr * *I = A->args_begin();
69        Expr * *E = A->args_end();
70        for (; I != E; ++I, ++TI) {
71          ExprResult Result = S.SubstExpr(*I, TemplateArgs);
72          *TI = Result.getAs<Expr>();
73        }
74      }
75      return new (C) AcquiredAfterAttr(A->getLocation(), C, tempInstArgs, A->args_size(), A->getSpellingListIndex());
76    }
77    case attr::AcquiredBefore: {
78      const auto *A = cast<AcquiredBeforeAttr>(At);
79      auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
80      {
81        EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
82        Expr * *TI = tempInstArgs;
83        Expr * *I = A->args_begin();
84        Expr * *E = A->args_end();
85        for (; I != E; ++I, ++TI) {
86          ExprResult Result = S.SubstExpr(*I, TemplateArgs);
87          *TI = Result.getAs<Expr>();
88        }
89      }
90      return new (C) AcquiredBeforeAttr(A->getLocation(), C, tempInstArgs, A->args_size(), A->getSpellingListIndex());
91    }
92    case attr::Alias: {
93      const auto *A = cast<AliasAttr>(At);
94      return A->clone(C);
95    }
96    case attr::AlignMac68k: {
97      const auto *A = cast<AlignMac68kAttr>(At);
98      return A->clone(C);
99    }
100    case attr::AlignValue: {
101      const auto *A = cast<AlignValueAttr>(At);
102      return A->clone(C);
103    }
104    case attr::Aligned: {
105      const auto *A = cast<AlignedAttr>(At);
106      return A->clone(C);
107    }
108    case attr::AllocAlign: {
109      const auto *A = cast<AllocAlignAttr>(At);
110      return A->clone(C);
111    }
112    case attr::AllocSize: {
113      const auto *A = cast<AllocSizeAttr>(At);
114      return new (C) AllocSizeAttr(A->getLocation(), C, A->getElemSizeParam(), A->getNumElemsParam(), A->getSpellingListIndex());
115    }
116    case attr::AlwaysInline: {
117      const auto *A = cast<AlwaysInlineAttr>(At);
118      return A->clone(C);
119    }
120    case attr::AnalyzerNoReturn: {
121      const auto *A = cast<AnalyzerNoReturnAttr>(At);
122      return A->clone(C);
123    }
124    case attr::Annotate: {
125      const auto *A = cast<AnnotateAttr>(At);
126      return A->clone(C);
127    }
128    case attr::AnyX86Interrupt: {
129      const auto *A = cast<AnyX86InterruptAttr>(At);
130      return A->clone(C);
131    }
132    case attr::AnyX86NoCallerSavedRegisters: {
133      const auto *A = cast<AnyX86NoCallerSavedRegistersAttr>(At);
134      return A->clone(C);
135    }
136    case attr::ArcWeakrefUnavailable: {
137      const auto *A = cast<ArcWeakrefUnavailableAttr>(At);
138      return A->clone(C);
139    }
140    case attr::ArgumentWithTypeTag: {
141      const auto *A = cast<ArgumentWithTypeTagAttr>(At);
142      return A->clone(C);
143    }
144    case attr::AsmLabel: {
145      const auto *A = cast<AsmLabelAttr>(At);
146      return A->clone(C);
147    }
148    case attr::AssertCapability: {
149      const auto *A = cast<AssertCapabilityAttr>(At);
150      auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
151      {
152        EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
153        Expr * *TI = tempInstArgs;
154        Expr * *I = A->args_begin();
155        Expr * *E = A->args_end();
156        for (; I != E; ++I, ++TI) {
157          ExprResult Result = S.SubstExpr(*I, TemplateArgs);
158          *TI = Result.getAs<Expr>();
159        }
160      }
161      return new (C) AssertCapabilityAttr(A->getLocation(), C, tempInstArgs, A->args_size(), A->getSpellingListIndex());
162    }
163    case attr::AssertExclusiveLock: {
164      const auto *A = cast<AssertExclusiveLockAttr>(At);
165      auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
166      {
167        EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
168        Expr * *TI = tempInstArgs;
169        Expr * *I = A->args_begin();
170        Expr * *E = A->args_end();
171        for (; I != E; ++I, ++TI) {
172          ExprResult Result = S.SubstExpr(*I, TemplateArgs);
173          *TI = Result.getAs<Expr>();
174        }
175      }
176      return new (C) AssertExclusiveLockAttr(A->getLocation(), C, tempInstArgs, A->args_size(), A->getSpellingListIndex());
177    }
178    case attr::AssertSharedLock: {
179      const auto *A = cast<AssertSharedLockAttr>(At);
180      auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
181      {
182        EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
183        Expr * *TI = tempInstArgs;
184        Expr * *I = A->args_begin();
185        Expr * *E = A->args_end();
186        for (; I != E; ++I, ++TI) {
187          ExprResult Result = S.SubstExpr(*I, TemplateArgs);
188          *TI = Result.getAs<Expr>();
189        }
190      }
191      return new (C) AssertSharedLockAttr(A->getLocation(), C, tempInstArgs, A->args_size(), A->getSpellingListIndex());
192    }
193    case attr::AssumeAligned: {
194      const auto *A = cast<AssumeAlignedAttr>(At);
195      return A->clone(C);
196    }
197    case attr::Availability: {
198      const auto *A = cast<AvailabilityAttr>(At);
199      return A->clone(C);
200    }
201    case attr::Blocks: {
202      const auto *A = cast<BlocksAttr>(At);
203      return A->clone(C);
204    }
205    case attr::C11NoReturn: {
206      const auto *A = cast<C11NoReturnAttr>(At);
207      return A->clone(C);
208    }
209    case attr::CDecl: {
210      const auto *A = cast<CDeclAttr>(At);
211      return A->clone(C);
212    }
213    case attr::CFAuditedTransfer: {
214      const auto *A = cast<CFAuditedTransferAttr>(At);
215      return A->clone(C);
216    }
217    case attr::CFConsumed: {
218      const auto *A = cast<CFConsumedAttr>(At);
219      return A->clone(C);
220    }
221    case attr::CFReturnsNotRetained: {
222      const auto *A = cast<CFReturnsNotRetainedAttr>(At);
223      return A->clone(C);
224    }
225    case attr::CFReturnsRetained: {
226      const auto *A = cast<CFReturnsRetainedAttr>(At);
227      return A->clone(C);
228    }
229    case attr::CFUnknownTransfer: {
230      const auto *A = cast<CFUnknownTransferAttr>(At);
231      return A->clone(C);
232    }
233    case attr::CUDAConstant: {
234      const auto *A = cast<CUDAConstantAttr>(At);
235      return A->clone(C);
236    }
237    case attr::CUDADevice: {
238      const auto *A = cast<CUDADeviceAttr>(At);
239      return A->clone(C);
240    }
241    case attr::CUDAGlobal: {
242      const auto *A = cast<CUDAGlobalAttr>(At);
243      return A->clone(C);
244    }
245    case attr::CUDAHost: {
246      const auto *A = cast<CUDAHostAttr>(At);
247      return A->clone(C);
248    }
249    case attr::CUDAInvalidTarget: {
250      const auto *A = cast<CUDAInvalidTargetAttr>(At);
251      return A->clone(C);
252    }
253    case attr::CUDALaunchBounds: {
254      const auto *A = cast<CUDALaunchBoundsAttr>(At);
255      return A->clone(C);
256    }
257    case attr::CUDAShared: {
258      const auto *A = cast<CUDASharedAttr>(At);
259      return A->clone(C);
260    }
261    case attr::CXX11NoReturn: {
262      const auto *A = cast<CXX11NoReturnAttr>(At);
263      return A->clone(C);
264    }
265    case attr::CallableWhen: {
266      const auto *A = cast<CallableWhenAttr>(At);
267      return A->clone(C);
268    }
269    case attr::Capability: {
270      const auto *A = cast<CapabilityAttr>(At);
271      return A->clone(C);
272    }
273    case attr::CapturedRecord: {
274      const auto *A = cast<CapturedRecordAttr>(At);
275      return A->clone(C);
276    }
277    case attr::CarriesDependency: {
278      const auto *A = cast<CarriesDependencyAttr>(At);
279      return A->clone(C);
280    }
281    case attr::Cleanup: {
282      const auto *A = cast<CleanupAttr>(At);
283      return A->clone(C);
284    }
285    case attr::Cold: {
286      const auto *A = cast<ColdAttr>(At);
287      return A->clone(C);
288    }
289    case attr::Common: {
290      const auto *A = cast<CommonAttr>(At);
291      return A->clone(C);
292    }
293    case attr::Const: {
294      const auto *A = cast<ConstAttr>(At);
295      return A->clone(C);
296    }
297    case attr::Constructor: {
298      const auto *A = cast<ConstructorAttr>(At);
299      return A->clone(C);
300    }
301    case attr::Consumable: {
302      const auto *A = cast<ConsumableAttr>(At);
303      return A->clone(C);
304    }
305    case attr::ConsumableAutoCast: {
306      const auto *A = cast<ConsumableAutoCastAttr>(At);
307      return A->clone(C);
308    }
309    case attr::ConsumableSetOnRead: {
310      const auto *A = cast<ConsumableSetOnReadAttr>(At);
311      return A->clone(C);
312    }
313    case attr::Convergent: {
314      const auto *A = cast<ConvergentAttr>(At);
315      return A->clone(C);
316    }
317    case attr::DLLExport: {
318      const auto *A = cast<DLLExportAttr>(At);
319      return A->clone(C);
320    }
321    case attr::DLLImport: {
322      const auto *A = cast<DLLImportAttr>(At);
323      return A->clone(C);
324    }
325    case attr::Deprecated: {
326      const auto *A = cast<DeprecatedAttr>(At);
327      return A->clone(C);
328    }
329    case attr::Destructor: {
330      const auto *A = cast<DestructorAttr>(At);
331      return A->clone(C);
332    }
333    case attr::DiagnoseIf: {
334      const auto *A = cast<DiagnoseIfAttr>(At);
335      Expr * tempInstCond;
336      {
337        EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
338        ExprResult Result = S.SubstExpr(A->getCond(), TemplateArgs);
339        tempInstCond = Result.getAs<Expr>();
340      }
341      return new (C) DiagnoseIfAttr(A->getLocation(), C, tempInstCond, A->getMessage(), A->getDiagnosticType(), A->getArgDependent(), A->getParent(), A->getSpellingListIndex());
342    }
343    case attr::DisableTailCalls: {
344      const auto *A = cast<DisableTailCallsAttr>(At);
345      return A->clone(C);
346    }
347    case attr::EmptyBases: {
348      const auto *A = cast<EmptyBasesAttr>(At);
349      return A->clone(C);
350    }
351    case attr::EnableIf: {
352      const auto *A = cast<EnableIfAttr>(At);
353      Expr * tempInstCond;
354      {
355        EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
356        ExprResult Result = S.SubstExpr(A->getCond(), TemplateArgs);
357        tempInstCond = Result.getAs<Expr>();
358      }
359      return new (C) EnableIfAttr(A->getLocation(), C, tempInstCond, A->getMessage(), A->getSpellingListIndex());
360    }
361    case attr::EnumExtensibility: {
362      const auto *A = cast<EnumExtensibilityAttr>(At);
363      return A->clone(C);
364    }
365    case attr::ExclusiveTrylockFunction: {
366      const auto *A = cast<ExclusiveTrylockFunctionAttr>(At);
367      Expr * tempInstSuccessValue;
368      {
369        EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
370        ExprResult Result = S.SubstExpr(A->getSuccessValue(), TemplateArgs);
371        tempInstSuccessValue = Result.getAs<Expr>();
372      }
373      auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
374      {
375        EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
376        Expr * *TI = tempInstArgs;
377        Expr * *I = A->args_begin();
378        Expr * *E = A->args_end();
379        for (; I != E; ++I, ++TI) {
380          ExprResult Result = S.SubstExpr(*I, TemplateArgs);
381          *TI = Result.getAs<Expr>();
382        }
383      }
384      return new (C) ExclusiveTrylockFunctionAttr(A->getLocation(), C, tempInstSuccessValue, tempInstArgs, A->args_size(), A->getSpellingListIndex());
385    }
386    case attr::ExternalSourceSymbol: {
387      const auto *A = cast<ExternalSourceSymbolAttr>(At);
388      return A->clone(C);
389    }
390    case attr::FallThrough: {
391      const auto *A = cast<FallThroughAttr>(At);
392      return A->clone(C);
393    }
394    case attr::FastCall: {
395      const auto *A = cast<FastCallAttr>(At);
396      return A->clone(C);
397    }
398    case attr::Final: {
399      const auto *A = cast<FinalAttr>(At);
400      return A->clone(C);
401    }
402    case attr::FlagEnum: {
403      const auto *A = cast<FlagEnumAttr>(At);
404      return A->clone(C);
405    }
406    case attr::Flatten: {
407      const auto *A = cast<FlattenAttr>(At);
408      return A->clone(C);
409    }
410    case attr::Format: {
411      const auto *A = cast<FormatAttr>(At);
412      return A->clone(C);
413    }
414    case attr::FormatArg: {
415      const auto *A = cast<FormatArgAttr>(At);
416      return A->clone(C);
417    }
418    case attr::GNUInline: {
419      const auto *A = cast<GNUInlineAttr>(At);
420      return A->clone(C);
421    }
422    case attr::GuardedBy: {
423      const auto *A = cast<GuardedByAttr>(At);
424      Expr * tempInstArg;
425      {
426        EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
427        ExprResult Result = S.SubstExpr(A->getArg(), TemplateArgs);
428        tempInstArg = Result.getAs<Expr>();
429      }
430      return new (C) GuardedByAttr(A->getLocation(), C, tempInstArg, A->getSpellingListIndex());
431    }
432    case attr::GuardedVar: {
433      const auto *A = cast<GuardedVarAttr>(At);
434      return A->clone(C);
435    }
436    case attr::Hot: {
437      const auto *A = cast<HotAttr>(At);
438      return A->clone(C);
439    }
440    case attr::IBAction: {
441      const auto *A = cast<IBActionAttr>(At);
442      return A->clone(C);
443    }
444    case attr::IBOutlet: {
445      const auto *A = cast<IBOutletAttr>(At);
446      return A->clone(C);
447    }
448    case attr::IBOutletCollection: {
449      const auto *A = cast<IBOutletCollectionAttr>(At);
450      return A->clone(C);
451    }
452    case attr::IFunc: {
453      const auto *A = cast<IFuncAttr>(At);
454      return A->clone(C);
455    }
456    case attr::InitPriority: {
457      const auto *A = cast<InitPriorityAttr>(At);
458      return A->clone(C);
459    }
460    case attr::InitSeg: {
461      const auto *A = cast<InitSegAttr>(At);
462      return A->clone(C);
463    }
464    case attr::IntelOclBicc: {
465      const auto *A = cast<IntelOclBiccAttr>(At);
466      return A->clone(C);
467    }
468    case attr::InternalLinkage: {
469      const auto *A = cast<InternalLinkageAttr>(At);
470      return A->clone(C);
471    }
472    case attr::LTOVisibilityPublic: {
473      const auto *A = cast<LTOVisibilityPublicAttr>(At);
474      return A->clone(C);
475    }
476    case attr::LayoutVersion: {
477      const auto *A = cast<LayoutVersionAttr>(At);
478      return A->clone(C);
479    }
480    case attr::LockReturned: {
481      const auto *A = cast<LockReturnedAttr>(At);
482      Expr * tempInstArg;
483      {
484        EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
485        ExprResult Result = S.SubstExpr(A->getArg(), TemplateArgs);
486        tempInstArg = Result.getAs<Expr>();
487      }
488      return new (C) LockReturnedAttr(A->getLocation(), C, tempInstArg, A->getSpellingListIndex());
489    }
490    case attr::LocksExcluded: {
491      const auto *A = cast<LocksExcludedAttr>(At);
492      auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
493      {
494        EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
495        Expr * *TI = tempInstArgs;
496        Expr * *I = A->args_begin();
497        Expr * *E = A->args_end();
498        for (; I != E; ++I, ++TI) {
499          ExprResult Result = S.SubstExpr(*I, TemplateArgs);
500          *TI = Result.getAs<Expr>();
501        }
502      }
503      return new (C) LocksExcludedAttr(A->getLocation(), C, tempInstArgs, A->args_size(), A->getSpellingListIndex());
504    }
505    case attr::LoopHint: {
506      const auto *A = cast<LoopHintAttr>(At);
507      return A->clone(C);
508    }
509    case attr::MSABI: {
510      const auto *A = cast<MSABIAttr>(At);
511      return A->clone(C);
512    }
513    case attr::MSInheritance: {
514      const auto *A = cast<MSInheritanceAttr>(At);
515      return A->clone(C);
516    }
517    case attr::MSNoVTable: {
518      const auto *A = cast<MSNoVTableAttr>(At);
519      return A->clone(C);
520    }
521    case attr::MSP430Interrupt: {
522      const auto *A = cast<MSP430InterruptAttr>(At);
523      return A->clone(C);
524    }
525    case attr::MSStruct: {
526      const auto *A = cast<MSStructAttr>(At);
527      return A->clone(C);
528    }
529    case attr::MSVtorDisp: {
530      const auto *A = cast<MSVtorDispAttr>(At);
531      return A->clone(C);
532    }
533    case attr::MaxFieldAlignment: {
534      const auto *A = cast<MaxFieldAlignmentAttr>(At);
535      return A->clone(C);
536    }
537    case attr::MayAlias: {
538      const auto *A = cast<MayAliasAttr>(At);
539      return A->clone(C);
540    }
541    case attr::MicroMips: {
542      const auto *A = cast<MicroMipsAttr>(At);
543      return A->clone(C);
544    }
545    case attr::MinSize: {
546      const auto *A = cast<MinSizeAttr>(At);
547      return A->clone(C);
548    }
549    case attr::Mips16: {
550      const auto *A = cast<Mips16Attr>(At);
551      return A->clone(C);
552    }
553    case attr::MipsInterrupt: {
554      const auto *A = cast<MipsInterruptAttr>(At);
555      return A->clone(C);
556    }
557    case attr::MipsLongCall: {
558      const auto *A = cast<MipsLongCallAttr>(At);
559      return A->clone(C);
560    }
561    case attr::MipsShortCall: {
562      const auto *A = cast<MipsShortCallAttr>(At);
563      return A->clone(C);
564    }
565    case attr::Mode: {
566      const auto *A = cast<ModeAttr>(At);
567      return A->clone(C);
568    }
569    case attr::NSConsumed: {
570      const auto *A = cast<NSConsumedAttr>(At);
571      return A->clone(C);
572    }
573    case attr::NSConsumesSelf: {
574      const auto *A = cast<NSConsumesSelfAttr>(At);
575      return A->clone(C);
576    }
577    case attr::NSReturnsAutoreleased: {
578      const auto *A = cast<NSReturnsAutoreleasedAttr>(At);
579      return A->clone(C);
580    }
581    case attr::NSReturnsNotRetained: {
582      const auto *A = cast<NSReturnsNotRetainedAttr>(At);
583      return A->clone(C);
584    }
585    case attr::NSReturnsRetained: {
586      const auto *A = cast<NSReturnsRetainedAttr>(At);
587      return A->clone(C);
588    }
589    case attr::Naked: {
590      const auto *A = cast<NakedAttr>(At);
591      return A->clone(C);
592    }
593    case attr::NoAlias: {
594      const auto *A = cast<NoAliasAttr>(At);
595      return A->clone(C);
596    }
597    case attr::NoCommon: {
598      const auto *A = cast<NoCommonAttr>(At);
599      return A->clone(C);
600    }
601    case attr::NoDebug: {
602      const auto *A = cast<NoDebugAttr>(At);
603      return A->clone(C);
604    }
605    case attr::NoDuplicate: {
606      const auto *A = cast<NoDuplicateAttr>(At);
607      return A->clone(C);
608    }
609    case attr::NoEscape: {
610      const auto *A = cast<NoEscapeAttr>(At);
611      return A->clone(C);
612    }
613    case attr::NoInline: {
614      const auto *A = cast<NoInlineAttr>(At);
615      return A->clone(C);
616    }
617    case attr::NoInstrumentFunction: {
618      const auto *A = cast<NoInstrumentFunctionAttr>(At);
619      return A->clone(C);
620    }
621    case attr::NoMicroMips: {
622      const auto *A = cast<NoMicroMipsAttr>(At);
623      return A->clone(C);
624    }
625    case attr::NoMips16: {
626      const auto *A = cast<NoMips16Attr>(At);
627      return A->clone(C);
628    }
629    case attr::NoReturn: {
630      const auto *A = cast<NoReturnAttr>(At);
631      return A->clone(C);
632    }
633    case attr::NoSanitize: {
634      const auto *A = cast<NoSanitizeAttr>(At);
635      return A->clone(C);
636    }
637    case attr::NoSplitStack: {
638      const auto *A = cast<NoSplitStackAttr>(At);
639      return A->clone(C);
640    }
641    case attr::NoThreadSafetyAnalysis: {
642      const auto *A = cast<NoThreadSafetyAnalysisAttr>(At);
643      return A->clone(C);
644    }
645    case attr::NoThrow: {
646      const auto *A = cast<NoThrowAttr>(At);
647      return A->clone(C);
648    }
649    case attr::NonNull: {
650      const auto *A = cast<NonNullAttr>(At);
651      return A->clone(C);
652    }
653    case attr::NotTailCalled: {
654      const auto *A = cast<NotTailCalledAttr>(At);
655      return A->clone(C);
656    }
657    case attr::OMPCaptureKind: {
658      const auto *A = cast<OMPCaptureKindAttr>(At);
659      return A->clone(C);
660    }
661    case attr::OMPCaptureNoInit: {
662      const auto *A = cast<OMPCaptureNoInitAttr>(At);
663      return A->clone(C);
664    }
665    case attr::OMPDeclareSimdDecl: {
666      const auto *A = cast<OMPDeclareSimdDeclAttr>(At);
667      return A->clone(C);
668    }
669    case attr::OMPDeclareTargetDecl: {
670      const auto *A = cast<OMPDeclareTargetDeclAttr>(At);
671      return A->clone(C);
672    }
673    case attr::OMPThreadPrivateDecl: {
674      const auto *A = cast<OMPThreadPrivateDeclAttr>(At);
675      return A->clone(C);
676    }
677    case attr::ObjCBoxable: {
678      const auto *A = cast<ObjCBoxableAttr>(At);
679      return A->clone(C);
680    }
681    case attr::ObjCBridge: {
682      const auto *A = cast<ObjCBridgeAttr>(At);
683      return A->clone(C);
684    }
685    case attr::ObjCBridgeMutable: {
686      const auto *A = cast<ObjCBridgeMutableAttr>(At);
687      return A->clone(C);
688    }
689    case attr::ObjCBridgeRelated: {
690      const auto *A = cast<ObjCBridgeRelatedAttr>(At);
691      return A->clone(C);
692    }
693    case attr::ObjCDesignatedInitializer: {
694      const auto *A = cast<ObjCDesignatedInitializerAttr>(At);
695      return A->clone(C);
696    }
697    case attr::ObjCException: {
698      const auto *A = cast<ObjCExceptionAttr>(At);
699      return A->clone(C);
700    }
701    case attr::ObjCExplicitProtocolImpl: {
702      const auto *A = cast<ObjCExplicitProtocolImplAttr>(At);
703      return A->clone(C);
704    }
705    case attr::ObjCIndependentClass: {
706      const auto *A = cast<ObjCIndependentClassAttr>(At);
707      return A->clone(C);
708    }
709    case attr::ObjCMethodFamily: {
710      const auto *A = cast<ObjCMethodFamilyAttr>(At);
711      return A->clone(C);
712    }
713    case attr::ObjCNSObject: {
714      const auto *A = cast<ObjCNSObjectAttr>(At);
715      return A->clone(C);
716    }
717    case attr::ObjCPreciseLifetime: {
718      const auto *A = cast<ObjCPreciseLifetimeAttr>(At);
719      return A->clone(C);
720    }
721    case attr::ObjCRequiresPropertyDefs: {
722      const auto *A = cast<ObjCRequiresPropertyDefsAttr>(At);
723      return A->clone(C);
724    }
725    case attr::ObjCRequiresSuper: {
726      const auto *A = cast<ObjCRequiresSuperAttr>(At);
727      return A->clone(C);
728    }
729    case attr::ObjCReturnsInnerPointer: {
730      const auto *A = cast<ObjCReturnsInnerPointerAttr>(At);
731      return A->clone(C);
732    }
733    case attr::ObjCRootClass: {
734      const auto *A = cast<ObjCRootClassAttr>(At);
735      return A->clone(C);
736    }
737    case attr::ObjCRuntimeName: {
738      const auto *A = cast<ObjCRuntimeNameAttr>(At);
739      return A->clone(C);
740    }
741    case attr::ObjCRuntimeVisible: {
742      const auto *A = cast<ObjCRuntimeVisibleAttr>(At);
743      return A->clone(C);
744    }
745    case attr::ObjCSubclassingRestricted: {
746      const auto *A = cast<ObjCSubclassingRestrictedAttr>(At);
747      return A->clone(C);
748    }
749    case attr::OpenCLAccess: {
750      const auto *A = cast<OpenCLAccessAttr>(At);
751      return A->clone(C);
752    }
753    case attr::OpenCLIntelReqdSubGroupSize: {
754      const auto *A = cast<OpenCLIntelReqdSubGroupSizeAttr>(At);
755      return A->clone(C);
756    }
757    case attr::OpenCLKernel: {
758      const auto *A = cast<OpenCLKernelAttr>(At);
759      return A->clone(C);
760    }
761    case attr::OpenCLUnrollHint: {
762      const auto *A = cast<OpenCLUnrollHintAttr>(At);
763      return A->clone(C);
764    }
765    case attr::OptimizeNone: {
766      const auto *A = cast<OptimizeNoneAttr>(At);
767      return A->clone(C);
768    }
769    case attr::Overloadable: {
770      const auto *A = cast<OverloadableAttr>(At);
771      return A->clone(C);
772    }
773    case attr::Override: {
774      const auto *A = cast<OverrideAttr>(At);
775      return A->clone(C);
776    }
777    case attr::Ownership: {
778      const auto *A = cast<OwnershipAttr>(At);
779      return A->clone(C);
780    }
781    case attr::Packed: {
782      const auto *A = cast<PackedAttr>(At);
783      return A->clone(C);
784    }
785    case attr::ParamTypestate: {
786      const auto *A = cast<ParamTypestateAttr>(At);
787      return A->clone(C);
788    }
789    case attr::Pascal: {
790      const auto *A = cast<PascalAttr>(At);
791      return A->clone(C);
792    }
793    case attr::PassObjectSize: {
794      const auto *A = cast<PassObjectSizeAttr>(At);
795      return A->clone(C);
796    }
797    case attr::Pcs: {
798      const auto *A = cast<PcsAttr>(At);
799      return A->clone(C);
800    }
801    case attr::PragmaClangBSSSection: {
802      const auto *A = cast<PragmaClangBSSSectionAttr>(At);
803      return A->clone(C);
804    }
805    case attr::PragmaClangDataSection: {
806      const auto *A = cast<PragmaClangDataSectionAttr>(At);
807      return A->clone(C);
808    }
809    case attr::PragmaClangRodataSection: {
810      const auto *A = cast<PragmaClangRodataSectionAttr>(At);
811      return A->clone(C);
812    }
813    case attr::PragmaClangTextSection: {
814      const auto *A = cast<PragmaClangTextSectionAttr>(At);
815      return A->clone(C);
816    }
817    case attr::PreserveAll: {
818      const auto *A = cast<PreserveAllAttr>(At);
819      return A->clone(C);
820    }
821    case attr::PreserveMost: {
822      const auto *A = cast<PreserveMostAttr>(At);
823      return A->clone(C);
824    }
825    case attr::PtGuardedBy: {
826      const auto *A = cast<PtGuardedByAttr>(At);
827      Expr * tempInstArg;
828      {
829        EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
830        ExprResult Result = S.SubstExpr(A->getArg(), TemplateArgs);
831        tempInstArg = Result.getAs<Expr>();
832      }
833      return new (C) PtGuardedByAttr(A->getLocation(), C, tempInstArg, A->getSpellingListIndex());
834    }
835    case attr::PtGuardedVar: {
836      const auto *A = cast<PtGuardedVarAttr>(At);
837      return A->clone(C);
838    }
839    case attr::Pure: {
840      const auto *A = cast<PureAttr>(At);
841      return A->clone(C);
842    }
843    case attr::RegCall: {
844      const auto *A = cast<RegCallAttr>(At);
845      return A->clone(C);
846    }
847    case attr::ReleaseCapability: {
848      const auto *A = cast<ReleaseCapabilityAttr>(At);
849      auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
850      {
851        EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
852        Expr * *TI = tempInstArgs;
853        Expr * *I = A->args_begin();
854        Expr * *E = A->args_end();
855        for (; I != E; ++I, ++TI) {
856          ExprResult Result = S.SubstExpr(*I, TemplateArgs);
857          *TI = Result.getAs<Expr>();
858        }
859      }
860      return new (C) ReleaseCapabilityAttr(A->getLocation(), C, tempInstArgs, A->args_size(), A->getSpellingListIndex());
861    }
862    case attr::RenderScriptKernel: {
863      const auto *A = cast<RenderScriptKernelAttr>(At);
864      return A->clone(C);
865    }
866    case attr::ReqdWorkGroupSize: {
867      const auto *A = cast<ReqdWorkGroupSizeAttr>(At);
868      return A->clone(C);
869    }
870    case attr::RequireConstantInit: {
871      const auto *A = cast<RequireConstantInitAttr>(At);
872      return A->clone(C);
873    }
874    case attr::RequiresCapability: {
875      const auto *A = cast<RequiresCapabilityAttr>(At);
876      auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
877      {
878        EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
879        Expr * *TI = tempInstArgs;
880        Expr * *I = A->args_begin();
881        Expr * *E = A->args_end();
882        for (; I != E; ++I, ++TI) {
883          ExprResult Result = S.SubstExpr(*I, TemplateArgs);
884          *TI = Result.getAs<Expr>();
885        }
886      }
887      return new (C) RequiresCapabilityAttr(A->getLocation(), C, tempInstArgs, A->args_size(), A->getSpellingListIndex());
888    }
889    case attr::Restrict: {
890      const auto *A = cast<RestrictAttr>(At);
891      return A->clone(C);
892    }
893    case attr::ReturnTypestate: {
894      const auto *A = cast<ReturnTypestateAttr>(At);
895      return A->clone(C);
896    }
897    case attr::ReturnsNonNull: {
898      const auto *A = cast<ReturnsNonNullAttr>(At);
899      return A->clone(C);
900    }
901    case attr::ReturnsTwice: {
902      const auto *A = cast<ReturnsTwiceAttr>(At);
903      return A->clone(C);
904    }
905    case attr::ScopedLockable: {
906      const auto *A = cast<ScopedLockableAttr>(At);
907      return A->clone(C);
908    }
909    case attr::Section: {
910      const auto *A = cast<SectionAttr>(At);
911      return A->clone(C);
912    }
913    case attr::SelectAny: {
914      const auto *A = cast<SelectAnyAttr>(At);
915      return A->clone(C);
916    }
917    case attr::Sentinel: {
918      const auto *A = cast<SentinelAttr>(At);
919      return A->clone(C);
920    }
921    case attr::SetTypestate: {
922      const auto *A = cast<SetTypestateAttr>(At);
923      return A->clone(C);
924    }
925    case attr::SharedTrylockFunction: {
926      const auto *A = cast<SharedTrylockFunctionAttr>(At);
927      Expr * tempInstSuccessValue;
928      {
929        EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
930        ExprResult Result = S.SubstExpr(A->getSuccessValue(), TemplateArgs);
931        tempInstSuccessValue = Result.getAs<Expr>();
932      }
933      auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
934      {
935        EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
936        Expr * *TI = tempInstArgs;
937        Expr * *I = A->args_begin();
938        Expr * *E = A->args_end();
939        for (; I != E; ++I, ++TI) {
940          ExprResult Result = S.SubstExpr(*I, TemplateArgs);
941          *TI = Result.getAs<Expr>();
942        }
943      }
944      return new (C) SharedTrylockFunctionAttr(A->getLocation(), C, tempInstSuccessValue, tempInstArgs, A->args_size(), A->getSpellingListIndex());
945    }
946    case attr::StdCall: {
947      const auto *A = cast<StdCallAttr>(At);
948      return A->clone(C);
949    }
950    case attr::Suppress: {
951      const auto *A = cast<SuppressAttr>(At);
952      return A->clone(C);
953    }
954    case attr::SwiftCall: {
955      const auto *A = cast<SwiftCallAttr>(At);
956      return A->clone(C);
957    }
958    case attr::SwiftContext: {
959      const auto *A = cast<SwiftContextAttr>(At);
960      return A->clone(C);
961    }
962    case attr::SwiftErrorResult: {
963      const auto *A = cast<SwiftErrorResultAttr>(At);
964      return A->clone(C);
965    }
966    case attr::SwiftIndirectResult: {
967      const auto *A = cast<SwiftIndirectResultAttr>(At);
968      return A->clone(C);
969    }
970    case attr::SysVABI: {
971      const auto *A = cast<SysVABIAttr>(At);
972      return A->clone(C);
973    }
974    case attr::TLSModel: {
975      const auto *A = cast<TLSModelAttr>(At);
976      return A->clone(C);
977    }
978    case attr::Target: {
979      const auto *A = cast<TargetAttr>(At);
980      return A->clone(C);
981    }
982    case attr::TestTypestate: {
983      const auto *A = cast<TestTypestateAttr>(At);
984      return A->clone(C);
985    }
986    case attr::ThisCall: {
987      const auto *A = cast<ThisCallAttr>(At);
988      return A->clone(C);
989    }
990    case attr::Thread: {
991      const auto *A = cast<ThreadAttr>(At);
992      return A->clone(C);
993    }
994    case attr::TransparentUnion: {
995      const auto *A = cast<TransparentUnionAttr>(At);
996      return A->clone(C);
997    }
998    case attr::TryAcquireCapability: {
999      const auto *A = cast<TryAcquireCapabilityAttr>(At);
1000      Expr * tempInstSuccessValue;
1001      {
1002        EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
1003        ExprResult Result = S.SubstExpr(A->getSuccessValue(), TemplateArgs);
1004        tempInstSuccessValue = Result.getAs<Expr>();
1005      }
1006      auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
1007      {
1008        EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
1009        Expr * *TI = tempInstArgs;
1010        Expr * *I = A->args_begin();
1011        Expr * *E = A->args_end();
1012        for (; I != E; ++I, ++TI) {
1013          ExprResult Result = S.SubstExpr(*I, TemplateArgs);
1014          *TI = Result.getAs<Expr>();
1015        }
1016      }
1017      return new (C) TryAcquireCapabilityAttr(A->getLocation(), C, tempInstSuccessValue, tempInstArgs, A->args_size(), A->getSpellingListIndex());
1018    }
1019    case attr::TypeTagForDatatype: {
1020      const auto *A = cast<TypeTagForDatatypeAttr>(At);
1021      return A->clone(C);
1022    }
1023    case attr::TypeVisibility: {
1024      return nullptr;
1025    }
1026    case attr::Unavailable: {
1027      const auto *A = cast<UnavailableAttr>(At);
1028      return A->clone(C);
1029    }
1030    case attr::Unused: {
1031      const auto *A = cast<UnusedAttr>(At);
1032      return A->clone(C);
1033    }
1034    case attr::Used: {
1035      const auto *A = cast<UsedAttr>(At);
1036      return A->clone(C);
1037    }
1038    case attr::Uuid: {
1039      const auto *A = cast<UuidAttr>(At);
1040      return A->clone(C);
1041    }
1042    case attr::VecReturn: {
1043      const auto *A = cast<VecReturnAttr>(At);
1044      return A->clone(C);
1045    }
1046    case attr::VecTypeHint: {
1047      const auto *A = cast<VecTypeHintAttr>(At);
1048      return A->clone(C);
1049    }
1050    case attr::VectorCall: {
1051      const auto *A = cast<VectorCallAttr>(At);
1052      return A->clone(C);
1053    }
1054    case attr::Visibility: {
1055      return nullptr;
1056    }
1057    case attr::WarnUnused: {
1058      const auto *A = cast<WarnUnusedAttr>(At);
1059      return A->clone(C);
1060    }
1061    case attr::WarnUnusedResult: {
1062      const auto *A = cast<WarnUnusedResultAttr>(At);
1063      return A->clone(C);
1064    }
1065    case attr::Weak: {
1066      const auto *A = cast<WeakAttr>(At);
1067      return A->clone(C);
1068    }
1069    case attr::WeakImport: {
1070      const auto *A = cast<WeakImportAttr>(At);
1071      return A->clone(C);
1072    }
1073    case attr::WeakRef: {
1074      const auto *A = cast<WeakRefAttr>(At);
1075      return A->clone(C);
1076    }
1077    case attr::WorkGroupSizeHint: {
1078      const auto *A = cast<WorkGroupSizeHintAttr>(At);
1079      return A->clone(C);
1080    }
1081    case attr::X86ForceAlignArgPointer: {
1082      const auto *A = cast<X86ForceAlignArgPointerAttr>(At);
1083      return A->clone(C);
1084    }
1085    case attr::XRayInstrument: {
1086      const auto *A = cast<XRayInstrumentAttr>(At);
1087      return A->clone(C);
1088    }
1089    case attr::XRayLogArgs: {
1090      const auto *A = cast<XRayLogArgsAttr>(At);
1091      return A->clone(C);
1092    }
1093  } // end switch
1094  llvm_unreachable("Unknown attribute!");
1095  return nullptr;
1096}
1097
1098Attr *instantiateTemplateAttributeForDecl(const Attr *At,
1099 ASTContext &C, Sema &S,
1100        const MultiLevelTemplateArgumentList &TemplateArgs) {
1101  switch (At->getKind()) {
1102    case attr::AMDGPUFlatWorkGroupSize: {
1103      return nullptr;
1104    }
1105    case attr::AMDGPUNumSGPR: {
1106      return nullptr;
1107    }
1108    case attr::AMDGPUNumVGPR: {
1109      return nullptr;
1110    }
1111    case attr::AMDGPUWavesPerEU: {
1112      return nullptr;
1113    }
1114    case attr::ARMInterrupt: {
1115      return nullptr;
1116    }
1117    case attr::AVRInterrupt: {
1118      return nullptr;
1119    }
1120    case attr::AVRSignal: {
1121      return nullptr;
1122    }
1123    case attr::AbiTag: {
1124      const auto *A = cast<AbiTagAttr>(At);
1125      return A->clone(C);
1126    }
1127    case attr::AcquireCapability: {
1128      return nullptr;
1129    }
1130    case attr::AcquiredAfter: {
1131      return nullptr;
1132    }
1133    case attr::AcquiredBefore: {
1134      return nullptr;
1135    }
1136    case attr::Alias: {
1137      return nullptr;
1138    }
1139    case attr::AlignMac68k: {
1140      return nullptr;
1141    }
1142    case attr::AlignValue: {
1143      return nullptr;
1144    }
1145    case attr::Aligned: {
1146      return nullptr;
1147    }
1148    case attr::AllocAlign: {
1149      return nullptr;
1150    }
1151    case attr::AllocSize: {
1152      return nullptr;
1153    }
1154    case attr::AlwaysInline: {
1155      return nullptr;
1156    }
1157    case attr::AnalyzerNoReturn: {
1158      return nullptr;
1159    }
1160    case attr::Annotate: {
1161      return nullptr;
1162    }
1163    case attr::AnyX86Interrupt: {
1164      return nullptr;
1165    }
1166    case attr::AnyX86NoCallerSavedRegisters: {
1167      return nullptr;
1168    }
1169    case attr::ArcWeakrefUnavailable: {
1170      return nullptr;
1171    }
1172    case attr::ArgumentWithTypeTag: {
1173      return nullptr;
1174    }
1175    case attr::AsmLabel: {
1176      return nullptr;
1177    }
1178    case attr::AssertCapability: {
1179      return nullptr;
1180    }
1181    case attr::AssertExclusiveLock: {
1182      return nullptr;
1183    }
1184    case attr::AssertSharedLock: {
1185      return nullptr;
1186    }
1187    case attr::AssumeAligned: {
1188      return nullptr;
1189    }
1190    case attr::Availability: {
1191      return nullptr;
1192    }
1193    case attr::Blocks: {
1194      return nullptr;
1195    }
1196    case attr::C11NoReturn: {
1197      return nullptr;
1198    }
1199    case attr::CDecl: {
1200      return nullptr;
1201    }
1202    case attr::CFAuditedTransfer: {
1203      return nullptr;
1204    }
1205    case attr::CFConsumed: {
1206      return nullptr;
1207    }
1208    case attr::CFReturnsNotRetained: {
1209      return nullptr;
1210    }
1211    case attr::CFReturnsRetained: {
1212      return nullptr;
1213    }
1214    case attr::CFUnknownTransfer: {
1215      return nullptr;
1216    }
1217    case attr::CUDAConstant: {
1218      return nullptr;
1219    }
1220    case attr::CUDADevice: {
1221      return nullptr;
1222    }
1223    case attr::CUDAGlobal: {
1224      return nullptr;
1225    }
1226    case attr::CUDAHost: {
1227      return nullptr;
1228    }
1229    case attr::CUDAInvalidTarget: {
1230      return nullptr;
1231    }
1232    case attr::CUDALaunchBounds: {
1233      return nullptr;
1234    }
1235    case attr::CUDAShared: {
1236      return nullptr;
1237    }
1238    case attr::CXX11NoReturn: {
1239      return nullptr;
1240    }
1241    case attr::CallableWhen: {
1242      return nullptr;
1243    }
1244    case attr::Capability: {
1245      return nullptr;
1246    }
1247    case attr::CapturedRecord: {
1248      return nullptr;
1249    }
1250    case attr::CarriesDependency: {
1251      return nullptr;
1252    }
1253    case attr::Cleanup: {
1254      return nullptr;
1255    }
1256    case attr::Cold: {
1257      return nullptr;
1258    }
1259    case attr::Common: {
1260      return nullptr;
1261    }
1262    case attr::Const: {
1263      return nullptr;
1264    }
1265    case attr::Constructor: {
1266      return nullptr;
1267    }
1268    case attr::Consumable: {
1269      return nullptr;
1270    }
1271    case attr::ConsumableAutoCast: {
1272      return nullptr;
1273    }
1274    case attr::ConsumableSetOnRead: {
1275      return nullptr;
1276    }
1277    case attr::Convergent: {
1278      return nullptr;
1279    }
1280    case attr::DLLExport: {
1281      return nullptr;
1282    }
1283    case attr::DLLImport: {
1284      return nullptr;
1285    }
1286    case attr::Deprecated: {
1287      const auto *A = cast<DeprecatedAttr>(At);
1288      return A->clone(C);
1289    }
1290    case attr::Destructor: {
1291      return nullptr;
1292    }
1293    case attr::DiagnoseIf: {
1294      return nullptr;
1295    }
1296    case attr::DisableTailCalls: {
1297      return nullptr;
1298    }
1299    case attr::EmptyBases: {
1300      return nullptr;
1301    }
1302    case attr::EnableIf: {
1303      return nullptr;
1304    }
1305    case attr::EnumExtensibility: {
1306      return nullptr;
1307    }
1308    case attr::ExclusiveTrylockFunction: {
1309      return nullptr;
1310    }
1311    case attr::ExternalSourceSymbol: {
1312      return nullptr;
1313    }
1314    case attr::FallThrough: {
1315      return nullptr;
1316    }
1317    case attr::FastCall: {
1318      return nullptr;
1319    }
1320    case attr::Final: {
1321      return nullptr;
1322    }
1323    case attr::FlagEnum: {
1324      return nullptr;
1325    }
1326    case attr::Flatten: {
1327      return nullptr;
1328    }
1329    case attr::Format: {
1330      return nullptr;
1331    }
1332    case attr::FormatArg: {
1333      return nullptr;
1334    }
1335    case attr::GNUInline: {
1336      return nullptr;
1337    }
1338    case attr::GuardedBy: {
1339      return nullptr;
1340    }
1341    case attr::GuardedVar: {
1342      return nullptr;
1343    }
1344    case attr::Hot: {
1345      return nullptr;
1346    }
1347    case attr::IBAction: {
1348      return nullptr;
1349    }
1350    case attr::IBOutlet: {
1351      return nullptr;
1352    }
1353    case attr::IBOutletCollection: {
1354      return nullptr;
1355    }
1356    case attr::IFunc: {
1357      return nullptr;
1358    }
1359    case attr::InitPriority: {
1360      return nullptr;
1361    }
1362    case attr::InitSeg: {
1363      return nullptr;
1364    }
1365    case attr::IntelOclBicc: {
1366      return nullptr;
1367    }
1368    case attr::InternalLinkage: {
1369      return nullptr;
1370    }
1371    case attr::LTOVisibilityPublic: {
1372      return nullptr;
1373    }
1374    case attr::LayoutVersion: {
1375      return nullptr;
1376    }
1377    case attr::LockReturned: {
1378      return nullptr;
1379    }
1380    case attr::LocksExcluded: {
1381      return nullptr;
1382    }
1383    case attr::LoopHint: {
1384      return nullptr;
1385    }
1386    case attr::MSABI: {
1387      return nullptr;
1388    }
1389    case attr::MSInheritance: {
1390      return nullptr;
1391    }
1392    case attr::MSNoVTable: {
1393      return nullptr;
1394    }
1395    case attr::MSP430Interrupt: {
1396      return nullptr;
1397    }
1398    case attr::MSStruct: {
1399      return nullptr;
1400    }
1401    case attr::MSVtorDisp: {
1402      return nullptr;
1403    }
1404    case attr::MaxFieldAlignment: {
1405      return nullptr;
1406    }
1407    case attr::MayAlias: {
1408      return nullptr;
1409    }
1410    case attr::MicroMips: {
1411      return nullptr;
1412    }
1413    case attr::MinSize: {
1414      return nullptr;
1415    }
1416    case attr::Mips16: {
1417      return nullptr;
1418    }
1419    case attr::MipsInterrupt: {
1420      return nullptr;
1421    }
1422    case attr::MipsLongCall: {
1423      return nullptr;
1424    }
1425    case attr::MipsShortCall: {
1426      return nullptr;
1427    }
1428    case attr::Mode: {
1429      return nullptr;
1430    }
1431    case attr::NSConsumed: {
1432      return nullptr;
1433    }
1434    case attr::NSConsumesSelf: {
1435      return nullptr;
1436    }
1437    case attr::NSReturnsAutoreleased: {
1438      return nullptr;
1439    }
1440    case attr::NSReturnsNotRetained: {
1441      return nullptr;
1442    }
1443    case attr::NSReturnsRetained: {
1444      return nullptr;
1445    }
1446    case attr::Naked: {
1447      return nullptr;
1448    }
1449    case attr::NoAlias: {
1450      return nullptr;
1451    }
1452    case attr::NoCommon: {
1453      return nullptr;
1454    }
1455    case attr::NoDebug: {
1456      return nullptr;
1457    }
1458    case attr::NoDuplicate: {
1459      return nullptr;
1460    }
1461    case attr::NoEscape: {
1462      return nullptr;
1463    }
1464    case attr::NoInline: {
1465      return nullptr;
1466    }
1467    case attr::NoInstrumentFunction: {
1468      return nullptr;
1469    }
1470    case attr::NoMicroMips: {
1471      return nullptr;
1472    }
1473    case attr::NoMips16: {
1474      return nullptr;
1475    }
1476    case attr::NoReturn: {
1477      return nullptr;
1478    }
1479    case attr::NoSanitize: {
1480      return nullptr;
1481    }
1482    case attr::NoSplitStack: {
1483      return nullptr;
1484    }
1485    case attr::NoThreadSafetyAnalysis: {
1486      return nullptr;
1487    }
1488    case attr::NoThrow: {
1489      return nullptr;
1490    }
1491    case attr::NonNull: {
1492      return nullptr;
1493    }
1494    case attr::NotTailCalled: {
1495      return nullptr;
1496    }
1497    case attr::OMPCaptureKind: {
1498      return nullptr;
1499    }
1500    case attr::OMPCaptureNoInit: {
1501      return nullptr;
1502    }
1503    case attr::OMPDeclareSimdDecl: {
1504      return nullptr;
1505    }
1506    case attr::OMPDeclareTargetDecl: {
1507      return nullptr;
1508    }
1509    case attr::OMPThreadPrivateDecl: {
1510      return nullptr;
1511    }
1512    case attr::ObjCBoxable: {
1513      return nullptr;
1514    }
1515    case attr::ObjCBridge: {
1516      return nullptr;
1517    }
1518    case attr::ObjCBridgeMutable: {
1519      return nullptr;
1520    }
1521    case attr::ObjCBridgeRelated: {
1522      return nullptr;
1523    }
1524    case attr::ObjCDesignatedInitializer: {
1525      return nullptr;
1526    }
1527    case attr::ObjCException: {
1528      return nullptr;
1529    }
1530    case attr::ObjCExplicitProtocolImpl: {
1531      return nullptr;
1532    }
1533    case attr::ObjCIndependentClass: {
1534      return nullptr;
1535    }
1536    case attr::ObjCMethodFamily: {
1537      return nullptr;
1538    }
1539    case attr::ObjCNSObject: {
1540      return nullptr;
1541    }
1542    case attr::ObjCPreciseLifetime: {
1543      return nullptr;
1544    }
1545    case attr::ObjCRequiresPropertyDefs: {
1546      return nullptr;
1547    }
1548    case attr::ObjCRequiresSuper: {
1549      return nullptr;
1550    }
1551    case attr::ObjCReturnsInnerPointer: {
1552      return nullptr;
1553    }
1554    case attr::ObjCRootClass: {
1555      return nullptr;
1556    }
1557    case attr::ObjCRuntimeName: {
1558      return nullptr;
1559    }
1560    case attr::ObjCRuntimeVisible: {
1561      return nullptr;
1562    }
1563    case attr::ObjCSubclassingRestricted: {
1564      return nullptr;
1565    }
1566    case attr::OpenCLAccess: {
1567      return nullptr;
1568    }
1569    case attr::OpenCLIntelReqdSubGroupSize: {
1570      return nullptr;
1571    }
1572    case attr::OpenCLKernel: {
1573      return nullptr;
1574    }
1575    case attr::OpenCLUnrollHint: {
1576      return nullptr;
1577    }
1578    case attr::OptimizeNone: {
1579      return nullptr;
1580    }
1581    case attr::Overloadable: {
1582      return nullptr;
1583    }
1584    case attr::Override: {
1585      return nullptr;
1586    }
1587    case attr::Ownership: {
1588      return nullptr;
1589    }
1590    case attr::Packed: {
1591      return nullptr;
1592    }
1593    case attr::ParamTypestate: {
1594      return nullptr;
1595    }
1596    case attr::Pascal: {
1597      return nullptr;
1598    }
1599    case attr::PassObjectSize: {
1600      return nullptr;
1601    }
1602    case attr::Pcs: {
1603      return nullptr;
1604    }
1605    case attr::PragmaClangBSSSection: {
1606      return nullptr;
1607    }
1608    case attr::PragmaClangDataSection: {
1609      return nullptr;
1610    }
1611    case attr::PragmaClangRodataSection: {
1612      return nullptr;
1613    }
1614    case attr::PragmaClangTextSection: {
1615      return nullptr;
1616    }
1617    case attr::PreserveAll: {
1618      return nullptr;
1619    }
1620    case attr::PreserveMost: {
1621      return nullptr;
1622    }
1623    case attr::PtGuardedBy: {
1624      return nullptr;
1625    }
1626    case attr::PtGuardedVar: {
1627      return nullptr;
1628    }
1629    case attr::Pure: {
1630      return nullptr;
1631    }
1632    case attr::RegCall: {
1633      return nullptr;
1634    }
1635    case attr::ReleaseCapability: {
1636      return nullptr;
1637    }
1638    case attr::RenderScriptKernel: {
1639      return nullptr;
1640    }
1641    case attr::ReqdWorkGroupSize: {
1642      return nullptr;
1643    }
1644    case attr::RequireConstantInit: {
1645      return nullptr;
1646    }
1647    case attr::RequiresCapability: {
1648      return nullptr;
1649    }
1650    case attr::Restrict: {
1651      return nullptr;
1652    }
1653    case attr::ReturnTypestate: {
1654      return nullptr;
1655    }
1656    case attr::ReturnsNonNull: {
1657      return nullptr;
1658    }
1659    case attr::ReturnsTwice: {
1660      return nullptr;
1661    }
1662    case attr::ScopedLockable: {
1663      return nullptr;
1664    }
1665    case attr::Section: {
1666      return nullptr;
1667    }
1668    case attr::SelectAny: {
1669      return nullptr;
1670    }
1671    case attr::Sentinel: {
1672      return nullptr;
1673    }
1674    case attr::SetTypestate: {
1675      return nullptr;
1676    }
1677    case attr::SharedTrylockFunction: {
1678      return nullptr;
1679    }
1680    case attr::StdCall: {
1681      return nullptr;
1682    }
1683    case attr::Suppress: {
1684      return nullptr;
1685    }
1686    case attr::SwiftCall: {
1687      return nullptr;
1688    }
1689    case attr::SwiftContext: {
1690      return nullptr;
1691    }
1692    case attr::SwiftErrorResult: {
1693      return nullptr;
1694    }
1695    case attr::SwiftIndirectResult: {
1696      return nullptr;
1697    }
1698    case attr::SysVABI: {
1699      return nullptr;
1700    }
1701    case attr::TLSModel: {
1702      return nullptr;
1703    }
1704    case attr::Target: {
1705      return nullptr;
1706    }
1707    case attr::TestTypestate: {
1708      return nullptr;
1709    }
1710    case attr::ThisCall: {
1711      return nullptr;
1712    }
1713    case attr::Thread: {
1714      return nullptr;
1715    }
1716    case attr::TransparentUnion: {
1717      return nullptr;
1718    }
1719    case attr::TryAcquireCapability: {
1720      return nullptr;
1721    }
1722    case attr::TypeTagForDatatype: {
1723      return nullptr;
1724    }
1725    case attr::TypeVisibility: {
1726      return nullptr;
1727    }
1728    case attr::Unavailable: {
1729      return nullptr;
1730    }
1731    case attr::Unused: {
1732      return nullptr;
1733    }
1734    case attr::Used: {
1735      return nullptr;
1736    }
1737    case attr::Uuid: {
1738      return nullptr;
1739    }
1740    case attr::VecReturn: {
1741      return nullptr;
1742    }
1743    case attr::VecTypeHint: {
1744      return nullptr;
1745    }
1746    case attr::VectorCall: {
1747      return nullptr;
1748    }
1749    case attr::Visibility: {
1750      return nullptr;
1751    }
1752    case attr::WarnUnused: {
1753      return nullptr;
1754    }
1755    case attr::WarnUnusedResult: {
1756      return nullptr;
1757    }
1758    case attr::Weak: {
1759      return nullptr;
1760    }
1761    case attr::WeakImport: {
1762      return nullptr;
1763    }
1764    case attr::WeakRef: {
1765      return nullptr;
1766    }
1767    case attr::WorkGroupSizeHint: {
1768      return nullptr;
1769    }
1770    case attr::X86ForceAlignArgPointer: {
1771      return nullptr;
1772    }
1773    case attr::XRayInstrument: {
1774      return nullptr;
1775    }
1776    case attr::XRayLogArgs: {
1777      return nullptr;
1778    }
1779  } // end switch
1780  llvm_unreachable("Unknown attribute!");
1781  return nullptr;
1782}
1783
1784} // end namespace sema
1785} // end namespace clang
1786