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

Generated by: LCOV version 1.13