| //===--- SemaTemplateInstantiateDecl.cpp - C++ Template Decl Instantiation ===/ |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| //===----------------------------------------------------------------------===/ |
| // |
| // This file implements C++ template instantiation for declarations. |
| // |
| //===----------------------------------------------------------------------===/ |
| #include "clang/Sema/SemaInternal.h" |
| #include "clang/AST/ASTConsumer.h" |
| #include "clang/AST/ASTContext.h" |
| #include "clang/AST/ASTMutationListener.h" |
| #include "clang/AST/DeclTemplate.h" |
| #include "clang/AST/DeclVisitor.h" |
| #include "clang/AST/DependentDiagnostic.h" |
| #include "clang/AST/Expr.h" |
| #include "clang/AST/ExprCXX.h" |
| #include "clang/AST/PrettyDeclStackTrace.h" |
| #include "clang/AST/TypeLoc.h" |
| #include "clang/Sema/Initialization.h" |
| #include "clang/Sema/Lookup.h" |
| #include "clang/Sema/Template.h" |
| #include "clang/Sema/TemplateInstCallback.h" |
| #include "llvm/Support/TimeProfiler.h" |
| |
| using namespace clang; |
| |
| static bool isDeclWithinFunction(const Decl *D) { |
| const DeclContext *DC = D->getDeclContext(); |
| if (DC->isFunctionOrMethod()) |
| return true; |
| |
| if (DC->isRecord()) |
| return cast<CXXRecordDecl>(DC)->isLocalClass(); |
| |
| return false; |
| } |
| |
| template<typename DeclT> |
| static bool SubstQualifier(Sema &SemaRef, const DeclT *OldDecl, DeclT *NewDecl, |
| const MultiLevelTemplateArgumentList &TemplateArgs) { |
| if (!OldDecl->getQualifierLoc()) |
| return false; |
| |
| assert((NewDecl->getFriendObjectKind() || |
| !OldDecl->getLexicalDeclContext()->isDependentContext()) && |
| "non-friend with qualified name defined in dependent context"); |
| Sema::ContextRAII SavedContext( |
| SemaRef, |
| const_cast<DeclContext *>(NewDecl->getFriendObjectKind() |
| ? NewDecl->getLexicalDeclContext() |
| : OldDecl->getLexicalDeclContext())); |
| |
| NestedNameSpecifierLoc NewQualifierLoc |
| = SemaRef.SubstNestedNameSpecifierLoc(OldDecl->getQualifierLoc(), |
| TemplateArgs); |
| |
| if (!NewQualifierLoc) |
| return true; |
| |
| NewDecl->setQualifierInfo(NewQualifierLoc); |
| return false; |
| } |
| |
| bool TemplateDeclInstantiator::SubstQualifier(const DeclaratorDecl *OldDecl, |
| DeclaratorDecl *NewDecl) { |
| return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs); |
| } |
| |
| bool TemplateDeclInstantiator::SubstQualifier(const TagDecl *OldDecl, |
| TagDecl *NewDecl) { |
| return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs); |
| } |
| |
| // Include attribute instantiation code. |
| #include "clang/Sema/AttrTemplateInstantiate.inc" |
| |
| static void instantiateDependentAlignedAttr( |
| Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, |
| const AlignedAttr *Aligned, Decl *New, bool IsPackExpansion) { |
| if (Aligned->isAlignmentExpr()) { |
| // The alignment expression is a constant expression. |
| EnterExpressionEvaluationContext Unevaluated( |
| S, Sema::ExpressionEvaluationContext::ConstantEvaluated); |
| ExprResult Result = S.SubstExpr(Aligned->getAlignmentExpr(), TemplateArgs); |
| if (!Result.isInvalid()) |
| S.AddAlignedAttr(New, *Aligned, Result.getAs<Expr>(), IsPackExpansion); |
| } else { |
| TypeSourceInfo *Result = S.SubstType(Aligned->getAlignmentType(), |
| TemplateArgs, Aligned->getLocation(), |
| DeclarationName()); |
| if (Result) |
| S.AddAlignedAttr(New, *Aligned, Result, IsPackExpansion); |
| } |
| } |
| |
| static void instantiateDependentAlignedAttr( |
| Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, |
| const AlignedAttr *Aligned, Decl *New) { |
| if (!Aligned->isPackExpansion()) { |
| instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, false); |
| return; |
| } |
| |
| SmallVector<UnexpandedParameterPack, 2> Unexpanded; |
| if (Aligned->isAlignmentExpr()) |
| S.collectUnexpandedParameterPacks(Aligned->getAlignmentExpr(), |
| Unexpanded); |
| else |
| S.collectUnexpandedParameterPacks(Aligned->getAlignmentType()->getTypeLoc(), |
| Unexpanded); |
| assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); |
| |
| // Determine whether we can expand this attribute pack yet. |
| bool Expand = true, RetainExpansion = false; |
| Optional<unsigned> NumExpansions; |
| // FIXME: Use the actual location of the ellipsis. |
| SourceLocation EllipsisLoc = Aligned->getLocation(); |
| if (S.CheckParameterPacksForExpansion(EllipsisLoc, Aligned->getRange(), |
| Unexpanded, TemplateArgs, Expand, |
| RetainExpansion, NumExpansions)) |
| return; |
| |
| if (!Expand) { |
| Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, -1); |
| instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, true); |
| } else { |
| for (unsigned I = 0; I != *NumExpansions; ++I) { |
| Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, I); |
| instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, false); |
| } |
| } |
| } |
| |
| static void instantiateDependentAssumeAlignedAttr( |
| Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, |
| const AssumeAlignedAttr *Aligned, Decl *New) { |
| // The alignment expression is a constant expression. |
| EnterExpressionEvaluationContext Unevaluated( |
| S, Sema::ExpressionEvaluationContext::ConstantEvaluated); |
| |
| Expr *E, *OE = nullptr; |
| ExprResult Result = S.SubstExpr(Aligned->getAlignment(), TemplateArgs); |
| if (Result.isInvalid()) |
| return; |
| E = Result.getAs<Expr>(); |
| |
| if (Aligned->getOffset()) { |
| Result = S.SubstExpr(Aligned->getOffset(), TemplateArgs); |
| if (Result.isInvalid()) |
| return; |
| OE = Result.getAs<Expr>(); |
| } |
| |
| S.AddAssumeAlignedAttr(New, *Aligned, E, OE); |
| } |
| |
| static void instantiateDependentAlignValueAttr( |
| Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, |
| const AlignValueAttr *Aligned, Decl *New) { |
| // The alignment expression is a constant expression. |
| EnterExpressionEvaluationContext Unevaluated( |
| S, Sema::ExpressionEvaluationContext::ConstantEvaluated); |
| ExprResult Result = S.SubstExpr(Aligned->getAlignment(), TemplateArgs); |
| if (!Result.isInvalid()) |
| S.AddAlignValueAttr(New, *Aligned, Result.getAs<Expr>()); |
| } |
| |
| static void instantiateDependentAllocAlignAttr( |
| Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, |
| const AllocAlignAttr *Align, Decl *New) { |
| Expr *Param = IntegerLiteral::Create( |
| S.getASTContext(), |
| llvm::APInt(64, Align->getParamIndex().getSourceIndex()), |
| S.getASTContext().UnsignedLongLongTy, Align->getLocation()); |
| S.AddAllocAlignAttr(New, *Align, Param); |
| } |
| |
| static Expr *instantiateDependentFunctionAttrCondition( |
| Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, |
| const Attr *A, Expr *OldCond, const Decl *Tmpl, FunctionDecl *New) { |
| Expr *Cond = nullptr; |
| { |
| Sema::ContextRAII SwitchContext(S, New); |
| EnterExpressionEvaluationContext Unevaluated( |
| S, Sema::ExpressionEvaluationContext::ConstantEvaluated); |
| ExprResult Result = S.SubstExpr(OldCond, TemplateArgs); |
| if (Result.isInvalid()) |
| return nullptr; |
| Cond = Result.getAs<Expr>(); |
| } |
| if (!Cond->isTypeDependent()) { |
| ExprResult Converted = S.PerformContextuallyConvertToBool(Cond); |
| if (Converted.isInvalid()) |
| return nullptr; |
| Cond = Converted.get(); |
| } |
| |
| SmallVector<PartialDiagnosticAt, 8> Diags; |
| if (OldCond->isValueDependent() && !Cond->isValueDependent() && |
| !Expr::isPotentialConstantExprUnevaluated(Cond, New, Diags)) { |
| S.Diag(A->getLocation(), diag::err_attr_cond_never_constant_expr) << A; |
| for (const auto &P : Diags) |
| S.Diag(P.first, P.second); |
| return nullptr; |
| } |
| return Cond; |
| } |
| |
| static void instantiateDependentEnableIfAttr( |
| Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, |
| const EnableIfAttr *EIA, const Decl *Tmpl, FunctionDecl *New) { |
| Expr *Cond = instantiateDependentFunctionAttrCondition( |
| S, TemplateArgs, EIA, EIA->getCond(), Tmpl, New); |
| |
| if (Cond) |
| New->addAttr(new (S.getASTContext()) EnableIfAttr(S.getASTContext(), *EIA, |
| Cond, EIA->getMessage())); |
| } |
| |
| static void instantiateDependentDiagnoseIfAttr( |
| Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, |
| const DiagnoseIfAttr *DIA, const Decl *Tmpl, FunctionDecl *New) { |
| Expr *Cond = instantiateDependentFunctionAttrCondition( |
| S, TemplateArgs, DIA, DIA->getCond(), Tmpl, New); |
| |
| if (Cond) |
| New->addAttr(new (S.getASTContext()) DiagnoseIfAttr( |
| S.getASTContext(), *DIA, Cond, DIA->getMessage(), |
| DIA->getDiagnosticType(), DIA->getArgDependent(), New)); |
| } |
| |
| // Constructs and adds to New a new instance of CUDALaunchBoundsAttr using |
| // template A as the base and arguments from TemplateArgs. |
| static void instantiateDependentCUDALaunchBoundsAttr( |
| Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, |
| const CUDALaunchBoundsAttr &Attr, Decl *New) { |
| // The alignment expression is a constant expression. |
| EnterExpressionEvaluationContext Unevaluated( |
| S, Sema::ExpressionEvaluationContext::ConstantEvaluated); |
| |
| ExprResult Result = S.SubstExpr(Attr.getMaxThreads(), TemplateArgs); |
| if (Result.isInvalid()) |
| return; |
| Expr *MaxThreads = Result.getAs<Expr>(); |
| |
| Expr *MinBlocks = nullptr; |
| if (Attr.getMinBlocks()) { |
| Result = S.SubstExpr(Attr.getMinBlocks(), TemplateArgs); |
| if (Result.isInvalid()) |
| return; |
| MinBlocks = Result.getAs<Expr>(); |
| } |
| |
| S.AddLaunchBoundsAttr(New, Attr, MaxThreads, MinBlocks); |
| } |
| |
| static void |
| instantiateDependentModeAttr(Sema &S, |
| const MultiLevelTemplateArgumentList &TemplateArgs, |
| const ModeAttr &Attr, Decl *New) { |
| S.AddModeAttr(New, Attr, Attr.getMode(), |
| /*InInstantiation=*/true); |
| } |
| |
| /// Instantiation of 'declare simd' attribute and its arguments. |
| static void instantiateOMPDeclareSimdDeclAttr( |
| Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, |
| const OMPDeclareSimdDeclAttr &Attr, Decl *New) { |
| // Allow 'this' in clauses with varlists. |
| if (auto *FTD = dyn_cast<FunctionTemplateDecl>(New)) |
| New = FTD->getTemplatedDecl(); |
| auto *FD = cast<FunctionDecl>(New); |
| auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(FD->getDeclContext()); |
| SmallVector<Expr *, 4> Uniforms, Aligneds, Alignments, Linears, Steps; |
| SmallVector<unsigned, 4> LinModifiers; |
| |
| auto SubstExpr = [&](Expr *E) -> ExprResult { |
| if (auto *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts())) |
| if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) { |
| Sema::ContextRAII SavedContext(S, FD); |
| LocalInstantiationScope Local(S); |
| if (FD->getNumParams() > PVD->getFunctionScopeIndex()) |
| Local.InstantiatedLocal( |
| PVD, FD->getParamDecl(PVD->getFunctionScopeIndex())); |
| return S.SubstExpr(E, TemplateArgs); |
| } |
| Sema::CXXThisScopeRAII ThisScope(S, ThisContext, Qualifiers(), |
| FD->isCXXInstanceMember()); |
| return S.SubstExpr(E, TemplateArgs); |
| }; |
| |
| // Substitute a single OpenMP clause, which is a potentially-evaluated |
| // full-expression. |
| auto Subst = [&](Expr *E) -> ExprResult { |
| EnterExpressionEvaluationContext Evaluated( |
| S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated); |
| ExprResult Res = SubstExpr(E); |
| if (Res.isInvalid()) |
| return Res; |
| return S.ActOnFinishFullExpr(Res.get(), false); |
| }; |
| |
| ExprResult Simdlen; |
| if (auto *E = Attr.getSimdlen()) |
| Simdlen = Subst(E); |
| |
| if (Attr.uniforms_size() > 0) { |
| for(auto *E : Attr.uniforms()) { |
| ExprResult Inst = Subst(E); |
| if (Inst.isInvalid()) |
| continue; |
| Uniforms.push_back(Inst.get()); |
| } |
| } |
| |
| auto AI = Attr.alignments_begin(); |
| for (auto *E : Attr.aligneds()) { |
| ExprResult Inst = Subst(E); |
| if (Inst.isInvalid()) |
| continue; |
| Aligneds.push_back(Inst.get()); |
| Inst = ExprEmpty(); |
| if (*AI) |
| Inst = S.SubstExpr(*AI, TemplateArgs); |
| Alignments.push_back(Inst.get()); |
| ++AI; |
| } |
| |
| auto SI = Attr.steps_begin(); |
| for (auto *E : Attr.linears()) { |
| ExprResult Inst = Subst(E); |
| if (Inst.isInvalid()) |
| continue; |
| Linears.push_back(Inst.get()); |
| Inst = ExprEmpty(); |
| if (*SI) |
| Inst = S.SubstExpr(*SI, TemplateArgs); |
| Steps.push_back(Inst.get()); |
| ++SI; |
| } |
| LinModifiers.append(Attr.modifiers_begin(), Attr.modifiers_end()); |
| (void)S.ActOnOpenMPDeclareSimdDirective( |
| S.ConvertDeclToDeclGroup(New), Attr.getBranchState(), Simdlen.get(), |
| Uniforms, Aligneds, Alignments, Linears, LinModifiers, Steps, |
| Attr.getRange()); |
| } |
| |
| /// Instantiation of 'declare variant' attribute and its arguments. |
| static void instantiateOMPDeclareVariantAttr( |
| Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, |
| const OMPDeclareVariantAttr &Attr, Decl *New) { |
| // Allow 'this' in clauses with varlists. |
| if (auto *FTD = dyn_cast<FunctionTemplateDecl>(New)) |
| New = FTD->getTemplatedDecl(); |
| auto *FD = cast<FunctionDecl>(New); |
| auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(FD->getDeclContext()); |
| |
| auto &&SubstExpr = [FD, ThisContext, &S, &TemplateArgs](Expr *E) { |
| if (auto *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts())) |
| if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) { |
| Sema::ContextRAII SavedContext(S, FD); |
| LocalInstantiationScope Local(S); |
| if (FD->getNumParams() > PVD->getFunctionScopeIndex()) |
| Local.InstantiatedLocal( |
| PVD, FD->getParamDecl(PVD->getFunctionScopeIndex())); |
| return S.SubstExpr(E, TemplateArgs); |
| } |
| Sema::CXXThisScopeRAII ThisScope(S, ThisContext, Qualifiers(), |
| FD->isCXXInstanceMember()); |
| return S.SubstExpr(E, TemplateArgs); |
| }; |
| |
| // Substitute a single OpenMP clause, which is a potentially-evaluated |
| // full-expression. |
| auto &&Subst = [&SubstExpr, &S](Expr *E) { |
| EnterExpressionEvaluationContext Evaluated( |
| S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated); |
| ExprResult Res = SubstExpr(E); |
| if (Res.isInvalid()) |
| return Res; |
| return S.ActOnFinishFullExpr(Res.get(), false); |
| }; |
| |
| ExprResult VariantFuncRef; |
| if (Expr *E = Attr.getVariantFuncRef()) |
| VariantFuncRef = Subst(E); |
| |
| ExprResult Score; |
| if (Expr *E = Attr.getScore()) |
| Score = Subst(E); |
| |
| // Check function/variant ref. |
| Optional<std::pair<FunctionDecl *, Expr *>> DeclVarData = |
| S.checkOpenMPDeclareVariantFunction( |
| S.ConvertDeclToDeclGroup(New), VariantFuncRef.get(), Attr.getRange()); |
| if (!DeclVarData) |
| return; |
| // Instantiate the attribute. |
| Sema::OpenMPDeclareVariantCtsSelectorData Data( |
| Attr.getCtxSelectorSet(), Attr.getCtxSelector(), |
| llvm::makeMutableArrayRef(Attr.implVendors_begin(), |
| Attr.implVendors_size()), |
| Score); |
| S.ActOnOpenMPDeclareVariantDirective(DeclVarData.getValue().first, |
| DeclVarData.getValue().second, |
| Attr.getRange(), Data); |
| } |
| |
| static void instantiateDependentAMDGPUFlatWorkGroupSizeAttr( |
| Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, |
| const AMDGPUFlatWorkGroupSizeAttr &Attr, Decl *New) { |
| // Both min and max expression are constant expressions. |
| EnterExpressionEvaluationContext Unevaluated( |
| S, Sema::ExpressionEvaluationContext::ConstantEvaluated); |
| |
| ExprResult Result = S.SubstExpr(Attr.getMin(), TemplateArgs); |
| if (Result.isInvalid()) |
| return; |
| Expr *MinExpr = Result.getAs<Expr>(); |
| |
| Result = S.SubstExpr(Attr.getMax(), TemplateArgs); |
| if (Result.isInvalid()) |
| return; |
| Expr *MaxExpr = Result.getAs<Expr>(); |
| |
| S.addAMDGPUFlatWorkGroupSizeAttr(New, Attr, MinExpr, MaxExpr); |
| } |
| |
| static ExplicitSpecifier |
| instantiateExplicitSpecifier(Sema &S, |
| const MultiLevelTemplateArgumentList &TemplateArgs, |
| ExplicitSpecifier ES, FunctionDecl *New) { |
| if (!ES.getExpr()) |
| return ES; |
| Expr *OldCond = ES.getExpr(); |
| Expr *Cond = nullptr; |
| { |
| EnterExpressionEvaluationContext Unevaluated( |
| S, Sema::ExpressionEvaluationContext::ConstantEvaluated); |
| ExprResult SubstResult = S.SubstExpr(OldCond, TemplateArgs); |
| if (SubstResult.isInvalid()) { |
| return ExplicitSpecifier::Invalid(); |
| } |
| Cond = SubstResult.get(); |
| } |
| ExplicitSpecifier Result(Cond, ES.getKind()); |
| if (!Cond->isTypeDependent()) |
| S.tryResolveExplicitSpecifier(Result); |
| return Result; |
| } |
| |
| static void instantiateDependentAMDGPUWavesPerEUAttr( |
| Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, |
| const AMDGPUWavesPerEUAttr &Attr, Decl *New) { |
| // Both min and max expression are constant expressions. |
| EnterExpressionEvaluationContext Unevaluated( |
| S, Sema::ExpressionEvaluationContext::ConstantEvaluated); |
| |
| ExprResult Result = S.SubstExpr(Attr.getMin(), TemplateArgs); |
| if (Result.isInvalid()) |
| return; |
| Expr *MinExpr = Result.getAs<Expr>(); |
| |
| Expr *MaxExpr = nullptr; |
| if (auto Max = Attr.getMax()) { |
| Result = S.SubstExpr(Max, TemplateArgs); |
| if (Result.isInvalid()) |
| return; |
| MaxExpr = Result.getAs<Expr>(); |
| } |
| |
| S.addAMDGPUWavesPerEUAttr(New, Attr, MinExpr, MaxExpr); |
| } |
| |
| void Sema::InstantiateAttrsForDecl( |
| const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Tmpl, |
| Decl *New, LateInstantiatedAttrVec *LateAttrs, |
| LocalInstantiationScope *OuterMostScope) { |
| if (NamedDecl *ND = dyn_cast<NamedDecl>(New)) { |
| for (const auto *TmplAttr : Tmpl->attrs()) { |
| // FIXME: If any of the special case versions from InstantiateAttrs become |
| // applicable to template declaration, we'll need to add them here. |
| CXXThisScopeRAII ThisScope( |
| *this, dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext()), |
| Qualifiers(), ND->isCXXInstanceMember()); |
| |
| Attr *NewAttr = sema::instantiateTemplateAttributeForDecl( |
| TmplAttr, Context, *this, TemplateArgs); |
| if (NewAttr) |
| New->addAttr(NewAttr); |
| } |
| } |
| } |
| |
| static Sema::RetainOwnershipKind |
| attrToRetainOwnershipKind(const Attr *A) { |
| switch (A->getKind()) { |
| case clang::attr::CFConsumed: |
| return Sema::RetainOwnershipKind::CF; |
| case clang::attr::OSConsumed: |
| return Sema::RetainOwnershipKind::OS; |
| case clang::attr::NSConsumed: |
| return Sema::RetainOwnershipKind::NS; |
| default: |
| llvm_unreachable("Wrong argument supplied"); |
| } |
| } |
| |
| void Sema::InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs, |
| const Decl *Tmpl, Decl *New, |
| LateInstantiatedAttrVec *LateAttrs, |
| LocalInstantiationScope *OuterMostScope) { |
| for (const auto *TmplAttr : Tmpl->attrs()) { |
| // FIXME: This should be generalized to more than just the AlignedAttr. |
| const AlignedAttr *Aligned = dyn_cast<AlignedAttr>(TmplAttr); |
| if (Aligned && Aligned->isAlignmentDependent()) { |
| instantiateDependentAlignedAttr(*this, TemplateArgs, Aligned, New); |
| continue; |
| } |
| |
| if (const auto *AssumeAligned = dyn_cast<AssumeAlignedAttr>(TmplAttr)) { |
| instantiateDependentAssumeAlignedAttr(*this, TemplateArgs, AssumeAligned, New); |
| continue; |
| } |
| |
| if (const auto *AlignValue = dyn_cast<AlignValueAttr>(TmplAttr)) { |
| instantiateDependentAlignValueAttr(*this, TemplateArgs, AlignValue, New); |
| continue; |
| } |
| |
| if (const auto *AllocAlign = dyn_cast<AllocAlignAttr>(TmplAttr)) { |
| instantiateDependentAllocAlignAttr(*this, TemplateArgs, AllocAlign, New); |
| continue; |
| } |
| |
| |
| if (const auto *EnableIf = dyn_cast<EnableIfAttr>(TmplAttr)) { |
| instantiateDependentEnableIfAttr(*this, TemplateArgs, EnableIf, Tmpl, |
| cast<FunctionDecl>(New)); |
| continue; |
| } |
| |
| if (const auto *DiagnoseIf = dyn_cast<DiagnoseIfAttr>(TmplAttr)) { |
| instantiateDependentDiagnoseIfAttr(*this, TemplateArgs, DiagnoseIf, Tmpl, |
| cast<FunctionDecl>(New)); |
| continue; |
| } |
| |
| if (const auto *CUDALaunchBounds = |
| dyn_cast<CUDALaunchBoundsAttr>(TmplAttr)) { |
| instantiateDependentCUDALaunchBoundsAttr(*this, TemplateArgs, |
| *CUDALaunchBounds, New); |
| continue; |
| } |
| |
| if (const auto *Mode = dyn_cast<ModeAttr>(TmplAttr)) { |
| instantiateDependentModeAttr(*this, TemplateArgs, *Mode, New); |
| continue; |
| } |
| |
| if (const auto *OMPAttr = dyn_cast<OMPDeclareSimdDeclAttr>(TmplAttr)) { |
| instantiateOMPDeclareSimdDeclAttr(*this, TemplateArgs, *OMPAttr, New); |
| continue; |
| } |
| |
| if (const auto *OMPAttr = dyn_cast<OMPDeclareVariantAttr>(TmplAttr)) { |
| instantiateOMPDeclareVariantAttr(*this, TemplateArgs, *OMPAttr, New); |
| continue; |
| } |
| |
| if (const auto *AMDGPUFlatWorkGroupSize = |
| dyn_cast<AMDGPUFlatWorkGroupSizeAttr>(TmplAttr)) { |
| instantiateDependentAMDGPUFlatWorkGroupSizeAttr( |
| *this, TemplateArgs, *AMDGPUFlatWorkGroupSize, New); |
| } |
| |
| if (const auto *AMDGPUFlatWorkGroupSize = |
| dyn_cast<AMDGPUWavesPerEUAttr>(TmplAttr)) { |
| instantiateDependentAMDGPUWavesPerEUAttr(*this, TemplateArgs, |
| *AMDGPUFlatWorkGroupSize, New); |
| } |
| |
| // Existing DLL attribute on the instantiation takes precedence. |
| if (TmplAttr->getKind() == attr::DLLExport || |
| TmplAttr->getKind() == attr::DLLImport) { |
| if (New->hasAttr<DLLExportAttr>() || New->hasAttr<DLLImportAttr>()) { |
| continue; |
| } |
| } |
| |
| if (const auto *ABIAttr = dyn_cast<ParameterABIAttr>(TmplAttr)) { |
| AddParameterABIAttr(New, *ABIAttr, ABIAttr->getABI()); |
| continue; |
| } |
| |
| if (isa<NSConsumedAttr>(TmplAttr) || isa<OSConsumedAttr>(TmplAttr) || |
| isa<CFConsumedAttr>(TmplAttr)) { |
| AddXConsumedAttr(New, *TmplAttr, attrToRetainOwnershipKind(TmplAttr), |
| /*template instantiation=*/true); |
| continue; |
| } |
| |
| if (auto *A = dyn_cast<PointerAttr>(TmplAttr)) { |
| if (!New->hasAttr<PointerAttr>()) |
| New->addAttr(A->clone(Context)); |
| continue; |
| } |
| |
| if (auto *A = dyn_cast<OwnerAttr>(TmplAttr)) { |
| if (!New->hasAttr<OwnerAttr>()) |
| New->addAttr(A->clone(Context)); |
| continue; |
| } |
| |
| assert(!TmplAttr->isPackExpansion()); |
| if (TmplAttr->isLateParsed() && LateAttrs) { |
| // Late parsed attributes must be instantiated and attached after the |
| // enclosing class has been instantiated. See Sema::InstantiateClass. |
| LocalInstantiationScope *Saved = nullptr; |
| if (CurrentInstantiationScope) |
| Saved = CurrentInstantiationScope->cloneScopes(OuterMostScope); |
| LateAttrs->push_back(LateInstantiatedAttribute(TmplAttr, Saved, New)); |
| } else { |
| // Allow 'this' within late-parsed attributes. |
| NamedDecl *ND = dyn_cast<NamedDecl>(New); |
| CXXRecordDecl *ThisContext = |
| dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext()); |
| CXXThisScopeRAII ThisScope(*this, ThisContext, Qualifiers(), |
| ND && ND->isCXXInstanceMember()); |
| |
| Attr *NewAttr = sema::instantiateTemplateAttribute(TmplAttr, Context, |
| *this, TemplateArgs); |
| if (NewAttr) |
| New->addAttr(NewAttr); |
| } |
| } |
| } |
| |
| /// Get the previous declaration of a declaration for the purposes of template |
| /// instantiation. If this finds a previous declaration, then the previous |
| /// declaration of the instantiation of D should be an instantiation of the |
| /// result of this function. |
| template<typename DeclT> |
| static DeclT *getPreviousDeclForInstantiation(DeclT *D) { |
| DeclT *Result = D->getPreviousDecl(); |
| |
| // If the declaration is within a class, and the previous declaration was |
| // merged from a different definition of that class, then we don't have a |
| // previous declaration for the purpose of template instantiation. |
| if (Result && isa<CXXRecordDecl>(D->getDeclContext()) && |
| D->getLexicalDeclContext() != Result->getLexicalDeclContext()) |
| return nullptr; |
| |
| return Result; |
| } |
| |
| Decl * |
| TemplateDeclInstantiator::VisitTranslationUnitDecl(TranslationUnitDecl *D) { |
| llvm_unreachable("Translation units cannot be instantiated"); |
| } |
| |
| Decl * |
| TemplateDeclInstantiator::VisitPragmaCommentDecl(PragmaCommentDecl *D) { |
| llvm_unreachable("pragma comment cannot be instantiated"); |
| } |
| |
| Decl *TemplateDeclInstantiator::VisitPragmaDetectMismatchDecl( |
| PragmaDetectMismatchDecl *D) { |
| llvm_unreachable("pragma comment cannot be instantiated"); |
| } |
| |
| Decl * |
| TemplateDeclInstantiator::VisitExternCContextDecl(ExternCContextDecl *D) { |
| llvm_unreachable("extern \"C\" context cannot be instantiated"); |
| } |
| |
| Decl * |
| TemplateDeclInstantiator::VisitLabelDecl(LabelDecl *D) { |
| LabelDecl *Inst = LabelDecl::Create(SemaRef.Context, Owner, D->getLocation(), |
| D->getIdentifier()); |
| Owner->addDecl(Inst); |
| return Inst; |
| } |
| |
| Decl * |
| TemplateDeclInstantiator::VisitNamespaceDecl(NamespaceDecl *D) { |
| llvm_unreachable("Namespaces cannot be instantiated"); |
| } |
| |
| Decl * |
| TemplateDeclInstantiator::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) { |
| NamespaceAliasDecl *Inst |
| = NamespaceAliasDecl::Create(SemaRef.Context, Owner, |
| D->getNamespaceLoc(), |
| D->getAliasLoc(), |
| D->getIdentifier(), |
| D->getQualifierLoc(), |
| D->getTargetNameLoc(), |
| D->getNamespace()); |
| Owner->addDecl(Inst); |
| return Inst; |
| } |
| |
| Decl *TemplateDeclInstantiator::InstantiateTypedefNameDecl(TypedefNameDecl *D, |
| bool IsTypeAlias) { |
| bool Invalid = false; |
| TypeSourceInfo *DI = D->getTypeSourceInfo(); |
| if (DI->getType()->isInstantiationDependentType() || |
| DI->getType()->isVariablyModifiedType()) { |
| DI = SemaRef.SubstType(DI, TemplateArgs, |
| D->getLocation(), D->getDeclName()); |
| if (!DI) { |
| Invalid = true; |
| DI = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.Context.IntTy); |
| } |
| } else { |
| SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType()); |
| } |
| |
| // HACK: g++ has a bug where it gets the value kind of ?: wrong. |
| // libstdc++ relies upon this bug in its implementation of common_type. |
| // If we happen to be processing that implementation, fake up the g++ ?: |
| // semantics. See LWG issue 2141 for more information on the bug. |
| const DecltypeType *DT = DI->getType()->getAs<DecltypeType>(); |
| CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext()); |
| if (DT && RD && isa<ConditionalOperator>(DT->getUnderlyingExpr()) && |
| DT->isReferenceType() && |
| RD->getEnclosingNamespaceContext() == SemaRef.getStdNamespace() && |
| RD->getIdentifier() && RD->getIdentifier()->isStr("common_type") && |
| D->getIdentifier() && D->getIdentifier()->isStr("type") && |
| SemaRef.getSourceManager().isInSystemHeader(D->getBeginLoc())) |
| // Fold it to the (non-reference) type which g++ would have produced. |
| DI = SemaRef.Context.getTrivialTypeSourceInfo( |
| DI->getType().getNonReferenceType()); |
| |
| // Create the new typedef |
| TypedefNameDecl *Typedef; |
| if (IsTypeAlias) |
| Typedef = TypeAliasDecl::Create(SemaRef.Context, Owner, D->getBeginLoc(), |
| D->getLocation(), D->getIdentifier(), DI); |
| else |
| Typedef = TypedefDecl::Create(SemaRef.Context, Owner, D->getBeginLoc(), |
| D->getLocation(), D->getIdentifier(), DI); |
| if (Invalid) |
| Typedef->setInvalidDecl(); |
| |
| // If the old typedef was the name for linkage purposes of an anonymous |
| // tag decl, re-establish that relationship for the new typedef. |
| if (const TagType *oldTagType = D->getUnderlyingType()->getAs<TagType>()) { |
| TagDecl *oldTag = oldTagType->getDecl(); |
| if (oldTag->getTypedefNameForAnonDecl() == D && !Invalid) { |
| TagDecl *newTag = DI->getType()->castAs<TagType>()->getDecl(); |
| assert(!newTag->hasNameForLinkage()); |
| newTag->setTypedefNameForAnonDecl(Typedef); |
| } |
| } |
| |
| if (TypedefNameDecl *Prev = getPreviousDeclForInstantiation(D)) { |
| NamedDecl *InstPrev = SemaRef.FindInstantiatedDecl(D->getLocation(), Prev, |
| TemplateArgs); |
| if (!InstPrev) |
| return nullptr; |
| |
| TypedefNameDecl *InstPrevTypedef = cast<TypedefNameDecl>(InstPrev); |
| |
| // If the typedef types are not identical, reject them. |
| SemaRef.isIncompatibleTypedef(InstPrevTypedef, Typedef); |
| |
| Typedef->setPreviousDecl(InstPrevTypedef); |
| } |
| |
| SemaRef.InstantiateAttrs(TemplateArgs, D, Typedef); |
| |
| if (D->getUnderlyingType()->getAs<DependentNameType>()) |
| SemaRef.inferGslPointerAttribute(Typedef); |
| |
| Typedef->setAccess(D->getAccess()); |
| |
| return Typedef; |
| } |
| |
| Decl *TemplateDeclInstantiator::VisitTypedefDecl(TypedefDecl *D) { |
| Decl *Typedef = InstantiateTypedefNameDecl(D, /*IsTypeAlias=*/false); |
| if (Typedef) |
| Owner->addDecl(Typedef); |
| return Typedef; |
| } |
| |
| Decl *TemplateDeclInstantiator::VisitTypeAliasDecl(TypeAliasDecl *D) { |
| Decl *Typedef = InstantiateTypedefNameDecl(D, /*IsTypeAlias=*/true); |
| if (Typedef) |
| Owner->addDecl(Typedef); |
| return Typedef; |
| } |
| |
| Decl * |
| TemplateDeclInstantiator::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) { |
| // Create a local instantiation scope for this type alias template, which |
| // will contain the instantiations of the template parameters. |
| LocalInstantiationScope Scope(SemaRef); |
| |
| TemplateParameterList *TempParams = D->getTemplateParameters(); |
| TemplateParameterList *InstParams = SubstTemplateParams(TempParams); |
| if (!InstParams) |
| return nullptr; |
| |
| TypeAliasDecl *Pattern = D->getTemplatedDecl(); |
| |
| TypeAliasTemplateDecl *PrevAliasTemplate = nullptr; |
| if (getPreviousDeclForInstantiation<TypedefNameDecl>(Pattern)) { |
| DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName()); |
| if (!Found.empty()) { |
| PrevAliasTemplate = dyn_cast<TypeAliasTemplateDecl>(Found.front()); |
| } |
| } |
| |
| TypeAliasDecl *AliasInst = cast_or_null<TypeAliasDecl>( |
| InstantiateTypedefNameDecl(Pattern, /*IsTypeAlias=*/true)); |
| if (!AliasInst) |
| return nullptr; |
| |
| TypeAliasTemplateDecl *Inst |
| = TypeAliasTemplateDecl::Create(SemaRef.Context, Owner, D->getLocation(), |
| D->getDeclName(), InstParams, AliasInst); |
| AliasInst->setDescribedAliasTemplate(Inst); |
| if (PrevAliasTemplate) |
| Inst->setPreviousDecl(PrevAliasTemplate); |
| |
| Inst->setAccess(D->getAccess()); |
| |
| if (!PrevAliasTemplate) |
| Inst->setInstantiatedFromMemberTemplate(D); |
| |
| Owner->addDecl(Inst); |
| |
| return Inst; |
| } |
| |
| Decl *TemplateDeclInstantiator::VisitBindingDecl(BindingDecl *D) { |
| auto *NewBD = BindingDecl::Create(SemaRef.Context, Owner, D->getLocation(), |
| D->getIdentifier()); |
| NewBD->setReferenced(D->isReferenced()); |
| SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewBD); |
| return NewBD; |
| } |
| |
| Decl *TemplateDeclInstantiator::VisitDecompositionDecl(DecompositionDecl *D) { |
| // Transform the bindings first. |
| SmallVector<BindingDecl*, 16> NewBindings; |
| for (auto *OldBD : D->bindings()) |
| NewBindings.push_back(cast<BindingDecl>(VisitBindingDecl(OldBD))); |
| ArrayRef<BindingDecl*> NewBindingArray = NewBindings; |
| |
| auto *NewDD = cast_or_null<DecompositionDecl>( |
| VisitVarDecl(D, /*InstantiatingVarTemplate=*/false, &NewBindingArray)); |
| |
| if (!NewDD || NewDD->isInvalidDecl()) |
| for (auto *NewBD : NewBindings) |
| NewBD->setInvalidDecl(); |
| |
| return NewDD; |
| } |
| |
| Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D) { |
| return VisitVarDecl(D, /*InstantiatingVarTemplate=*/false); |
| } |
| |
| Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D, |
| bool InstantiatingVarTemplate, |
| ArrayRef<BindingDecl*> *Bindings) { |
| |
| // Do substitution on the type of the declaration |
| TypeSourceInfo *DI = SemaRef.SubstType( |
| D->getTypeSourceInfo(), TemplateArgs, D->getTypeSpecStartLoc(), |
| D->getDeclName(), /*AllowDeducedTST*/true); |
| if (!DI) |
| return nullptr; |
| |
| if (DI->getType()->isFunctionType()) { |
| SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function) |
| << D->isStaticDataMember() << DI->getType(); |
| return nullptr; |
| } |
| |
| DeclContext *DC = Owner; |
| if (D->isLocalExternDecl()) |
| SemaRef.adjustContextForLocalExternDecl(DC); |
| |
| // Build the instantiated declaration. |
| VarDecl *Var; |
| if (Bindings) |
| Var = DecompositionDecl::Create(SemaRef.Context, DC, D->getInnerLocStart(), |
| D->getLocation(), DI->getType(), DI, |
| D->getStorageClass(), *Bindings); |
| else |
| Var = VarDecl::Create(SemaRef.Context, DC, D->getInnerLocStart(), |
| D->getLocation(), D->getIdentifier(), DI->getType(), |
| DI, D->getStorageClass()); |
| |
| // In ARC, infer 'retaining' for variables of retainable type. |
| if (SemaRef.getLangOpts().ObjCAutoRefCount && |
| SemaRef.inferObjCARCLifetime(Var)) |
| Var->setInvalidDecl(); |
| |
| // Substitute the nested name specifier, if any. |
| if (SubstQualifier(D, Var)) |
| return nullptr; |
| |
| SemaRef.BuildVariableInstantiation(Var, D, TemplateArgs, LateAttrs, Owner, |
| StartingScope, InstantiatingVarTemplate); |
| |
| if (D->isNRVOVariable()) { |
| QualType ReturnType = cast<FunctionDecl>(DC)->getReturnType(); |
| if (SemaRef.isCopyElisionCandidate(ReturnType, Var, Sema::CES_Strict)) |
| Var->setNRVOVariable(true); |
| } |
| |
| Var->setImplicit(D->isImplicit()); |
| |
| if (Var->isStaticLocal()) |
| SemaRef.CheckStaticLocalForDllExport(Var); |
| |
| return Var; |
| } |
| |
| Decl *TemplateDeclInstantiator::VisitAccessSpecDecl(AccessSpecDecl *D) { |
| AccessSpecDecl* AD |
| = AccessSpecDecl::Create(SemaRef.Context, D->getAccess(), Owner, |
| D->getAccessSpecifierLoc(), D->getColonLoc()); |
| Owner->addHiddenDecl(AD); |
| return AD; |
| } |
| |
| Decl *TemplateDeclInstantiator::VisitFieldDecl(FieldDecl *D) { |
| bool Invalid = false; |
| TypeSourceInfo *DI = D->getTypeSourceInfo(); |
| if (DI->getType()->isInstantiationDependentType() || |
| DI->getType()->isVariablyModifiedType()) { |
| DI = SemaRef.SubstType(DI, TemplateArgs, |
| D->getLocation(), D->getDeclName()); |
| if (!DI) { |
| DI = D->getTypeSourceInfo(); |
| Invalid = true; |
| } else if (DI->getType()->isFunctionType()) { |
| // C++ [temp.arg.type]p3: |
| // If a declaration acquires a function type through a type |
| // dependent on a template-parameter and this causes a |
| // declaration that does not use the syntactic form of a |
| // function declarator to have function type, the program is |
| // ill-formed. |
| SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function) |
| << DI->getType(); |
| Invalid = true; |
| } |
| } else { |
| SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType()); |
| } |
| |
| Expr *BitWidth = D->getBitWidth(); |
| if (Invalid) |
| BitWidth = nullptr; |
| else if (BitWidth) { |
| // The bit-width expression is a constant expression. |
| EnterExpressionEvaluationContext Unevaluated( |
| SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated); |
| |
| ExprResult InstantiatedBitWidth |
| = SemaRef.SubstExpr(BitWidth, TemplateArgs); |
| if (InstantiatedBitWidth.isInvalid()) { |
| Invalid = true; |
| BitWidth = nullptr; |
| } else |
| BitWidth = InstantiatedBitWidth.getAs<Expr>(); |
| } |
| |
| FieldDecl *Field = SemaRef.CheckFieldDecl(D->getDeclName(), |
| DI->getType(), DI, |
| cast<RecordDecl>(Owner), |
| D->getLocation(), |
| D->isMutable(), |
| BitWidth, |
| D->getInClassInitStyle(), |
| D->getInnerLocStart(), |
| D->getAccess(), |
| nullptr); |
| if (!Field) { |
| cast<Decl>(Owner)->setInvalidDecl(); |
| return nullptr; |
| } |
| |
| SemaRef.InstantiateAttrs(TemplateArgs, D, Field, LateAttrs, StartingScope); |
| |
| if (Field->hasAttrs()) |
| SemaRef.CheckAlignasUnderalignment(Field); |
| |
| if (Invalid) |
| Field->setInvalidDecl(); |
| |
| if (!Field->getDeclName()) { |
| // Keep track of where this decl came from. |
| SemaRef.Context.setInstantiatedFromUnnamedFieldDecl(Field, D); |
| } |
| if (CXXRecordDecl *Parent= dyn_cast<CXXRecordDecl>(Field->getDeclContext())) { |
| if (Parent->isAnonymousStructOrUnion() && |
| Parent->getRedeclContext()->isFunctionOrMethod()) |
| SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Field); |
| } |
| |
| Field->setImplicit(D->isImplicit()); |
| Field->setAccess(D->getAccess()); |
| Owner->addDecl(Field); |
| |
| return Field; |
| } |
| |
| Decl *TemplateDeclInstantiator::VisitMSPropertyDecl(MSPropertyDecl *D) { |
| bool Invalid = false; |
| TypeSourceInfo *DI = D->getTypeSourceInfo(); |
| |
| if (DI->getType()->isVariablyModifiedType()) { |
| SemaRef.Diag(D->getLocation(), diag::err_property_is_variably_modified) |
| << D; |
| Invalid = true; |
| } else if (DI->getType()->isInstantiationDependentType()) { |
| DI = SemaRef.SubstType(DI, TemplateArgs, |
| D->getLocation(), D->getDeclName()); |
| if (!DI) { |
| DI = D->getTypeSourceInfo(); |
| Invalid = true; |
| } else if (DI->getType()->isFunctionType()) { |
| // C++ [temp.arg.type]p3: |
| // If a declaration acquires a function type through a type |
| // dependent on a template-parameter and this causes a |
| // declaration that does not use the syntactic form of a |
| // function declarator to have function type, the program is |
| // ill-formed. |
| SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function) |
| << DI->getType(); |
| Invalid = true; |
| } |
| } else { |
| SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType()); |
| } |
| |
| MSPropertyDecl *Property = MSPropertyDecl::Create( |
| SemaRef.Context, Owner, D->getLocation(), D->getDeclName(), DI->getType(), |
| DI, D->getBeginLoc(), D->getGetterId(), D->getSetterId()); |
| |
| SemaRef.InstantiateAttrs(TemplateArgs, D, Property, LateAttrs, |
| StartingScope); |
| |
| if (Invalid) |
| Property->setInvalidDecl(); |
| |
| Property->setAccess(D->getAccess()); |
| Owner->addDecl(Property); |
| |
| return Property; |
| } |
| |
| Decl *TemplateDeclInstantiator::VisitIndirectFieldDecl(IndirectFieldDecl *D) { |
| NamedDecl **NamedChain = |
| new (SemaRef.Context)NamedDecl*[D->getChainingSize()]; |
| |
| int i = 0; |
| for (auto *PI : D->chain()) { |
| NamedDecl *Next = SemaRef.FindInstantiatedDecl(D->getLocation(), PI, |
| TemplateArgs); |
| if (!Next) |
| return nullptr; |
| |
| NamedChain[i++] = Next; |
| } |
| |
| QualType T = cast<FieldDecl>(NamedChain[i-1])->getType(); |
| IndirectFieldDecl *IndirectField = IndirectFieldDecl::Create( |
| SemaRef.Context, Owner, D->getLocation(), D->getIdentifier(), T, |
| {NamedChain, D->getChainingSize()}); |
| |
| for (const auto *Attr : D->attrs()) |
| IndirectField->addAttr(Attr->clone(SemaRef.Context)); |
| |
| IndirectField->setImplicit(D->isImplicit()); |
| IndirectField->setAccess(D->getAccess()); |
| Owner->addDecl(IndirectField); |
| return IndirectField; |
| } |
| |
| Decl *TemplateDeclInstantiator::VisitFriendDecl(FriendDecl *D) { |
| // Handle friend type expressions by simply substituting template |
| // parameters into the pattern type and checking the result. |
| if (TypeSourceInfo *Ty = D->getFriendType()) { |
| TypeSourceInfo *InstTy; |
| // If this is an unsupported friend, don't bother substituting template |
| // arguments into it. The actual type referred to won't be used by any |
| // parts of Clang, and may not be valid for instantiating. Just use the |
| // same info for the instantiated friend. |
| if (D->isUnsupportedFriend()) { |
| InstTy = Ty; |
| } else { |
| InstTy = SemaRef.SubstType(Ty, TemplateArgs, |
| D->getLocation(), DeclarationName()); |
| } |
| if (!InstTy) |
| return nullptr; |
| |
| FriendDecl *FD = SemaRef.CheckFriendTypeDecl(D->getBeginLoc(), |
| D->getFriendLoc(), InstTy); |
| if (!FD) |
| return nullptr; |
| |
| FD->setAccess(AS_public); |
| FD->setUnsupportedFriend(D->isUnsupportedFriend()); |
| Owner->addDecl(FD); |
| return FD; |
| } |
| |
| NamedDecl *ND = D->getFriendDecl(); |
| assert(ND && "friend decl must be a decl or a type!"); |
| |
| // All of the Visit implementations for the various potential friend |
| // declarations have to be carefully written to work for friend |
| // objects, with the most important detail being that the target |
| // decl should almost certainly not be placed in Owner. |
| Decl *NewND = Visit(ND); |
| if (!NewND) return nullptr; |
| |
| FriendDecl *FD = |
| FriendDecl::Create(SemaRef.Context, Owner, D->getLocation(), |
| cast<NamedDecl>(NewND), D->getFriendLoc()); |
| FD->setAccess(AS_public); |
| FD->setUnsupportedFriend(D->isUnsupportedFriend()); |
| Owner->addDecl(FD); |
| return FD; |
| } |
| |
| Decl *TemplateDeclInstantiator::VisitStaticAssertDecl(StaticAssertDecl *D) { |
| Expr *AssertExpr = D->getAssertExpr(); |
| |
| // The expression in a static assertion is a constant expression. |
| EnterExpressionEvaluationContext Unevaluated( |
| SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated); |
| |
| ExprResult InstantiatedAssertExpr |
| = SemaRef.SubstExpr(AssertExpr, TemplateArgs); |
| if (InstantiatedAssertExpr.isInvalid()) |
| return nullptr; |
| |
| return SemaRef.BuildStaticAssertDeclaration(D->getLocation(), |
| InstantiatedAssertExpr.get(), |
| D->getMessage(), |
| D->getRParenLoc(), |
| D->isFailed()); |
| } |
| |
| Decl *TemplateDeclInstantiator::VisitEnumDecl(EnumDecl *D) { |
| EnumDecl *PrevDecl = nullptr; |
| if (EnumDecl *PatternPrev = getPreviousDeclForInstantiation(D)) { |
| NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(), |
| PatternPrev, |
| TemplateArgs); |
| if (!Prev) return nullptr; |
| PrevDecl = cast<EnumDecl>(Prev); |
| } |
| |
| EnumDecl *Enum = |
| EnumDecl::Create(SemaRef.Context, Owner, D->getBeginLoc(), |
| D->getLocation(), D->getIdentifier(), PrevDecl, |
| D->isScoped(), D->isScopedUsingClassTag(), D->isFixed()); |
| if (D->isFixed()) { |
| if (TypeSourceInfo *TI = D->getIntegerTypeSourceInfo()) { |
| // If we have type source information for the underlying type, it means it |
| // has been explicitly set by the user. Perform substitution on it before |
| // moving on. |
| SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc(); |
| TypeSourceInfo *NewTI = SemaRef.SubstType(TI, TemplateArgs, UnderlyingLoc, |
| DeclarationName()); |
| if (!NewTI || SemaRef.CheckEnumUnderlyingType(NewTI)) |
| Enum->setIntegerType(SemaRef.Context.IntTy); |
| else |
| Enum->setIntegerTypeSourceInfo(NewTI); |
| } else { |
| assert(!D->getIntegerType()->isDependentType() |
| && "Dependent type without type source info"); |
| Enum->setIntegerType(D->getIntegerType()); |
| } |
| } |
| |
| SemaRef.InstantiateAttrs(TemplateArgs, D, Enum); |
| |
| Enum->setInstantiationOfMemberEnum(D, TSK_ImplicitInstantiation); |
| Enum->setAccess(D->getAccess()); |
| // Forward the mangling number from the template to the instantiated decl. |
| SemaRef.Context.setManglingNumber(Enum, SemaRef.Context.getManglingNumber(D)); |
| // See if the old tag was defined along with a declarator. |
| // If it did, mark the new tag as being associated with that declarator. |
| if (DeclaratorDecl *DD = SemaRef.Context.getDeclaratorForUnnamedTagDecl(D)) |
| SemaRef.Context.addDeclaratorForUnnamedTagDecl(Enum, DD); |
| // See if the old tag was defined along with a typedef. |
| // If it did, mark the new tag as being associated with that typedef. |
| if (TypedefNameDecl *TND = SemaRef.Context.getTypedefNameForUnnamedTagDecl(D)) |
| SemaRef.Context.addTypedefNameForUnnamedTagDecl(Enum, TND); |
| if (SubstQualifier(D, Enum)) return nullptr; |
| Owner->addDecl(Enum); |
| |
| EnumDecl *Def = D->getDefinition(); |
| if (Def && Def != D) { |
| // If this is an out-of-line definition of an enum member template, check |
| // that the underlying types match in the instantiation of both |
| // declarations. |
| if (TypeSourceInfo *TI = Def->getIntegerTypeSourceInfo()) { |
| SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc(); |
| QualType DefnUnderlying = |
| SemaRef.SubstType(TI->getType(), TemplateArgs, |
| UnderlyingLoc, DeclarationName()); |
| SemaRef.CheckEnumRedeclaration(Def->getLocation(), Def->isScoped(), |
| DefnUnderlying, /*IsFixed=*/true, Enum); |
| } |
| } |
| |
| // C++11 [temp.inst]p1: The implicit instantiation of a class template |
| // specialization causes the implicit instantiation of the declarations, but |
| // not the definitions of scoped member enumerations. |
| // |
| // DR1484 clarifies that enumeration definitions inside of a template |
| // declaration aren't considered entities that can be separately instantiated |
| // from the rest of the entity they are declared inside of. |
| if (isDeclWithinFunction(D) ? D == Def : Def && !Enum->isScoped()) { |
| SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Enum); |
| InstantiateEnumDefinition(Enum, Def); |
| } |
| |
| return Enum; |
| } |
| |
| void TemplateDeclInstantiator::InstantiateEnumDefinition( |
| EnumDecl *Enum, EnumDecl *Pattern) { |
| Enum->startDefinition(); |
| |
| // Update the location to refer to the definition. |
| Enum->setLocation(Pattern->getLocation()); |
| |
| SmallVector<Decl*, 4> Enumerators; |
| |
| EnumConstantDecl *LastEnumConst = nullptr; |
| for (auto *EC : Pattern->enumerators()) { |
| // The specified value for the enumerator. |
| ExprResult Value((Expr *)nullptr); |
| if (Expr *UninstValue = EC->getInitExpr()) { |
| // The enumerator's value expression is a constant expression. |
| EnterExpressionEvaluationContext Unevaluated( |
| SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated); |
| |
| Value = SemaRef.SubstExpr(UninstValue, TemplateArgs); |
| } |
| |
| // Drop the initial value and continue. |
| bool isInvalid = false; |
| if (Value.isInvalid()) { |
| Value = nullptr; |
| isInvalid = true; |
| } |
| |
| EnumConstantDecl *EnumConst |
| = SemaRef.CheckEnumConstant(Enum, LastEnumConst, |
| EC->getLocation(), EC->getIdentifier(), |
| Value.get()); |
| |
| if (isInvalid) { |
| if (EnumConst) |
| EnumConst->setInvalidDecl(); |
| Enum->setInvalidDecl(); |
| } |
| |
| if (EnumConst) { |
| SemaRef.InstantiateAttrs(TemplateArgs, EC, EnumConst); |
| |
| EnumConst->setAccess(Enum->getAccess()); |
| Enum->addDecl(EnumConst); |
| Enumerators.push_back(EnumConst); |
| LastEnumConst = EnumConst; |
| |
| if (Pattern->getDeclContext()->isFunctionOrMethod() && |
| !Enum->isScoped()) { |
| // If the enumeration is within a function or method, record the enum |
| // constant as a local. |
| SemaRef.CurrentInstantiationScope->InstantiatedLocal(EC, EnumConst); |
| } |
| } |
| } |
| |
| SemaRef.ActOnEnumBody(Enum->getLocation(), Enum->getBraceRange(), Enum, |
| Enumerators, nullptr, ParsedAttributesView()); |
| } |
| |
| Decl *TemplateDeclInstantiator::VisitEnumConstantDecl(EnumConstantDecl *D) { |
| llvm_unreachable("EnumConstantDecls can only occur within EnumDecls."); |
| } |
| |
| Decl * |
| TemplateDeclInstantiator::VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D) { |
| llvm_unreachable("BuiltinTemplateDecls cannot be instantiated."); |
| } |
| |
| Decl *TemplateDeclInstantiator::VisitClassTemplateDecl(ClassTemplateDecl *D) { |
| bool isFriend = (D->getFriendObjectKind() != Decl::FOK_None); |
| |
| // Create a local instantiation scope for this class template, which |
| // will contain the instantiations of the template parameters. |
| LocalInstantiationScope Scope(SemaRef); |
| TemplateParameterList *TempParams = D->getTemplateParameters(); |
| TemplateParameterList *InstParams = SubstTemplateParams(TempParams); |
| if (!InstParams) |
| return nullptr; |
| |
| CXXRecordDecl *Pattern = D->getTemplatedDecl(); |
| |
| // Instantiate the qualifier. We have to do this first in case |
| // we're a friend declaration, because if we are then we need to put |
| // the new declaration in the appropriate context. |
| NestedNameSpecifierLoc QualifierLoc = Pattern->getQualifierLoc(); |
| if (QualifierLoc) { |
| QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, |
| TemplateArgs); |
| if (!QualifierLoc) |
| return nullptr; |
| } |
| |
| CXXRecordDecl *PrevDecl = nullptr; |
| ClassTemplateDecl *PrevClassTemplate = nullptr; |
| |
| if (!isFriend && getPreviousDeclForInstantiation(Pattern)) { |
| DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName()); |
| if (!Found.empty()) { |
| PrevClassTemplate = dyn_cast<ClassTemplateDecl>(Found.front()); |
| if (PrevClassTemplate) |
| PrevDecl = PrevClassTemplate->getTemplatedDecl(); |
| } |
| } |
| |
| // If this isn't a friend, then it's a member template, in which |
| // case we just want to build the instantiation in the |
| // specialization. If it is a friend, we want to build it in |
| // the appropriate context. |
| DeclContext *DC = Owner; |
| if (isFriend) { |
| if (QualifierLoc) { |
| CXXScopeSpec SS; |
| SS.Adopt(QualifierLoc); |
| DC = SemaRef.computeDeclContext(SS); |
| if (!DC) return nullptr; |
| } else { |
| DC = SemaRef.FindInstantiatedContext(Pattern->getLocation(), |
| Pattern->getDeclContext(), |
| TemplateArgs); |
| } |
| |
| // Look for a previous declaration of the template in the owning |
| // context. |
| LookupResult R(SemaRef, Pattern->getDeclName(), Pattern->getLocation(), |
| Sema::LookupOrdinaryName, |
| SemaRef.forRedeclarationInCurContext()); |
| SemaRef.LookupQualifiedName(R, DC); |
| |
| if (R.isSingleResult()) { |
| PrevClassTemplate = R.getAsSingle<ClassTemplateDecl>(); |
| if (PrevClassTemplate) |
| PrevDecl = PrevClassTemplate->getTemplatedDecl(); |
| } |
| |
| if (!PrevClassTemplate && QualifierLoc) { |
| SemaRef.Diag(Pattern->getLocation(), diag::err_not_tag_in_scope) |
| << D->getTemplatedDecl()->getTagKind() << Pattern->getDeclName() << DC |
| << QualifierLoc.getSourceRange(); |
| return nullptr; |
| } |
| |
| bool AdoptedPreviousTemplateParams = false; |
| if (PrevClassTemplate) { |
| bool Complain = true; |
| |
| // HACK: libstdc++ 4.2.1 contains an ill-formed friend class |
| // template for struct std::tr1::__detail::_Map_base, where the |
| // template parameters of the friend declaration don't match the |
| // template parameters of the original declaration. In this one |
| // case, we don't complain about the ill-formed friend |
| // declaration. |
| if (isFriend && Pattern->getIdentifier() && |
| Pattern->getIdentifier()->isStr("_Map_base") && |
| DC->isNamespace() && |
| cast<NamespaceDecl>(DC)->getIdentifier() && |
| cast<NamespaceDecl>(DC)->getIdentifier()->isStr("__detail")) { |
| DeclContext *DCParent = DC->getParent(); |
| if (DCParent->isNamespace() && |
| cast<NamespaceDecl>(DCParent)->getIdentifier() && |
| cast<NamespaceDecl>(DCParent)->getIdentifier()->isStr("tr1")) { |
| if (cast<Decl>(DCParent)->isInStdNamespace()) |
| Complain = false; |
| } |
| } |
| |
| TemplateParameterList *PrevParams |
| = PrevClassTemplate->getMostRecentDecl()->getTemplateParameters(); |
| |
| // Make sure the parameter lists match. |
| if (!SemaRef.TemplateParameterListsAreEqual(InstParams, PrevParams, |
| Complain, |
| Sema::TPL_TemplateMatch)) { |
| if (Complain) |
| return nullptr; |
| |
| AdoptedPreviousTemplateParams = true; |
| InstParams = PrevParams; |
| } |
| |
| // Do some additional validation, then merge default arguments |
| // from the existing declarations. |
| if (!AdoptedPreviousTemplateParams && |
| SemaRef.CheckTemplateParameterList(InstParams, PrevParams, |
| Sema::TPC_ClassTemplate)) |
| return nullptr; |
| } |
| } |
| |
| CXXRecordDecl *RecordInst = CXXRecordDecl::Create( |
| SemaRef.Context, Pattern->getTagKind(), DC, Pattern->getBeginLoc(), |
| Pattern->getLocation(), Pattern->getIdentifier(), PrevDecl, |
| /*DelayTypeCreation=*/true); |
| |
| if (QualifierLoc) |
| RecordInst->setQualifierInfo(QualifierLoc); |
| |
| SemaRef.InstantiateAttrsForDecl(TemplateArgs, Pattern, RecordInst, LateAttrs, |
| StartingScope); |
| |
| ClassTemplateDecl *Inst |
| = ClassTemplateDecl::Create(SemaRef.Context, DC, D->getLocation(), |
| D->getIdentifier(), InstParams, RecordInst); |
| assert(!(isFriend && Owner->isDependentContext())); |
| Inst->setPreviousDecl(PrevClassTemplate); |
| |
| RecordInst->setDescribedClassTemplate(Inst); |
| |
| if (isFriend) { |
| if (PrevClassTemplate) |
| Inst->setAccess(PrevClassTemplate->getAccess()); |
| else |
| Inst->setAccess(D->getAccess()); |
| |
| Inst->setObjectOfFriendDecl(); |
| // TODO: do we want to track the instantiation progeny of this |
| // friend target decl? |
| } else { |
| Inst->setAccess(D->getAccess()); |
| if (!PrevClassTemplate) |
| Inst->setInstantiatedFromMemberTemplate(D); |
| } |
| |
| // Trigger creation of the type for the instantiation. |
| SemaRef.Context.getInjectedClassNameType(RecordInst, |
| Inst->getInjectedClassNameSpecialization()); |
| |
| // Finish handling of friends. |
| if (isFriend) { |
| DC->makeDeclVisibleInContext(Inst); |
| Inst->setLexicalDeclContext(Owner); |
| RecordInst->setLexicalDeclContext(Owner); |
| return Inst; |
| } |
| |
| if (D->isOutOfLine()) { |
| Inst->setLexicalDeclContext(D->getLexicalDeclContext()); |
| RecordInst->setLexicalDeclContext(D->getLexicalDeclContext()); |
| } |
| |
| Owner->addDecl(Inst); |
| |
| if (!PrevClassTemplate) { |
| // Queue up any out-of-line partial specializations of this member |
| // class template; the client will force their instantiation once |
| // the enclosing class has been instantiated. |
| SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs; |
| D->getPartialSpecializations(PartialSpecs); |
| for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) |
| if (PartialSpecs[I]->getFirstDecl()->isOutOfLine()) |
| OutOfLinePartialSpecs.push_back(std::make_pair(Inst, PartialSpecs[I])); |
| } |
| |
| return Inst; |
| } |
| |
| Decl * |
| TemplateDeclInstantiator::VisitClassTemplatePartialSpecializationDecl( |
| ClassTemplatePartialSpecializationDecl *D) { |
| ClassTemplateDecl *ClassTemplate = D->getSpecializedTemplate(); |
| |
| // Lookup the already-instantiated declaration in the instantiation |
| // of the class template and return that. |
| DeclContext::lookup_result Found |
| = Owner->lookup(ClassTemplate->getDeclName()); |
| if (Found.empty()) |
| return nullptr; |
| |
| ClassTemplateDecl *InstClassTemplate |
| = dyn_cast<ClassTemplateDecl>(Found.front()); |
| if (!InstClassTemplate) |
| return nullptr; |
| |
| if (ClassTemplatePartialSpecializationDecl *Result |
| = InstClassTemplate->findPartialSpecInstantiatedFromMember(D)) |
| return Result; |
| |
| return InstantiateClassTemplatePartialSpecialization(InstClassTemplate, D); |
| } |
| |
| Decl *TemplateDeclInstantiator::VisitVarTemplateDecl(VarTemplateDecl *D) { |
| assert(D->getTemplatedDecl()->isStaticDataMember() && |
| "Only static data member templates are allowed."); |
| |
| // Create a local instantiation scope for this variable template, which |
| // will contain the instantiations of the template parameters. |
| LocalInstantiationScope Scope(SemaRef); |
| TemplateParameterList *TempParams = D->getTemplateParameters(); |
| TemplateParameterList *InstParams = SubstTemplateParams(TempParams); |
| if (!InstParams) |
| return nullptr; |
| |
| VarDecl *Pattern = D->getTemplatedDecl(); |
| VarTemplateDecl *PrevVarTemplate = nullptr; |
| |
| if (getPreviousDeclForInstantiation(Pattern)) { |
| DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName()); |
| if (!Found.empty()) |
| PrevVarTemplate = dyn_cast<VarTemplateDecl>(Found.front()); |
| } |
| |
| VarDecl *VarInst = |
| cast_or_null<VarDecl>(VisitVarDecl(Pattern, |
| /*InstantiatingVarTemplate=*/true)); |
| if (!VarInst) return nullptr; |
| |
| DeclContext *DC = Owner; |
| |
| VarTemplateDecl *Inst = VarTemplateDecl::Create( |
| SemaRef.Context, DC, D->getLocation(), D->getIdentifier(), InstParams, |
| VarInst); |
| VarInst->setDescribedVarTemplate(Inst); |
| Inst->setPreviousDecl(PrevVarTemplate); |
| |
| Inst->setAccess(D->getAccess()); |
| if (!PrevVarTemplate) |
| Inst->setInstantiatedFromMemberTemplate(D); |
| |
| if (D->isOutOfLine()) { |
| Inst->setLexicalDeclContext(D->getLexicalDeclContext()); |
| VarInst->setLexicalDeclContext(D->getLexicalDeclContext()); |
| } |
| |
| Owner->addDecl(Inst); |
| |
| if (!PrevVarTemplate) { |
| // Queue up any out-of-line partial specializations of this member |
| // variable template; the client will force their instantiation once |
| // the enclosing class has been instantiated. |
| SmallVector<VarTemplatePartialSpecializationDecl *, 4> PartialSpecs; |
| D->getPartialSpecializations(PartialSpecs); |
| for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) |
| if (PartialSpecs[I]->getFirstDecl()->isOutOfLine()) |
| OutOfLineVarPartialSpecs.push_back( |
| std::make_pair(Inst, PartialSpecs[I])); |
| } |
| |
| return Inst; |
| } |
| |
| Decl *TemplateDeclInstantiator::VisitVarTemplatePartialSpecializationDecl( |
| VarTemplatePartialSpecializationDecl *D) { |
| assert(D->isStaticDataMember() && |
| "Only static data member templates are allowed."); |
| |
| VarTemplateDecl *VarTemplate = D->getSpecializedTemplate(); |
| |
| // Lookup the already-instantiated declaration and return that. |
| DeclContext::lookup_result Found = Owner->lookup(VarTemplate->getDeclName()); |
| assert(!Found.empty() && "Instantiation found nothing?"); |
| |
| VarTemplateDecl *InstVarTemplate = dyn_cast<VarTemplateDecl>(Found.front()); |
| assert(InstVarTemplate && "Instantiation did not find a variable template?"); |
| |
| if (VarTemplatePartialSpecializationDecl *Result = |
| InstVarTemplate->findPartialSpecInstantiatedFromMember(D)) |
| return Result; |
| |
| return InstantiateVarTemplatePartialSpecialization(InstVarTemplate, D); |
| } |
| |
| Decl * |
| TemplateDeclInstantiator::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) { |
| // Create a local instantiation scope for this function template, which |
| // will contain the instantiations of the template parameters and then get |
| // merged with the local instantiation scope for the function template |
| // itself. |
| LocalInstantiationScope Scope(SemaRef); |
| |
| TemplateParameterList *TempParams = D->getTemplateParameters(); |
| TemplateParameterList *InstParams = SubstTemplateParams(TempParams); |
| if (!InstParams) |
| return nullptr; |
| |
| FunctionDecl *Instantiated = nullptr; |
| if (CXXMethodDecl *DMethod = dyn_cast<CXXMethodDecl>(D->getTemplatedDecl())) |
| Instantiated = cast_or_null<FunctionDecl>(VisitCXXMethodDecl(DMethod, |
| InstParams)); |
| else |
| Instantiated = cast_or_null<FunctionDecl>(VisitFunctionDecl( |
| D->getTemplatedDecl(), |
| InstParams)); |
| |
| if (!Instantiated) |
| return nullptr; |
| |
| // Link the instantiated function template declaration to the function |
| // template from which it was instantiated. |
| FunctionTemplateDecl *InstTemplate |
| = Instantiated->getDescribedFunctionTemplate(); |
| InstTemplate->setAccess(D->getAccess()); |
| assert(InstTemplate && |
| "VisitFunctionDecl/CXXMethodDecl didn't create a template!"); |
| |
| bool isFriend = (InstTemplate->getFriendObjectKind() != Decl::FOK_None); |
| |
| // Link the instantiation back to the pattern *unless* this is a |
| // non-definition friend declaration. |
| if (!InstTemplate->getInstantiatedFromMemberTemplate() && |
| !(isFriend && !D->getTemplatedDecl()->isThisDeclarationADefinition())) |
| InstTemplate->setInstantiatedFromMemberTemplate(D); |
| |
| // Make declarations visible in the appropriate context. |
| if (!isFriend) { |
| Owner->addDecl(InstTemplate); |
| } else if (InstTemplate->getDeclContext()->isRecord() && |
| !getPreviousDeclForInstantiation(D)) { |
| SemaRef.CheckFriendAccess(InstTemplate); |
| } |
| |
| return InstTemplate; |
| } |
| |
| Decl *TemplateDeclInstantiator::VisitCXXRecordDecl(CXXRecordDecl *D) { |
| CXXRecordDecl *PrevDecl = nullptr; |
| if (D->isInjectedClassName()) |
| PrevDecl = cast<CXXRecordDecl>(Owner); |
| else if (CXXRecordDecl *PatternPrev = getPreviousDeclForInstantiation(D)) { |
| NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(), |
| PatternPrev, |
| TemplateArgs); |
| if (!Prev) return nullptr; |
| PrevDecl = cast<CXXRecordDecl>(Prev); |
| } |
| |
| CXXRecordDecl *Record = CXXRecordDecl::Create( |
| SemaRef.Context, D->getTagKind(), Owner, D->getBeginLoc(), |
| D->getLocation(), D->getIdentifier(), PrevDecl); |
| |
| // Substitute the nested name specifier, if any. |
| if (SubstQualifier(D, Record)) |
| return nullptr; |
| |
| SemaRef.InstantiateAttrsForDecl(TemplateArgs, D, Record, LateAttrs, |
| StartingScope); |
| |
| Record->setImplicit(D->isImplicit()); |
| // FIXME: Check against AS_none is an ugly hack to work around the issue that |
| // the tag decls introduced by friend class declarations don't have an access |
| // specifier. Remove once this area of the code gets sorted out. |
| if (D->getAccess() != AS_none) |
| Record->setAccess(D->getAccess()); |
| if (!D->isInjectedClassName()) |
| Record->setInstantiationOfMemberClass(D, TSK_ImplicitInstantiation); |
| |
| // If the original function was part of a friend declaration, |
| // inherit its namespace state. |
| if (D->getFriendObjectKind()) |
| Record->setObjectOfFriendDecl(); |
| |
| // Make sure that anonymous structs and unions are recorded. |
| if (D->isAnonymousStructOrUnion()) |
| Record->setAnonymousStructOrUnion(true); |
| |
| if (D->isLocalClass()) |
| SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Record); |
| |
| // Forward the mangling number from the template to the instantiated decl. |
| SemaRef.Context.setManglingNumber(Record, |
| SemaRef.Context.getManglingNumber(D)); |
| |
| // See if the old tag was defined along with a declarator. |
| // If it did, mark the new tag as being associated with that declarator. |
| if (DeclaratorDecl *DD = SemaRef.Context.getDeclaratorForUnnamedTagDecl(D)) |
| SemaRef.Context.addDeclaratorForUnnamedTagDecl(Record, DD); |
| |
| // See if the old tag was defined along with a typedef. |
| // If it did, mark the new tag as being associated with that typedef. |
| if (TypedefNameDecl *TND = SemaRef.Context.getTypedefNameForUnnamedTagDecl(D)) |
| SemaRef.Context.addTypedefNameForUnnamedTagDecl(Record, TND); |
| |
| Owner->addDecl(Record); |
| |
| // DR1484 clarifies that the members of a local class are instantiated as part |
| // of the instantiation of their enclosing entity. |
| if (D->isCompleteDefinition() && D->isLocalClass()) { |
| Sema::LocalEagerInstantiationScope LocalInstantiations(SemaRef); |
| |
| SemaRef.InstantiateClass(D->getLocation(), Record, D, TemplateArgs, |
| TSK_ImplicitInstantiation, |
| /*Complain=*/true); |
| |
| // For nested local classes, we will instantiate the members when we |
| // reach the end of the outermost (non-nested) local class. |
| if (!D->isCXXClassMember()) |
| SemaRef.InstantiateClassMembers(D->getLocation(), Record, TemplateArgs, |
| TSK_ImplicitInstantiation); |
| |
| // This class may have local implicit instantiations that need to be |
| // performed within this scope. |
| LocalInstantiations.perform(); |
| } |
| |
| SemaRef.DiagnoseUnusedNestedTypedefs(Record); |
| |
| return Record; |
| } |
| |
| /// Adjust the given function type for an instantiation of the |
| /// given declaration, to cope with modifications to the function's type that |
| /// aren't reflected in the type-source information. |
| /// |
| /// \param D The declaration we're instantiating. |
| /// \param TInfo The already-instantiated type. |
| static QualType adjustFunctionTypeForInstantiation(ASTContext &Context, |
| FunctionDecl *D, |
| TypeSourceInfo *TInfo) { |
| const FunctionProtoType *OrigFunc |
| = D->getType()->castAs<FunctionProtoType>(); |
| const FunctionProtoType *NewFunc |
| = TInfo->getType()->castAs<FunctionProtoType>(); |
| if (OrigFunc->getExtInfo() == NewFunc->getExtInfo()) |
| return TInfo->getType(); |
| |
| FunctionProtoType::ExtProtoInfo NewEPI = NewFunc->getExtProtoInfo(); |
| NewEPI.ExtInfo = OrigFunc->getExtInfo(); |
| return Context.getFunctionType(NewFunc->getReturnType(), |
| NewFunc->getParamTypes(), NewEPI); |
| } |
| |
| /// Normal class members are of more specific types and therefore |
| /// don't make it here. This function serves three purposes: |
| /// 1) instantiating function templates |
| /// 2) substituting friend declarations |
| /// 3) substituting deduction guide declarations for nested class templates |
| Decl *TemplateDeclInstantiator::VisitFunctionDecl(FunctionDecl *D, |
| TemplateParameterList *TemplateParams) { |
| // Check whether there is already a function template specialization for |
| // this declaration. |
| FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate(); |
| if (FunctionTemplate && !TemplateParams) { |
| ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost(); |
| |
| void *InsertPos = nullptr; |
| FunctionDecl *SpecFunc |
| = FunctionTemplate->findSpecialization(Innermost, InsertPos); |
| |
| // If we already have a function template specialization, return it. |
| if (SpecFunc) |
| return SpecFunc; |
| } |
| |
| bool isFriend; |
| if (FunctionTemplate) |
| isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None); |
| else |
| isFriend = (D->getFriendObjectKind() != Decl::FOK_None); |
| |
| bool MergeWithParentScope = (TemplateParams != nullptr) || |
| Owner->isFunctionOrMethod() || |
| !(isa<Decl>(Owner) && |
| cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod()); |
| LocalInstantiationScope Scope(SemaRef, MergeWithParentScope); |
| |
| ExplicitSpecifier InstantiatedExplicitSpecifier; |
| if (auto *DGuide = dyn_cast<CXXDeductionGuideDecl>(D)) { |
| InstantiatedExplicitSpecifier = instantiateExplicitSpecifier( |
| SemaRef, TemplateArgs, DGuide->getExplicitSpecifier(), DGuide); |
| if (InstantiatedExplicitSpecifier.isInvalid()) |
| return nullptr; |
| } |
| |
| SmallVector<ParmVarDecl *, 4> Params; |
| TypeSourceInfo *TInfo = SubstFunctionType(D, Params); |
| if (!TInfo) |
| return nullptr; |
| QualType T = adjustFunctionTypeForInstantiation(SemaRef.Context, D, TInfo); |
| |
| NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc(); |
| if (QualifierLoc) { |
| QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, |
| TemplateArgs); |
| if (!QualifierLoc) |
| return nullptr; |
| } |
| |
| // If we're instantiating a local function declaration, put the result |
| // in the enclosing namespace; otherwise we need to find the instantiated |
| // context. |
| DeclContext *DC; |
| if (D->isLocalExternDecl()) { |
| DC = Owner; |
| SemaRef.adjustContextForLocalExternDecl(DC); |
| } else if (isFriend && QualifierLoc) { |
| CXXScopeSpec SS; |
| SS.Adopt(QualifierLoc); |
| DC = SemaRef.computeDeclContext(SS); |
| if (!DC) return nullptr; |
| } else { |
| DC = SemaRef.FindInstantiatedContext(D->getLocation(), D->getDeclContext(), |
| TemplateArgs); |
| } |
| |
| DeclarationNameInfo NameInfo |
| = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs); |
| |
| FunctionDecl *Function; |
| if (auto *DGuide = dyn_cast<CXXDeductionGuideDecl>(D)) { |
| Function = CXXDeductionGuideDecl::Create( |
| SemaRef.Context, DC, D->getInnerLocStart(), |
| InstantiatedExplicitSpecifier, NameInfo, T, TInfo, |
| D->getSourceRange().getEnd()); |
| if (DGuide->isCopyDeductionCandidate()) |
| cast<CXXDeductionGuideDecl>(Function)->setIsCopyDeductionCandidate(); |
| Function->setAccess(D->getAccess()); |
| } else { |
| Function = FunctionDecl::Create( |
| SemaRef.Context, DC, D->getInnerLocStart(), NameInfo, T, TInfo, |
| D->getCanonicalDecl()->getStorageClass(), D->isInlineSpecified(), |
| D->hasWrittenPrototype(), D->getConstexprKind()); |
| Function->setRangeEnd(D->getSourceRange().getEnd()); |
| } |
| |
| if (D->isInlined()) |
| Function->setImplicitlyInline(); |
| |
| if (QualifierLoc) |
| Function->setQualifierInfo(QualifierLoc); |
| |
| if (D->isLocalExternDecl()) |
| Function->setLocalExternDecl(); |
| |
| DeclContext *LexicalDC = Owner; |
| if (!isFriend && D->isOutOfLine() && !D->isLocalExternDecl()) { |
| assert(D->getDeclContext()->isFileContext()); |
| LexicalDC = D->getDeclContext(); |
| } |
| |
| Function->setLexicalDeclContext(LexicalDC); |
| |
| // Attach the parameters |
| for (unsigned P = 0; P < Params.size(); ++P) |
| if (Params[P]) |
| Params[P]->setOwningFunction(Function); |
| Function->setParams(Params); |
| |
| if (TemplateParams) { |
| // Our resulting instantiation is actually a function template, since we |
| // are substituting only the outer template parameters. For example, given |
| // |
| // template<typename T> |
| // struct X { |
| // template<typename U> friend void f(T, U); |
| // }; |
| // |
| // X<int> x; |
| // |
| // We are instantiating the friend function template "f" within X<int>, |
| // which means substituting int for T, but leaving "f" as a friend function |
| // template. |
| // Build the function template itself. |
| FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, DC, |
| Function->getLocation(), |
| Function->getDeclName(), |
| TemplateParams, Function); |
| Function->setDescribedFunctionTemplate(FunctionTemplate); |
| |
| FunctionTemplate->setLexicalDeclContext(LexicalDC); |
| |
| if (isFriend && D->isThisDeclarationADefinition()) { |
| FunctionTemplate->setInstantiatedFromMemberTemplate( |
| D->getDescribedFunctionTemplate()); |
| } |
| } else if (FunctionTemplate) { |
| // Record this function template specialization. |
| ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost(); |
| Function->setFunctionTemplateSpecialization(FunctionTemplate, |
| TemplateArgumentList::CreateCopy(SemaRef.Context, |
| Innermost), |
| /*InsertPos=*/nullptr); |
| } else if (isFriend && D->isThisDeclarationADefinition()) { |
| // Do not connect the friend to the template unless it's actually a |
| // definition. We don't want non-template functions to be marked as being |
| // template instantiations. |
| Function->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation); |
| } |
| |
| if (isFriend) |
| Function->setObjectOfFriendDecl(); |
| |
| if (InitFunctionInstantiation(Function, D)) |
| Function->setInvalidDecl(); |
| |
| bool IsExplicitSpecialization = false; |
| |
| LookupResult Previous( |
| SemaRef, Function->getDeclName(), SourceLocation(), |
| D->isLocalExternDecl() ? Sema::LookupRedeclarationWithLinkage |
| : Sema::LookupOrdinaryName, |
| D->isLocalExternDecl() ? Sema::ForExternalRedeclaration |
| : SemaRef.forRedeclarationInCurContext()); |
| |
| if (DependentFunctionTemplateSpecializationInfo *Info |
| = D->getDependentSpecializationInfo()) { |
| assert(isFriend && "non-friend has dependent specialization info?"); |
| |
| // Instantiate the explicit template arguments. |
| TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(), |
| Info->getRAngleLoc()); |
| if (SemaRef.Subst(Info->getTemplateArgs(), Info->getNumTemplateArgs(), |
| ExplicitArgs, TemplateArgs)) |
| return nullptr; |
| |
| // Map the candidate templates to their instantiations. |
| for (unsigned I = 0, E = Info->getNumTemplates(); I != E; ++I) { |
| Decl *Temp = SemaRef.FindInstantiatedDecl(D->getLocation(), |
| Info->getTemplate(I), |
| TemplateArgs); |
| if (!Temp) return nullptr; |
| |
| Previous.addDecl(cast<FunctionTemplateDecl>(Temp)); |
| } |
| |
| if (SemaRef.CheckFunctionTemplateSpecialization(Function, |
| &ExplicitArgs, |
| Previous)) |
| Function->setInvalidDecl(); |
| |
| IsExplicitSpecialization = true; |
| } else if (const ASTTemplateArgumentListInfo *Info = |
| D->getTemplateSpecializationArgsAsWritten()) { |
| // The name of this function was written as a template-id. |
| SemaRef.LookupQualifiedName(Previous, DC); |
| |
| // Instantiate the explicit template arguments. |
| TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(), |
| Info->getRAngleLoc()); |
| if (SemaRef.Subst(Info->getTemplateArgs(), Info->getNumTemplateArgs(), |
| ExplicitArgs, TemplateArgs)) |
| return nullptr; |
| |
| if (SemaRef.CheckFunctionTemplateSpecialization(Function, |
| &ExplicitArgs, |
| Previous)) |
| Function->setInvalidDecl(); |
| |
| IsExplicitSpecialization = true; |
| } else if (TemplateParams || !FunctionTemplate) { |
| // Look only into the namespace where the friend would be declared to |
| // find a previous declaration. This is the innermost enclosing namespace, |
| // as described in ActOnFriendFunctionDecl. |
| SemaRef.LookupQualifiedName(Previous, DC); |
| |
| // In C++, the previous declaration we find might be a tag type |
| // (class or enum). In this case, the new declaration will hide the |
| // tag type. Note that this does does not apply if we're declaring a |
| // typedef (C++ [dcl.typedef]p4). |
| if (Previous.isSingleTagDecl()) |
| Previous.clear(); |
| } |
| |
| SemaRef.CheckFunctionDeclaration(/*Scope*/ nullptr, Function, Previous, |
| IsExplicitSpecialization); |
| |
| NamedDecl *PrincipalDecl = (TemplateParams |
| ? cast<NamedDecl>(FunctionTemplate) |
| : Function); |
| |
| // If the original function was part of a friend declaration, |
| // inherit its namespace state and add it to the owner. |
| if (isFriend) { |
| Function->setObjectOfFriendDecl(); |
| if (FunctionTemplateDecl *FT = Function->getDescribedFunctionTemplate()) |
| FT->setObjectOfFriendDecl(); |
| DC->makeDeclVisibleInContext(PrincipalDecl); |
| |
| bool QueuedInstantiation = false; |
| |
| // C++11 [temp.friend]p4 (DR329): |
| // When a function is defined in a friend function declaration in a class |
| // template, the function is instantiated when the function is odr-used. |
| // The same restrictions on multiple declarations and definitions that |
| // apply to non-template function declarations and definitions also apply |
| // to these implicit definitions. |
| if (D->isThisDeclarationADefinition()) { |
| SemaRef.CheckForFunctionRedefinition(Function); |
| if (!Function->isInvalidDecl()) { |
| for (auto R : Function->redecls()) { |
| if (R == Function) |
| continue; |
| |
| // If some prior declaration of this function has been used, we need |
| // to instantiate its definition. |
| if (!QueuedInstantiation && R->isUsed(false)) { |
| if (MemberSpecializationInfo *MSInfo = |
| Function->getMemberSpecializationInfo()) { |
| if (MSInfo->getPointOfInstantiation().isInvalid()) { |
| SourceLocation Loc = R->getLocation(); // FIXME |
| MSInfo->setPointOfInstantiation(Loc); |
| SemaRef.PendingLocalImplicitInstantiations.push_back( |
| std::make_pair(Function, Loc)); |
| QueuedInstantiation = true; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| // Check the template parameter list against the previous declaration. The |
| // goal here is to pick up default arguments added since the friend was |
| // declared; we know the template parameter lists match, since otherwise |
| // we would not have picked this template as the previous declaration. |
| if (TemplateParams && FunctionTemplate->getPreviousDecl()) { |
| SemaRef.CheckTemplateParameterList( |
| TemplateParams, |
| FunctionTemplate->getPreviousDecl()->getTemplateParameters(), |
| Function->isThisDeclarationADefinition() |
| ? Sema::TPC_FriendFunctionTemplateDefinition |
| : Sema::TPC_FriendFunctionTemplate); |
| } |
| } |
| |
| if (Function->isLocalExternDecl() && !Function->getPreviousDecl()) |
| DC->makeDeclVisibleInContext(PrincipalDecl); |
| |
| if (Function->isOverloadedOperator() && !DC->isRecord() && |
| PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary)) |
| PrincipalDecl->setNonMemberOperator(); |
| |
| assert(!D->isDefaulted() && "only methods should be defaulted"); |
| return Function; |
| } |
| |
| Decl *TemplateDeclInstantiator::VisitCXXMethodDecl( |
| CXXMethodDecl *D, TemplateParameterList *TemplateParams, |
| Optional<const ASTTemplateArgumentListInfo *> |
| ClassScopeSpecializationArgs) { |
| FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate(); |
| if (FunctionTemplate && !TemplateParams) { |
| // We are creating a function template specialization from a function |
| // template. Check whether there is already a function template |
| // specialization for this particular set of template arguments. |
| ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost(); |
| |
| void *InsertPos = nullptr; |
| FunctionDecl *SpecFunc |
| = FunctionTemplate->findSpecialization(Innermost, InsertPos); |
| |
| // If we already have a function template specialization, return it. |
| if (SpecFunc) |
| return SpecFunc; |
| } |
| |
| bool isFriend; |
| if (FunctionTemplate) |
| isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None); |
| else |
| isFriend = (D->getFriendObjectKind() != Decl::FOK_None); |
| |
| bool MergeWithParentScope = (TemplateParams != nullptr) || |
| !(isa<Decl>(Owner) && |
| cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod()); |
| LocalInstantiationScope Scope(SemaRef, MergeWithParentScope); |
| |
| // Instantiate enclosing template arguments for friends. |
| SmallVector<TemplateParameterList *, 4> TempParamLists; |
| unsigned NumTempParamLists = 0; |
| if (isFriend && (NumTempParamLists = D->getNumTemplateParameterLists())) { |
| TempParamLists.resize(NumTempParamLists); |
| for (unsigned I = 0; I != NumTempParamLists; ++I) { |
| TemplateParameterList *TempParams = D->getTemplateParameterList(I); |
| TemplateParameterList *InstParams = SubstTemplateParams(TempParams); |
| if (!InstParams) |
| return nullptr; |
| TempParamLists[I] = InstParams; |
| } |
| } |
| |
| ExplicitSpecifier InstantiatedExplicitSpecifier = |
| instantiateExplicitSpecifier(SemaRef, TemplateArgs, |
| ExplicitSpecifier::getFromDecl(D), D); |
| if (InstantiatedExplicitSpecifier.isInvalid()) |
| return nullptr; |
| |
| SmallVector<ParmVarDecl *, 4> Params; |
| TypeSourceInfo *TInfo = SubstFunctionType(D, Params); |
| if (!TInfo) |
| return nullptr; |
| QualType T = adjustFunctionTypeForInstantiation(SemaRef.Context, D, TInfo); |
| |
| NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc(); |
| if (QualifierLoc) { |
| QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, |
| TemplateArgs); |
| if (!QualifierLoc) |
| return nullptr; |
| } |
| |
| DeclContext *DC = Owner; |
| if (isFriend) { |
| if (QualifierLoc) { |
| CXXScopeSpec SS; |
| SS.Adopt(QualifierLoc); |
| DC = SemaRef.computeDeclContext(SS); |
| |
| if (DC && SemaRef.RequireCompleteDeclContext(SS, DC)) |
| return nullptr; |
| } else { |
| DC = SemaRef.FindInstantiatedContext(D->getLocation(), |
| D->getDeclContext(), |
| TemplateArgs); |
| } |
| if (!DC) return nullptr; |
| } |
| |
| // Build the instantiated method declaration. |
| CXXRecordDecl *Record = cast<CXXRecordDecl>(DC); |
| CXXMethodDecl *Method = nullptr; |
| |
| SourceLocation StartLoc = D->getInnerLocStart(); |
| DeclarationNameInfo NameInfo |
| = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs); |
| if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) { |
| Method = CXXConstructorDecl::Create( |
| SemaRef.Context, Record, StartLoc, NameInfo, T, TInfo, |
| InstantiatedExplicitSpecifier, Constructor->isInlineSpecified(), false, |
| Constructor->getConstexprKind()); |
| Method->setRangeEnd(Constructor->getEndLoc()); |
| } else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(D)) { |
| Method = CXXDestructorDecl::Create( |
| SemaRef.Context, Record, StartLoc, NameInfo, T, TInfo, |
| Destructor->isInlineSpecified(), false, Destructor->getConstexprKind()); |
| Method->setRangeEnd(Destructor->getEndLoc()); |
| } else if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) { |
| Method = CXXConversionDecl::Create( |
| SemaRef.Context, Record, StartLoc, NameInfo, T, TInfo, |
| Conversion->isInlineSpecified(), InstantiatedExplicitSpecifier, |
| Conversion->getConstexprKind(), Conversion->getEndLoc()); |
| } else { |
| StorageClass SC = D->isStatic() ? SC_Static : SC_None; |
| Method = CXXMethodDecl::Create(SemaRef.Context, Record, StartLoc, NameInfo, |
| T, TInfo, SC, D->isInlineSpecified(), |
| D->getConstexprKind(), D->getEndLoc()); |
| } |
| |
| if (D->isInlined()) |
| Method->setImplicitlyInline(); |
| |
| if (QualifierLoc) |
| Method->setQualifierInfo(QualifierLoc); |
| |
| if (TemplateParams) { |
| // Our resulting instantiation is actually a function template, since we |
| // are substituting only the outer template parameters. For example, given |
| // |
| // template<typename T> |
| // struct X { |
| // template<typename U> void f(T, U); |
| // }; |
| // |
| // X<int> x; |
| // |
| // We are instantiating the member template "f" within X<int>, which means |
| // substituting int for T, but leaving "f" as a member function template. |
| // Build the function template itself. |
| FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, Record, |
| Method->getLocation(), |
| Method->getDeclName(), |
| TemplateParams, Method); |
| if (isFriend) { |
| FunctionTemplate->setLexicalDeclContext(Owner); |
| FunctionTemplate->setObjectOfFriendDecl(); |
| } else if (D->isOutOfLine()) |
| FunctionTemplate->setLexicalDeclContext(D->getLexicalDeclContext()); |
| Method->setDescribedFunctionTemplate(FunctionTemplate); |
| } else if (FunctionTemplate) { |
| // Record this function template specialization. |
| ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost(); |
| Method->setFunctionTemplateSpecialization(FunctionTemplate, |
| TemplateArgumentList::CreateCopy(SemaRef.Context, |
| Innermost), |
| /*InsertPos=*/nullptr); |
| } else if (!isFriend) { |
| // Record that this is an instantiation of a member function. |
| Method->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation); |
| } |
| |
| // If we are instantiating a member function defined |
| // out-of-line, the instantiation will have the same lexical |
| // context (which will be a namespace scope) as the template. |
| if (isFriend) { |
| if (NumTempParamLists) |
| Method->setTemplateParameterListsInfo( |
| SemaRef.Context, |
| llvm::makeArrayRef(TempParamLists.data(), NumTempParamLists)); |
| |
| Method->setLexicalDeclContext(Owner); |
| Method->setObjectOfFriendDecl(); |
| } else if (D->isOutOfLine()) |
| Method->setLexicalDeclContext(D->getLexicalDeclContext()); |
| |
| // Attach the parameters |
| for (unsigned P = 0; P < Params.size(); ++P) |
| Params[P]->setOwningFunction(Method); |
| Method->setParams(Params); |
| |
| if (InitMethodInstantiation(Method, D)) |
| Method->setInvalidDecl(); |
| |
| LookupResult Previous(SemaRef, NameInfo, Sema::LookupOrdinaryName, |
| Sema::ForExternalRedeclaration); |
| |
| bool IsExplicitSpecialization = false; |
| |
| // If the name of this function was written as a template-id, instantiate |
| // the explicit template arguments. |
| if (DependentFunctionTemplateSpecializationInfo *Info |
| = D->getDependentSpecializationInfo()) { |
| assert(isFriend && "non-friend has dependent specialization info?"); |
| |
| // Instantiate the explicit template arguments. |
| TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(), |
| Info->getRAngleLoc()); |
| if (SemaRef.Subst(Info->getTemplateArgs(), Info->getNumTemplateArgs(), |
| ExplicitArgs, TemplateArgs)) |
| return nullptr; |
| |
| // Map the candidate templates to their instantiations. |
| for (unsigned I = 0, E = Info->getNumTemplates(); I != E; ++I) { |
| Decl *Temp = SemaRef.FindInstantiatedDecl(D->getLocation(), |
| Info->getTemplate(I), |
| TemplateArgs); |
| if (!Temp) return nullptr; |
| |
| Previous.addDecl(cast<FunctionTemplateDecl>(Temp)); |
| } |
| |
| if (SemaRef.CheckFunctionTemplateSpecialization(Method, |
| &ExplicitArgs, |
| Previous)) |
| Method->setInvalidDecl(); |
| |
| IsExplicitSpecialization = true; |
| } else if (const ASTTemplateArgumentListInfo *Info = |
| ClassScopeSpecializationArgs.getValueOr( |
| D->getTemplateSpecializationArgsAsWritten())) { |
| SemaRef.LookupQualifiedName(Previous, DC); |
| |
| TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(), |
| Info->getRAngleLoc()); |
| if (SemaRef.Subst(Info->getTemplateArgs(), Info->getNumTemplateArgs(), |
| ExplicitArgs, TemplateArgs)) |
| return nullptr; |
| |
| if (SemaRef.CheckFunctionTemplateSpecialization(Method, |
| &ExplicitArgs, |
| Previous)) |
| Method->setInvalidDecl(); |
| |
| IsExplicitSpecialization = true; |
| } else if (ClassScopeSpecializationArgs) { |
| // Class-scope explicit specialization written without explicit template |
| // arguments. |
| SemaRef.LookupQualifiedName(Previous, DC); |
| if (SemaRef.CheckFunctionTemplateSpecialization(Method, nullptr, Previous)) |
| Method->setInvalidDecl(); |
| |
| IsExplicitSpecialization = true; |
| } else if (!FunctionTemplate || TemplateParams || isFriend) { |
| SemaRef.LookupQualifiedName(Previous, Record); |
| |
| // In C++, the previous declaration we find might be a tag type |
| // (class or enum). In this case, the new declaration will hide the |
| // tag type. Note that this does does not apply if we're declaring a |
| // typedef (C++ [dcl.typedef]p4). |
| if (Previous.isSingleTagDecl()) |
| Previous.clear(); |
| } |
| |
| SemaRef.CheckFunctionDeclaration(nullptr, Method, Previous, |
| IsExplicitSpecialization); |
| |
| if (D->isPure()) |
| SemaRef.CheckPureMethod(Method, SourceRange()); |
| |
| // Propagate access. For a non-friend declaration, the access is |
| // whatever we're propagating from. For a friend, it should be the |
| // previous declaration we just found. |
| if (isFriend && Method->getPreviousDecl()) |
| Method->setAccess(Method->getPreviousDecl()->getAccess()); |
| else |
| Method->setAccess(D->getAccess()); |
| if (FunctionTemplate) |
| FunctionTemplate->setAccess(Method->getAccess()); |
| |
| SemaRef.CheckOverrideControl(Method); |
| |
| // If a function is defined as defaulted or deleted, mark it as such now. |
| if (D->isExplicitlyDefaulted()) |
| SemaRef.SetDeclDefaulted(Method, Method->getLocation()); |
| if (D->isDeletedAsWritten()) |
| SemaRef.SetDeclDeleted(Method, Method->getLocation()); |
| |
| // If this is an explicit specialization, mark the implicitly-instantiated |
| // template specialization as being an explicit specialization too. |
| // FIXME: Is this necessary? |
| if (IsExplicitSpecialization && !isFriend) |
| SemaRef.CompleteMemberSpecialization(Method, Previous); |
| |
| // If there's a function template, let our caller handle it. |
| if (FunctionTemplate) { |
| // do nothing |
| |
| // Don't hide a (potentially) valid declaration with an invalid one. |
| } else if (Method->isInvalidDecl() && !Previous.empty()) { |
| // do nothing |
| |
| // Otherwise, check access to friends and make them visible. |
| } else if (isFriend) { |
| // We only need to re-check access for methods which we didn't |
| // manage to match during parsing. |
| if (!D->getPreviousDecl()) |
| SemaRef.CheckFriendAccess(Method); |
| |
| Record->makeDeclVisibleInContext(Method); |
| |
| // Otherwise, add the declaration. We don't need to do this for |
| // class-scope specializations because we'll have matched them with |
| // the appropriate template. |
| } else { |
| Owner->addDecl(Method); |
| } |
| |
| // PR17480: Honor the used attribute to instantiate member function |
| // definitions |
| if (Method->hasAttr<UsedAttr>()) { |
| if (const auto *A = dyn_cast<CXXRecordDecl>(Owner)) { |
| SourceLocation Loc; |
| if (const MemberSpecializationInfo *MSInfo = |
| A->getMemberSpecializationInfo()) |
| Loc = MSInfo->getPointOfInstantiation(); |
| else if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(A)) |
| Loc = Spec->getPointOfInstantiation(); |
| SemaRef.MarkFunctionReferenced(Loc, Method); |
| } |
| } |
| |
| return Method; |
| } |
| |
| Decl *TemplateDeclInstantiator::VisitCXXConstructorDecl(CXXConstructorDecl *D) { |
| return VisitCXXMethodDecl(D); |
| } |
| |
| Decl *TemplateDeclInstantiator::VisitCXXDestructorDecl(CXXDestructorDecl *D) { |
| return VisitCXXMethodDecl(D); |
| } |
| |
| Decl *TemplateDeclInstantiator::VisitCXXConversionDecl(CXXConversionDecl *D) { |
| return VisitCXXMethodDecl(D); |
| } |
| |
| Decl *TemplateDeclInstantiator::VisitParmVarDecl(ParmVarDecl *D) { |
| return SemaRef.SubstParmVarDecl(D, TemplateArgs, /*indexAdjustment*/ 0, None, |
| /*ExpectParameterPack=*/ false); |
| } |
| |
| Decl *TemplateDeclInstantiator::VisitTemplateTypeParmDecl( |
| TemplateTypeParmDecl *D) { |
| // TODO: don't always clone when decls are refcounted. |
| assert(D->getTypeForDecl()->isTemplateTypeParmType()); |
| |
| TemplateTypeParmDecl *Inst = TemplateTypeParmDecl::Create( |
| SemaRef.Context, Owner, D->getBeginLoc(), D->getLocation(), |
| D->getDepth() - TemplateArgs.getNumSubstitutedLevels(), D->getIndex(), |
| D->getIdentifier(), D->wasDeclaredWithTypename(), D->isParameterPack()); |
| Inst->setAccess(AS_public); |
| Inst->setImplicit(D->isImplicit()); |
| |
| if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) { |
| TypeSourceInfo *InstantiatedDefaultArg = |
| SemaRef.SubstType(D->getDefaultArgumentInfo(), TemplateArgs, |
| D->getDefaultArgumentLoc(), D->getDeclName()); |
| if (InstantiatedDefaultArg) |
| Inst->setDefaultArgument(InstantiatedDefaultArg); |
| } |
| |
| // Introduce this template parameter's instantiation into the instantiation |
| // scope. |
| SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Inst); |
| |
| return Inst; |
| } |
| |
| Decl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl( |
| NonTypeTemplateParmDecl *D) { |
| // Substitute into the type of the non-type template parameter. |
| TypeLoc TL = D->getTypeSourceInfo()->getTypeLoc(); |
| SmallVector<TypeSourceInfo *, 4> ExpandedParameterPackTypesAsWritten; |
| SmallVector<QualType, 4> ExpandedParameterPackTypes; |
| bool IsExpandedParameterPack = false; |
| TypeSourceInfo *DI; |
| QualType T; |
| bool Invalid = false; |
| |
| if (D->isExpandedParameterPack()) { |
| // The non-type template parameter pack is an already-expanded pack |
| // expansion of types. Substitute into each of the expanded types. |
| ExpandedParameterPackTypes.reserve(D->getNumExpansionTypes()); |
| ExpandedParameterPackTypesAsWritten.reserve(D->getNumExpansionTypes()); |
| for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) { |
| TypeSourceInfo *NewDI = |
| SemaRef.SubstType(D->getExpansionTypeSourceInfo(I), TemplateArgs, |
| D->getLocation(), D->getDeclName()); |
| if (!NewDI) |
| return nullptr; |
| |
| QualType NewT = |
| SemaRef.CheckNonTypeTemplateParameterType(NewDI, D->getLocation()); |
| if (NewT.isNull()) |
| return nullptr; |
| |
| ExpandedParameterPackTypesAsWritten.push_back(NewDI); |
| ExpandedParameterPackTypes.push_back(NewT); |
| } |
| |
| IsExpandedParameterPack = true; |
| DI = D->getTypeSourceInfo(); |
| T = DI->getType(); |
| } else if (D->isPackExpansion()) { |
| // The non-type template parameter pack's type is a pack expansion of types. |
| // Determine whether we need to expand this parameter pack into separate |
| // types. |
| PackExpansionTypeLoc Expansion = TL.castAs<PackExpansionTypeLoc>(); |
| TypeLoc Pattern = Expansion.getPatternLoc(); |
| SmallVector<UnexpandedParameterPack, 2> Unexpanded; |
| SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded); |
| |
| // Determine whether the set of unexpanded parameter packs can and should |
| // be expanded. |
| bool Expand = true; |
| bool RetainExpansion = false; |
| Optional<unsigned> OrigNumExpansions |
| = Expansion.getTypePtr()->getNumExpansions(); |
| Optional<unsigned> NumExpansions = OrigNumExpansions; |
| if (SemaRef.CheckParameterPacksForExpansion(Expansion.getEllipsisLoc(), |
| Pattern.getSourceRange(), |
| Unexpanded, |
| TemplateArgs, |
| Expand, RetainExpansion, |
| NumExpansions)) |
| return nullptr; |
| |
| if (Expand) { |
| for (unsigned I = 0; I != *NumExpansions; ++I) { |
| Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I); |
| TypeSourceInfo *NewDI = SemaRef.SubstType(Pattern, TemplateArgs, |
| D->getLocation(), |
| D->getDeclName()); |
| if (!NewDI) |
| return nullptr; |
| |
| QualType NewT = |
| SemaRef.CheckNonTypeTemplateParameterType(NewDI, D->getLocation()); |
| if (NewT.isNull()) |
| return nullptr; |
| |
| ExpandedParameterPackTypesAsWritten.push_back(NewDI); |
| ExpandedParameterPackTypes.push_back(NewT); |
| } |
| |
| // Note that we have an expanded parameter pack. The "type" of this |
| // expanded parameter pack is the original expansion type, but callers |
| // will end up using the expanded parameter pack types for type-checking. |
| IsExpandedParameterPack = true; |
| DI = D->getTypeSourceInfo(); |
| T = DI->getType(); |
| } else { |
| // We cannot fully expand the pack expansion now, so substitute into the |
| // pattern and create a new pack expansion type. |
| Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1); |
| TypeSourceInfo *NewPattern = SemaRef.SubstType(Pattern, TemplateArgs, |
| D->getLocation(), |
| D->getDeclName()); |
| if (!NewPattern) |
| return nullptr; |
| |
| SemaRef.CheckNonTypeTemplateParameterType(NewPattern, D->getLocation()); |
| DI = SemaRef.CheckPackExpansion(NewPattern, Expansion.getEllipsisLoc(), |
| NumExpansions); |
| if (!DI) |
| return nullptr; |
| |
| T = DI->getType(); |
| } |
| } else { |
| // Simple case: substitution into a parameter that is not a parameter pack. |
| DI = SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs, |
| D->getLocation(), D->getDeclName()); |
| if (!DI) |
| return nullptr; |
| |
| // Check that this type is acceptable for a non-type template parameter. |
| T = SemaRef.CheckNonTypeTemplateParameterType(DI, D->getLocation()); |
| if (T.isNull()) { |
| T = SemaRef.Context.IntTy; |
| Invalid = true; |
| } |
| } |
| |
| NonTypeTemplateParmDecl *Param; |
| if (IsExpandedParameterPack) |
| Param = NonTypeTemplateParmDecl::Create( |
| SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(), |
| D->getDepth() - TemplateArgs.getNumSubstitutedLevels(), |
| D->getPosition(), D->getIdentifier(), T, DI, ExpandedParameterPackTypes, |
| ExpandedParameterPackTypesAsWritten); |
| else |
| Param = NonTypeTemplateParmDecl::Create( |
| SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(), |
| D->getDepth() - TemplateArgs.getNumSubstitutedLevels(), |
| D->getPosition(), D->getIdentifier(), T, D->isParameterPack(), DI); |
| |
| Param->setAccess(AS_public); |
| Param->setImplicit(D->isImplicit()); |
| if (Invalid) |
| Param->setInvalidDecl(); |
| |
| if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) { |
| EnterExpressionEvaluationContext ConstantEvaluated( |
| SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated); |
| ExprResult Value = SemaRef.SubstExpr(D->getDefaultArgument(), TemplateArgs); |
| if (!Value.isInvalid()) |
| Param->setDefaultArgument(Value.get()); |
| } |
| |
| // Introduce this template parameter's instantiation into the instantiation |
| // scope. |
| SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param); |
| return Param; |
| } |
| |
| static void collectUnexpandedParameterPacks( |
| Sema &S, |
| TemplateParameterList *Params, |
| SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) { |
| for (const auto &P : *Params) { |
| if (P->isTemplateParameterPack()) |
| continue; |
| if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) |
| S.collectUnexpandedParameterPacks(NTTP->getTypeSourceInfo()->getTypeLoc(), |
| Unexpanded); |
| if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(P)) |
| collectUnexpandedParameterPacks(S, TTP->getTemplateParameters(), |
| Unexpanded); |
| } |
| } |
| |
| Decl * |
| TemplateDeclInstantiator::VisitTemplateTemplateParmDecl( |
| TemplateTemplateParmDecl *D) { |
| // Instantiate the template parameter list of the template template parameter. |
| TemplateParameterList *TempParams = D->getTemplateParameters(); |
| TemplateParameterList *InstParams; |
| SmallVector<TemplateParameterList*, 8> ExpandedParams; |
| |
| bool IsExpandedParameterPack = false; |
| |
| if (D->isExpandedParameterPack()) { |
| // The template template parameter pack is an already-expanded pack |
| // expansion of template parameters. Substitute into each of the expanded |
| // parameters. |
| ExpandedParams.reserve(D->getNumExpansionTemplateParameters()); |
| for (unsigned I = 0, N = D->getNumExpansionTemplateParameters(); |
| I != N; ++I) { |
| LocalInstantiationScope Scope(SemaRef); |
| TemplateParameterList *Expansion = |
| SubstTemplateParams(D->getExpansionTemplateParameters(I)); |
| if (!Expansion) |
| return nullptr; |
| ExpandedParams.push_back(Expansion); |
| } |
| |
| IsExpandedParameterPack = true; |
| InstParams = TempParams; |
| } else if (D->isPackExpansion()) { |
| // The template template parameter pack expands to a pack of template |
| // template parameters. Determine whether we need to expand this parameter |
| // pack into separate parameters. |
| SmallVector<UnexpandedParameterPack, 2> Unexpanded; |
| collectUnexpandedParameterPacks(SemaRef, D->getTemplateParameters(), |
| Unexpanded); |
| |
| // Determine whether the set of unexpanded parameter packs can and should |
| // be expanded. |
| bool Expand = true; |
| bool RetainExpansion = false; |
| Optional<unsigned> NumExpansions; |
| if (SemaRef.CheckParameterPacksForExpansion(D->getLocation(), |
| TempParams->getSourceRange(), |
| Unexpanded, |
| TemplateArgs, |
| Expand, RetainExpansion, |
| NumExpansions)) |
| return nullptr; |
| |
| if (Expand) { |
| for (unsigned I = 0; I != *NumExpansions; ++I) { |
| Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I); |
| LocalInstantiationScope Scope(SemaRef); |
| TemplateParameterList *Expansion = SubstTemplateParams(TempParams); |
| if (!Expansion) |
| return nullptr; |
| ExpandedParams.push_back(Expansion); |
| } |
| |
| // Note that we have an expanded parameter pack. The "type" of this |
| // expanded parameter pack is the original expansion type, but callers |
| // will end up using the expanded parameter pack types for type-checking. |
| IsExpandedParameterPack = true; |
| InstParams = TempParams; |
| } else { |
| // We cannot fully expand the pack expansion now, so just substitute |
| // into the pattern. |
| Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1); |
| |
| LocalInstantiationScope Scope(SemaRef); |
| InstParams = SubstTemplateParams(TempParams); |
| if (!InstParams) |
| return nullptr; |
| } |
| } else { |
| // Perform the actual substitution of template parameters within a new, |
| // local instantiation scope. |
| LocalInstantiationScope Scope(SemaRef); |
| InstParams = SubstTemplateParams(TempParams); |
| if (!InstParams) |
| return nullptr; |
| } |
| |
| // Build the template template parameter. |
| TemplateTemplateParmDecl *Param; |
| if (IsExpandedParameterPack) |
| Param = TemplateTemplateParmDecl::Create( |
| SemaRef.Context, Owner, D->getLocation(), |
| D->getDepth() - TemplateArgs.getNumSubstitutedLevels(), |
| D->getPosition(), D->getIdentifier(), InstParams, ExpandedParams); |
| else |
| Param = TemplateTemplateParmDecl::Create( |
| SemaRef.Context, Owner, D->getLocation(), |
| D->getDepth() - TemplateArgs.getNumSubstitutedLevels(), |
| D->getPosition(), D->isParameterPack(), D->getIdentifier(), InstParams); |
| if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) { |
| NestedNameSpecifierLoc QualifierLoc = |
| D->getDefaultArgument().getTemplateQualifierLoc(); |
| QualifierLoc = |
| SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, TemplateArgs); |
| TemplateName TName = SemaRef.SubstTemplateName( |
| QualifierLoc, D->getDefaultArgument().getArgument().getAsTemplate(), |
| D->getDefaultArgument().getTemplateNameLoc(), TemplateArgs |