LCOV - code coverage report
Current view: top level - build-llvm/tools/clang/include/clang/Sema - AttrTemplateInstantiate.inc (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 193 798 24.2 %
Date: 2017-09-14 15:23:50 Functions: 2 2 100.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13