clang/Sema/AttrTemplateInstantiate.inc

0001 /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
0002 |*                                                                            *|
0003 |* Template instantiation code for attributes                                 *|
0004 |*                                                                            *|
0005 |* Automatically generated file, do not edit!                                 *|
0006 |* From: Attr.td                                                              *|
0007 |*                                                                            *|
0008 \*===----------------------------------------------------------------------===*/
0009
0010 namespace clang {
0011 namespace sema {
0012
0013 Attr *instantiateTemplateAttribute(const Attr *At, ASTContext &C, Sema &S,
0014         const MultiLevelTemplateArgumentList &TemplateArgs) {
0015   switch (At->getKind()) {
0016     case attr::AArch64SVEPcs: {
0017       const auto *A = cast<AArch64SVEPcsAttr>(At);
0018       return A->clone(C);
0019     }
0020     case attr::AArch64VectorPcs: {
0021       const auto *A = cast<AArch64VectorPcsAttr>(At);
0022       return A->clone(C);
0023     }
0024     case attr::AMDGPUFlatWorkGroupSize: {
0025       const auto *A = cast<AMDGPUFlatWorkGroupSizeAttr>(At);
0026       return A->clone(C);
0027     }
0028     case attr::AMDGPUKernelCall: {
0029       const auto *A = cast<AMDGPUKernelCallAttr>(At);
0030       return A->clone(C);
0031     }
0032     case attr::AMDGPUMaxNumWorkGroups: {
0033       const auto *A = cast<AMDGPUMaxNumWorkGroupsAttr>(At);
0034       return A->clone(C);
0035     }
0036     case attr::AMDGPUNumSGPR: {
0037       const auto *A = cast<AMDGPUNumSGPRAttr>(At);
0038       return A->clone(C);
0039     }
0040     case attr::AMDGPUNumVGPR: {
0041       const auto *A = cast<AMDGPUNumVGPRAttr>(At);
0042       return A->clone(C);
0043     }
0044     case attr::AMDGPUWavesPerEU: {
0045       const auto *A = cast<AMDGPUWavesPerEUAttr>(At);
0046       return A->clone(C);
0047     }
0048     case attr::ARMInterrupt: {
0049       const auto *A = cast<ARMInterruptAttr>(At);
0050       return A->clone(C);
0051     }
0052     case attr::AVRInterrupt: {
0053       const auto *A = cast<AVRInterruptAttr>(At);
0054       return A->clone(C);
0055     }
0056     case attr::AVRSignal: {
0057       const auto *A = cast<AVRSignalAttr>(At);
0058       return A->clone(C);
0059     }
0060     case attr::AbiTag: {
0061       const auto *A = cast<AbiTagAttr>(At);
0062       return A->clone(C);
0063     }
0064     case attr::AcquireCapability: {
0065       const auto *A = cast<AcquireCapabilityAttr>(At);
0066       auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
0067       {
0068         EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
0069         Expr * *TI = tempInstArgs;
0070         Expr * *I = A->args_begin();
0071         Expr * *E = A->args_end();
0072         for (; I != E; ++I, ++TI) {
0073           ExprResult Result = S.SubstExpr(*I, TemplateArgs);
0074           if (Result.isInvalid())
0075             return nullptr;
0076           *TI = Result.get();
0077         }
0078       }
0079       return new (C) AcquireCapabilityAttr(C, *A, tempInstArgs, A->args_size());
0080     }
0081     case attr::AcquireHandle: {
0082       const auto *A = cast<AcquireHandleAttr>(At);
0083       return A->clone(C);
0084     }
0085     case attr::AcquiredAfter: {
0086       const auto *A = cast<AcquiredAfterAttr>(At);
0087       auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
0088       {
0089         EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
0090         Expr * *TI = tempInstArgs;
0091         Expr * *I = A->args_begin();
0092         Expr * *E = A->args_end();
0093         for (; I != E; ++I, ++TI) {
0094           ExprResult Result = S.SubstExpr(*I, TemplateArgs);
0095           if (Result.isInvalid())
0096             return nullptr;
0097           *TI = Result.get();
0098         }
0099       }
0100       return new (C) AcquiredAfterAttr(C, *A, tempInstArgs, A->args_size());
0101     }
0102     case attr::AcquiredBefore: {
0103       const auto *A = cast<AcquiredBeforeAttr>(At);
0104       auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
0105       {
0106         EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
0107         Expr * *TI = tempInstArgs;
0108         Expr * *I = A->args_begin();
0109         Expr * *E = A->args_end();
0110         for (; I != E; ++I, ++TI) {
0111           ExprResult Result = S.SubstExpr(*I, TemplateArgs);
0112           if (Result.isInvalid())
0113             return nullptr;
0114           *TI = Result.get();
0115         }
0116       }
0117       return new (C) AcquiredBeforeAttr(C, *A, tempInstArgs, A->args_size());
0118     }
0119     case attr::AddressSpace: {
0120       const auto *A = cast<AddressSpaceAttr>(At);
0121       return A->clone(C);
0122     }
0123     case attr::Alias: {
0124       const auto *A = cast<AliasAttr>(At);
0125       return A->clone(C);
0126     }
0127     case attr::AlignMac68k: {
0128       const auto *A = cast<AlignMac68kAttr>(At);
0129       return A->clone(C);
0130     }
0131     case attr::AlignNatural: {
0132       const auto *A = cast<AlignNaturalAttr>(At);
0133       return A->clone(C);
0134     }
0135     case attr::AlignValue: {
0136       const auto *A = cast<AlignValueAttr>(At);
0137       return A->clone(C);
0138     }
0139     case attr::Aligned: {
0140       const auto *A = cast<AlignedAttr>(At);
0141       return A->clone(C);
0142     }
0143     case attr::AllocAlign: {
0144       const auto *A = cast<AllocAlignAttr>(At);
0145       return A->clone(C);
0146     }
0147     case attr::AllocSize: {
0148       const auto *A = cast<AllocSizeAttr>(At);
0149       return new (C) AllocSizeAttr(C, *A, A->getElemSizeParam(), A->getNumElemsParam());
0150     }
0151     case attr::Allocating: {
0152       const auto *A = cast<AllocatingAttr>(At);
0153       return A->clone(C);
0154     }
0155     case attr::AlwaysDestroy: {
0156       const auto *A = cast<AlwaysDestroyAttr>(At);
0157       return A->clone(C);
0158     }
0159     case attr::AlwaysInline: {
0160       const auto *A = cast<AlwaysInlineAttr>(At);
0161       return A->clone(C);
0162     }
0163     case attr::AnalyzerNoReturn: {
0164       const auto *A = cast<AnalyzerNoReturnAttr>(At);
0165       return A->clone(C);
0166     }
0167     case attr::Annotate: {
0168       const auto *A = cast<AnnotateAttr>(At);
0169       return A->clone(C);
0170     }
0171     case attr::AnnotateType: {
0172       const auto *A = cast<AnnotateTypeAttr>(At);
0173       return A->clone(C);
0174     }
0175     case attr::AnyX86Interrupt: {
0176       const auto *A = cast<AnyX86InterruptAttr>(At);
0177       return A->clone(C);
0178     }
0179     case attr::AnyX86NoCallerSavedRegisters: {
0180       const auto *A = cast<AnyX86NoCallerSavedRegistersAttr>(At);
0181       return A->clone(C);
0182     }
0183     case attr::AnyX86NoCfCheck: {
0184       const auto *A = cast<AnyX86NoCfCheckAttr>(At);
0185       return A->clone(C);
0186     }
0187     case attr::ArcWeakrefUnavailable: {
0188       const auto *A = cast<ArcWeakrefUnavailableAttr>(At);
0189       return A->clone(C);
0190     }
0191     case attr::ArgumentWithTypeTag: {
0192       const auto *A = cast<ArgumentWithTypeTagAttr>(At);
0193       return A->clone(C);
0194     }
0195     case attr::ArmAgnostic: {
0196       const auto *A = cast<ArmAgnosticAttr>(At);
0197       return A->clone(C);
0198     }
0199     case attr::ArmBuiltinAlias: {
0200       const auto *A = cast<ArmBuiltinAliasAttr>(At);
0201       return A->clone(C);
0202     }
0203     case attr::ArmIn: {
0204       const auto *A = cast<ArmInAttr>(At);
0205       return A->clone(C);
0206     }
0207     case attr::ArmInOut: {
0208       const auto *A = cast<ArmInOutAttr>(At);
0209       return A->clone(C);
0210     }
0211     case attr::ArmLocallyStreaming: {
0212       const auto *A = cast<ArmLocallyStreamingAttr>(At);
0213       return A->clone(C);
0214     }
0215     case attr::ArmMveStrictPolymorphism: {
0216       const auto *A = cast<ArmMveStrictPolymorphismAttr>(At);
0217       return A->clone(C);
0218     }
0219     case attr::ArmNew: {
0220       const auto *A = cast<ArmNewAttr>(At);
0221       return A->clone(C);
0222     }
0223     case attr::ArmOut: {
0224       const auto *A = cast<ArmOutAttr>(At);
0225       return A->clone(C);
0226     }
0227     case attr::ArmPreserves: {
0228       const auto *A = cast<ArmPreservesAttr>(At);
0229       return A->clone(C);
0230     }
0231     case attr::ArmStreaming: {
0232       const auto *A = cast<ArmStreamingAttr>(At);
0233       return A->clone(C);
0234     }
0235     case attr::ArmStreamingCompatible: {
0236       const auto *A = cast<ArmStreamingCompatibleAttr>(At);
0237       return A->clone(C);
0238     }
0239     case attr::Artificial: {
0240       const auto *A = cast<ArtificialAttr>(At);
0241       return A->clone(C);
0242     }
0243     case attr::AsmLabel: {
0244       const auto *A = cast<AsmLabelAttr>(At);
0245       return A->clone(C);
0246     }
0247     case attr::AssertCapability: {
0248       const auto *A = cast<AssertCapabilityAttr>(At);
0249       auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
0250       {
0251         EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
0252         Expr * *TI = tempInstArgs;
0253         Expr * *I = A->args_begin();
0254         Expr * *E = A->args_end();
0255         for (; I != E; ++I, ++TI) {
0256           ExprResult Result = S.SubstExpr(*I, TemplateArgs);
0257           if (Result.isInvalid())
0258             return nullptr;
0259           *TI = Result.get();
0260         }
0261       }
0262       return new (C) AssertCapabilityAttr(C, *A, tempInstArgs, A->args_size());
0263     }
0264     case attr::AssertExclusiveLock: {
0265       const auto *A = cast<AssertExclusiveLockAttr>(At);
0266       auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
0267       {
0268         EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
0269         Expr * *TI = tempInstArgs;
0270         Expr * *I = A->args_begin();
0271         Expr * *E = A->args_end();
0272         for (; I != E; ++I, ++TI) {
0273           ExprResult Result = S.SubstExpr(*I, TemplateArgs);
0274           if (Result.isInvalid())
0275             return nullptr;
0276           *TI = Result.get();
0277         }
0278       }
0279       return new (C) AssertExclusiveLockAttr(C, *A, tempInstArgs, A->args_size());
0280     }
0281     case attr::AssertSharedLock: {
0282       const auto *A = cast<AssertSharedLockAttr>(At);
0283       auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
0284       {
0285         EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
0286         Expr * *TI = tempInstArgs;
0287         Expr * *I = A->args_begin();
0288         Expr * *E = A->args_end();
0289         for (; I != E; ++I, ++TI) {
0290           ExprResult Result = S.SubstExpr(*I, TemplateArgs);
0291           if (Result.isInvalid())
0292             return nullptr;
0293           *TI = Result.get();
0294         }
0295       }
0296       return new (C) AssertSharedLockAttr(C, *A, tempInstArgs, A->args_size());
0297     }
0298     case attr::AssumeAligned: {
0299       const auto *A = cast<AssumeAlignedAttr>(At);
0300       return A->clone(C);
0301     }
0302     case attr::Availability: {
0303       const auto *A = cast<AvailabilityAttr>(At);
0304       return A->clone(C);
0305     }
0306     case attr::AvailableOnlyInDefaultEvalMethod: {
0307       const auto *A = cast<AvailableOnlyInDefaultEvalMethodAttr>(At);
0308       return A->clone(C);
0309     }
0310     case attr::BPFFastCall: {
0311       const auto *A = cast<BPFFastCallAttr>(At);
0312       return A->clone(C);
0313     }
0314     case attr::BPFPreserveAccessIndex: {
0315       const auto *A = cast<BPFPreserveAccessIndexAttr>(At);
0316       return A->clone(C);
0317     }
0318     case attr::BPFPreserveStaticOffset: {
0319       const auto *A = cast<BPFPreserveStaticOffsetAttr>(At);
0320       return A->clone(C);
0321     }
0322     case attr::BTFDeclTag: {
0323       const auto *A = cast<BTFDeclTagAttr>(At);
0324       return A->clone(C);
0325     }
0326     case attr::BTFTypeTag: {
0327       const auto *A = cast<BTFTypeTagAttr>(At);
0328       return A->clone(C);
0329     }
0330     case attr::Blocking: {
0331       const auto *A = cast<BlockingAttr>(At);
0332       return A->clone(C);
0333     }
0334     case attr::Blocks: {
0335       const auto *A = cast<BlocksAttr>(At);
0336       return A->clone(C);
0337     }
0338     case attr::Builtin: {
0339       const auto *A = cast<BuiltinAttr>(At);
0340       return A->clone(C);
0341     }
0342     case attr::BuiltinAlias: {
0343       const auto *A = cast<BuiltinAliasAttr>(At);
0344       return A->clone(C);
0345     }
0346     case attr::C11NoReturn: {
0347       const auto *A = cast<C11NoReturnAttr>(At);
0348       return A->clone(C);
0349     }
0350     case attr::CDecl: {
0351       const auto *A = cast<CDeclAttr>(At);
0352       return A->clone(C);
0353     }
0354     case attr::CFAuditedTransfer: {
0355       const auto *A = cast<CFAuditedTransferAttr>(At);
0356       return A->clone(C);
0357     }
0358     case attr::CFConsumed: {
0359       const auto *A = cast<CFConsumedAttr>(At);
0360       return A->clone(C);
0361     }
0362     case attr::CFGuard: {
0363       const auto *A = cast<CFGuardAttr>(At);
0364       return A->clone(C);
0365     }
0366     case attr::CFICanonicalJumpTable: {
0367       const auto *A = cast<CFICanonicalJumpTableAttr>(At);
0368       return A->clone(C);
0369     }
0370     case attr::CFReturnsNotRetained: {
0371       const auto *A = cast<CFReturnsNotRetainedAttr>(At);
0372       return A->clone(C);
0373     }
0374     case attr::CFReturnsRetained: {
0375       const auto *A = cast<CFReturnsRetainedAttr>(At);
0376       return A->clone(C);
0377     }
0378     case attr::CFUnknownTransfer: {
0379       const auto *A = cast<CFUnknownTransferAttr>(At);
0380       return A->clone(C);
0381     }
0382     case attr::CPUDispatch: {
0383       const auto *A = cast<CPUDispatchAttr>(At);
0384       return A->clone(C);
0385     }
0386     case attr::CPUSpecific: {
0387       const auto *A = cast<CPUSpecificAttr>(At);
0388       return A->clone(C);
0389     }
0390     case attr::CUDAConstant: {
0391       const auto *A = cast<CUDAConstantAttr>(At);
0392       return A->clone(C);
0393     }
0394     case attr::CUDADevice: {
0395       const auto *A = cast<CUDADeviceAttr>(At);
0396       return A->clone(C);
0397     }
0398     case attr::CUDADeviceBuiltinSurfaceType: {
0399       const auto *A = cast<CUDADeviceBuiltinSurfaceTypeAttr>(At);
0400       return A->clone(C);
0401     }
0402     case attr::CUDADeviceBuiltinTextureType: {
0403       const auto *A = cast<CUDADeviceBuiltinTextureTypeAttr>(At);
0404       return A->clone(C);
0405     }
0406     case attr::CUDAGlobal: {
0407       const auto *A = cast<CUDAGlobalAttr>(At);
0408       return A->clone(C);
0409     }
0410     case attr::CUDAGridConstant: {
0411       const auto *A = cast<CUDAGridConstantAttr>(At);
0412       return A->clone(C);
0413     }
0414     case attr::CUDAHost: {
0415       const auto *A = cast<CUDAHostAttr>(At);
0416       return A->clone(C);
0417     }
0418     case attr::CUDAInvalidTarget: {
0419       const auto *A = cast<CUDAInvalidTargetAttr>(At);
0420       return A->clone(C);
0421     }
0422     case attr::CUDALaunchBounds: {
0423       const auto *A = cast<CUDALaunchBoundsAttr>(At);
0424       return A->clone(C);
0425     }
0426     case attr::CUDAShared: {
0427       const auto *A = cast<CUDASharedAttr>(At);
0428       return A->clone(C);
0429     }
0430     case attr::CXX11NoReturn: {
0431       const auto *A = cast<CXX11NoReturnAttr>(At);
0432       return A->clone(C);
0433     }
0434     case attr::CXXAssume: {
0435       const auto *A = cast<CXXAssumeAttr>(At);
0436       return A->clone(C);
0437     }
0438     case attr::CallableWhen: {
0439       const auto *A = cast<CallableWhenAttr>(At);
0440       return A->clone(C);
0441     }
0442     case attr::Callback: {
0443       const auto *A = cast<CallbackAttr>(At);
0444       return A->clone(C);
0445     }
0446     case attr::CalledOnce: {
0447       const auto *A = cast<CalledOnceAttr>(At);
0448       return A->clone(C);
0449     }
0450     case attr::Capability: {
0451       const auto *A = cast<CapabilityAttr>(At);
0452       return A->clone(C);
0453     }
0454     case attr::CapturedRecord: {
0455       const auto *A = cast<CapturedRecordAttr>(At);
0456       return A->clone(C);
0457     }
0458     case attr::CarriesDependency: {
0459       const auto *A = cast<CarriesDependencyAttr>(At);
0460       return A->clone(C);
0461     }
0462     case attr::Cleanup: {
0463       const auto *A = cast<CleanupAttr>(At);
0464       return A->clone(C);
0465     }
0466     case attr::ClspvLibclcBuiltin: {
0467       const auto *A = cast<ClspvLibclcBuiltinAttr>(At);
0468       return A->clone(C);
0469     }
0470     case attr::CmseNSCall: {
0471       const auto *A = cast<CmseNSCallAttr>(At);
0472       return A->clone(C);
0473     }
0474     case attr::CmseNSEntry: {
0475       const auto *A = cast<CmseNSEntryAttr>(At);
0476       return A->clone(C);
0477     }
0478     case attr::CodeAlign: {
0479       const auto *A = cast<CodeAlignAttr>(At);
0480       return A->clone(C);
0481     }
0482     case attr::CodeModel: {
0483       const auto *A = cast<CodeModelAttr>(At);
0484       return A->clone(C);
0485     }
0486     case attr::CodeSeg: {
0487       const auto *A = cast<CodeSegAttr>(At);
0488       return A->clone(C);
0489     }
0490     case attr::Cold: {
0491       const auto *A = cast<ColdAttr>(At);
0492       return A->clone(C);
0493     }
0494     case attr::Common: {
0495       const auto *A = cast<CommonAttr>(At);
0496       return A->clone(C);
0497     }
0498     case attr::Const: {
0499       const auto *A = cast<ConstAttr>(At);
0500       return A->clone(C);
0501     }
0502     case attr::ConstInit: {
0503       const auto *A = cast<ConstInitAttr>(At);
0504       return A->clone(C);
0505     }
0506     case attr::Constructor: {
0507       const auto *A = cast<ConstructorAttr>(At);
0508       return A->clone(C);
0509     }
0510     case attr::Consumable: {
0511       const auto *A = cast<ConsumableAttr>(At);
0512       return A->clone(C);
0513     }
0514     case attr::ConsumableAutoCast: {
0515       const auto *A = cast<ConsumableAutoCastAttr>(At);
0516       return A->clone(C);
0517     }
0518     case attr::ConsumableSetOnRead: {
0519       const auto *A = cast<ConsumableSetOnReadAttr>(At);
0520       return A->clone(C);
0521     }
0522     case attr::Convergent: {
0523       const auto *A = cast<ConvergentAttr>(At);
0524       return A->clone(C);
0525     }
0526     case attr::CoroAwaitElidable: {
0527       const auto *A = cast<CoroAwaitElidableAttr>(At);
0528       return A->clone(C);
0529     }
0530     case attr::CoroAwaitElidableArgument: {
0531       const auto *A = cast<CoroAwaitElidableArgumentAttr>(At);
0532       return A->clone(C);
0533     }
0534     case attr::CoroDisableLifetimeBound: {
0535       const auto *A = cast<CoroDisableLifetimeBoundAttr>(At);
0536       return A->clone(C);
0537     }
0538     case attr::CoroLifetimeBound: {
0539       const auto *A = cast<CoroLifetimeBoundAttr>(At);
0540       return A->clone(C);
0541     }
0542     case attr::CoroOnlyDestroyWhenComplete: {
0543       const auto *A = cast<CoroOnlyDestroyWhenCompleteAttr>(At);
0544       return A->clone(C);
0545     }
0546     case attr::CoroReturnType: {
0547       const auto *A = cast<CoroReturnTypeAttr>(At);
0548       return A->clone(C);
0549     }
0550     case attr::CoroWrapper: {
0551       const auto *A = cast<CoroWrapperAttr>(At);
0552       return A->clone(C);
0553     }
0554     case attr::CountedBy: {
0555       const auto *A = cast<CountedByAttr>(At);
0556       return A->clone(C);
0557     }
0558     case attr::CountedByOrNull: {
0559       const auto *A = cast<CountedByOrNullAttr>(At);
0560       return A->clone(C);
0561     }
0562     case attr::DLLExport: {
0563       const auto *A = cast<DLLExportAttr>(At);
0564       return A->clone(C);
0565     }
0566     case attr::DLLExportStaticLocal: {
0567       const auto *A = cast<DLLExportStaticLocalAttr>(At);
0568       return A->clone(C);
0569     }
0570     case attr::DLLImport: {
0571       const auto *A = cast<DLLImportAttr>(At);
0572       return A->clone(C);
0573     }
0574     case attr::DLLImportStaticLocal: {
0575       const auto *A = cast<DLLImportStaticLocalAttr>(At);
0576       return A->clone(C);
0577     }
0578     case attr::Deprecated: {
0579       const auto *A = cast<DeprecatedAttr>(At);
0580       return A->clone(C);
0581     }
0582     case attr::Destructor: {
0583       const auto *A = cast<DestructorAttr>(At);
0584       return A->clone(C);
0585     }
0586     case attr::DiagnoseAsBuiltin: {
0587       const auto *A = cast<DiagnoseAsBuiltinAttr>(At);
0588       return A->clone(C);
0589     }
0590     case attr::DiagnoseIf: {
0591       const auto *A = cast<DiagnoseIfAttr>(At);
0592       Expr * tempInstCond;
0593       {
0594         EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
0595         ExprResult Result = S.SubstExpr(A->getCond(), TemplateArgs);
0596         if (Result.isInvalid())
0597           return nullptr;
0598         tempInstCond = Result.get();
0599       }
0600       return new (C) DiagnoseIfAttr(C, *A, tempInstCond, A->getMessage(), A->getDefaultSeverity(), A->getWarningGroup(), A->getArgDependent(), A->getParent());
0601     }
0602     case attr::DisableSanitizerInstrumentation: {
0603       const auto *A = cast<DisableSanitizerInstrumentationAttr>(At);
0604       return A->clone(C);
0605     }
0606     case attr::DisableTailCalls: {
0607       const auto *A = cast<DisableTailCallsAttr>(At);
0608       return A->clone(C);
0609     }
0610     case attr::EmptyBases: {
0611       const auto *A = cast<EmptyBasesAttr>(At);
0612       return A->clone(C);
0613     }
0614     case attr::EnableIf: {
0615       const auto *A = cast<EnableIfAttr>(At);
0616       Expr * tempInstCond;
0617       {
0618         EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
0619         ExprResult Result = S.SubstExpr(A->getCond(), TemplateArgs);
0620         if (Result.isInvalid())
0621           return nullptr;
0622         tempInstCond = Result.get();
0623       }
0624       return new (C) EnableIfAttr(C, *A, tempInstCond, A->getMessage());
0625     }
0626     case attr::EnforceTCB: {
0627       const auto *A = cast<EnforceTCBAttr>(At);
0628       return A->clone(C);
0629     }
0630     case attr::EnforceTCBLeaf: {
0631       const auto *A = cast<EnforceTCBLeafAttr>(At);
0632       return A->clone(C);
0633     }
0634     case attr::EnumExtensibility: {
0635       const auto *A = cast<EnumExtensibilityAttr>(At);
0636       return A->clone(C);
0637     }
0638     case attr::Error: {
0639       const auto *A = cast<ErrorAttr>(At);
0640       return A->clone(C);
0641     }
0642     case attr::ExcludeFromExplicitInstantiation: {
0643       const auto *A = cast<ExcludeFromExplicitInstantiationAttr>(At);
0644       return A->clone(C);
0645     }
0646     case attr::ExclusiveTrylockFunction: {
0647       const auto *A = cast<ExclusiveTrylockFunctionAttr>(At);
0648       Expr * tempInstSuccessValue;
0649       {
0650         EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
0651         ExprResult Result = S.SubstExpr(A->getSuccessValue(), TemplateArgs);
0652         if (Result.isInvalid())
0653           return nullptr;
0654         tempInstSuccessValue = Result.get();
0655       }
0656       auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
0657       {
0658         EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
0659         Expr * *TI = tempInstArgs;
0660         Expr * *I = A->args_begin();
0661         Expr * *E = A->args_end();
0662         for (; I != E; ++I, ++TI) {
0663           ExprResult Result = S.SubstExpr(*I, TemplateArgs);
0664           if (Result.isInvalid())
0665             return nullptr;
0666           *TI = Result.get();
0667         }
0668       }
0669       return new (C) ExclusiveTrylockFunctionAttr(C, *A, tempInstSuccessValue, tempInstArgs, A->args_size());
0670     }
0671     case attr::ExplicitInit: {
0672       const auto *A = cast<ExplicitInitAttr>(At);
0673       return A->clone(C);
0674     }
0675     case attr::ExternalSourceSymbol: {
0676       const auto *A = cast<ExternalSourceSymbolAttr>(At);
0677       return A->clone(C);
0678     }
0679     case attr::FallThrough: {
0680       const auto *A = cast<FallThroughAttr>(At);
0681       return A->clone(C);
0682     }
0683     case attr::FastCall: {
0684       const auto *A = cast<FastCallAttr>(At);
0685       return A->clone(C);
0686     }
0687     case attr::Final: {
0688       const auto *A = cast<FinalAttr>(At);
0689       return A->clone(C);
0690     }
0691     case attr::FlagEnum: {
0692       const auto *A = cast<FlagEnumAttr>(At);
0693       return A->clone(C);
0694     }
0695     case attr::Flatten: {
0696       const auto *A = cast<FlattenAttr>(At);
0697       return A->clone(C);
0698     }
0699     case attr::Format: {
0700       const auto *A = cast<FormatAttr>(At);
0701       return A->clone(C);
0702     }
0703     case attr::FormatArg: {
0704       const auto *A = cast<FormatArgAttr>(At);
0705       return A->clone(C);
0706     }
0707     case attr::FunctionReturnThunks: {
0708       const auto *A = cast<FunctionReturnThunksAttr>(At);
0709       return A->clone(C);
0710     }
0711     case attr::GNUInline: {
0712       const auto *A = cast<GNUInlineAttr>(At);
0713       return A->clone(C);
0714     }
0715     case attr::GuardedBy: {
0716       const auto *A = cast<GuardedByAttr>(At);
0717       Expr * tempInstArg;
0718       {
0719         EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
0720         ExprResult Result = S.SubstExpr(A->getArg(), TemplateArgs);
0721         if (Result.isInvalid())
0722           return nullptr;
0723         tempInstArg = Result.get();
0724       }
0725       return new (C) GuardedByAttr(C, *A, tempInstArg);
0726     }
0727     case attr::GuardedVar: {
0728       const auto *A = cast<GuardedVarAttr>(At);
0729       return A->clone(C);
0730     }
0731     case attr::HIPManaged: {
0732       const auto *A = cast<HIPManagedAttr>(At);
0733       return A->clone(C);
0734     }
0735     case attr::HLSLContainedType: {
0736       const auto *A = cast<HLSLContainedTypeAttr>(At);
0737       return A->clone(C);
0738     }
0739     case attr::HLSLControlFlowHint: {
0740       const auto *A = cast<HLSLControlFlowHintAttr>(At);
0741       return A->clone(C);
0742     }
0743     case attr::HLSLGroupSharedAddressSpace: {
0744       const auto *A = cast<HLSLGroupSharedAddressSpaceAttr>(At);
0745       return A->clone(C);
0746     }
0747     case attr::HLSLLoopHint: {
0748       const auto *A = cast<HLSLLoopHintAttr>(At);
0749       return A->clone(C);
0750     }
0751     case attr::HLSLNumThreads: {
0752       const auto *A = cast<HLSLNumThreadsAttr>(At);
0753       return A->clone(C);
0754     }
0755     case attr::HLSLPackOffset: {
0756       const auto *A = cast<HLSLPackOffsetAttr>(At);
0757       return A->clone(C);
0758     }
0759     case attr::HLSLParamModifier: {
0760       const auto *A = cast<HLSLParamModifierAttr>(At);
0761       return A->clone(C);
0762     }
0763     case attr::HLSLROV: {
0764       const auto *A = cast<HLSLROVAttr>(At);
0765       return A->clone(C);
0766     }
0767     case attr::HLSLRawBuffer: {
0768       const auto *A = cast<HLSLRawBufferAttr>(At);
0769       return A->clone(C);
0770     }
0771     case attr::HLSLResource: {
0772       const auto *A = cast<HLSLResourceAttr>(At);
0773       return A->clone(C);
0774     }
0775     case attr::HLSLResourceBinding: {
0776       const auto *A = cast<HLSLResourceBindingAttr>(At);
0777       return A->clone(C);
0778     }
0779     case attr::HLSLResourceClass: {
0780       const auto *A = cast<HLSLResourceClassAttr>(At);
0781       return A->clone(C);
0782     }
0783     case attr::HLSLSV_DispatchThreadID: {
0784       const auto *A = cast<HLSLSV_DispatchThreadIDAttr>(At);
0785       return A->clone(C);
0786     }
0787     case attr::HLSLSV_GroupID: {
0788       const auto *A = cast<HLSLSV_GroupIDAttr>(At);
0789       return A->clone(C);
0790     }
0791     case attr::HLSLSV_GroupIndex: {
0792       const auto *A = cast<HLSLSV_GroupIndexAttr>(At);
0793       return A->clone(C);
0794     }
0795     case attr::HLSLSV_GroupThreadID: {
0796       const auto *A = cast<HLSLSV_GroupThreadIDAttr>(At);
0797       return A->clone(C);
0798     }
0799     case attr::HLSLShader: {
0800       const auto *A = cast<HLSLShaderAttr>(At);
0801       return A->clone(C);
0802     }
0803     case attr::HLSLWaveSize: {
0804       const auto *A = cast<HLSLWaveSizeAttr>(At);
0805       return A->clone(C);
0806     }
0807     case attr::Hot: {
0808       const auto *A = cast<HotAttr>(At);
0809       return A->clone(C);
0810     }
0811     case attr::HybridPatchable: {
0812       const auto *A = cast<HybridPatchableAttr>(At);
0813       return A->clone(C);
0814     }
0815     case attr::IBAction: {
0816       const auto *A = cast<IBActionAttr>(At);
0817       return A->clone(C);
0818     }
0819     case attr::IBOutlet: {
0820       const auto *A = cast<IBOutletAttr>(At);
0821       return A->clone(C);
0822     }
0823     case attr::IBOutletCollection: {
0824       const auto *A = cast<IBOutletCollectionAttr>(At);
0825       return A->clone(C);
0826     }
0827     case attr::IFunc: {
0828       const auto *A = cast<IFuncAttr>(At);
0829       return A->clone(C);
0830     }
0831     case attr::InitPriority: {
0832       const auto *A = cast<InitPriorityAttr>(At);
0833       return A->clone(C);
0834     }
0835     case attr::InitSeg: {
0836       const auto *A = cast<InitSegAttr>(At);
0837       return A->clone(C);
0838     }
0839     case attr::IntelOclBicc: {
0840       const auto *A = cast<IntelOclBiccAttr>(At);
0841       return A->clone(C);
0842     }
0843     case attr::InternalLinkage: {
0844       const auto *A = cast<InternalLinkageAttr>(At);
0845       return A->clone(C);
0846     }
0847     case attr::LTOVisibilityPublic: {
0848       const auto *A = cast<LTOVisibilityPublicAttr>(At);
0849       return A->clone(C);
0850     }
0851     case attr::LayoutVersion: {
0852       const auto *A = cast<LayoutVersionAttr>(At);
0853       return A->clone(C);
0854     }
0855     case attr::Leaf: {
0856       const auto *A = cast<LeafAttr>(At);
0857       return A->clone(C);
0858     }
0859     case attr::LifetimeBound: {
0860       const auto *A = cast<LifetimeBoundAttr>(At);
0861       return A->clone(C);
0862     }
0863     case attr::LifetimeCaptureBy: {
0864       const auto *A = cast<LifetimeCaptureByAttr>(At);
0865       return A->clone(C);
0866     }
0867     case attr::Likely: {
0868       const auto *A = cast<LikelyAttr>(At);
0869       return A->clone(C);
0870     }
0871     case attr::LoaderUninitialized: {
0872       const auto *A = cast<LoaderUninitializedAttr>(At);
0873       return A->clone(C);
0874     }
0875     case attr::LockReturned: {
0876       const auto *A = cast<LockReturnedAttr>(At);
0877       Expr * tempInstArg;
0878       {
0879         EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
0880         ExprResult Result = S.SubstExpr(A->getArg(), TemplateArgs);
0881         if (Result.isInvalid())
0882           return nullptr;
0883         tempInstArg = Result.get();
0884       }
0885       return new (C) LockReturnedAttr(C, *A, tempInstArg);
0886     }
0887     case attr::LocksExcluded: {
0888       const auto *A = cast<LocksExcludedAttr>(At);
0889       auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
0890       {
0891         EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
0892         Expr * *TI = tempInstArgs;
0893         Expr * *I = A->args_begin();
0894         Expr * *E = A->args_end();
0895         for (; I != E; ++I, ++TI) {
0896           ExprResult Result = S.SubstExpr(*I, TemplateArgs);
0897           if (Result.isInvalid())
0898             return nullptr;
0899           *TI = Result.get();
0900         }
0901       }
0902       return new (C) LocksExcludedAttr(C, *A, tempInstArgs, A->args_size());
0903     }
0904     case attr::LoopHint: {
0905       const auto *A = cast<LoopHintAttr>(At);
0906       return A->clone(C);
0907     }
0908     case attr::M68kInterrupt: {
0909       const auto *A = cast<M68kInterruptAttr>(At);
0910       return A->clone(C);
0911     }
0912     case attr::M68kRTD: {
0913       const auto *A = cast<M68kRTDAttr>(At);
0914       return A->clone(C);
0915     }
0916     case attr::MIGServerRoutine: {
0917       const auto *A = cast<MIGServerRoutineAttr>(At);
0918       return A->clone(C);
0919     }
0920     case attr::MSABI: {
0921       const auto *A = cast<MSABIAttr>(At);
0922       return A->clone(C);
0923     }
0924     case attr::MSAllocator: {
0925       const auto *A = cast<MSAllocatorAttr>(At);
0926       return A->clone(C);
0927     }
0928     case attr::MSConstexpr: {
0929       const auto *A = cast<MSConstexprAttr>(At);
0930       return A->clone(C);
0931     }
0932     case attr::MSInheritance: {
0933       const auto *A = cast<MSInheritanceAttr>(At);
0934       return A->clone(C);
0935     }
0936     case attr::MSNoVTable: {
0937       const auto *A = cast<MSNoVTableAttr>(At);
0938       return A->clone(C);
0939     }
0940     case attr::MSP430Interrupt: {
0941       const auto *A = cast<MSP430InterruptAttr>(At);
0942       return A->clone(C);
0943     }
0944     case attr::MSStruct: {
0945       const auto *A = cast<MSStructAttr>(At);
0946       return A->clone(C);
0947     }
0948     case attr::MSVtorDisp: {
0949       const auto *A = cast<MSVtorDispAttr>(At);
0950       return A->clone(C);
0951     }
0952     case attr::MaxFieldAlignment: {
0953       const auto *A = cast<MaxFieldAlignmentAttr>(At);
0954       return A->clone(C);
0955     }
0956     case attr::MayAlias: {
0957       const auto *A = cast<MayAliasAttr>(At);
0958       return A->clone(C);
0959     }
0960     case attr::MaybeUndef: {
0961       const auto *A = cast<MaybeUndefAttr>(At);
0962       return A->clone(C);
0963     }
0964     case attr::MicroMips: {
0965       const auto *A = cast<MicroMipsAttr>(At);
0966       return A->clone(C);
0967     }
0968     case attr::MinSize: {
0969       const auto *A = cast<MinSizeAttr>(At);
0970       return A->clone(C);
0971     }
0972     case attr::MinVectorWidth: {
0973       const auto *A = cast<MinVectorWidthAttr>(At);
0974       return A->clone(C);
0975     }
0976     case attr::Mips16: {
0977       const auto *A = cast<Mips16Attr>(At);
0978       return A->clone(C);
0979     }
0980     case attr::MipsInterrupt: {
0981       const auto *A = cast<MipsInterruptAttr>(At);
0982       return A->clone(C);
0983     }
0984     case attr::MipsLongCall: {
0985       const auto *A = cast<MipsLongCallAttr>(At);
0986       return A->clone(C);
0987     }
0988     case attr::MipsShortCall: {
0989       const auto *A = cast<MipsShortCallAttr>(At);
0990       return A->clone(C);
0991     }
0992     case attr::Mode: {
0993       const auto *A = cast<ModeAttr>(At);
0994       return A->clone(C);
0995     }
0996     case attr::MustTail: {
0997       const auto *A = cast<MustTailAttr>(At);
0998       return A->clone(C);
0999     }
1000     case attr::NSConsumed: {
1001       const auto *A = cast<NSConsumedAttr>(At);
1002       return A->clone(C);
1003     }
1004     case attr::NSConsumesSelf: {
1005       const auto *A = cast<NSConsumesSelfAttr>(At);
1006       return A->clone(C);
1007     }
1008     case attr::NSErrorDomain: {
1009       const auto *A = cast<NSErrorDomainAttr>(At);
1010       return A->clone(C);
1011     }
1012     case attr::NSReturnsAutoreleased: {
1013       const auto *A = cast<NSReturnsAutoreleasedAttr>(At);
1014       return A->clone(C);
1015     }
1016     case attr::NSReturnsNotRetained: {
1017       const auto *A = cast<NSReturnsNotRetainedAttr>(At);
1018       return A->clone(C);
1019     }
1020     case attr::NSReturnsRetained: {
1021       const auto *A = cast<NSReturnsRetainedAttr>(At);
1022       return A->clone(C);
1023     }
1024     case attr::NVPTXKernel: {
1025       const auto *A = cast<NVPTXKernelAttr>(At);
1026       return A->clone(C);
1027     }
1028     case attr::Naked: {
1029       const auto *A = cast<NakedAttr>(At);
1030       return A->clone(C);
1031     }
1032     case attr::NoAlias: {
1033       const auto *A = cast<NoAliasAttr>(At);
1034       return A->clone(C);
1035     }
1036     case attr::NoBuiltin: {
1037       const auto *A = cast<NoBuiltinAttr>(At);
1038       return A->clone(C);
1039     }
1040     case attr::NoCommon: {
1041       const auto *A = cast<NoCommonAttr>(At);
1042       return A->clone(C);
1043     }
1044     case attr::NoConvergent: {
1045       const auto *A = cast<NoConvergentAttr>(At);
1046       return A->clone(C);
1047     }
1048     case attr::NoDebug: {
1049       const auto *A = cast<NoDebugAttr>(At);
1050       return A->clone(C);
1051     }
1052     case attr::NoDeref: {
1053       const auto *A = cast<NoDerefAttr>(At);
1054       return A->clone(C);
1055     }
1056     case attr::NoDestroy: {
1057       const auto *A = cast<NoDestroyAttr>(At);
1058       return A->clone(C);
1059     }
1060     case attr::NoDuplicate: {
1061       const auto *A = cast<NoDuplicateAttr>(At);
1062       return A->clone(C);
1063     }
1064     case attr::NoEscape: {
1065       const auto *A = cast<NoEscapeAttr>(At);
1066       return A->clone(C);
1067     }
1068     case attr::NoInline: {
1069       const auto *A = cast<NoInlineAttr>(At);
1070       return A->clone(C);
1071     }
1072     case attr::NoInstrumentFunction: {
1073       const auto *A = cast<NoInstrumentFunctionAttr>(At);
1074       return A->clone(C);
1075     }
1076     case attr::NoMerge: {
1077       const auto *A = cast<NoMergeAttr>(At);
1078       return A->clone(C);
1079     }
1080     case attr::NoMicroMips: {
1081       const auto *A = cast<NoMicroMipsAttr>(At);
1082       return A->clone(C);
1083     }
1084     case attr::NoMips16: {
1085       const auto *A = cast<NoMips16Attr>(At);
1086       return A->clone(C);
1087     }
1088     case attr::NoProfileFunction: {
1089       const auto *A = cast<NoProfileFunctionAttr>(At);
1090       return A->clone(C);
1091     }
1092     case attr::NoRandomizeLayout: {
1093       const auto *A = cast<NoRandomizeLayoutAttr>(At);
1094       return A->clone(C);
1095     }
1096     case attr::NoReturn: {
1097       const auto *A = cast<NoReturnAttr>(At);
1098       return A->clone(C);
1099     }
1100     case attr::NoSanitize: {
1101       const auto *A = cast<NoSanitizeAttr>(At);
1102       return A->clone(C);
1103     }
1104     case attr::NoSpecializations: {
1105       const auto *A = cast<NoSpecializationsAttr>(At);
1106       return new (C) NoSpecializationsAttr(C, *A, A->getMessage());
1107     }
1108     case attr::NoSpeculativeLoadHardening: {
1109       const auto *A = cast<NoSpeculativeLoadHardeningAttr>(At);
1110       return A->clone(C);
1111     }
1112     case attr::NoSplitStack: {
1113       const auto *A = cast<NoSplitStackAttr>(At);
1114       return A->clone(C);
1115     }
1116     case attr::NoStackProtector: {
1117       const auto *A = cast<NoStackProtectorAttr>(At);
1118       return A->clone(C);
1119     }
1120     case attr::NoThreadSafetyAnalysis: {
1121       const auto *A = cast<NoThreadSafetyAnalysisAttr>(At);
1122       return A->clone(C);
1123     }
1124     case attr::NoThrow: {
1125       const auto *A = cast<NoThrowAttr>(At);
1126       return A->clone(C);
1127     }
1128     case attr::NoTrivialAutoVarInit: {
1129       const auto *A = cast<NoTrivialAutoVarInitAttr>(At);
1130       return A->clone(C);
1131     }
1132     case attr::NoUniqueAddress: {
1133       const auto *A = cast<NoUniqueAddressAttr>(At);
1134       return A->clone(C);
1135     }
1136     case attr::NoUwtable: {
1137       const auto *A = cast<NoUwtableAttr>(At);
1138       return A->clone(C);
1139     }
1140     case attr::NonAllocating: {
1141       const auto *A = cast<NonAllocatingAttr>(At);
1142       return A->clone(C);
1143     }
1144     case attr::NonBlocking: {
1145       const auto *A = cast<NonBlockingAttr>(At);
1146       return A->clone(C);
1147     }
1148     case attr::NonNull: {
1149       const auto *A = cast<NonNullAttr>(At);
1150       return A->clone(C);
1151     }
1152     case attr::NotTailCalled: {
1153       const auto *A = cast<NotTailCalledAttr>(At);
1154       return A->clone(C);
1155     }
1156     case attr::OMPAllocateDecl: {
1157       const auto *A = cast<OMPAllocateDeclAttr>(At);
1158       return A->clone(C);
1159     }
1160     case attr::OMPAssume: {
1161       const auto *A = cast<OMPAssumeAttr>(At);
1162       return A->clone(C);
1163     }
1164     case attr::OMPCaptureKind: {
1165       const auto *A = cast<OMPCaptureKindAttr>(At);
1166       return A->clone(C);
1167     }
1168     case attr::OMPCaptureNoInit: {
1169       const auto *A = cast<OMPCaptureNoInitAttr>(At);
1170       return A->clone(C);
1171     }
1172     case attr::OMPDeclareSimdDecl: {
1173       const auto *A = cast<OMPDeclareSimdDeclAttr>(At);
1174       return A->clone(C);
1175     }
1176     case attr::OMPDeclareTargetDecl: {
1177       const auto *A = cast<OMPDeclareTargetDeclAttr>(At);
1178       return A->clone(C);
1179     }
1180     case attr::OMPDeclareVariant: {
1181       const auto *A = cast<OMPDeclareVariantAttr>(At);
1182       return A->clone(C);
1183     }
1184     case attr::OMPReferencedVar: {
1185       const auto *A = cast<OMPReferencedVarAttr>(At);
1186       return A->clone(C);
1187     }
1188     case attr::OMPThreadPrivateDecl: {
1189       const auto *A = cast<OMPThreadPrivateDeclAttr>(At);
1190       return A->clone(C);
1191     }
1192     case attr::OSConsumed: {
1193       const auto *A = cast<OSConsumedAttr>(At);
1194       return A->clone(C);
1195     }
1196     case attr::OSConsumesThis: {
1197       const auto *A = cast<OSConsumesThisAttr>(At);
1198       return A->clone(C);
1199     }
1200     case attr::OSReturnsNotRetained: {
1201       const auto *A = cast<OSReturnsNotRetainedAttr>(At);
1202       return A->clone(C);
1203     }
1204     case attr::OSReturnsRetained: {
1205       const auto *A = cast<OSReturnsRetainedAttr>(At);
1206       return A->clone(C);
1207     }
1208     case attr::OSReturnsRetainedOnNonZero: {
1209       const auto *A = cast<OSReturnsRetainedOnNonZeroAttr>(At);
1210       return A->clone(C);
1211     }
1212     case attr::OSReturnsRetainedOnZero: {
1213       const auto *A = cast<OSReturnsRetainedOnZeroAttr>(At);
1214       return A->clone(C);
1215     }
1216     case attr::ObjCBoxable: {
1217       const auto *A = cast<ObjCBoxableAttr>(At);
1218       return A->clone(C);
1219     }
1220     case attr::ObjCBridge: {
1221       const auto *A = cast<ObjCBridgeAttr>(At);
1222       return A->clone(C);
1223     }
1224     case attr::ObjCBridgeMutable: {
1225       const auto *A = cast<ObjCBridgeMutableAttr>(At);
1226       return A->clone(C);
1227     }
1228     case attr::ObjCBridgeRelated: {
1229       const auto *A = cast<ObjCBridgeRelatedAttr>(At);
1230       return A->clone(C);
1231     }
1232     case attr::ObjCClassStub: {
1233       const auto *A = cast<ObjCClassStubAttr>(At);
1234       return A->clone(C);
1235     }
1236     case attr::ObjCDesignatedInitializer: {
1237       const auto *A = cast<ObjCDesignatedInitializerAttr>(At);
1238       return A->clone(C);
1239     }
1240     case attr::ObjCDirect: {
1241       const auto *A = cast<ObjCDirectAttr>(At);
1242       return A->clone(C);
1243     }
1244     case attr::ObjCDirectMembers: {
1245       const auto *A = cast<ObjCDirectMembersAttr>(At);
1246       return A->clone(C);
1247     }
1248     case attr::ObjCException: {
1249       const auto *A = cast<ObjCExceptionAttr>(At);
1250       return A->clone(C);
1251     }
1252     case attr::ObjCExplicitProtocolImpl: {
1253       const auto *A = cast<ObjCExplicitProtocolImplAttr>(At);
1254       return A->clone(C);
1255     }
1256     case attr::ObjCExternallyRetained: {
1257       const auto *A = cast<ObjCExternallyRetainedAttr>(At);
1258       return A->clone(C);
1259     }
1260     case attr::ObjCGC: {
1261       const auto *A = cast<ObjCGCAttr>(At);
1262       return A->clone(C);
1263     }
1264     case attr::ObjCIndependentClass: {
1265       const auto *A = cast<ObjCIndependentClassAttr>(At);
1266       return A->clone(C);
1267     }
1268     case attr::ObjCInertUnsafeUnretained: {
1269       const auto *A = cast<ObjCInertUnsafeUnretainedAttr>(At);
1270       return A->clone(C);
1271     }
1272     case attr::ObjCKindOf: {
1273       const auto *A = cast<ObjCKindOfAttr>(At);
1274       return A->clone(C);
1275     }
1276     case attr::ObjCMethodFamily: {
1277       const auto *A = cast<ObjCMethodFamilyAttr>(At);
1278       return A->clone(C);
1279     }
1280     case attr::ObjCNSObject: {
1281       const auto *A = cast<ObjCNSObjectAttr>(At);
1282       return A->clone(C);
1283     }
1284     case attr::ObjCNonLazyClass: {
1285       const auto *A = cast<ObjCNonLazyClassAttr>(At);
1286       return A->clone(C);
1287     }
1288     case attr::ObjCNonRuntimeProtocol: {
1289       const auto *A = cast<ObjCNonRuntimeProtocolAttr>(At);
1290       return A->clone(C);
1291     }
1292     case attr::ObjCOwnership: {
1293       const auto *A = cast<ObjCOwnershipAttr>(At);
1294       return A->clone(C);
1295     }
1296     case attr::ObjCPreciseLifetime: {
1297       const auto *A = cast<ObjCPreciseLifetimeAttr>(At);
1298       return A->clone(C);
1299     }
1300     case attr::ObjCRequiresPropertyDefs: {
1301       const auto *A = cast<ObjCRequiresPropertyDefsAttr>(At);
1302       return A->clone(C);
1303     }
1304     case attr::ObjCRequiresSuper: {
1305       const auto *A = cast<ObjCRequiresSuperAttr>(At);
1306       return A->clone(C);
1307     }
1308     case attr::ObjCReturnsInnerPointer: {
1309       const auto *A = cast<ObjCReturnsInnerPointerAttr>(At);
1310       return A->clone(C);
1311     }
1312     case attr::ObjCRootClass: {
1313       const auto *A = cast<ObjCRootClassAttr>(At);
1314       return A->clone(C);
1315     }
1316     case attr::ObjCRuntimeName: {
1317       const auto *A = cast<ObjCRuntimeNameAttr>(At);
1318       return A->clone(C);
1319     }
1320     case attr::ObjCRuntimeVisible: {
1321       const auto *A = cast<ObjCRuntimeVisibleAttr>(At);
1322       return A->clone(C);
1323     }
1324     case attr::ObjCSubclassingRestricted: {
1325       const auto *A = cast<ObjCSubclassingRestrictedAttr>(At);
1326       return A->clone(C);
1327     }
1328     case attr::OpenCLAccess: {
1329       const auto *A = cast<OpenCLAccessAttr>(At);
1330       return A->clone(C);
1331     }
1332     case attr::OpenCLConstantAddressSpace: {
1333       const auto *A = cast<OpenCLConstantAddressSpaceAttr>(At);
1334       return A->clone(C);
1335     }
1336     case attr::OpenCLGenericAddressSpace: {
1337       const auto *A = cast<OpenCLGenericAddressSpaceAttr>(At);
1338       return A->clone(C);
1339     }
1340     case attr::OpenCLGlobalAddressSpace: {
1341       const auto *A = cast<OpenCLGlobalAddressSpaceAttr>(At);
1342       return A->clone(C);
1343     }
1344     case attr::OpenCLGlobalDeviceAddressSpace: {
1345       const auto *A = cast<OpenCLGlobalDeviceAddressSpaceAttr>(At);
1346       return A->clone(C);
1347     }
1348     case attr::OpenCLGlobalHostAddressSpace: {
1349       const auto *A = cast<OpenCLGlobalHostAddressSpaceAttr>(At);
1350       return A->clone(C);
1351     }
1352     case attr::OpenCLIntelReqdSubGroupSize: {
1353       const auto *A = cast<OpenCLIntelReqdSubGroupSizeAttr>(At);
1354       return A->clone(C);
1355     }
1356     case attr::OpenCLKernel: {
1357       const auto *A = cast<OpenCLKernelAttr>(At);
1358       return A->clone(C);
1359     }
1360     case attr::OpenCLLocalAddressSpace: {
1361       const auto *A = cast<OpenCLLocalAddressSpaceAttr>(At);
1362       return A->clone(C);
1363     }
1364     case attr::OpenCLPrivateAddressSpace: {
1365       const auto *A = cast<OpenCLPrivateAddressSpaceAttr>(At);
1366       return A->clone(C);
1367     }
1368     case attr::OpenCLUnrollHint: {
1369       const auto *A = cast<OpenCLUnrollHintAttr>(At);
1370       return A->clone(C);
1371     }
1372     case attr::OptimizeNone: {
1373       const auto *A = cast<OptimizeNoneAttr>(At);
1374       return A->clone(C);
1375     }
1376     case attr::Overloadable: {
1377       const auto *A = cast<OverloadableAttr>(At);
1378       return A->clone(C);
1379     }
1380     case attr::Override: {
1381       const auto *A = cast<OverrideAttr>(At);
1382       return A->clone(C);
1383     }
1384     case attr::Owner: {
1385       const auto *A = cast<OwnerAttr>(At);
1386       return A->clone(C);
1387     }
1388     case attr::Ownership: {
1389       const auto *A = cast<OwnershipAttr>(At);
1390       return A->clone(C);
1391     }
1392     case attr::Packed: {
1393       const auto *A = cast<PackedAttr>(At);
1394       return A->clone(C);
1395     }
1396     case attr::ParamTypestate: {
1397       const auto *A = cast<ParamTypestateAttr>(At);
1398       return A->clone(C);
1399     }
1400     case attr::Pascal: {
1401       const auto *A = cast<PascalAttr>(At);
1402       return A->clone(C);
1403     }
1404     case attr::PassObjectSize: {
1405       const auto *A = cast<PassObjectSizeAttr>(At);
1406       return A->clone(C);
1407     }
1408     case attr::PatchableFunctionEntry: {
1409       const auto *A = cast<PatchableFunctionEntryAttr>(At);
1410       return A->clone(C);
1411     }
1412     case attr::Pcs: {
1413       const auto *A = cast<PcsAttr>(At);
1414       return A->clone(C);
1415     }
1416     case attr::Pointer: {
1417       const auto *A = cast<PointerAttr>(At);
1418       return A->clone(C);
1419     }
1420     case attr::PragmaClangBSSSection: {
1421       const auto *A = cast<PragmaClangBSSSectionAttr>(At);
1422       return A->clone(C);
1423     }
1424     case attr::PragmaClangDataSection: {
1425       const auto *A = cast<PragmaClangDataSectionAttr>(At);
1426       return A->clone(C);
1427     }
1428     case attr::PragmaClangRelroSection: {
1429       const auto *A = cast<PragmaClangRelroSectionAttr>(At);
1430       return A->clone(C);
1431     }
1432     case attr::PragmaClangRodataSection: {
1433       const auto *A = cast<PragmaClangRodataSectionAttr>(At);
1434       return A->clone(C);
1435     }
1436     case attr::PragmaClangTextSection: {
1437       const auto *A = cast<PragmaClangTextSectionAttr>(At);
1438       return A->clone(C);
1439     }
1440     case attr::PreferredName: {
1441       const auto *A = cast<PreferredNameAttr>(At);
1442       TypeSourceInfo * tempInstTypedefType =
1443         S.SubstType(A->getTypedefTypeLoc(), TemplateArgs, A->getLoc(), A->getAttrName());
1444       if (!tempInstTypedefType)
1445         return nullptr;
1446       return new (C) PreferredNameAttr(C, *A, tempInstTypedefType);
1447     }
1448     case attr::PreferredType: {
1449       const auto *A = cast<PreferredTypeAttr>(At);
1450       return A->clone(C);
1451     }
1452     case attr::PreserveAll: {
1453       const auto *A = cast<PreserveAllAttr>(At);
1454       return A->clone(C);
1455     }
1456     case attr::PreserveMost: {
1457       const auto *A = cast<PreserveMostAttr>(At);
1458       return A->clone(C);
1459     }
1460     case attr::PreserveNone: {
1461       const auto *A = cast<PreserveNoneAttr>(At);
1462       return A->clone(C);
1463     }
1464     case attr::PtGuardedBy: {
1465       const auto *A = cast<PtGuardedByAttr>(At);
1466       Expr * tempInstArg;
1467       {
1468         EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
1469         ExprResult Result = S.SubstExpr(A->getArg(), TemplateArgs);
1470         if (Result.isInvalid())
1471           return nullptr;
1472         tempInstArg = Result.get();
1473       }
1474       return new (C) PtGuardedByAttr(C, *A, tempInstArg);
1475     }
1476     case attr::PtGuardedVar: {
1477       const auto *A = cast<PtGuardedVarAttr>(At);
1478       return A->clone(C);
1479     }
1480     case attr::Ptr32: {
1481       const auto *A = cast<Ptr32Attr>(At);
1482       return A->clone(C);
1483     }
1484     case attr::Ptr64: {
1485       const auto *A = cast<Ptr64Attr>(At);
1486       return A->clone(C);
1487     }
1488     case attr::Pure: {
1489       const auto *A = cast<PureAttr>(At);
1490       return A->clone(C);
1491     }
1492     case attr::RISCVInterrupt: {
1493       const auto *A = cast<RISCVInterruptAttr>(At);
1494       return A->clone(C);
1495     }
1496     case attr::RISCVVectorCC: {
1497       const auto *A = cast<RISCVVectorCCAttr>(At);
1498       return A->clone(C);
1499     }
1500     case attr::RandomizeLayout: {
1501       const auto *A = cast<RandomizeLayoutAttr>(At);
1502       return A->clone(C);
1503     }
1504     case attr::ReadOnlyPlacement: {
1505       const auto *A = cast<ReadOnlyPlacementAttr>(At);
1506       return A->clone(C);
1507     }
1508     case attr::RegCall: {
1509       const auto *A = cast<RegCallAttr>(At);
1510       return A->clone(C);
1511     }
1512     case attr::Reinitializes: {
1513       const auto *A = cast<ReinitializesAttr>(At);
1514       return A->clone(C);
1515     }
1516     case attr::ReleaseCapability: {
1517       const auto *A = cast<ReleaseCapabilityAttr>(At);
1518       auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
1519       {
1520         EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
1521         Expr * *TI = tempInstArgs;
1522         Expr * *I = A->args_begin();
1523         Expr * *E = A->args_end();
1524         for (; I != E; ++I, ++TI) {
1525           ExprResult Result = S.SubstExpr(*I, TemplateArgs);
1526           if (Result.isInvalid())
1527             return nullptr;
1528           *TI = Result.get();
1529         }
1530       }
1531       return new (C) ReleaseCapabilityAttr(C, *A, tempInstArgs, A->args_size());
1532     }
1533     case attr::ReleaseHandle: {
1534       const auto *A = cast<ReleaseHandleAttr>(At);
1535       return A->clone(C);
1536     }
1537     case attr::ReqdWorkGroupSize: {
1538       const auto *A = cast<ReqdWorkGroupSizeAttr>(At);
1539       return A->clone(C);
1540     }
1541     case attr::RequiresCapability: {
1542       const auto *A = cast<RequiresCapabilityAttr>(At);
1543       auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
1544       {
1545         EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
1546         Expr * *TI = tempInstArgs;
1547         Expr * *I = A->args_begin();
1548         Expr * *E = A->args_end();
1549         for (; I != E; ++I, ++TI) {
1550           ExprResult Result = S.SubstExpr(*I, TemplateArgs);
1551           if (Result.isInvalid())
1552             return nullptr;
1553           *TI = Result.get();
1554         }
1555       }
1556       return new (C) RequiresCapabilityAttr(C, *A, tempInstArgs, A->args_size());
1557     }
1558     case attr::Restrict: {
1559       const auto *A = cast<RestrictAttr>(At);
1560       return A->clone(C);
1561     }
1562     case attr::Retain: {
1563       const auto *A = cast<RetainAttr>(At);
1564       return A->clone(C);
1565     }
1566     case attr::ReturnTypestate: {
1567       const auto *A = cast<ReturnTypestateAttr>(At);
1568       return A->clone(C);
1569     }
1570     case attr::ReturnsNonNull: {
1571       const auto *A = cast<ReturnsNonNullAttr>(At);
1572       return A->clone(C);
1573     }
1574     case attr::ReturnsTwice: {
1575       const auto *A = cast<ReturnsTwiceAttr>(At);
1576       return A->clone(C);
1577     }
1578     case attr::SPtr: {
1579       const auto *A = cast<SPtrAttr>(At);
1580       return A->clone(C);
1581     }
1582     case attr::SYCLKernel: {
1583       const auto *A = cast<SYCLKernelAttr>(At);
1584       return A->clone(C);
1585     }
1586     case attr::SYCLKernelEntryPoint: {
1587       const auto *A = cast<SYCLKernelEntryPointAttr>(At);
1588       TypeSourceInfo * tempInstKernelName =
1589         S.SubstType(A->getKernelNameLoc(), TemplateArgs, A->getLoc(), A->getAttrName());
1590       if (!tempInstKernelName)
1591         return nullptr;
1592       return new (C) SYCLKernelEntryPointAttr(C, *A, tempInstKernelName, A->getInvalid());
1593     }
1594     case attr::SYCLSpecialClass: {
1595       const auto *A = cast<SYCLSpecialClassAttr>(At);
1596       return A->clone(C);
1597     }
1598     case attr::ScopedLockable: {
1599       const auto *A = cast<ScopedLockableAttr>(At);
1600       return A->clone(C);
1601     }
1602     case attr::Section: {
1603       const auto *A = cast<SectionAttr>(At);
1604       return A->clone(C);
1605     }
1606     case attr::SelectAny: {
1607       const auto *A = cast<SelectAnyAttr>(At);
1608       return A->clone(C);
1609     }
1610     case attr::Sentinel: {
1611       const auto *A = cast<SentinelAttr>(At);
1612       return A->clone(C);
1613     }
1614     case attr::SetTypestate: {
1615       const auto *A = cast<SetTypestateAttr>(At);
1616       return A->clone(C);
1617     }
1618     case attr::SharedTrylockFunction: {
1619       const auto *A = cast<SharedTrylockFunctionAttr>(At);
1620       Expr * tempInstSuccessValue;
1621       {
1622         EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
1623         ExprResult Result = S.SubstExpr(A->getSuccessValue(), TemplateArgs);
1624         if (Result.isInvalid())
1625           return nullptr;
1626         tempInstSuccessValue = Result.get();
1627       }
1628       auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
1629       {
1630         EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
1631         Expr * *TI = tempInstArgs;
1632         Expr * *I = A->args_begin();
1633         Expr * *E = A->args_end();
1634         for (; I != E; ++I, ++TI) {
1635           ExprResult Result = S.SubstExpr(*I, TemplateArgs);
1636           if (Result.isInvalid())
1637             return nullptr;
1638           *TI = Result.get();
1639         }
1640       }
1641       return new (C) SharedTrylockFunctionAttr(C, *A, tempInstSuccessValue, tempInstArgs, A->args_size());
1642     }
1643     case attr::SizedBy: {
1644       const auto *A = cast<SizedByAttr>(At);
1645       return A->clone(C);
1646     }
1647     case attr::SizedByOrNull: {
1648       const auto *A = cast<SizedByOrNullAttr>(At);
1649       return A->clone(C);
1650     }
1651     case attr::SpeculativeLoadHardening: {
1652       const auto *A = cast<SpeculativeLoadHardeningAttr>(At);
1653       return A->clone(C);
1654     }
1655     case attr::StandaloneDebug: {
1656       const auto *A = cast<StandaloneDebugAttr>(At);
1657       return A->clone(C);
1658     }
1659     case attr::StdCall: {
1660       const auto *A = cast<StdCallAttr>(At);
1661       return A->clone(C);
1662     }
1663     case attr::StrictFP: {
1664       const auto *A = cast<StrictFPAttr>(At);
1665       return A->clone(C);
1666     }
1667     case attr::StrictGuardStackCheck: {
1668       const auto *A = cast<StrictGuardStackCheckAttr>(At);
1669       return A->clone(C);
1670     }
1671     case attr::Suppress: {
1672       const auto *A = cast<SuppressAttr>(At);
1673       return A->clone(C);
1674     }
1675     case attr::SwiftAsync: {
1676       const auto *A = cast<SwiftAsyncAttr>(At);
1677       return A->clone(C);
1678     }
1679     case attr::SwiftAsyncCall: {
1680       const auto *A = cast<SwiftAsyncCallAttr>(At);
1681       return A->clone(C);
1682     }
1683     case attr::SwiftAsyncContext: {
1684       const auto *A = cast<SwiftAsyncContextAttr>(At);
1685       return A->clone(C);
1686     }
1687     case attr::SwiftAsyncError: {
1688       const auto *A = cast<SwiftAsyncErrorAttr>(At);
1689       return A->clone(C);
1690     }
1691     case attr::SwiftAsyncName: {
1692       const auto *A = cast<SwiftAsyncNameAttr>(At);
1693       return A->clone(C);
1694     }
1695     case attr::SwiftAttr: {
1696       const auto *A = cast<SwiftAttrAttr>(At);
1697       return A->clone(C);
1698     }
1699     case attr::SwiftBridge: {
1700       const auto *A = cast<SwiftBridgeAttr>(At);
1701       return A->clone(C);
1702     }
1703     case attr::SwiftBridgedTypedef: {
1704       const auto *A = cast<SwiftBridgedTypedefAttr>(At);
1705       return A->clone(C);
1706     }
1707     case attr::SwiftCall: {
1708       const auto *A = cast<SwiftCallAttr>(At);
1709       return A->clone(C);
1710     }
1711     case attr::SwiftContext: {
1712       const auto *A = cast<SwiftContextAttr>(At);
1713       return A->clone(C);
1714     }
1715     case attr::SwiftError: {
1716       const auto *A = cast<SwiftErrorAttr>(At);
1717       return A->clone(C);
1718     }
1719     case attr::SwiftErrorResult: {
1720       const auto *A = cast<SwiftErrorResultAttr>(At);
1721       return A->clone(C);
1722     }
1723     case attr::SwiftImportAsNonGeneric: {
1724       const auto *A = cast<SwiftImportAsNonGenericAttr>(At);
1725       return A->clone(C);
1726     }
1727     case attr::SwiftImportPropertyAsAccessors: {
1728       const auto *A = cast<SwiftImportPropertyAsAccessorsAttr>(At);
1729       return A->clone(C);
1730     }
1731     case attr::SwiftIndirectResult: {
1732       const auto *A = cast<SwiftIndirectResultAttr>(At);
1733       return A->clone(C);
1734     }
1735     case attr::SwiftName: {
1736       const auto *A = cast<SwiftNameAttr>(At);
1737       return A->clone(C);
1738     }
1739     case attr::SwiftNewType: {
1740       const auto *A = cast<SwiftNewTypeAttr>(At);
1741       return A->clone(C);
1742     }
1743     case attr::SwiftObjCMembers: {
1744       const auto *A = cast<SwiftObjCMembersAttr>(At);
1745       return A->clone(C);
1746     }
1747     case attr::SwiftPrivate: {
1748       const auto *A = cast<SwiftPrivateAttr>(At);
1749       return A->clone(C);
1750     }
1751     case attr::SwiftVersionedAddition: {
1752       const auto *A = cast<SwiftVersionedAdditionAttr>(At);
1753       return A->clone(C);
1754     }
1755     case attr::SwiftVersionedRemoval: {
1756       const auto *A = cast<SwiftVersionedRemovalAttr>(At);
1757       return A->clone(C);
1758     }
1759     case attr::SysVABI: {
1760       const auto *A = cast<SysVABIAttr>(At);
1761       return A->clone(C);
1762     }
1763     case attr::TLSModel: {
1764       const auto *A = cast<TLSModelAttr>(At);
1765       return A->clone(C);
1766     }
1767     case attr::Target: {
1768       const auto *A = cast<TargetAttr>(At);
1769       return A->clone(C);
1770     }
1771     case attr::TargetClones: {
1772       const auto *A = cast<TargetClonesAttr>(At);
1773       return A->clone(C);
1774     }
1775     case attr::TargetVersion: {
1776       const auto *A = cast<TargetVersionAttr>(At);
1777       return A->clone(C);
1778     }
1779     case attr::TestTypestate: {
1780       const auto *A = cast<TestTypestateAttr>(At);
1781       return A->clone(C);
1782     }
1783     case attr::ThisCall: {
1784       const auto *A = cast<ThisCallAttr>(At);
1785       return A->clone(C);
1786     }
1787     case attr::Thread: {
1788       const auto *A = cast<ThreadAttr>(At);
1789       return A->clone(C);
1790     }
1791     case attr::TransparentUnion: {
1792       const auto *A = cast<TransparentUnionAttr>(At);
1793       return A->clone(C);
1794     }
1795     case attr::TrivialABI: {
1796       const auto *A = cast<TrivialABIAttr>(At);
1797       return A->clone(C);
1798     }
1799     case attr::TryAcquireCapability: {
1800       const auto *A = cast<TryAcquireCapabilityAttr>(At);
1801       Expr * tempInstSuccessValue;
1802       {
1803         EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
1804         ExprResult Result = S.SubstExpr(A->getSuccessValue(), TemplateArgs);
1805         if (Result.isInvalid())
1806           return nullptr;
1807         tempInstSuccessValue = Result.get();
1808       }
1809       auto *tempInstArgs = new (C, 16) Expr *[A->args_size()];
1810       {
1811         EnterExpressionEvaluationContext Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);
1812         Expr * *TI = tempInstArgs;
1813         Expr * *I = A->args_begin();
1814         Expr * *E = A->args_end();
1815         for (; I != E; ++I, ++TI) {
1816           ExprResult Result = S.SubstExpr(*I, TemplateArgs);
1817           if (Result.isInvalid())
1818             return nullptr;
1819           *TI = Result.get();
1820         }
1821       }
1822       return new (C) TryAcquireCapabilityAttr(C, *A, tempInstSuccessValue, tempInstArgs, A->args_size());
1823     }
1824     case attr::TypeNonNull: {
1825       const auto *A = cast<TypeNonNullAttr>(At);
1826       return A->clone(C);
1827     }
1828     case attr::TypeNullUnspecified: {
1829       const auto *A = cast<TypeNullUnspecifiedAttr>(At);
1830       return A->clone(C);
1831     }
1832     case attr::TypeNullable: {
1833       const auto *A = cast<TypeNullableAttr>(At);
1834       return A->clone(C);
1835     }
1836     case attr::TypeNullableResult: {
1837       const auto *A = cast<TypeNullableResultAttr>(At);
1838       return A->clone(C);
1839     }
1840     case attr::TypeTagForDatatype: {
1841       const auto *A = cast<TypeTagForDatatypeAttr>(At);
1842       return A->clone(C);
1843     }
1844     case attr::TypeVisibility: {
1845       return nullptr;
1846     }
1847     case attr::UPtr: {
1848       const auto *A = cast<UPtrAttr>(At);
1849       return A->clone(C);
1850     }
1851     case attr::Unavailable: {
1852       const auto *A = cast<UnavailableAttr>(At);
1853       return A->clone(C);
1854     }
1855     case attr::Uninitialized: {
1856       const auto *A = cast<UninitializedAttr>(At);
1857       return A->clone(C);
1858     }
1859     case attr::Unlikely: {
1860       const auto *A = cast<UnlikelyAttr>(At);
1861       return A->clone(C);
1862     }
1863     case attr::UnsafeBufferUsage: {
1864       const auto *A = cast<UnsafeBufferUsageAttr>(At);
1865       return A->clone(C);
1866     }
1867     case attr::Unused: {
1868       const auto *A = cast<UnusedAttr>(At);
1869       return A->clone(C);
1870     }
1871     case attr::UseHandle: {
1872       const auto *A = cast<UseHandleAttr>(At);
1873       return A->clone(C);
1874     }
1875     case attr::Used: {
1876       const auto *A = cast<UsedAttr>(At);
1877       return A->clone(C);
1878     }
1879     case attr::UsingIfExists: {
1880       const auto *A = cast<UsingIfExistsAttr>(At);
1881       return A->clone(C);
1882     }
1883     case attr::Uuid: {
1884       const auto *A = cast<UuidAttr>(At);
1885       return A->clone(C);
1886     }
1887     case attr::VTablePointerAuthentication: {
1888       const auto *A = cast<VTablePointerAuthenticationAttr>(At);
1889       return A->clone(C);
1890     }
1891     case attr::VecReturn: {
1892       const auto *A = cast<VecReturnAttr>(At);
1893       return A->clone(C);
1894     }
1895     case attr::VecTypeHint: {
1896       const auto *A = cast<VecTypeHintAttr>(At);
1897       return A->clone(C);
1898     }
1899     case attr::VectorCall: {
1900       const auto *A = cast<VectorCallAttr>(At);
1901       return A->clone(C);
1902     }
1903     case attr::Visibility: {
1904       return nullptr;
1905     }
1906     case attr::WarnUnused: {
1907       const auto *A = cast<WarnUnusedAttr>(At);
1908       return A->clone(C);
1909     }
1910     case attr::WarnUnusedResult: {
1911       const auto *A = cast<WarnUnusedResultAttr>(At);
1912       return A->clone(C);
1913     }
1914     case attr::Weak: {
1915       const auto *A = cast<WeakAttr>(At);
1916       return A->clone(C);
1917     }
1918     case attr::WeakImport: {
1919       const auto *A = cast<WeakImportAttr>(At);
1920       return A->clone(C);
1921     }
1922     case attr::WeakRef: {
1923       const auto *A = cast<WeakRefAttr>(At);
1924       return A->clone(C);
1925     }
1926     case attr::WebAssemblyExportName: {
1927       const auto *A = cast<WebAssemblyExportNameAttr>(At);
1928       return A->clone(C);
1929     }
1930     case attr::WebAssemblyFuncref: {
1931       const auto *A = cast<WebAssemblyFuncrefAttr>(At);
1932       return A->clone(C);
1933     }
1934     case attr::WebAssemblyImportModule: {
1935       const auto *A = cast<WebAssemblyImportModuleAttr>(At);
1936       return A->clone(C);
1937     }
1938     case attr::WebAssemblyImportName: {
1939       const auto *A = cast<WebAssemblyImportNameAttr>(At);
1940       return A->clone(C);
1941     }
1942     case attr::WorkGroupSizeHint: {
1943       const auto *A = cast<WorkGroupSizeHintAttr>(At);
1944       return A->clone(C);
1945     }
1946     case attr::X86ForceAlignArgPointer: {
1947       const auto *A = cast<X86ForceAlignArgPointerAttr>(At);
1948       return A->clone(C);
1949     }
1950     case attr::XRayInstrument: {
1951       const auto *A = cast<XRayInstrumentAttr>(At);
1952       return A->clone(C);
1953     }
1954     case attr::XRayLogArgs: {
1955       const auto *A = cast<XRayLogArgsAttr>(At);
1956       return A->clone(C);
1957     }
1958     case attr::ZeroCallUsedRegs: {
1959       const auto *A = cast<ZeroCallUsedRegsAttr>(At);
1960       return A->clone(C);
1961     }
1962   } // end switch
1963   llvm_unreachable("Unknown attribute!");
1964   return nullptr;
1965 }
1966
1967 Attr *instantiateTemplateAttributeForDecl(const Attr *At,
1968  ASTContext &C, Sema &S,
1969         const MultiLevelTemplateArgumentList &TemplateArgs) {
1970   switch (At->getKind()) {
1971     case attr::AArch64SVEPcs: {
1972       return nullptr;
1973     }
1974     case attr::AArch64VectorPcs: {
1975       return nullptr;
1976     }
1977     case attr::AMDGPUFlatWorkGroupSize: {
1978       return nullptr;
1979     }
1980     case attr::AMDGPUKernelCall: {
1981       return nullptr;
1982     }
1983     case attr::AMDGPUMaxNumWorkGroups: {
1984       return nullptr;
1985     }
1986     case attr::AMDGPUNumSGPR: {
1987       return nullptr;
1988     }
1989     case attr::AMDGPUNumVGPR: {
1990       return nullptr;
1991     }
1992     case attr::AMDGPUWavesPerEU: {
1993       return nullptr;
1994     }
1995     case attr::ARMInterrupt: {
1996       return nullptr;
1997     }
1998     case attr::AVRInterrupt: {
1999       return nullptr;
2000     }
2001     case attr::AVRSignal: {
2002       return nullptr;
2003     }
2004     case attr::AbiTag: {
2005       const auto *A = cast<AbiTagAttr>(At);
2006       return A->clone(C);
2007     }
2008     case attr::AcquireCapability: {
2009       return nullptr;
2010     }
2011     case attr::AcquireHandle: {
2012       return nullptr;
2013     }
2014     case attr::AcquiredAfter: {
2015       return nullptr;
2016     }
2017     case attr::AcquiredBefore: {
2018       return nullptr;
2019     }
2020     case attr::AddressSpace: {
2021       return nullptr;
2022     }
2023     case attr::Alias: {
2024       return nullptr;
2025     }
2026     case attr::AlignMac68k: {
2027       return nullptr;
2028     }
2029     case attr::AlignNatural: {
2030       return nullptr;
2031     }
2032     case attr::AlignValue: {
2033       return nullptr;
2034     }
2035     case attr::Aligned: {
2036       return nullptr;
2037     }
2038     case attr::AllocAlign: {
2039       return nullptr;
2040     }
2041     case attr::AllocSize: {
2042       return nullptr;
2043     }
2044     case attr::Allocating: {
2045       return nullptr;
2046     }
2047     case attr::AlwaysDestroy: {
2048       return nullptr;
2049     }
2050     case attr::AlwaysInline: {
2051       return nullptr;
2052     }
2053     case attr::AnalyzerNoReturn: {
2054       return nullptr;
2055     }
2056     case attr::Annotate: {
2057       return nullptr;
2058     }
2059     case attr::AnnotateType: {
2060       return nullptr;
2061     }
2062     case attr::AnyX86Interrupt: {
2063       return nullptr;
2064     }
2065     case attr::AnyX86NoCallerSavedRegisters: {
2066       return nullptr;
2067     }
2068     case attr::AnyX86NoCfCheck: {
2069       return nullptr;
2070     }
2071     case attr::ArcWeakrefUnavailable: {
2072       return nullptr;
2073     }
2074     case attr::ArgumentWithTypeTag: {
2075       return nullptr;
2076     }
2077     case attr::ArmAgnostic: {
2078       return nullptr;
2079     }
2080     case attr::ArmBuiltinAlias: {
2081       return nullptr;
2082     }
2083     case attr::ArmIn: {
2084       return nullptr;
2085     }
2086     case attr::ArmInOut: {
2087       return nullptr;
2088     }
2089     case attr::ArmLocallyStreaming: {
2090       return nullptr;
2091     }
2092     case attr::ArmMveStrictPolymorphism: {
2093       return nullptr;
2094     }
2095     case attr::ArmNew: {
2096       return nullptr;
2097     }
2098     case attr::ArmOut: {
2099       return nullptr;
2100     }
2101     case attr::ArmPreserves: {
2102       return nullptr;
2103     }
2104     case attr::ArmStreaming: {
2105       return nullptr;
2106     }
2107     case attr::ArmStreamingCompatible: {
2108       return nullptr;
2109     }
2110     case attr::Artificial: {
2111       return nullptr;
2112     }
2113     case attr::AsmLabel: {
2114       return nullptr;
2115     }
2116     case attr::AssertCapability: {
2117       return nullptr;
2118     }
2119     case attr::AssertExclusiveLock: {
2120       return nullptr;
2121     }
2122     case attr::AssertSharedLock: {
2123       return nullptr;
2124     }
2125     case attr::AssumeAligned: {
2126       return nullptr;
2127     }
2128     case attr::Availability: {
2129       return nullptr;
2130     }
2131     case attr::AvailableOnlyInDefaultEvalMethod: {
2132       return nullptr;
2133     }
2134     case attr::BPFFastCall: {
2135       return nullptr;
2136     }
2137     case attr::BPFPreserveAccessIndex: {
2138       return nullptr;
2139     }
2140     case attr::BPFPreserveStaticOffset: {
2141       return nullptr;
2142     }
2143     case attr::BTFDeclTag: {
2144       return nullptr;
2145     }
2146     case attr::BTFTypeTag: {
2147       return nullptr;
2148     }
2149     case attr::Blocking: {
2150       return nullptr;
2151     }
2152     case attr::Blocks: {
2153       return nullptr;
2154     }
2155     case attr::Builtin: {
2156       return nullptr;
2157     }
2158     case attr::BuiltinAlias: {
2159       return nullptr;
2160     }
2161     case attr::C11NoReturn: {
2162       return nullptr;
2163     }
2164     case attr::CDecl: {
2165       return nullptr;
2166     }
2167     case attr::CFAuditedTransfer: {
2168       return nullptr;
2169     }
2170     case attr::CFConsumed: {
2171       return nullptr;
2172     }
2173     case attr::CFGuard: {
2174       return nullptr;
2175     }
2176     case attr::CFICanonicalJumpTable: {
2177       return nullptr;
2178     }
2179     case attr::CFReturnsNotRetained: {
2180       return nullptr;
2181     }
2182     case attr::CFReturnsRetained: {
2183       return nullptr;
2184     }
2185     case attr::CFUnknownTransfer: {
2186       return nullptr;
2187     }
2188     case attr::CPUDispatch: {
2189       return nullptr;
2190     }
2191     case attr::CPUSpecific: {
2192       return nullptr;
2193     }
2194     case attr::CUDAConstant: {
2195       return nullptr;
2196     }
2197     case attr::CUDADevice: {
2198       return nullptr;
2199     }
2200     case attr::CUDADeviceBuiltinSurfaceType: {
2201       const auto *A = cast<CUDADeviceBuiltinSurfaceTypeAttr>(At);
2202       return A->clone(C);
2203     }
2204     case attr::CUDADeviceBuiltinTextureType: {
2205       const auto *A = cast<CUDADeviceBuiltinTextureTypeAttr>(At);
2206       return A->clone(C);
2207     }
2208     case attr::CUDAGlobal: {
2209       return nullptr;
2210     }
2211     case attr::CUDAGridConstant: {
2212       return nullptr;
2213     }
2214     case attr::CUDAHost: {
2215       return nullptr;
2216     }
2217     case attr::CUDAInvalidTarget: {
2218       return nullptr;
2219     }
2220     case attr::CUDALaunchBounds: {
2221       return nullptr;
2222     }
2223     case attr::CUDAShared: {
2224       return nullptr;
2225     }
2226     case attr::CXX11NoReturn: {
2227       return nullptr;
2228     }
2229     case attr::CXXAssume: {
2230       return nullptr;
2231     }
2232     case attr::CallableWhen: {
2233       return nullptr;
2234     }
2235     case attr::Callback: {
2236       return nullptr;
2237     }
2238     case attr::CalledOnce: {
2239       return nullptr;
2240     }
2241     case attr::Capability: {
2242       return nullptr;
2243     }
2244     case attr::CapturedRecord: {
2245       return nullptr;
2246     }
2247     case attr::CarriesDependency: {
2248       return nullptr;
2249     }
2250     case attr::Cleanup: {
2251       return nullptr;
2252     }
2253     case attr::ClspvLibclcBuiltin: {
2254       return nullptr;
2255     }
2256     case attr::CmseNSCall: {
2257       return nullptr;
2258     }
2259     case attr::CmseNSEntry: {
2260       return nullptr;
2261     }
2262     case attr::CodeAlign: {
2263       return nullptr;
2264     }
2265     case attr::CodeModel: {
2266       return nullptr;
2267     }
2268     case attr::CodeSeg: {
2269       return nullptr;
2270     }
2271     case attr::Cold: {
2272       return nullptr;
2273     }
2274     case attr::Common: {
2275       return nullptr;
2276     }
2277     case attr::Const: {
2278       return nullptr;
2279     }
2280     case attr::ConstInit: {
2281       return nullptr;
2282     }
2283     case attr::Constructor: {
2284       return nullptr;
2285     }
2286     case attr::Consumable: {
2287       return nullptr;
2288     }
2289     case attr::ConsumableAutoCast: {
2290       return nullptr;
2291     }
2292     case attr::ConsumableSetOnRead: {
2293       return nullptr;
2294     }
2295     case attr::Convergent: {
2296       return nullptr;
2297     }
2298     case attr::CoroAwaitElidable: {
2299       return nullptr;
2300     }
2301     case attr::CoroAwaitElidableArgument: {
2302       return nullptr;
2303     }
2304     case attr::CoroDisableLifetimeBound: {
2305       return nullptr;
2306     }
2307     case attr::CoroLifetimeBound: {
2308       return nullptr;
2309     }
2310     case attr::CoroOnlyDestroyWhenComplete: {
2311       return nullptr;
2312     }
2313     case attr::CoroReturnType: {
2314       return nullptr;
2315     }
2316     case attr::CoroWrapper: {
2317       return nullptr;
2318     }
2319     case attr::CountedBy: {
2320       return nullptr;
2321     }
2322     case attr::CountedByOrNull: {
2323       return nullptr;
2324     }
2325     case attr::DLLExport: {
2326       return nullptr;
2327     }
2328     case attr::DLLExportStaticLocal: {
2329       return nullptr;
2330     }
2331     case attr::DLLImport: {
2332       return nullptr;
2333     }
2334     case attr::DLLImportStaticLocal: {
2335       return nullptr;
2336     }
2337     case attr::Deprecated: {
2338       const auto *A = cast<DeprecatedAttr>(At);
2339       return A->clone(C);
2340     }
2341     case attr::Destructor: {
2342       return nullptr;
2343     }
2344     case attr::DiagnoseAsBuiltin: {
2345       return nullptr;
2346     }
2347     case attr::DiagnoseIf: {
2348       return nullptr;
2349     }
2350     case attr::DisableSanitizerInstrumentation: {
2351       return nullptr;
2352     }
2353     case attr::DisableTailCalls: {
2354       return nullptr;
2355     }
2356     case attr::EmptyBases: {
2357       return nullptr;
2358     }
2359     case attr::EnableIf: {
2360       return nullptr;
2361     }
2362     case attr::EnforceTCB: {
2363       return nullptr;
2364     }
2365     case attr::EnforceTCBLeaf: {
2366       return nullptr;
2367     }
2368     case attr::EnumExtensibility: {
2369       return nullptr;
2370     }
2371     case attr::Error: {
2372       return nullptr;
2373     }
2374     case attr::ExcludeFromExplicitInstantiation: {
2375       const auto *A = cast<ExcludeFromExplicitInstantiationAttr>(At);
2376       return A->clone(C);
2377     }
2378     case attr::ExclusiveTrylockFunction: {
2379       return nullptr;
2380     }
2381     case attr::ExplicitInit: {
2382       return nullptr;
2383     }
2384     case attr::ExternalSourceSymbol: {
2385       return nullptr;
2386     }
2387     case attr::FallThrough: {
2388       return nullptr;
2389     }
2390     case attr::FastCall: {
2391       return nullptr;
2392     }
2393     case attr::Final: {
2394       return nullptr;
2395     }
2396     case attr::FlagEnum: {
2397       return nullptr;
2398     }
2399     case attr::Flatten: {
2400       return nullptr;
2401     }
2402     case attr::Format: {
2403       return nullptr;
2404     }
2405     case attr::FormatArg: {
2406       return nullptr;
2407     }
2408     case attr::FunctionReturnThunks: {
2409       return nullptr;
2410     }
2411     case attr::GNUInline: {
2412       return nullptr;
2413     }
2414     case attr::GuardedBy: {
2415       return nullptr;
2416     }
2417     case attr::GuardedVar: {
2418       return nullptr;
2419     }
2420     case attr::HIPManaged: {
2421       return nullptr;
2422     }
2423     case attr::HLSLContainedType: {
2424       return nullptr;
2425     }
2426     case attr::HLSLControlFlowHint: {
2427       return nullptr;
2428     }
2429     case attr::HLSLGroupSharedAddressSpace: {
2430       return nullptr;
2431     }
2432     case attr::HLSLLoopHint: {
2433       return nullptr;
2434     }
2435     case attr::HLSLNumThreads: {
2436       return nullptr;
2437     }
2438     case attr::HLSLPackOffset: {
2439       return nullptr;
2440     }
2441     case attr::HLSLParamModifier: {
2442       return nullptr;
2443     }
2444     case attr::HLSLROV: {
2445       return nullptr;
2446     }
2447     case attr::HLSLRawBuffer: {
2448       return nullptr;
2449     }
2450     case attr::HLSLResource: {
2451       return nullptr;
2452     }
2453     case attr::HLSLResourceBinding: {
2454       return nullptr;
2455     }
2456     case attr::HLSLResourceClass: {
2457       return nullptr;
2458     }
2459     case attr::HLSLSV_DispatchThreadID: {
2460       return nullptr;
2461     }
2462     case attr::HLSLSV_GroupID: {
2463       return nullptr;
2464     }
2465     case attr::HLSLSV_GroupIndex: {
2466       return nullptr;
2467     }
2468     case attr::HLSLSV_GroupThreadID: {
2469       return nullptr;
2470     }
2471     case attr::HLSLShader: {
2472       return nullptr;
2473     }
2474     case attr::HLSLWaveSize: {
2475       return nullptr;
2476     }
2477     case attr::Hot: {
2478       return nullptr;
2479     }
2480     case attr::HybridPatchable: {
2481       return nullptr;
2482     }
2483     case attr::IBAction: {
2484       return nullptr;
2485     }
2486     case attr::IBOutlet: {
2487       return nullptr;
2488     }
2489     case attr::IBOutletCollection: {
2490       return nullptr;
2491     }
2492     case attr::IFunc: {
2493       return nullptr;
2494     }
2495     case attr::InitPriority: {
2496       return nullptr;
2497     }
2498     case attr::InitSeg: {
2499       return nullptr;
2500     }
2501     case attr::IntelOclBicc: {
2502       return nullptr;
2503     }
2504     case attr::InternalLinkage: {
2505       return nullptr;
2506     }
2507     case attr::LTOVisibilityPublic: {
2508       return nullptr;
2509     }
2510     case attr::LayoutVersion: {
2511       return nullptr;
2512     }
2513     case attr::Leaf: {
2514       return nullptr;
2515     }
2516     case attr::LifetimeBound: {
2517       return nullptr;
2518     }
2519     case attr::LifetimeCaptureBy: {
2520       return nullptr;
2521     }
2522     case attr::Likely: {
2523       return nullptr;
2524     }
2525     case attr::LoaderUninitialized: {
2526       return nullptr;
2527     }
2528     case attr::LockReturned: {
2529       return nullptr;
2530     }
2531     case attr::LocksExcluded: {
2532       return nullptr;
2533     }
2534     case attr::LoopHint: {
2535       return nullptr;
2536     }
2537     case attr::M68kInterrupt: {
2538       return nullptr;
2539     }
2540     case attr::M68kRTD: {
2541       return nullptr;
2542     }
2543     case attr::MIGServerRoutine: {
2544       return nullptr;
2545     }
2546     case attr::MSABI: {
2547       return nullptr;
2548     }
2549     case attr::MSAllocator: {
2550       return nullptr;
2551     }
2552     case attr::MSConstexpr: {
2553       return nullptr;
2554     }
2555     case attr::MSInheritance: {
2556       return nullptr;
2557     }
2558     case attr::MSNoVTable: {
2559       return nullptr;
2560     }
2561     case attr::MSP430Interrupt: {
2562       return nullptr;
2563     }
2564     case attr::MSStruct: {
2565       return nullptr;
2566     }
2567     case attr::MSVtorDisp: {
2568       return nullptr;
2569     }
2570     case attr::MaxFieldAlignment: {
2571       return nullptr;
2572     }
2573     case attr::MayAlias: {
2574       return nullptr;
2575     }
2576     case attr::MaybeUndef: {
2577       return nullptr;
2578     }
2579     case attr::MicroMips: {
2580       return nullptr;
2581     }
2582     case attr::MinSize: {
2583       return nullptr;
2584     }
2585     case attr::MinVectorWidth: {
2586       return nullptr;
2587     }
2588     case attr::Mips16: {
2589       return nullptr;
2590     }
2591     case attr::MipsInterrupt: {
2592       return nullptr;
2593     }
2594     case attr::MipsLongCall: {
2595       return nullptr;
2596     }
2597     case attr::MipsShortCall: {
2598       return nullptr;
2599     }
2600     case attr::Mode: {
2601       return nullptr;
2602     }
2603     case attr::MustTail: {
2604       return nullptr;
2605     }
2606     case attr::NSConsumed: {
2607       return nullptr;
2608     }
2609     case attr::NSConsumesSelf: {
2610       return nullptr;
2611     }
2612     case attr::NSErrorDomain: {
2613       return nullptr;
2614     }
2615     case attr::NSReturnsAutoreleased: {
2616       return nullptr;
2617     }
2618     case attr::NSReturnsNotRetained: {
2619       return nullptr;
2620     }
2621     case attr::NSReturnsRetained: {
2622       return nullptr;
2623     }
2624     case attr::NVPTXKernel: {
2625       return nullptr;
2626     }
2627     case attr::Naked: {
2628       return nullptr;
2629     }
2630     case attr::NoAlias: {
2631       return nullptr;
2632     }
2633     case attr::NoBuiltin: {
2634       return nullptr;
2635     }
2636     case attr::NoCommon: {
2637       return nullptr;
2638     }
2639     case attr::NoConvergent: {
2640       return nullptr;
2641     }
2642     case attr::NoDebug: {
2643       return nullptr;
2644     }
2645     case attr::NoDeref: {
2646       return nullptr;
2647     }
2648     case attr::NoDestroy: {
2649       return nullptr;
2650     }
2651     case attr::NoDuplicate: {
2652       return nullptr;
2653     }
2654     case attr::NoEscape: {
2655       return nullptr;
2656     }
2657     case attr::NoInline: {
2658       return nullptr;
2659     }
2660     case attr::NoInstrumentFunction: {
2661       return nullptr;
2662     }
2663     case attr::NoMerge: {
2664       return nullptr;
2665     }
2666     case attr::NoMicroMips: {
2667       return nullptr;
2668     }
2669     case attr::NoMips16: {
2670       return nullptr;
2671     }
2672     case attr::NoProfileFunction: {
2673       return nullptr;
2674     }
2675     case attr::NoRandomizeLayout: {
2676       return nullptr;
2677     }
2678     case attr::NoReturn: {
2679       return nullptr;
2680     }
2681     case attr::NoSanitize: {
2682       return nullptr;
2683     }
2684     case attr::NoSpecializations: {
2685       const auto *A = cast<NoSpecializationsAttr>(At);
2686       return new (C) NoSpecializationsAttr(C, *A, A->getMessage());
2687     }
2688     case attr::NoSpeculativeLoadHardening: {
2689       return nullptr;
2690     }
2691     case attr::NoSplitStack: {
2692       return nullptr;
2693     }
2694     case attr::NoStackProtector: {
2695       return nullptr;
2696     }
2697     case attr::NoThreadSafetyAnalysis: {
2698       return nullptr;
2699     }
2700     case attr::NoThrow: {
2701       return nullptr;
2702     }
2703     case attr::NoTrivialAutoVarInit: {
2704       return nullptr;
2705     }
2706     case attr::NoUniqueAddress: {
2707       return nullptr;
2708     }
2709     case attr::NoUwtable: {
2710       return nullptr;
2711     }
2712     case attr::NonAllocating: {
2713       return nullptr;
2714     }
2715     case attr::NonBlocking: {
2716       return nullptr;
2717     }
2718     case attr::NonNull: {
2719       return nullptr;
2720     }
2721     case attr::NotTailCalled: {
2722       return nullptr;
2723     }
2724     case attr::OMPAllocateDecl: {
2725       return nullptr;
2726     }
2727     case attr::OMPAssume: {
2728       return nullptr;
2729     }
2730     case attr::OMPCaptureKind: {
2731       return nullptr;
2732     }
2733     case attr::OMPCaptureNoInit: {
2734       return nullptr;
2735     }
2736     case attr::OMPDeclareSimdDecl: {
2737       return nullptr;
2738     }
2739     case attr::OMPDeclareTargetDecl: {
2740       return nullptr;
2741     }
2742     case attr::OMPDeclareVariant: {
2743       return nullptr;
2744     }
2745     case attr::OMPReferencedVar: {
2746       return nullptr;
2747     }
2748     case attr::OMPThreadPrivateDecl: {
2749       return nullptr;
2750     }
2751     case attr::OSConsumed: {
2752       return nullptr;
2753     }
2754     case attr::OSConsumesThis: {
2755       return nullptr;
2756     }
2757     case attr::OSReturnsNotRetained: {
2758       return nullptr;
2759     }
2760     case attr::OSReturnsRetained: {
2761       return nullptr;
2762     }
2763     case attr::OSReturnsRetainedOnNonZero: {
2764       return nullptr;
2765     }
2766     case attr::OSReturnsRetainedOnZero: {
2767       return nullptr;
2768     }
2769     case attr::ObjCBoxable: {
2770       return nullptr;
2771     }
2772     case attr::ObjCBridge: {
2773       return nullptr;
2774     }
2775     case attr::ObjCBridgeMutable: {
2776       return nullptr;
2777     }
2778     case attr::ObjCBridgeRelated: {
2779       return nullptr;
2780     }
2781     case attr::ObjCClassStub: {
2782       return nullptr;
2783     }
2784     case attr::ObjCDesignatedInitializer: {
2785       return nullptr;
2786     }
2787     case attr::ObjCDirect: {
2788       return nullptr;
2789     }
2790     case attr::ObjCDirectMembers: {
2791       return nullptr;
2792     }
2793     case attr::ObjCException: {
2794       return nullptr;
2795     }
2796     case attr::ObjCExplicitProtocolImpl: {
2797       return nullptr;
2798     }
2799     case attr::ObjCExternallyRetained: {
2800       return nullptr;
2801     }
2802     case attr::ObjCGC: {
2803       return nullptr;
2804     }
2805     case attr::ObjCIndependentClass: {
2806       return nullptr;
2807     }
2808     case attr::ObjCInertUnsafeUnretained: {
2809       return nullptr;
2810     }
2811     case attr::ObjCKindOf: {
2812       return nullptr;
2813     }
2814     case attr::ObjCMethodFamily: {
2815       return nullptr;
2816     }
2817     case attr::ObjCNSObject: {
2818       return nullptr;
2819     }
2820     case attr::ObjCNonLazyClass: {
2821       return nullptr;
2822     }
2823     case attr::ObjCNonRuntimeProtocol: {
2824       return nullptr;
2825     }
2826     case attr::ObjCOwnership: {
2827       return nullptr;
2828     }
2829     case attr::ObjCPreciseLifetime: {
2830       return nullptr;
2831     }
2832     case attr::ObjCRequiresPropertyDefs: {
2833       return nullptr;
2834     }
2835     case attr::ObjCRequiresSuper: {
2836       return nullptr;
2837     }
2838     case attr::ObjCReturnsInnerPointer: {
2839       return nullptr;
2840     }
2841     case attr::ObjCRootClass: {
2842       return nullptr;
2843     }
2844     case attr::ObjCRuntimeName: {
2845       return nullptr;
2846     }
2847     case attr::ObjCRuntimeVisible: {
2848       return nullptr;
2849     }
2850     case attr::ObjCSubclassingRestricted: {
2851       return nullptr;
2852     }
2853     case attr::OpenCLAccess: {
2854       return nullptr;
2855     }
2856     case attr::OpenCLConstantAddressSpace: {
2857       return nullptr;
2858     }
2859     case attr::OpenCLGenericAddressSpace: {
2860       return nullptr;
2861     }
2862     case attr::OpenCLGlobalAddressSpace: {
2863       return nullptr;
2864     }
2865     case attr::OpenCLGlobalDeviceAddressSpace: {
2866       return nullptr;
2867     }
2868     case attr::OpenCLGlobalHostAddressSpace: {
2869       return nullptr;
2870     }
2871     case attr::OpenCLIntelReqdSubGroupSize: {
2872       return nullptr;
2873     }
2874     case attr::OpenCLKernel: {
2875       return nullptr;
2876     }
2877     case attr::OpenCLLocalAddressSpace: {
2878       return nullptr;
2879     }
2880     case attr::OpenCLPrivateAddressSpace: {
2881       return nullptr;
2882     }
2883     case attr::OpenCLUnrollHint: {
2884       return nullptr;
2885     }
2886     case attr::OptimizeNone: {
2887       return nullptr;
2888     }
2889     case attr::Overloadable: {
2890       return nullptr;
2891     }
2892     case attr::Override: {
2893       return nullptr;
2894     }
2895     case attr::Owner: {
2896       return nullptr;
2897     }
2898     case attr::Ownership: {
2899       return nullptr;
2900     }
2901     case attr::Packed: {
2902       return nullptr;
2903     }
2904     case attr::ParamTypestate: {
2905       return nullptr;
2906     }
2907     case attr::Pascal: {
2908       return nullptr;
2909     }
2910     case attr::PassObjectSize: {
2911       return nullptr;
2912     }
2913     case attr::PatchableFunctionEntry: {
2914       return nullptr;
2915     }
2916     case attr::Pcs: {
2917       return nullptr;
2918     }
2919     case attr::Pointer: {
2920       return nullptr;
2921     }
2922     case attr::PragmaClangBSSSection: {
2923       return nullptr;
2924     }
2925     case attr::PragmaClangDataSection: {
2926       return nullptr;
2927     }
2928     case attr::PragmaClangRelroSection: {
2929       return nullptr;
2930     }
2931     case attr::PragmaClangRodataSection: {
2932       return nullptr;
2933     }
2934     case attr::PragmaClangTextSection: {
2935       return nullptr;
2936     }
2937     case attr::PreferredName: {
2938       const auto *A = cast<PreferredNameAttr>(At);
2939       TypeSourceInfo * tempInstTypedefType =
2940         S.SubstType(A->getTypedefTypeLoc(), TemplateArgs, A->getLoc(), A->getAttrName());
2941       if (!tempInstTypedefType)
2942         return nullptr;
2943       return new (C) PreferredNameAttr(C, *A, tempInstTypedefType);
2944     }
2945     case attr::PreferredType: {
2946       return nullptr;
2947     }
2948     case attr::PreserveAll: {
2949       return nullptr;
2950     }
2951     case attr::PreserveMost: {
2952       return nullptr;
2953     }
2954     case attr::PreserveNone: {
2955       return nullptr;
2956     }
2957     case attr::PtGuardedBy: {
2958       return nullptr;
2959     }
2960     case attr::PtGuardedVar: {
2961       return nullptr;
2962     }
2963     case attr::Ptr32: {
2964       return nullptr;
2965     }
2966     case attr::Ptr64: {
2967       return nullptr;
2968     }
2969     case attr::Pure: {
2970       return nullptr;
2971     }
2972     case attr::RISCVInterrupt: {
2973       return nullptr;
2974     }
2975     case attr::RISCVVectorCC: {
2976       return nullptr;
2977     }
2978     case attr::RandomizeLayout: {
2979       return nullptr;
2980     }
2981     case attr::ReadOnlyPlacement: {
2982       return nullptr;
2983     }
2984     case attr::RegCall: {
2985       return nullptr;
2986     }
2987     case attr::Reinitializes: {
2988       return nullptr;
2989     }
2990     case attr::ReleaseCapability: {
2991       return nullptr;
2992     }
2993     case attr::ReleaseHandle: {
2994       return nullptr;
2995     }
2996     case attr::ReqdWorkGroupSize: {
2997       return nullptr;
2998     }
2999     case attr::RequiresCapability: {
3000       return nullptr;
3001     }
3002     case attr::Restrict: {
3003       return nullptr;
3004     }
3005     case attr::Retain: {
3006       return nullptr;
3007     }
3008     case attr::ReturnTypestate: {
3009       return nullptr;
3010     }
3011     case attr::ReturnsNonNull: {
3012       return nullptr;
3013     }
3014     case attr::ReturnsTwice: {
3015       return nullptr;
3016     }
3017     case attr::SPtr: {
3018       return nullptr;
3019     }
3020     case attr::SYCLKernel: {
3021       return nullptr;
3022     }
3023     case attr::SYCLKernelEntryPoint: {
3024       return nullptr;
3025     }
3026     case attr::SYCLSpecialClass: {
3027       return nullptr;
3028     }
3029     case attr::ScopedLockable: {
3030       return nullptr;
3031     }
3032     case attr::Section: {
3033       return nullptr;
3034     }
3035     case attr::SelectAny: {
3036       return nullptr;
3037     }
3038     case attr::Sentinel: {
3039       return nullptr;
3040     }
3041     case attr::SetTypestate: {
3042       return nullptr;
3043     }
3044     case attr::SharedTrylockFunction: {
3045       return nullptr;
3046     }
3047     case attr::SizedBy: {
3048       return nullptr;
3049     }
3050     case attr::SizedByOrNull: {
3051       return nullptr;
3052     }
3053     case attr::SpeculativeLoadHardening: {
3054       return nullptr;
3055     }
3056     case attr::StandaloneDebug: {
3057       return nullptr;
3058     }
3059     case attr::StdCall: {
3060       return nullptr;
3061     }
3062     case attr::StrictFP: {
3063       return nullptr;
3064     }
3065     case attr::StrictGuardStackCheck: {
3066       return nullptr;
3067     }
3068     case attr::Suppress: {
3069       return nullptr;
3070     }
3071     case attr::SwiftAsync: {
3072       return nullptr;
3073     }
3074     case attr::SwiftAsyncCall: {
3075       return nullptr;
3076     }
3077     case attr::SwiftAsyncContext: {
3078       return nullptr;
3079     }
3080     case attr::SwiftAsyncError: {
3081       return nullptr;
3082     }
3083     case attr::SwiftAsyncName: {
3084       return nullptr;
3085     }
3086     case attr::SwiftAttr: {
3087       return nullptr;
3088     }
3089     case attr::SwiftBridge: {
3090       return nullptr;
3091     }
3092     case attr::SwiftBridgedTypedef: {
3093       return nullptr;
3094     }
3095     case attr::SwiftCall: {
3096       return nullptr;
3097     }
3098     case attr::SwiftContext: {
3099       return nullptr;
3100     }
3101     case attr::SwiftError: {
3102       return nullptr;
3103     }
3104     case attr::SwiftErrorResult: {
3105       return nullptr;
3106     }
3107     case attr::SwiftImportAsNonGeneric: {
3108       return nullptr;
3109     }
3110     case attr::SwiftImportPropertyAsAccessors: {
3111       return nullptr;
3112     }
3113     case attr::SwiftIndirectResult: {
3114       return nullptr;
3115     }
3116     case attr::SwiftName: {
3117       return nullptr;
3118     }
3119     case attr::SwiftNewType: {
3120       return nullptr;
3121     }
3122     case attr::SwiftObjCMembers: {
3123       return nullptr;
3124     }
3125     case attr::SwiftPrivate: {
3126       return nullptr;
3127     }
3128     case attr::SwiftVersionedAddition: {
3129       return nullptr;
3130     }
3131     case attr::SwiftVersionedRemoval: {
3132       return nullptr;
3133     }
3134     case attr::SysVABI: {
3135       return nullptr;
3136     }
3137     case attr::TLSModel: {
3138       return nullptr;
3139     }
3140     case attr::Target: {
3141       return nullptr;
3142     }
3143     case attr::TargetClones: {
3144       return nullptr;
3145     }
3146     case attr::TargetVersion: {
3147       return nullptr;
3148     }
3149     case attr::TestTypestate: {
3150       return nullptr;
3151     }
3152     case attr::ThisCall: {
3153       return nullptr;
3154     }
3155     case attr::Thread: {
3156       return nullptr;
3157     }
3158     case attr::TransparentUnion: {
3159       return nullptr;
3160     }
3161     case attr::TrivialABI: {
3162       return nullptr;
3163     }
3164     case attr::TryAcquireCapability: {
3165       return nullptr;
3166     }
3167     case attr::TypeNonNull: {
3168       return nullptr;
3169     }
3170     case attr::TypeNullUnspecified: {
3171       return nullptr;
3172     }
3173     case attr::TypeNullable: {
3174       return nullptr;
3175     }
3176     case attr::TypeNullableResult: {
3177       return nullptr;
3178     }
3179     case attr::TypeTagForDatatype: {
3180       return nullptr;
3181     }
3182     case attr::TypeVisibility: {
3183       return nullptr;
3184     }
3185     case attr::UPtr: {
3186       return nullptr;
3187     }
3188     case attr::Unavailable: {
3189       const auto *A = cast<UnavailableAttr>(At);
3190       return A->clone(C);
3191     }
3192     case attr::Uninitialized: {
3193       return nullptr;
3194     }
3195     case attr::Unlikely: {
3196       return nullptr;
3197     }
3198     case attr::UnsafeBufferUsage: {
3199       return nullptr;
3200     }
3201     case attr::Unused: {
3202       return nullptr;
3203     }
3204     case attr::UseHandle: {
3205       return nullptr;
3206     }
3207     case attr::Used: {
3208       return nullptr;
3209     }
3210     case attr::UsingIfExists: {
3211       return nullptr;
3212     }
3213     case attr::Uuid: {
3214       return nullptr;
3215     }
3216     case attr::VTablePointerAuthentication: {
3217       return nullptr;
3218     }
3219     case attr::VecReturn: {
3220       return nullptr;
3221     }
3222     case attr::VecTypeHint: {
3223       return nullptr;
3224     }
3225     case attr::VectorCall: {
3226       return nullptr;
3227     }
3228     case attr::Visibility: {
3229       return nullptr;
3230     }
3231     case attr::WarnUnused: {
3232       return nullptr;
3233     }
3234     case attr::WarnUnusedResult: {
3235       return nullptr;
3236     }
3237     case attr::Weak: {
3238       return nullptr;
3239     }
3240     case attr::WeakImport: {
3241       return nullptr;
3242     }
3243     case attr::WeakRef: {
3244       return nullptr;
3245     }
3246     case attr::WebAssemblyExportName: {
3247       return nullptr;
3248     }
3249     case attr::WebAssemblyFuncref: {
3250       return nullptr;
3251     }
3252     case attr::WebAssemblyImportModule: {
3253       return nullptr;
3254     }
3255     case attr::WebAssemblyImportName: {
3256       return nullptr;
3257     }
3258     case attr::WorkGroupSizeHint: {
3259       return nullptr;
3260     }
3261     case attr::X86ForceAlignArgPointer: {
3262       return nullptr;
3263     }
3264     case attr::XRayInstrument: {
3265       return nullptr;
3266     }
3267     case attr::XRayLogArgs: {
3268       return nullptr;
3269     }
3270     case attr::ZeroCallUsedRegs: {
3271       return nullptr;
3272     }
3273   } // end switch
3274   llvm_unreachable("Unknown attribute!");
3275   return nullptr;
3276 }
3277
3278 } // end namespace sema
3279 } // end namespace clang