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