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

Generated by: LCOV version 1.13