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

Generated by: LCOV version 1.13