1 //===--- SemaTemplateInstantiateDecl.cpp - C++ Template Decl Instantiation ===/
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //===----------------------------------------------------------------------===/
9 // This file implements C++ template instantiation for declarations.
11 //===----------------------------------------------------------------------===/
12 #include "clang/Sema/SemaInternal.h"
13 #include "clang/AST/ASTConsumer.h"
14 #include "clang/AST/ASTContext.h"
15 #include "clang/AST/ASTMutationListener.h"
16 #include "clang/AST/DeclTemplate.h"
17 #include "clang/AST/DeclVisitor.h"
18 #include "clang/AST/DependentDiagnostic.h"
19 #include "clang/AST/Expr.h"
20 #include "clang/AST/ExprCXX.h"
21 #include "clang/AST/TypeLoc.h"
22 #include "clang/Sema/Initialization.h"
23 #include "clang/Sema/Lookup.h"
24 #include "clang/Sema/PrettyDeclStackTrace.h"
25 #include "clang/Sema/Template.h"
27 using namespace clang;
29 static bool isDeclWithinFunction(const Decl *D) {
30 const DeclContext *DC = D->getDeclContext();
31 if (DC->isFunctionOrMethod())
35 return cast<CXXRecordDecl>(DC)->isLocalClass();
40 template<typename DeclT>
41 static bool SubstQualifier(Sema &SemaRef, const DeclT *OldDecl, DeclT *NewDecl,
42 const MultiLevelTemplateArgumentList &TemplateArgs) {
43 if (!OldDecl->getQualifierLoc())
46 assert((NewDecl->getFriendObjectKind() ||
47 !OldDecl->getLexicalDeclContext()->isDependentContext()) &&
48 "non-friend with qualified name defined in dependent context");
49 Sema::ContextRAII SavedContext(
51 const_cast<DeclContext *>(NewDecl->getFriendObjectKind()
52 ? NewDecl->getLexicalDeclContext()
53 : OldDecl->getLexicalDeclContext()));
55 NestedNameSpecifierLoc NewQualifierLoc
56 = SemaRef.SubstNestedNameSpecifierLoc(OldDecl->getQualifierLoc(),
62 NewDecl->setQualifierInfo(NewQualifierLoc);
66 bool TemplateDeclInstantiator::SubstQualifier(const DeclaratorDecl *OldDecl,
67 DeclaratorDecl *NewDecl) {
68 return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs);
71 bool TemplateDeclInstantiator::SubstQualifier(const TagDecl *OldDecl,
73 return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs);
76 // Include attribute instantiation code.
77 #include "clang/Sema/AttrTemplateInstantiate.inc"
79 static void instantiateDependentAlignedAttr(
80 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
81 const AlignedAttr *Aligned, Decl *New, bool IsPackExpansion) {
82 if (Aligned->isAlignmentExpr()) {
83 // The alignment expression is a constant expression.
84 EnterExpressionEvaluationContext Unevaluated(S, Sema::ConstantEvaluated);
85 ExprResult Result = S.SubstExpr(Aligned->getAlignmentExpr(), TemplateArgs);
86 if (!Result.isInvalid())
87 S.AddAlignedAttr(Aligned->getLocation(), New, Result.getAs<Expr>(),
88 Aligned->getSpellingListIndex(), IsPackExpansion);
90 TypeSourceInfo *Result = S.SubstType(Aligned->getAlignmentType(),
91 TemplateArgs, Aligned->getLocation(),
94 S.AddAlignedAttr(Aligned->getLocation(), New, Result,
95 Aligned->getSpellingListIndex(), IsPackExpansion);
99 static void instantiateDependentAlignedAttr(
100 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
101 const AlignedAttr *Aligned, Decl *New) {
102 if (!Aligned->isPackExpansion()) {
103 instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, false);
107 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
108 if (Aligned->isAlignmentExpr())
109 S.collectUnexpandedParameterPacks(Aligned->getAlignmentExpr(),
112 S.collectUnexpandedParameterPacks(Aligned->getAlignmentType()->getTypeLoc(),
114 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
116 // Determine whether we can expand this attribute pack yet.
117 bool Expand = true, RetainExpansion = false;
118 Optional<unsigned> NumExpansions;
119 // FIXME: Use the actual location of the ellipsis.
120 SourceLocation EllipsisLoc = Aligned->getLocation();
121 if (S.CheckParameterPacksForExpansion(EllipsisLoc, Aligned->getRange(),
122 Unexpanded, TemplateArgs, Expand,
123 RetainExpansion, NumExpansions))
127 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, -1);
128 instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, true);
130 for (unsigned I = 0; I != *NumExpansions; ++I) {
131 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, I);
132 instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, false);
137 static void instantiateDependentAssumeAlignedAttr(
138 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
139 const AssumeAlignedAttr *Aligned, Decl *New) {
140 // The alignment expression is a constant expression.
141 EnterExpressionEvaluationContext Unevaluated(S, Sema::ConstantEvaluated);
143 Expr *E, *OE = nullptr;
144 ExprResult Result = S.SubstExpr(Aligned->getAlignment(), TemplateArgs);
145 if (Result.isInvalid())
147 E = Result.getAs<Expr>();
149 if (Aligned->getOffset()) {
150 Result = S.SubstExpr(Aligned->getOffset(), TemplateArgs);
151 if (Result.isInvalid())
153 OE = Result.getAs<Expr>();
156 S.AddAssumeAlignedAttr(Aligned->getLocation(), New, E, OE,
157 Aligned->getSpellingListIndex());
160 static void instantiateDependentAlignValueAttr(
161 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
162 const AlignValueAttr *Aligned, Decl *New) {
163 // The alignment expression is a constant expression.
164 EnterExpressionEvaluationContext Unevaluated(S, Sema::ConstantEvaluated);
165 ExprResult Result = S.SubstExpr(Aligned->getAlignment(), TemplateArgs);
166 if (!Result.isInvalid())
167 S.AddAlignValueAttr(Aligned->getLocation(), New, Result.getAs<Expr>(),
168 Aligned->getSpellingListIndex());
171 static Expr *instantiateDependentFunctionAttrCondition(
172 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
173 const Attr *A, Expr *OldCond, const Decl *Tmpl, FunctionDecl *New) {
174 Expr *Cond = nullptr;
176 Sema::ContextRAII SwitchContext(S, New);
177 EnterExpressionEvaluationContext Unevaluated(S, Sema::ConstantEvaluated);
178 ExprResult Result = S.SubstExpr(OldCond, TemplateArgs);
179 if (Result.isInvalid())
181 Cond = Result.getAs<Expr>();
183 if (!Cond->isTypeDependent()) {
184 ExprResult Converted = S.PerformContextuallyConvertToBool(Cond);
185 if (Converted.isInvalid())
187 Cond = Converted.get();
190 SmallVector<PartialDiagnosticAt, 8> Diags;
191 if (OldCond->isValueDependent() && !Cond->isValueDependent() &&
192 !Expr::isPotentialConstantExprUnevaluated(Cond, New, Diags)) {
193 S.Diag(A->getLocation(), diag::err_attr_cond_never_constant_expr) << A;
194 for (const auto &P : Diags)
195 S.Diag(P.first, P.second);
201 static void instantiateDependentEnableIfAttr(
202 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
203 const EnableIfAttr *EIA, const Decl *Tmpl, FunctionDecl *New) {
204 Expr *Cond = instantiateDependentFunctionAttrCondition(
205 S, TemplateArgs, EIA, EIA->getCond(), Tmpl, New);
208 New->addAttr(new (S.getASTContext()) EnableIfAttr(
209 EIA->getLocation(), S.getASTContext(), Cond, EIA->getMessage(),
210 EIA->getSpellingListIndex()));
213 static void instantiateDependentDiagnoseIfAttr(
214 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
215 const DiagnoseIfAttr *DIA, const Decl *Tmpl, FunctionDecl *New) {
216 Expr *Cond = instantiateDependentFunctionAttrCondition(
217 S, TemplateArgs, DIA, DIA->getCond(), Tmpl, New);
220 New->addAttr(new (S.getASTContext()) DiagnoseIfAttr(
221 DIA->getLocation(), S.getASTContext(), Cond, DIA->getMessage(),
222 DIA->getDiagnosticType(), DIA->getArgDependent(), New,
223 DIA->getSpellingListIndex()));
226 // Constructs and adds to New a new instance of CUDALaunchBoundsAttr using
227 // template A as the base and arguments from TemplateArgs.
228 static void instantiateDependentCUDALaunchBoundsAttr(
229 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
230 const CUDALaunchBoundsAttr &Attr, Decl *New) {
231 // The alignment expression is a constant expression.
232 EnterExpressionEvaluationContext Unevaluated(S, Sema::ConstantEvaluated);
234 ExprResult Result = S.SubstExpr(Attr.getMaxThreads(), TemplateArgs);
235 if (Result.isInvalid())
237 Expr *MaxThreads = Result.getAs<Expr>();
239 Expr *MinBlocks = nullptr;
240 if (Attr.getMinBlocks()) {
241 Result = S.SubstExpr(Attr.getMinBlocks(), TemplateArgs);
242 if (Result.isInvalid())
244 MinBlocks = Result.getAs<Expr>();
247 S.AddLaunchBoundsAttr(Attr.getLocation(), New, MaxThreads, MinBlocks,
248 Attr.getSpellingListIndex());
252 instantiateDependentModeAttr(Sema &S,
253 const MultiLevelTemplateArgumentList &TemplateArgs,
254 const ModeAttr &Attr, Decl *New) {
255 S.AddModeAttr(Attr.getRange(), New, Attr.getMode(),
256 Attr.getSpellingListIndex(), /*InInstantiation=*/true);
259 /// Instantiation of 'declare simd' attribute and its arguments.
260 static void instantiateOMPDeclareSimdDeclAttr(
261 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
262 const OMPDeclareSimdDeclAttr &Attr, Decl *New) {
263 // Allow 'this' in clauses with varlists.
264 if (auto *FTD = dyn_cast<FunctionTemplateDecl>(New))
265 New = FTD->getTemplatedDecl();
266 auto *FD = cast<FunctionDecl>(New);
267 auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(FD->getDeclContext());
268 SmallVector<Expr *, 4> Uniforms, Aligneds, Alignments, Linears, Steps;
269 SmallVector<unsigned, 4> LinModifiers;
271 auto &&Subst = [&](Expr *E) -> ExprResult {
272 if (auto *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts()))
273 if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
274 Sema::ContextRAII SavedContext(S, FD);
275 LocalInstantiationScope Local(S);
276 if (FD->getNumParams() > PVD->getFunctionScopeIndex())
277 Local.InstantiatedLocal(
278 PVD, FD->getParamDecl(PVD->getFunctionScopeIndex()));
279 return S.SubstExpr(E, TemplateArgs);
281 Sema::CXXThisScopeRAII ThisScope(S, ThisContext, /*TypeQuals=*/0,
282 FD->isCXXInstanceMember());
283 return S.SubstExpr(E, TemplateArgs);
287 if (auto *E = Attr.getSimdlen())
290 if (Attr.uniforms_size() > 0) {
291 for(auto *E : Attr.uniforms()) {
292 ExprResult Inst = Subst(E);
293 if (Inst.isInvalid())
295 Uniforms.push_back(Inst.get());
299 auto AI = Attr.alignments_begin();
300 for (auto *E : Attr.aligneds()) {
301 ExprResult Inst = Subst(E);
302 if (Inst.isInvalid())
304 Aligneds.push_back(Inst.get());
307 Inst = S.SubstExpr(*AI, TemplateArgs);
308 Alignments.push_back(Inst.get());
312 auto SI = Attr.steps_begin();
313 for (auto *E : Attr.linears()) {
314 ExprResult Inst = Subst(E);
315 if (Inst.isInvalid())
317 Linears.push_back(Inst.get());
320 Inst = S.SubstExpr(*SI, TemplateArgs);
321 Steps.push_back(Inst.get());
324 LinModifiers.append(Attr.modifiers_begin(), Attr.modifiers_end());
325 (void)S.ActOnOpenMPDeclareSimdDirective(
326 S.ConvertDeclToDeclGroup(New), Attr.getBranchState(), Simdlen.get(),
327 Uniforms, Aligneds, Alignments, Linears, LinModifiers, Steps,
331 void Sema::InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs,
332 const Decl *Tmpl, Decl *New,
333 LateInstantiatedAttrVec *LateAttrs,
334 LocalInstantiationScope *OuterMostScope) {
335 for (const auto *TmplAttr : Tmpl->attrs()) {
336 // FIXME: This should be generalized to more than just the AlignedAttr.
337 const AlignedAttr *Aligned = dyn_cast<AlignedAttr>(TmplAttr);
338 if (Aligned && Aligned->isAlignmentDependent()) {
339 instantiateDependentAlignedAttr(*this, TemplateArgs, Aligned, New);
343 const AssumeAlignedAttr *AssumeAligned = dyn_cast<AssumeAlignedAttr>(TmplAttr);
345 instantiateDependentAssumeAlignedAttr(*this, TemplateArgs, AssumeAligned, New);
349 const AlignValueAttr *AlignValue = dyn_cast<AlignValueAttr>(TmplAttr);
351 instantiateDependentAlignValueAttr(*this, TemplateArgs, AlignValue, New);
355 if (const auto *EnableIf = dyn_cast<EnableIfAttr>(TmplAttr)) {
356 instantiateDependentEnableIfAttr(*this, TemplateArgs, EnableIf, Tmpl,
357 cast<FunctionDecl>(New));
361 if (const auto *DiagnoseIf = dyn_cast<DiagnoseIfAttr>(TmplAttr)) {
362 instantiateDependentDiagnoseIfAttr(*this, TemplateArgs, DiagnoseIf, Tmpl,
363 cast<FunctionDecl>(New));
367 if (const CUDALaunchBoundsAttr *CUDALaunchBounds =
368 dyn_cast<CUDALaunchBoundsAttr>(TmplAttr)) {
369 instantiateDependentCUDALaunchBoundsAttr(*this, TemplateArgs,
370 *CUDALaunchBounds, New);
374 if (const ModeAttr *Mode = dyn_cast<ModeAttr>(TmplAttr)) {
375 instantiateDependentModeAttr(*this, TemplateArgs, *Mode, New);
379 if (const auto *OMPAttr = dyn_cast<OMPDeclareSimdDeclAttr>(TmplAttr)) {
380 instantiateOMPDeclareSimdDeclAttr(*this, TemplateArgs, *OMPAttr, New);
384 // Existing DLL attribute on the instantiation takes precedence.
385 if (TmplAttr->getKind() == attr::DLLExport ||
386 TmplAttr->getKind() == attr::DLLImport) {
387 if (New->hasAttr<DLLExportAttr>() || New->hasAttr<DLLImportAttr>()) {
392 if (auto ABIAttr = dyn_cast<ParameterABIAttr>(TmplAttr)) {
393 AddParameterABIAttr(ABIAttr->getRange(), New, ABIAttr->getABI(),
394 ABIAttr->getSpellingListIndex());
398 if (isa<NSConsumedAttr>(TmplAttr) || isa<CFConsumedAttr>(TmplAttr)) {
399 AddNSConsumedAttr(TmplAttr->getRange(), New,
400 TmplAttr->getSpellingListIndex(),
401 isa<NSConsumedAttr>(TmplAttr),
402 /*template instantiation*/ true);
406 assert(!TmplAttr->isPackExpansion());
407 if (TmplAttr->isLateParsed() && LateAttrs) {
408 // Late parsed attributes must be instantiated and attached after the
409 // enclosing class has been instantiated. See Sema::InstantiateClass.
410 LocalInstantiationScope *Saved = nullptr;
411 if (CurrentInstantiationScope)
412 Saved = CurrentInstantiationScope->cloneScopes(OuterMostScope);
413 LateAttrs->push_back(LateInstantiatedAttribute(TmplAttr, Saved, New));
415 // Allow 'this' within late-parsed attributes.
416 NamedDecl *ND = dyn_cast<NamedDecl>(New);
417 CXXRecordDecl *ThisContext =
418 dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext());
419 CXXThisScopeRAII ThisScope(*this, ThisContext, /*TypeQuals*/0,
420 ND && ND->isCXXInstanceMember());
422 Attr *NewAttr = sema::instantiateTemplateAttribute(TmplAttr, Context,
423 *this, TemplateArgs);
425 New->addAttr(NewAttr);
430 /// Get the previous declaration of a declaration for the purposes of template
431 /// instantiation. If this finds a previous declaration, then the previous
432 /// declaration of the instantiation of D should be an instantiation of the
433 /// result of this function.
434 template<typename DeclT>
435 static DeclT *getPreviousDeclForInstantiation(DeclT *D) {
436 DeclT *Result = D->getPreviousDecl();
438 // If the declaration is within a class, and the previous declaration was
439 // merged from a different definition of that class, then we don't have a
440 // previous declaration for the purpose of template instantiation.
441 if (Result && isa<CXXRecordDecl>(D->getDeclContext()) &&
442 D->getLexicalDeclContext() != Result->getLexicalDeclContext())
449 TemplateDeclInstantiator::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
450 llvm_unreachable("Translation units cannot be instantiated");
454 TemplateDeclInstantiator::VisitPragmaCommentDecl(PragmaCommentDecl *D) {
455 llvm_unreachable("pragma comment cannot be instantiated");
458 Decl *TemplateDeclInstantiator::VisitPragmaDetectMismatchDecl(
459 PragmaDetectMismatchDecl *D) {
460 llvm_unreachable("pragma comment cannot be instantiated");
464 TemplateDeclInstantiator::VisitExternCContextDecl(ExternCContextDecl *D) {
465 llvm_unreachable("extern \"C\" context cannot be instantiated");
469 TemplateDeclInstantiator::VisitLabelDecl(LabelDecl *D) {
470 LabelDecl *Inst = LabelDecl::Create(SemaRef.Context, Owner, D->getLocation(),
472 Owner->addDecl(Inst);
477 TemplateDeclInstantiator::VisitNamespaceDecl(NamespaceDecl *D) {
478 llvm_unreachable("Namespaces cannot be instantiated");
482 TemplateDeclInstantiator::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
483 NamespaceAliasDecl *Inst
484 = NamespaceAliasDecl::Create(SemaRef.Context, Owner,
485 D->getNamespaceLoc(),
488 D->getQualifierLoc(),
489 D->getTargetNameLoc(),
491 Owner->addDecl(Inst);
495 Decl *TemplateDeclInstantiator::InstantiateTypedefNameDecl(TypedefNameDecl *D,
497 bool Invalid = false;
498 TypeSourceInfo *DI = D->getTypeSourceInfo();
499 if (DI->getType()->isInstantiationDependentType() ||
500 DI->getType()->isVariablyModifiedType()) {
501 DI = SemaRef.SubstType(DI, TemplateArgs,
502 D->getLocation(), D->getDeclName());
505 DI = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.Context.IntTy);
508 SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType());
511 // HACK: g++ has a bug where it gets the value kind of ?: wrong.
512 // libstdc++ relies upon this bug in its implementation of common_type.
513 // If we happen to be processing that implementation, fake up the g++ ?:
514 // semantics. See LWG issue 2141 for more information on the bug.
515 const DecltypeType *DT = DI->getType()->getAs<DecltypeType>();
516 CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
517 if (DT && RD && isa<ConditionalOperator>(DT->getUnderlyingExpr()) &&
518 DT->isReferenceType() &&
519 RD->getEnclosingNamespaceContext() == SemaRef.getStdNamespace() &&
520 RD->getIdentifier() && RD->getIdentifier()->isStr("common_type") &&
521 D->getIdentifier() && D->getIdentifier()->isStr("type") &&
522 SemaRef.getSourceManager().isInSystemHeader(D->getLocStart()))
523 // Fold it to the (non-reference) type which g++ would have produced.
524 DI = SemaRef.Context.getTrivialTypeSourceInfo(
525 DI->getType().getNonReferenceType());
527 // Create the new typedef
528 TypedefNameDecl *Typedef;
530 Typedef = TypeAliasDecl::Create(SemaRef.Context, Owner, D->getLocStart(),
531 D->getLocation(), D->getIdentifier(), DI);
533 Typedef = TypedefDecl::Create(SemaRef.Context, Owner, D->getLocStart(),
534 D->getLocation(), D->getIdentifier(), DI);
536 Typedef->setInvalidDecl();
538 // If the old typedef was the name for linkage purposes of an anonymous
539 // tag decl, re-establish that relationship for the new typedef.
540 if (const TagType *oldTagType = D->getUnderlyingType()->getAs<TagType>()) {
541 TagDecl *oldTag = oldTagType->getDecl();
542 if (oldTag->getTypedefNameForAnonDecl() == D && !Invalid) {
543 TagDecl *newTag = DI->getType()->castAs<TagType>()->getDecl();
544 assert(!newTag->hasNameForLinkage());
545 newTag->setTypedefNameForAnonDecl(Typedef);
549 if (TypedefNameDecl *Prev = getPreviousDeclForInstantiation(D)) {
550 NamedDecl *InstPrev = SemaRef.FindInstantiatedDecl(D->getLocation(), Prev,
555 TypedefNameDecl *InstPrevTypedef = cast<TypedefNameDecl>(InstPrev);
557 // If the typedef types are not identical, reject them.
558 SemaRef.isIncompatibleTypedef(InstPrevTypedef, Typedef);
560 Typedef->setPreviousDecl(InstPrevTypedef);
563 SemaRef.InstantiateAttrs(TemplateArgs, D, Typedef);
565 Typedef->setAccess(D->getAccess());
570 Decl *TemplateDeclInstantiator::VisitTypedefDecl(TypedefDecl *D) {
571 Decl *Typedef = InstantiateTypedefNameDecl(D, /*IsTypeAlias=*/false);
573 Owner->addDecl(Typedef);
577 Decl *TemplateDeclInstantiator::VisitTypeAliasDecl(TypeAliasDecl *D) {
578 Decl *Typedef = InstantiateTypedefNameDecl(D, /*IsTypeAlias=*/true);
580 Owner->addDecl(Typedef);
585 TemplateDeclInstantiator::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
586 // Create a local instantiation scope for this type alias template, which
587 // will contain the instantiations of the template parameters.
588 LocalInstantiationScope Scope(SemaRef);
590 TemplateParameterList *TempParams = D->getTemplateParameters();
591 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
595 TypeAliasDecl *Pattern = D->getTemplatedDecl();
597 TypeAliasTemplateDecl *PrevAliasTemplate = nullptr;
598 if (getPreviousDeclForInstantiation<TypedefNameDecl>(Pattern)) {
599 DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
600 if (!Found.empty()) {
601 PrevAliasTemplate = dyn_cast<TypeAliasTemplateDecl>(Found.front());
605 TypeAliasDecl *AliasInst = cast_or_null<TypeAliasDecl>(
606 InstantiateTypedefNameDecl(Pattern, /*IsTypeAlias=*/true));
610 TypeAliasTemplateDecl *Inst
611 = TypeAliasTemplateDecl::Create(SemaRef.Context, Owner, D->getLocation(),
612 D->getDeclName(), InstParams, AliasInst);
613 AliasInst->setDescribedAliasTemplate(Inst);
614 if (PrevAliasTemplate)
615 Inst->setPreviousDecl(PrevAliasTemplate);
617 Inst->setAccess(D->getAccess());
619 if (!PrevAliasTemplate)
620 Inst->setInstantiatedFromMemberTemplate(D);
622 Owner->addDecl(Inst);
627 Decl *TemplateDeclInstantiator::VisitBindingDecl(BindingDecl *D) {
628 auto *NewBD = BindingDecl::Create(SemaRef.Context, Owner, D->getLocation(),
630 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewBD);
634 Decl *TemplateDeclInstantiator::VisitDecompositionDecl(DecompositionDecl *D) {
635 // Transform the bindings first.
636 SmallVector<BindingDecl*, 16> NewBindings;
637 for (auto *OldBD : D->bindings())
638 NewBindings.push_back(cast<BindingDecl>(VisitBindingDecl(OldBD)));
639 ArrayRef<BindingDecl*> NewBindingArray = NewBindings;
641 auto *NewDD = cast_or_null<DecompositionDecl>(
642 VisitVarDecl(D, /*InstantiatingVarTemplate=*/false, &NewBindingArray));
644 if (!NewDD || NewDD->isInvalidDecl())
645 for (auto *NewBD : NewBindings)
646 NewBD->setInvalidDecl();
651 Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D) {
652 return VisitVarDecl(D, /*InstantiatingVarTemplate=*/false);
655 Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D,
656 bool InstantiatingVarTemplate,
657 ArrayRef<BindingDecl*> *Bindings) {
659 // Do substitution on the type of the declaration
660 TypeSourceInfo *DI = SemaRef.SubstType(D->getTypeSourceInfo(),
662 D->getTypeSpecStartLoc(),
667 if (DI->getType()->isFunctionType()) {
668 SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function)
669 << D->isStaticDataMember() << DI->getType();
673 DeclContext *DC = Owner;
674 if (D->isLocalExternDecl())
675 SemaRef.adjustContextForLocalExternDecl(DC);
677 // Build the instantiated declaration.
680 Var = DecompositionDecl::Create(SemaRef.Context, DC, D->getInnerLocStart(),
681 D->getLocation(), DI->getType(), DI,
682 D->getStorageClass(), *Bindings);
684 Var = VarDecl::Create(SemaRef.Context, DC, D->getInnerLocStart(),
685 D->getLocation(), D->getIdentifier(), DI->getType(),
686 DI, D->getStorageClass());
688 // In ARC, infer 'retaining' for variables of retainable type.
689 if (SemaRef.getLangOpts().ObjCAutoRefCount &&
690 SemaRef.inferObjCARCLifetime(Var))
691 Var->setInvalidDecl();
693 // Substitute the nested name specifier, if any.
694 if (SubstQualifier(D, Var))
697 SemaRef.BuildVariableInstantiation(Var, D, TemplateArgs, LateAttrs, Owner,
698 StartingScope, InstantiatingVarTemplate);
700 if (D->isNRVOVariable()) {
701 QualType ReturnType = cast<FunctionDecl>(DC)->getReturnType();
702 if (SemaRef.isCopyElisionCandidate(ReturnType, Var, false))
703 Var->setNRVOVariable(true);
706 Var->setImplicit(D->isImplicit());
711 Decl *TemplateDeclInstantiator::VisitAccessSpecDecl(AccessSpecDecl *D) {
713 = AccessSpecDecl::Create(SemaRef.Context, D->getAccess(), Owner,
714 D->getAccessSpecifierLoc(), D->getColonLoc());
715 Owner->addHiddenDecl(AD);
719 Decl *TemplateDeclInstantiator::VisitFieldDecl(FieldDecl *D) {
720 bool Invalid = false;
721 TypeSourceInfo *DI = D->getTypeSourceInfo();
722 if (DI->getType()->isInstantiationDependentType() ||
723 DI->getType()->isVariablyModifiedType()) {
724 DI = SemaRef.SubstType(DI, TemplateArgs,
725 D->getLocation(), D->getDeclName());
727 DI = D->getTypeSourceInfo();
729 } else if (DI->getType()->isFunctionType()) {
730 // C++ [temp.arg.type]p3:
731 // If a declaration acquires a function type through a type
732 // dependent on a template-parameter and this causes a
733 // declaration that does not use the syntactic form of a
734 // function declarator to have function type, the program is
736 SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function)
741 SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType());
744 Expr *BitWidth = D->getBitWidth();
748 // The bit-width expression is a constant expression.
749 EnterExpressionEvaluationContext Unevaluated(SemaRef,
750 Sema::ConstantEvaluated);
752 ExprResult InstantiatedBitWidth
753 = SemaRef.SubstExpr(BitWidth, TemplateArgs);
754 if (InstantiatedBitWidth.isInvalid()) {
758 BitWidth = InstantiatedBitWidth.getAs<Expr>();
761 FieldDecl *Field = SemaRef.CheckFieldDecl(D->getDeclName(),
763 cast<RecordDecl>(Owner),
767 D->getInClassInitStyle(),
768 D->getInnerLocStart(),
772 cast<Decl>(Owner)->setInvalidDecl();
776 SemaRef.InstantiateAttrs(TemplateArgs, D, Field, LateAttrs, StartingScope);
778 if (Field->hasAttrs())
779 SemaRef.CheckAlignasUnderalignment(Field);
782 Field->setInvalidDecl();
784 if (!Field->getDeclName()) {
785 // Keep track of where this decl came from.
786 SemaRef.Context.setInstantiatedFromUnnamedFieldDecl(Field, D);
788 if (CXXRecordDecl *Parent= dyn_cast<CXXRecordDecl>(Field->getDeclContext())) {
789 if (Parent->isAnonymousStructOrUnion() &&
790 Parent->getRedeclContext()->isFunctionOrMethod())
791 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Field);
794 Field->setImplicit(D->isImplicit());
795 Field->setAccess(D->getAccess());
796 Owner->addDecl(Field);
801 Decl *TemplateDeclInstantiator::VisitMSPropertyDecl(MSPropertyDecl *D) {
802 bool Invalid = false;
803 TypeSourceInfo *DI = D->getTypeSourceInfo();
805 if (DI->getType()->isVariablyModifiedType()) {
806 SemaRef.Diag(D->getLocation(), diag::err_property_is_variably_modified)
809 } else if (DI->getType()->isInstantiationDependentType()) {
810 DI = SemaRef.SubstType(DI, TemplateArgs,
811 D->getLocation(), D->getDeclName());
813 DI = D->getTypeSourceInfo();
815 } else if (DI->getType()->isFunctionType()) {
816 // C++ [temp.arg.type]p3:
817 // If a declaration acquires a function type through a type
818 // dependent on a template-parameter and this causes a
819 // declaration that does not use the syntactic form of a
820 // function declarator to have function type, the program is
822 SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function)
827 SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType());
830 MSPropertyDecl *Property = MSPropertyDecl::Create(
831 SemaRef.Context, Owner, D->getLocation(), D->getDeclName(), DI->getType(),
832 DI, D->getLocStart(), D->getGetterId(), D->getSetterId());
834 SemaRef.InstantiateAttrs(TemplateArgs, D, Property, LateAttrs,
838 Property->setInvalidDecl();
840 Property->setAccess(D->getAccess());
841 Owner->addDecl(Property);
846 Decl *TemplateDeclInstantiator::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
847 NamedDecl **NamedChain =
848 new (SemaRef.Context)NamedDecl*[D->getChainingSize()];
851 for (auto *PI : D->chain()) {
852 NamedDecl *Next = SemaRef.FindInstantiatedDecl(D->getLocation(), PI,
857 NamedChain[i++] = Next;
860 QualType T = cast<FieldDecl>(NamedChain[i-1])->getType();
861 IndirectFieldDecl *IndirectField = IndirectFieldDecl::Create(
862 SemaRef.Context, Owner, D->getLocation(), D->getIdentifier(), T,
863 {NamedChain, D->getChainingSize()});
865 for (const auto *Attr : D->attrs())
866 IndirectField->addAttr(Attr->clone(SemaRef.Context));
868 IndirectField->setImplicit(D->isImplicit());
869 IndirectField->setAccess(D->getAccess());
870 Owner->addDecl(IndirectField);
871 return IndirectField;
874 Decl *TemplateDeclInstantiator::VisitFriendDecl(FriendDecl *D) {
875 // Handle friend type expressions by simply substituting template
876 // parameters into the pattern type and checking the result.
877 if (TypeSourceInfo *Ty = D->getFriendType()) {
878 TypeSourceInfo *InstTy;
879 // If this is an unsupported friend, don't bother substituting template
880 // arguments into it. The actual type referred to won't be used by any
881 // parts of Clang, and may not be valid for instantiating. Just use the
882 // same info for the instantiated friend.
883 if (D->isUnsupportedFriend()) {
886 InstTy = SemaRef.SubstType(Ty, TemplateArgs,
887 D->getLocation(), DeclarationName());
892 FriendDecl *FD = SemaRef.CheckFriendTypeDecl(D->getLocStart(),
893 D->getFriendLoc(), InstTy);
897 FD->setAccess(AS_public);
898 FD->setUnsupportedFriend(D->isUnsupportedFriend());
903 NamedDecl *ND = D->getFriendDecl();
904 assert(ND && "friend decl must be a decl or a type!");
906 // All of the Visit implementations for the various potential friend
907 // declarations have to be carefully written to work for friend
908 // objects, with the most important detail being that the target
909 // decl should almost certainly not be placed in Owner.
910 Decl *NewND = Visit(ND);
911 if (!NewND) return nullptr;
914 FriendDecl::Create(SemaRef.Context, Owner, D->getLocation(),
915 cast<NamedDecl>(NewND), D->getFriendLoc());
916 FD->setAccess(AS_public);
917 FD->setUnsupportedFriend(D->isUnsupportedFriend());
922 Decl *TemplateDeclInstantiator::VisitStaticAssertDecl(StaticAssertDecl *D) {
923 Expr *AssertExpr = D->getAssertExpr();
925 // The expression in a static assertion is a constant expression.
926 EnterExpressionEvaluationContext Unevaluated(SemaRef,
927 Sema::ConstantEvaluated);
929 ExprResult InstantiatedAssertExpr
930 = SemaRef.SubstExpr(AssertExpr, TemplateArgs);
931 if (InstantiatedAssertExpr.isInvalid())
934 return SemaRef.BuildStaticAssertDeclaration(D->getLocation(),
935 InstantiatedAssertExpr.get(),
941 Decl *TemplateDeclInstantiator::VisitEnumDecl(EnumDecl *D) {
942 EnumDecl *PrevDecl = nullptr;
943 if (EnumDecl *PatternPrev = getPreviousDeclForInstantiation(D)) {
944 NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(),
947 if (!Prev) return nullptr;
948 PrevDecl = cast<EnumDecl>(Prev);
951 EnumDecl *Enum = EnumDecl::Create(SemaRef.Context, Owner, D->getLocStart(),
952 D->getLocation(), D->getIdentifier(),
953 PrevDecl, D->isScoped(),
954 D->isScopedUsingClassTag(), D->isFixed());
956 if (TypeSourceInfo *TI = D->getIntegerTypeSourceInfo()) {
957 // If we have type source information for the underlying type, it means it
958 // has been explicitly set by the user. Perform substitution on it before
960 SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
961 TypeSourceInfo *NewTI = SemaRef.SubstType(TI, TemplateArgs, UnderlyingLoc,
963 if (!NewTI || SemaRef.CheckEnumUnderlyingType(NewTI))
964 Enum->setIntegerType(SemaRef.Context.IntTy);
966 Enum->setIntegerTypeSourceInfo(NewTI);
968 assert(!D->getIntegerType()->isDependentType()
969 && "Dependent type without type source info");
970 Enum->setIntegerType(D->getIntegerType());
974 SemaRef.InstantiateAttrs(TemplateArgs, D, Enum);
976 Enum->setInstantiationOfMemberEnum(D, TSK_ImplicitInstantiation);
977 Enum->setAccess(D->getAccess());
978 // Forward the mangling number from the template to the instantiated decl.
979 SemaRef.Context.setManglingNumber(Enum, SemaRef.Context.getManglingNumber(D));
980 // See if the old tag was defined along with a declarator.
981 // If it did, mark the new tag as being associated with that declarator.
982 if (DeclaratorDecl *DD = SemaRef.Context.getDeclaratorForUnnamedTagDecl(D))
983 SemaRef.Context.addDeclaratorForUnnamedTagDecl(Enum, DD);
984 // See if the old tag was defined along with a typedef.
985 // If it did, mark the new tag as being associated with that typedef.
986 if (TypedefNameDecl *TND = SemaRef.Context.getTypedefNameForUnnamedTagDecl(D))
987 SemaRef.Context.addTypedefNameForUnnamedTagDecl(Enum, TND);
988 if (SubstQualifier(D, Enum)) return nullptr;
989 Owner->addDecl(Enum);
991 EnumDecl *Def = D->getDefinition();
992 if (Def && Def != D) {
993 // If this is an out-of-line definition of an enum member template, check
994 // that the underlying types match in the instantiation of both
996 if (TypeSourceInfo *TI = Def->getIntegerTypeSourceInfo()) {
997 SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
998 QualType DefnUnderlying =
999 SemaRef.SubstType(TI->getType(), TemplateArgs,
1000 UnderlyingLoc, DeclarationName());
1001 SemaRef.CheckEnumRedeclaration(Def->getLocation(), Def->isScoped(),
1003 /*EnumUnderlyingIsImplicit=*/false, Enum);
1007 // C++11 [temp.inst]p1: The implicit instantiation of a class template
1008 // specialization causes the implicit instantiation of the declarations, but
1009 // not the definitions of scoped member enumerations.
1011 // DR1484 clarifies that enumeration definitions inside of a template
1012 // declaration aren't considered entities that can be separately instantiated
1013 // from the rest of the entity they are declared inside of.
1014 if (isDeclWithinFunction(D) ? D == Def : Def && !Enum->isScoped()) {
1015 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Enum);
1016 InstantiateEnumDefinition(Enum, Def);
1022 void TemplateDeclInstantiator::InstantiateEnumDefinition(
1023 EnumDecl *Enum, EnumDecl *Pattern) {
1024 Enum->startDefinition();
1026 // Update the location to refer to the definition.
1027 Enum->setLocation(Pattern->getLocation());
1029 SmallVector<Decl*, 4> Enumerators;
1031 EnumConstantDecl *LastEnumConst = nullptr;
1032 for (auto *EC : Pattern->enumerators()) {
1033 // The specified value for the enumerator.
1034 ExprResult Value((Expr *)nullptr);
1035 if (Expr *UninstValue = EC->getInitExpr()) {
1036 // The enumerator's value expression is a constant expression.
1037 EnterExpressionEvaluationContext Unevaluated(SemaRef,
1038 Sema::ConstantEvaluated);
1040 Value = SemaRef.SubstExpr(UninstValue, TemplateArgs);
1043 // Drop the initial value and continue.
1044 bool isInvalid = false;
1045 if (Value.isInvalid()) {
1050 EnumConstantDecl *EnumConst
1051 = SemaRef.CheckEnumConstant(Enum, LastEnumConst,
1052 EC->getLocation(), EC->getIdentifier(),
1057 EnumConst->setInvalidDecl();
1058 Enum->setInvalidDecl();
1062 SemaRef.InstantiateAttrs(TemplateArgs, EC, EnumConst);
1064 EnumConst->setAccess(Enum->getAccess());
1065 Enum->addDecl(EnumConst);
1066 Enumerators.push_back(EnumConst);
1067 LastEnumConst = EnumConst;
1069 if (Pattern->getDeclContext()->isFunctionOrMethod() &&
1070 !Enum->isScoped()) {
1071 // If the enumeration is within a function or method, record the enum
1072 // constant as a local.
1073 SemaRef.CurrentInstantiationScope->InstantiatedLocal(EC, EnumConst);
1078 SemaRef.ActOnEnumBody(Enum->getLocation(), Enum->getBraceRange(), Enum,
1083 Decl *TemplateDeclInstantiator::VisitEnumConstantDecl(EnumConstantDecl *D) {
1084 llvm_unreachable("EnumConstantDecls can only occur within EnumDecls.");
1088 TemplateDeclInstantiator::VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D) {
1089 llvm_unreachable("BuiltinTemplateDecls cannot be instantiated.");
1092 Decl *TemplateDeclInstantiator::VisitClassTemplateDecl(ClassTemplateDecl *D) {
1093 bool isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
1095 // Create a local instantiation scope for this class template, which
1096 // will contain the instantiations of the template parameters.
1097 LocalInstantiationScope Scope(SemaRef);
1098 TemplateParameterList *TempParams = D->getTemplateParameters();
1099 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
1103 CXXRecordDecl *Pattern = D->getTemplatedDecl();
1105 // Instantiate the qualifier. We have to do this first in case
1106 // we're a friend declaration, because if we are then we need to put
1107 // the new declaration in the appropriate context.
1108 NestedNameSpecifierLoc QualifierLoc = Pattern->getQualifierLoc();
1110 QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
1116 CXXRecordDecl *PrevDecl = nullptr;
1117 ClassTemplateDecl *PrevClassTemplate = nullptr;
1119 if (!isFriend && getPreviousDeclForInstantiation(Pattern)) {
1120 DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
1121 if (!Found.empty()) {
1122 PrevClassTemplate = dyn_cast<ClassTemplateDecl>(Found.front());
1123 if (PrevClassTemplate)
1124 PrevDecl = PrevClassTemplate->getTemplatedDecl();
1128 // If this isn't a friend, then it's a member template, in which
1129 // case we just want to build the instantiation in the
1130 // specialization. If it is a friend, we want to build it in
1131 // the appropriate context.
1132 DeclContext *DC = Owner;
1136 SS.Adopt(QualifierLoc);
1137 DC = SemaRef.computeDeclContext(SS);
1138 if (!DC) return nullptr;
1140 DC = SemaRef.FindInstantiatedContext(Pattern->getLocation(),
1141 Pattern->getDeclContext(),
1145 // Look for a previous declaration of the template in the owning
1147 LookupResult R(SemaRef, Pattern->getDeclName(), Pattern->getLocation(),
1148 Sema::LookupOrdinaryName, Sema::ForRedeclaration);
1149 SemaRef.LookupQualifiedName(R, DC);
1151 if (R.isSingleResult()) {
1152 PrevClassTemplate = R.getAsSingle<ClassTemplateDecl>();
1153 if (PrevClassTemplate)
1154 PrevDecl = PrevClassTemplate->getTemplatedDecl();
1157 if (!PrevClassTemplate && QualifierLoc) {
1158 SemaRef.Diag(Pattern->getLocation(), diag::err_not_tag_in_scope)
1159 << D->getTemplatedDecl()->getTagKind() << Pattern->getDeclName() << DC
1160 << QualifierLoc.getSourceRange();
1164 bool AdoptedPreviousTemplateParams = false;
1165 if (PrevClassTemplate) {
1166 bool Complain = true;
1168 // HACK: libstdc++ 4.2.1 contains an ill-formed friend class
1169 // template for struct std::tr1::__detail::_Map_base, where the
1170 // template parameters of the friend declaration don't match the
1171 // template parameters of the original declaration. In this one
1172 // case, we don't complain about the ill-formed friend
1174 if (isFriend && Pattern->getIdentifier() &&
1175 Pattern->getIdentifier()->isStr("_Map_base") &&
1176 DC->isNamespace() &&
1177 cast<NamespaceDecl>(DC)->getIdentifier() &&
1178 cast<NamespaceDecl>(DC)->getIdentifier()->isStr("__detail")) {
1179 DeclContext *DCParent = DC->getParent();
1180 if (DCParent->isNamespace() &&
1181 cast<NamespaceDecl>(DCParent)->getIdentifier() &&
1182 cast<NamespaceDecl>(DCParent)->getIdentifier()->isStr("tr1")) {
1183 if (cast<Decl>(DCParent)->isInStdNamespace())
1188 TemplateParameterList *PrevParams
1189 = PrevClassTemplate->getTemplateParameters();
1191 // Make sure the parameter lists match.
1192 if (!SemaRef.TemplateParameterListsAreEqual(InstParams, PrevParams,
1194 Sema::TPL_TemplateMatch)) {
1198 AdoptedPreviousTemplateParams = true;
1199 InstParams = PrevParams;
1202 // Do some additional validation, then merge default arguments
1203 // from the existing declarations.
1204 if (!AdoptedPreviousTemplateParams &&
1205 SemaRef.CheckTemplateParameterList(InstParams, PrevParams,
1206 Sema::TPC_ClassTemplate))
1211 CXXRecordDecl *RecordInst
1212 = CXXRecordDecl::Create(SemaRef.Context, Pattern->getTagKind(), DC,
1213 Pattern->getLocStart(), Pattern->getLocation(),
1214 Pattern->getIdentifier(), PrevDecl,
1215 /*DelayTypeCreation=*/true);
1218 RecordInst->setQualifierInfo(QualifierLoc);
1220 ClassTemplateDecl *Inst
1221 = ClassTemplateDecl::Create(SemaRef.Context, DC, D->getLocation(),
1222 D->getIdentifier(), InstParams, RecordInst);
1223 assert(!(isFriend && Owner->isDependentContext()));
1224 Inst->setPreviousDecl(PrevClassTemplate);
1226 RecordInst->setDescribedClassTemplate(Inst);
1229 if (PrevClassTemplate)
1230 Inst->setAccess(PrevClassTemplate->getAccess());
1232 Inst->setAccess(D->getAccess());
1234 Inst->setObjectOfFriendDecl();
1235 // TODO: do we want to track the instantiation progeny of this
1236 // friend target decl?
1238 Inst->setAccess(D->getAccess());
1239 if (!PrevClassTemplate)
1240 Inst->setInstantiatedFromMemberTemplate(D);
1243 // Trigger creation of the type for the instantiation.
1244 SemaRef.Context.getInjectedClassNameType(RecordInst,
1245 Inst->getInjectedClassNameSpecialization());
1247 // Finish handling of friends.
1249 DC->makeDeclVisibleInContext(Inst);
1250 Inst->setLexicalDeclContext(Owner);
1251 RecordInst->setLexicalDeclContext(Owner);
1255 if (D->isOutOfLine()) {
1256 Inst->setLexicalDeclContext(D->getLexicalDeclContext());
1257 RecordInst->setLexicalDeclContext(D->getLexicalDeclContext());
1260 Owner->addDecl(Inst);
1262 if (!PrevClassTemplate) {
1263 // Queue up any out-of-line partial specializations of this member
1264 // class template; the client will force their instantiation once
1265 // the enclosing class has been instantiated.
1266 SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs;
1267 D->getPartialSpecializations(PartialSpecs);
1268 for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
1269 if (PartialSpecs[I]->getFirstDecl()->isOutOfLine())
1270 OutOfLinePartialSpecs.push_back(std::make_pair(Inst, PartialSpecs[I]));
1277 TemplateDeclInstantiator::VisitClassTemplatePartialSpecializationDecl(
1278 ClassTemplatePartialSpecializationDecl *D) {
1279 ClassTemplateDecl *ClassTemplate = D->getSpecializedTemplate();
1281 // Lookup the already-instantiated declaration in the instantiation
1282 // of the class template and return that.
1283 DeclContext::lookup_result Found
1284 = Owner->lookup(ClassTemplate->getDeclName());
1288 ClassTemplateDecl *InstClassTemplate
1289 = dyn_cast<ClassTemplateDecl>(Found.front());
1290 if (!InstClassTemplate)
1293 if (ClassTemplatePartialSpecializationDecl *Result
1294 = InstClassTemplate->findPartialSpecInstantiatedFromMember(D))
1297 return InstantiateClassTemplatePartialSpecialization(InstClassTemplate, D);
1300 Decl *TemplateDeclInstantiator::VisitVarTemplateDecl(VarTemplateDecl *D) {
1301 assert(D->getTemplatedDecl()->isStaticDataMember() &&
1302 "Only static data member templates are allowed.");
1304 // Create a local instantiation scope for this variable template, which
1305 // will contain the instantiations of the template parameters.
1306 LocalInstantiationScope Scope(SemaRef);
1307 TemplateParameterList *TempParams = D->getTemplateParameters();
1308 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
1312 VarDecl *Pattern = D->getTemplatedDecl();
1313 VarTemplateDecl *PrevVarTemplate = nullptr;
1315 if (getPreviousDeclForInstantiation(Pattern)) {
1316 DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
1318 PrevVarTemplate = dyn_cast<VarTemplateDecl>(Found.front());
1322 cast_or_null<VarDecl>(VisitVarDecl(Pattern,
1323 /*InstantiatingVarTemplate=*/true));
1324 if (!VarInst) return nullptr;
1326 DeclContext *DC = Owner;
1328 VarTemplateDecl *Inst = VarTemplateDecl::Create(
1329 SemaRef.Context, DC, D->getLocation(), D->getIdentifier(), InstParams,
1331 VarInst->setDescribedVarTemplate(Inst);
1332 Inst->setPreviousDecl(PrevVarTemplate);
1334 Inst->setAccess(D->getAccess());
1335 if (!PrevVarTemplate)
1336 Inst->setInstantiatedFromMemberTemplate(D);
1338 if (D->isOutOfLine()) {
1339 Inst->setLexicalDeclContext(D->getLexicalDeclContext());
1340 VarInst->setLexicalDeclContext(D->getLexicalDeclContext());
1343 Owner->addDecl(Inst);
1345 if (!PrevVarTemplate) {
1346 // Queue up any out-of-line partial specializations of this member
1347 // variable template; the client will force their instantiation once
1348 // the enclosing class has been instantiated.
1349 SmallVector<VarTemplatePartialSpecializationDecl *, 4> PartialSpecs;
1350 D->getPartialSpecializations(PartialSpecs);
1351 for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
1352 if (PartialSpecs[I]->getFirstDecl()->isOutOfLine())
1353 OutOfLineVarPartialSpecs.push_back(
1354 std::make_pair(Inst, PartialSpecs[I]));
1360 Decl *TemplateDeclInstantiator::VisitVarTemplatePartialSpecializationDecl(
1361 VarTemplatePartialSpecializationDecl *D) {
1362 assert(D->isStaticDataMember() &&
1363 "Only static data member templates are allowed.");
1365 VarTemplateDecl *VarTemplate = D->getSpecializedTemplate();
1367 // Lookup the already-instantiated declaration and return that.
1368 DeclContext::lookup_result Found = Owner->lookup(VarTemplate->getDeclName());
1369 assert(!Found.empty() && "Instantiation found nothing?");
1371 VarTemplateDecl *InstVarTemplate = dyn_cast<VarTemplateDecl>(Found.front());
1372 assert(InstVarTemplate && "Instantiation did not find a variable template?");
1374 if (VarTemplatePartialSpecializationDecl *Result =
1375 InstVarTemplate->findPartialSpecInstantiatedFromMember(D))
1378 return InstantiateVarTemplatePartialSpecialization(InstVarTemplate, D);
1382 TemplateDeclInstantiator::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
1383 // Create a local instantiation scope for this function template, which
1384 // will contain the instantiations of the template parameters and then get
1385 // merged with the local instantiation scope for the function template
1387 LocalInstantiationScope Scope(SemaRef);
1389 TemplateParameterList *TempParams = D->getTemplateParameters();
1390 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
1394 FunctionDecl *Instantiated = nullptr;
1395 if (CXXMethodDecl *DMethod = dyn_cast<CXXMethodDecl>(D->getTemplatedDecl()))
1396 Instantiated = cast_or_null<FunctionDecl>(VisitCXXMethodDecl(DMethod,
1399 Instantiated = cast_or_null<FunctionDecl>(VisitFunctionDecl(
1400 D->getTemplatedDecl(),
1406 // Link the instantiated function template declaration to the function
1407 // template from which it was instantiated.
1408 FunctionTemplateDecl *InstTemplate
1409 = Instantiated->getDescribedFunctionTemplate();
1410 InstTemplate->setAccess(D->getAccess());
1411 assert(InstTemplate &&
1412 "VisitFunctionDecl/CXXMethodDecl didn't create a template!");
1414 bool isFriend = (InstTemplate->getFriendObjectKind() != Decl::FOK_None);
1416 // Link the instantiation back to the pattern *unless* this is a
1417 // non-definition friend declaration.
1418 if (!InstTemplate->getInstantiatedFromMemberTemplate() &&
1419 !(isFriend && !D->getTemplatedDecl()->isThisDeclarationADefinition()))
1420 InstTemplate->setInstantiatedFromMemberTemplate(D);
1422 // Make declarations visible in the appropriate context.
1424 Owner->addDecl(InstTemplate);
1425 } else if (InstTemplate->getDeclContext()->isRecord() &&
1426 !getPreviousDeclForInstantiation(D)) {
1427 SemaRef.CheckFriendAccess(InstTemplate);
1430 return InstTemplate;
1433 Decl *TemplateDeclInstantiator::VisitCXXRecordDecl(CXXRecordDecl *D) {
1434 CXXRecordDecl *PrevDecl = nullptr;
1435 if (D->isInjectedClassName())
1436 PrevDecl = cast<CXXRecordDecl>(Owner);
1437 else if (CXXRecordDecl *PatternPrev = getPreviousDeclForInstantiation(D)) {
1438 NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(),
1441 if (!Prev) return nullptr;
1442 PrevDecl = cast<CXXRecordDecl>(Prev);
1445 CXXRecordDecl *Record
1446 = CXXRecordDecl::Create(SemaRef.Context, D->getTagKind(), Owner,
1447 D->getLocStart(), D->getLocation(),
1448 D->getIdentifier(), PrevDecl);
1450 // Substitute the nested name specifier, if any.
1451 if (SubstQualifier(D, Record))
1454 Record->setImplicit(D->isImplicit());
1455 // FIXME: Check against AS_none is an ugly hack to work around the issue that
1456 // the tag decls introduced by friend class declarations don't have an access
1457 // specifier. Remove once this area of the code gets sorted out.
1458 if (D->getAccess() != AS_none)
1459 Record->setAccess(D->getAccess());
1460 if (!D->isInjectedClassName())
1461 Record->setInstantiationOfMemberClass(D, TSK_ImplicitInstantiation);
1463 // If the original function was part of a friend declaration,
1464 // inherit its namespace state.
1465 if (D->getFriendObjectKind())
1466 Record->setObjectOfFriendDecl();
1468 // Make sure that anonymous structs and unions are recorded.
1469 if (D->isAnonymousStructOrUnion())
1470 Record->setAnonymousStructOrUnion(true);
1472 if (D->isLocalClass())
1473 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Record);
1475 // Forward the mangling number from the template to the instantiated decl.
1476 SemaRef.Context.setManglingNumber(Record,
1477 SemaRef.Context.getManglingNumber(D));
1479 // See if the old tag was defined along with a declarator.
1480 // If it did, mark the new tag as being associated with that declarator.
1481 if (DeclaratorDecl *DD = SemaRef.Context.getDeclaratorForUnnamedTagDecl(D))
1482 SemaRef.Context.addDeclaratorForUnnamedTagDecl(Record, DD);
1484 // See if the old tag was defined along with a typedef.
1485 // If it did, mark the new tag as being associated with that typedef.
1486 if (TypedefNameDecl *TND = SemaRef.Context.getTypedefNameForUnnamedTagDecl(D))
1487 SemaRef.Context.addTypedefNameForUnnamedTagDecl(Record, TND);
1489 Owner->addDecl(Record);
1491 // DR1484 clarifies that the members of a local class are instantiated as part
1492 // of the instantiation of their enclosing entity.
1493 if (D->isCompleteDefinition() && D->isLocalClass()) {
1494 Sema::SavePendingLocalImplicitInstantiationsRAII
1495 SavedPendingLocalImplicitInstantiations(SemaRef);
1497 SemaRef.InstantiateClass(D->getLocation(), Record, D, TemplateArgs,
1498 TSK_ImplicitInstantiation,
1501 // For nested local classes, we will instantiate the members when we
1502 // reach the end of the outermost (non-nested) local class.
1503 if (!D->isCXXClassMember())
1504 SemaRef.InstantiateClassMembers(D->getLocation(), Record, TemplateArgs,
1505 TSK_ImplicitInstantiation);
1507 // This class may have local implicit instantiations that need to be
1508 // performed within this scope.
1509 SemaRef.PerformPendingInstantiations(/*LocalOnly=*/true);
1512 SemaRef.DiagnoseUnusedNestedTypedefs(Record);
1517 /// \brief Adjust the given function type for an instantiation of the
1518 /// given declaration, to cope with modifications to the function's type that
1519 /// aren't reflected in the type-source information.
1521 /// \param D The declaration we're instantiating.
1522 /// \param TInfo The already-instantiated type.
1523 static QualType adjustFunctionTypeForInstantiation(ASTContext &Context,
1525 TypeSourceInfo *TInfo) {
1526 const FunctionProtoType *OrigFunc
1527 = D->getType()->castAs<FunctionProtoType>();
1528 const FunctionProtoType *NewFunc
1529 = TInfo->getType()->castAs<FunctionProtoType>();
1530 if (OrigFunc->getExtInfo() == NewFunc->getExtInfo())
1531 return TInfo->getType();
1533 FunctionProtoType::ExtProtoInfo NewEPI = NewFunc->getExtProtoInfo();
1534 NewEPI.ExtInfo = OrigFunc->getExtInfo();
1535 return Context.getFunctionType(NewFunc->getReturnType(),
1536 NewFunc->getParamTypes(), NewEPI);
1539 /// Normal class members are of more specific types and therefore
1540 /// don't make it here. This function serves two purposes:
1541 /// 1) instantiating function templates
1542 /// 2) substituting friend declarations
1543 Decl *TemplateDeclInstantiator::VisitFunctionDecl(FunctionDecl *D,
1544 TemplateParameterList *TemplateParams) {
1545 // Check whether there is already a function template specialization for
1546 // this declaration.
1547 FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate();
1548 if (FunctionTemplate && !TemplateParams) {
1549 ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
1551 void *InsertPos = nullptr;
1552 FunctionDecl *SpecFunc
1553 = FunctionTemplate->findSpecialization(Innermost, InsertPos);
1555 // If we already have a function template specialization, return it.
1561 if (FunctionTemplate)
1562 isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None);
1564 isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
1566 bool MergeWithParentScope = (TemplateParams != nullptr) ||
1567 Owner->isFunctionOrMethod() ||
1568 !(isa<Decl>(Owner) &&
1569 cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
1570 LocalInstantiationScope Scope(SemaRef, MergeWithParentScope);
1572 SmallVector<ParmVarDecl *, 4> Params;
1573 TypeSourceInfo *TInfo = SubstFunctionType(D, Params);
1576 QualType T = adjustFunctionTypeForInstantiation(SemaRef.Context, D, TInfo);
1578 NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
1580 QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
1586 // If we're instantiating a local function declaration, put the result
1587 // in the enclosing namespace; otherwise we need to find the instantiated
1590 if (D->isLocalExternDecl()) {
1592 SemaRef.adjustContextForLocalExternDecl(DC);
1593 } else if (isFriend && QualifierLoc) {
1595 SS.Adopt(QualifierLoc);
1596 DC = SemaRef.computeDeclContext(SS);
1597 if (!DC) return nullptr;
1599 DC = SemaRef.FindInstantiatedContext(D->getLocation(), D->getDeclContext(),
1603 FunctionDecl *Function =
1604 FunctionDecl::Create(SemaRef.Context, DC, D->getInnerLocStart(),
1605 D->getNameInfo(), T, TInfo,
1606 D->getCanonicalDecl()->getStorageClass(),
1607 D->isInlineSpecified(), D->hasWrittenPrototype(),
1609 Function->setRangeEnd(D->getSourceRange().getEnd());
1612 Function->setImplicitlyInline();
1615 Function->setQualifierInfo(QualifierLoc);
1617 if (D->isLocalExternDecl())
1618 Function->setLocalExternDecl();
1620 DeclContext *LexicalDC = Owner;
1621 if (!isFriend && D->isOutOfLine() && !D->isLocalExternDecl()) {
1622 assert(D->getDeclContext()->isFileContext());
1623 LexicalDC = D->getDeclContext();
1626 Function->setLexicalDeclContext(LexicalDC);
1628 // Attach the parameters
1629 for (unsigned P = 0; P < Params.size(); ++P)
1631 Params[P]->setOwningFunction(Function);
1632 Function->setParams(Params);
1634 SourceLocation InstantiateAtPOI;
1635 if (TemplateParams) {
1636 // Our resulting instantiation is actually a function template, since we
1637 // are substituting only the outer template parameters. For example, given
1639 // template<typename T>
1641 // template<typename U> friend void f(T, U);
1646 // We are instantiating the friend function template "f" within X<int>,
1647 // which means substituting int for T, but leaving "f" as a friend function
1649 // Build the function template itself.
1650 FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, DC,
1651 Function->getLocation(),
1652 Function->getDeclName(),
1653 TemplateParams, Function);
1654 Function->setDescribedFunctionTemplate(FunctionTemplate);
1656 FunctionTemplate->setLexicalDeclContext(LexicalDC);
1658 if (isFriend && D->isThisDeclarationADefinition()) {
1659 // TODO: should we remember this connection regardless of whether
1660 // the friend declaration provided a body?
1661 FunctionTemplate->setInstantiatedFromMemberTemplate(
1662 D->getDescribedFunctionTemplate());
1664 } else if (FunctionTemplate) {
1665 // Record this function template specialization.
1666 ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
1667 Function->setFunctionTemplateSpecialization(FunctionTemplate,
1668 TemplateArgumentList::CreateCopy(SemaRef.Context,
1670 /*InsertPos=*/nullptr);
1671 } else if (isFriend) {
1672 // Note, we need this connection even if the friend doesn't have a body.
1673 // Its body may exist but not have been attached yet due to deferred
1675 // FIXME: It might be cleaner to set this when attaching the body to the
1676 // friend function declaration, however that would require finding all the
1677 // instantiations and modifying them.
1678 Function->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation);
1681 if (InitFunctionInstantiation(Function, D))
1682 Function->setInvalidDecl();
1684 bool isExplicitSpecialization = false;
1686 LookupResult Previous(
1687 SemaRef, Function->getDeclName(), SourceLocation(),
1688 D->isLocalExternDecl() ? Sema::LookupRedeclarationWithLinkage
1689 : Sema::LookupOrdinaryName,
1690 Sema::ForRedeclaration);
1692 if (DependentFunctionTemplateSpecializationInfo *Info
1693 = D->getDependentSpecializationInfo()) {
1694 assert(isFriend && "non-friend has dependent specialization info?");
1696 // This needs to be set now for future sanity.
1697 Function->setObjectOfFriendDecl();
1699 // Instantiate the explicit template arguments.
1700 TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(),
1701 Info->getRAngleLoc());
1702 if (SemaRef.Subst(Info->getTemplateArgs(), Info->getNumTemplateArgs(),
1703 ExplicitArgs, TemplateArgs))
1706 // Map the candidate templates to their instantiations.
1707 for (unsigned I = 0, E = Info->getNumTemplates(); I != E; ++I) {
1708 Decl *Temp = SemaRef.FindInstantiatedDecl(D->getLocation(),
1709 Info->getTemplate(I),
1711 if (!Temp) return nullptr;
1713 Previous.addDecl(cast<FunctionTemplateDecl>(Temp));
1716 if (SemaRef.CheckFunctionTemplateSpecialization(Function,
1719 Function->setInvalidDecl();
1721 isExplicitSpecialization = true;
1723 } else if (TemplateParams || !FunctionTemplate) {
1724 // Look only into the namespace where the friend would be declared to
1725 // find a previous declaration. This is the innermost enclosing namespace,
1726 // as described in ActOnFriendFunctionDecl.
1727 SemaRef.LookupQualifiedName(Previous, DC);
1729 // In C++, the previous declaration we find might be a tag type
1730 // (class or enum). In this case, the new declaration will hide the
1731 // tag type. Note that this does does not apply if we're declaring a
1732 // typedef (C++ [dcl.typedef]p4).
1733 if (Previous.isSingleTagDecl())
1737 SemaRef.CheckFunctionDeclaration(/*Scope*/ nullptr, Function, Previous,
1738 isExplicitSpecialization);
1740 NamedDecl *PrincipalDecl = (TemplateParams
1741 ? cast<NamedDecl>(FunctionTemplate)
1744 // If the original function was part of a friend declaration,
1745 // inherit its namespace state and add it to the owner.
1747 PrincipalDecl->setObjectOfFriendDecl();
1748 DC->makeDeclVisibleInContext(PrincipalDecl);
1750 bool QueuedInstantiation = false;
1752 // C++11 [temp.friend]p4 (DR329):
1753 // When a function is defined in a friend function declaration in a class
1754 // template, the function is instantiated when the function is odr-used.
1755 // The same restrictions on multiple declarations and definitions that
1756 // apply to non-template function declarations and definitions also apply
1757 // to these implicit definitions.
1758 if (D->isThisDeclarationADefinition()) {
1759 // Check for a function body.
1760 const FunctionDecl *Definition = nullptr;
1761 if (Function->isDefined(Definition) &&
1762 Definition->getTemplateSpecializationKind() == TSK_Undeclared) {
1763 SemaRef.Diag(Function->getLocation(), diag::err_redefinition)
1764 << Function->getDeclName();
1765 SemaRef.Diag(Definition->getLocation(), diag::note_previous_definition);
1767 // Check for redefinitions due to other instantiations of this or
1768 // a similar friend function.
1769 else for (auto R : Function->redecls()) {
1773 // If some prior declaration of this function has been used, we need
1774 // to instantiate its definition.
1775 if (!QueuedInstantiation && R->isUsed(false)) {
1776 if (MemberSpecializationInfo *MSInfo =
1777 Function->getMemberSpecializationInfo()) {
1778 if (MSInfo->getPointOfInstantiation().isInvalid()) {
1779 SourceLocation Loc = R->getLocation(); // FIXME
1780 MSInfo->setPointOfInstantiation(Loc);
1781 SemaRef.PendingLocalImplicitInstantiations.push_back(
1782 std::make_pair(Function, Loc));
1783 QueuedInstantiation = true;
1788 // If some prior declaration of this function was a friend with an
1789 // uninstantiated definition, reject it.
1790 if (R->getFriendObjectKind()) {
1791 if (const FunctionDecl *RPattern =
1792 R->getTemplateInstantiationPattern()) {
1793 if (RPattern->isDefined(RPattern)) {
1794 SemaRef.Diag(Function->getLocation(), diag::err_redefinition)
1795 << Function->getDeclName();
1796 SemaRef.Diag(R->getLocation(), diag::note_previous_definition);
1805 if (Function->isLocalExternDecl() && !Function->getPreviousDecl())
1806 DC->makeDeclVisibleInContext(PrincipalDecl);
1808 if (Function->isOverloadedOperator() && !DC->isRecord() &&
1809 PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
1810 PrincipalDecl->setNonMemberOperator();
1812 assert(!D->isDefaulted() && "only methods should be defaulted");
1817 TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D,
1818 TemplateParameterList *TemplateParams,
1819 bool IsClassScopeSpecialization) {
1820 FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate();
1821 if (FunctionTemplate && !TemplateParams) {
1822 // We are creating a function template specialization from a function
1823 // template. Check whether there is already a function template
1824 // specialization for this particular set of template arguments.
1825 ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
1827 void *InsertPos = nullptr;
1828 FunctionDecl *SpecFunc
1829 = FunctionTemplate->findSpecialization(Innermost, InsertPos);
1831 // If we already have a function template specialization, return it.
1837 if (FunctionTemplate)
1838 isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None);
1840 isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
1842 bool MergeWithParentScope = (TemplateParams != nullptr) ||
1843 !(isa<Decl>(Owner) &&
1844 cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
1845 LocalInstantiationScope Scope(SemaRef, MergeWithParentScope);
1847 // Instantiate enclosing template arguments for friends.
1848 SmallVector<TemplateParameterList *, 4> TempParamLists;
1849 unsigned NumTempParamLists = 0;
1850 if (isFriend && (NumTempParamLists = D->getNumTemplateParameterLists())) {
1851 TempParamLists.resize(NumTempParamLists);
1852 for (unsigned I = 0; I != NumTempParamLists; ++I) {
1853 TemplateParameterList *TempParams = D->getTemplateParameterList(I);
1854 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
1857 TempParamLists[I] = InstParams;
1861 SmallVector<ParmVarDecl *, 4> Params;
1862 TypeSourceInfo *TInfo = SubstFunctionType(D, Params);
1865 QualType T = adjustFunctionTypeForInstantiation(SemaRef.Context, D, TInfo);
1867 NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
1869 QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
1875 DeclContext *DC = Owner;
1879 SS.Adopt(QualifierLoc);
1880 DC = SemaRef.computeDeclContext(SS);
1882 if (DC && SemaRef.RequireCompleteDeclContext(SS, DC))
1885 DC = SemaRef.FindInstantiatedContext(D->getLocation(),
1886 D->getDeclContext(),
1889 if (!DC) return nullptr;
1892 // Build the instantiated method declaration.
1893 CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
1894 CXXMethodDecl *Method = nullptr;
1896 SourceLocation StartLoc = D->getInnerLocStart();
1897 DeclarationNameInfo NameInfo
1898 = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
1899 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
1900 Method = CXXConstructorDecl::Create(SemaRef.Context, Record,
1901 StartLoc, NameInfo, T, TInfo,
1902 Constructor->isExplicit(),
1903 Constructor->isInlineSpecified(),
1904 false, Constructor->isConstexpr());
1905 Method->setRangeEnd(Constructor->getLocEnd());
1906 } else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(D)) {
1907 Method = CXXDestructorDecl::Create(SemaRef.Context, Record,
1908 StartLoc, NameInfo, T, TInfo,
1909 Destructor->isInlineSpecified(),
1911 Method->setRangeEnd(Destructor->getLocEnd());
1912 } else if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) {
1913 Method = CXXConversionDecl::Create(SemaRef.Context, Record,
1914 StartLoc, NameInfo, T, TInfo,
1915 Conversion->isInlineSpecified(),
1916 Conversion->isExplicit(),
1917 Conversion->isConstexpr(),
1918 Conversion->getLocEnd());
1920 StorageClass SC = D->isStatic() ? SC_Static : SC_None;
1921 Method = CXXMethodDecl::Create(SemaRef.Context, Record,
1922 StartLoc, NameInfo, T, TInfo,
1923 SC, D->isInlineSpecified(),
1924 D->isConstexpr(), D->getLocEnd());
1928 Method->setImplicitlyInline();
1931 Method->setQualifierInfo(QualifierLoc);
1933 if (TemplateParams) {
1934 // Our resulting instantiation is actually a function template, since we
1935 // are substituting only the outer template parameters. For example, given
1937 // template<typename T>
1939 // template<typename U> void f(T, U);
1944 // We are instantiating the member template "f" within X<int>, which means
1945 // substituting int for T, but leaving "f" as a member function template.
1946 // Build the function template itself.
1947 FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, Record,
1948 Method->getLocation(),
1949 Method->getDeclName(),
1950 TemplateParams, Method);
1952 FunctionTemplate->setLexicalDeclContext(Owner);
1953 FunctionTemplate->setObjectOfFriendDecl();
1954 } else if (D->isOutOfLine())
1955 FunctionTemplate->setLexicalDeclContext(D->getLexicalDeclContext());
1956 Method->setDescribedFunctionTemplate(FunctionTemplate);
1957 } else if (FunctionTemplate) {
1958 // Record this function template specialization.
1959 ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
1960 Method->setFunctionTemplateSpecialization(FunctionTemplate,
1961 TemplateArgumentList::CreateCopy(SemaRef.Context,
1963 /*InsertPos=*/nullptr);
1964 } else if (!isFriend) {
1965 // Record that this is an instantiation of a member function.
1966 Method->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation);
1969 // If we are instantiating a member function defined
1970 // out-of-line, the instantiation will have the same lexical
1971 // context (which will be a namespace scope) as the template.
1973 if (NumTempParamLists)
1974 Method->setTemplateParameterListsInfo(
1976 llvm::makeArrayRef(TempParamLists.data(), NumTempParamLists));
1978 Method->setLexicalDeclContext(Owner);
1979 Method->setObjectOfFriendDecl();
1980 } else if (D->isOutOfLine())
1981 Method->setLexicalDeclContext(D->getLexicalDeclContext());
1983 // Attach the parameters
1984 for (unsigned P = 0; P < Params.size(); ++P)
1985 Params[P]->setOwningFunction(Method);
1986 Method->setParams(Params);
1988 if (InitMethodInstantiation(Method, D))
1989 Method->setInvalidDecl();
1991 LookupResult Previous(SemaRef, NameInfo, Sema::LookupOrdinaryName,
1992 Sema::ForRedeclaration);
1994 if (!FunctionTemplate || TemplateParams || isFriend) {
1995 SemaRef.LookupQualifiedName(Previous, Record);
1997 // In C++, the previous declaration we find might be a tag type
1998 // (class or enum). In this case, the new declaration will hide the
1999 // tag type. Note that this does does not apply if we're declaring a
2000 // typedef (C++ [dcl.typedef]p4).
2001 if (Previous.isSingleTagDecl())
2005 if (!IsClassScopeSpecialization)
2006 SemaRef.CheckFunctionDeclaration(nullptr, Method, Previous, false);
2009 SemaRef.CheckPureMethod(Method, SourceRange());
2011 // Propagate access. For a non-friend declaration, the access is
2012 // whatever we're propagating from. For a friend, it should be the
2013 // previous declaration we just found.
2014 if (isFriend && Method->getPreviousDecl())
2015 Method->setAccess(Method->getPreviousDecl()->getAccess());
2017 Method->setAccess(D->getAccess());
2018 if (FunctionTemplate)
2019 FunctionTemplate->setAccess(Method->getAccess());
2021 SemaRef.CheckOverrideControl(Method);
2023 // If a function is defined as defaulted or deleted, mark it as such now.
2024 if (D->isExplicitlyDefaulted())
2025 SemaRef.SetDeclDefaulted(Method, Method->getLocation());
2026 if (D->isDeletedAsWritten())
2027 SemaRef.SetDeclDeleted(Method, Method->getLocation());
2029 // If there's a function template, let our caller handle it.
2030 if (FunctionTemplate) {
2033 // Don't hide a (potentially) valid declaration with an invalid one.
2034 } else if (Method->isInvalidDecl() && !Previous.empty()) {
2037 // Otherwise, check access to friends and make them visible.
2038 } else if (isFriend) {
2039 // We only need to re-check access for methods which we didn't
2040 // manage to match during parsing.
2041 if (!D->getPreviousDecl())
2042 SemaRef.CheckFriendAccess(Method);
2044 Record->makeDeclVisibleInContext(Method);
2046 // Otherwise, add the declaration. We don't need to do this for
2047 // class-scope specializations because we'll have matched them with
2048 // the appropriate template.
2049 } else if (!IsClassScopeSpecialization) {
2050 Owner->addDecl(Method);
2056 Decl *TemplateDeclInstantiator::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
2057 return VisitCXXMethodDecl(D);
2060 Decl *TemplateDeclInstantiator::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
2061 return VisitCXXMethodDecl(D);
2064 Decl *TemplateDeclInstantiator::VisitCXXConversionDecl(CXXConversionDecl *D) {
2065 return VisitCXXMethodDecl(D);
2068 Decl *TemplateDeclInstantiator::VisitParmVarDecl(ParmVarDecl *D) {
2069 return SemaRef.SubstParmVarDecl(D, TemplateArgs, /*indexAdjustment*/ 0, None,
2070 /*ExpectParameterPack=*/ false);
2073 Decl *TemplateDeclInstantiator::VisitTemplateTypeParmDecl(
2074 TemplateTypeParmDecl *D) {
2075 // TODO: don't always clone when decls are refcounted.
2076 assert(D->getTypeForDecl()->isTemplateTypeParmType());
2078 TemplateTypeParmDecl *Inst =
2079 TemplateTypeParmDecl::Create(SemaRef.Context, Owner,
2080 D->getLocStart(), D->getLocation(),
2081 D->getDepth() - TemplateArgs.getNumLevels(),
2082 D->getIndex(), D->getIdentifier(),
2083 D->wasDeclaredWithTypename(),
2084 D->isParameterPack());
2085 Inst->setAccess(AS_public);
2087 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
2088 TypeSourceInfo *InstantiatedDefaultArg =
2089 SemaRef.SubstType(D->getDefaultArgumentInfo(), TemplateArgs,
2090 D->getDefaultArgumentLoc(), D->getDeclName());
2091 if (InstantiatedDefaultArg)
2092 Inst->setDefaultArgument(InstantiatedDefaultArg);
2095 // Introduce this template parameter's instantiation into the instantiation
2097 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Inst);
2102 Decl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl(
2103 NonTypeTemplateParmDecl *D) {
2104 // Substitute into the type of the non-type template parameter.
2105 TypeLoc TL = D->getTypeSourceInfo()->getTypeLoc();
2106 SmallVector<TypeSourceInfo *, 4> ExpandedParameterPackTypesAsWritten;
2107 SmallVector<QualType, 4> ExpandedParameterPackTypes;
2108 bool IsExpandedParameterPack = false;
2111 bool Invalid = false;
2113 if (D->isExpandedParameterPack()) {
2114 // The non-type template parameter pack is an already-expanded pack
2115 // expansion of types. Substitute into each of the expanded types.
2116 ExpandedParameterPackTypes.reserve(D->getNumExpansionTypes());
2117 ExpandedParameterPackTypesAsWritten.reserve(D->getNumExpansionTypes());
2118 for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
2119 TypeSourceInfo *NewDI =
2120 SemaRef.SubstType(D->getExpansionTypeSourceInfo(I), TemplateArgs,
2121 D->getLocation(), D->getDeclName());
2126 SemaRef.CheckNonTypeTemplateParameterType(NewDI, D->getLocation());
2130 ExpandedParameterPackTypesAsWritten.push_back(NewDI);
2131 ExpandedParameterPackTypes.push_back(NewT);
2134 IsExpandedParameterPack = true;
2135 DI = D->getTypeSourceInfo();
2137 } else if (D->isPackExpansion()) {
2138 // The non-type template parameter pack's type is a pack expansion of types.
2139 // Determine whether we need to expand this parameter pack into separate
2141 PackExpansionTypeLoc Expansion = TL.castAs<PackExpansionTypeLoc>();
2142 TypeLoc Pattern = Expansion.getPatternLoc();
2143 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
2144 SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded);
2146 // Determine whether the set of unexpanded parameter packs can and should
2149 bool RetainExpansion = false;
2150 Optional<unsigned> OrigNumExpansions
2151 = Expansion.getTypePtr()->getNumExpansions();
2152 Optional<unsigned> NumExpansions = OrigNumExpansions;
2153 if (SemaRef.CheckParameterPacksForExpansion(Expansion.getEllipsisLoc(),
2154 Pattern.getSourceRange(),
2157 Expand, RetainExpansion,
2162 for (unsigned I = 0; I != *NumExpansions; ++I) {
2163 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
2164 TypeSourceInfo *NewDI = SemaRef.SubstType(Pattern, TemplateArgs,
2171 SemaRef.CheckNonTypeTemplateParameterType(NewDI, D->getLocation());
2175 ExpandedParameterPackTypesAsWritten.push_back(NewDI);
2176 ExpandedParameterPackTypes.push_back(NewT);
2179 // Note that we have an expanded parameter pack. The "type" of this
2180 // expanded parameter pack is the original expansion type, but callers
2181 // will end up using the expanded parameter pack types for type-checking.
2182 IsExpandedParameterPack = true;
2183 DI = D->getTypeSourceInfo();
2186 // We cannot fully expand the pack expansion now, so substitute into the
2187 // pattern and create a new pack expansion type.
2188 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
2189 TypeSourceInfo *NewPattern = SemaRef.SubstType(Pattern, TemplateArgs,
2195 SemaRef.CheckNonTypeTemplateParameterType(NewPattern, D->getLocation());
2196 DI = SemaRef.CheckPackExpansion(NewPattern, Expansion.getEllipsisLoc(),
2204 // Simple case: substitution into a parameter that is not a parameter pack.
2205 DI = SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs,
2206 D->getLocation(), D->getDeclName());
2210 // Check that this type is acceptable for a non-type template parameter.
2211 T = SemaRef.CheckNonTypeTemplateParameterType(DI, D->getLocation());
2213 T = SemaRef.Context.IntTy;
2218 NonTypeTemplateParmDecl *Param;
2219 if (IsExpandedParameterPack)
2220 Param = NonTypeTemplateParmDecl::Create(
2221 SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
2222 D->getDepth() - TemplateArgs.getNumLevels(), D->getPosition(),
2223 D->getIdentifier(), T, DI, ExpandedParameterPackTypes,
2224 ExpandedParameterPackTypesAsWritten);
2226 Param = NonTypeTemplateParmDecl::Create(SemaRef.Context, Owner,
2227 D->getInnerLocStart(),
2229 D->getDepth() - TemplateArgs.getNumLevels(),
2231 D->getIdentifier(), T,
2232 D->isParameterPack(), DI);
2234 Param->setAccess(AS_public);
2236 Param->setInvalidDecl();
2238 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
2239 EnterExpressionEvaluationContext ConstantEvaluated(SemaRef,
2240 Sema::ConstantEvaluated);
2241 ExprResult Value = SemaRef.SubstExpr(D->getDefaultArgument(), TemplateArgs);
2242 if (!Value.isInvalid())
2243 Param->setDefaultArgument(Value.get());
2246 // Introduce this template parameter's instantiation into the instantiation
2248 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);
2252 static void collectUnexpandedParameterPacks(
2254 TemplateParameterList *Params,
2255 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
2256 for (const auto &P : *Params) {
2257 if (P->isTemplateParameterPack())
2259 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P))
2260 S.collectUnexpandedParameterPacks(NTTP->getTypeSourceInfo()->getTypeLoc(),
2262 if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
2263 collectUnexpandedParameterPacks(S, TTP->getTemplateParameters(),
2269 TemplateDeclInstantiator::VisitTemplateTemplateParmDecl(
2270 TemplateTemplateParmDecl *D) {
2271 // Instantiate the template parameter list of the template template parameter.
2272 TemplateParameterList *TempParams = D->getTemplateParameters();
2273 TemplateParameterList *InstParams;
2274 SmallVector<TemplateParameterList*, 8> ExpandedParams;
2276 bool IsExpandedParameterPack = false;
2278 if (D->isExpandedParameterPack()) {
2279 // The template template parameter pack is an already-expanded pack
2280 // expansion of template parameters. Substitute into each of the expanded
2282 ExpandedParams.reserve(D->getNumExpansionTemplateParameters());
2283 for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
2285 LocalInstantiationScope Scope(SemaRef);
2286 TemplateParameterList *Expansion =
2287 SubstTemplateParams(D->getExpansionTemplateParameters(I));
2290 ExpandedParams.push_back(Expansion);
2293 IsExpandedParameterPack = true;
2294 InstParams = TempParams;
2295 } else if (D->isPackExpansion()) {
2296 // The template template parameter pack expands to a pack of template
2297 // template parameters. Determine whether we need to expand this parameter
2298 // pack into separate parameters.
2299 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
2300 collectUnexpandedParameterPacks(SemaRef, D->getTemplateParameters(),
2303 // Determine whether the set of unexpanded parameter packs can and should
2306 bool RetainExpansion = false;
2307 Optional<unsigned> NumExpansions;
2308 if (SemaRef.CheckParameterPacksForExpansion(D->getLocation(),
2309 TempParams->getSourceRange(),
2312 Expand, RetainExpansion,
2317 for (unsigned I = 0; I != *NumExpansions; ++I) {
2318 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
2319 LocalInstantiationScope Scope(SemaRef);
2320 TemplateParameterList *Expansion = SubstTemplateParams(TempParams);
2323 ExpandedParams.push_back(Expansion);
2326 // Note that we have an expanded parameter pack. The "type" of this
2327 // expanded parameter pack is the original expansion type, but callers
2328 // will end up using the expanded parameter pack types for type-checking.
2329 IsExpandedParameterPack = true;
2330 InstParams = TempParams;
2332 // We cannot fully expand the pack expansion now, so just substitute
2333 // into the pattern.
2334 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
2336 LocalInstantiationScope Scope(SemaRef);
2337 InstParams = SubstTemplateParams(TempParams);
2342 // Perform the actual substitution of template parameters within a new,
2343 // local instantiation scope.
2344 LocalInstantiationScope Scope(SemaRef);
2345 InstParams = SubstTemplateParams(TempParams);
2350 // Build the template template parameter.
2351 TemplateTemplateParmDecl *Param;
2352 if (IsExpandedParameterPack)
2353 Param = TemplateTemplateParmDecl::Create(SemaRef.Context, Owner,
2355 D->getDepth() - TemplateArgs.getNumLevels(),
2357 D->getIdentifier(), InstParams,
2360 Param = TemplateTemplateParmDecl::Create(SemaRef.Context, Owner,
2362 D->getDepth() - TemplateArgs.getNumLevels(),
2364 D->isParameterPack(),
2365 D->getIdentifier(), InstParams);
2366 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
2367 NestedNameSpecifierLoc QualifierLoc =
2368 D->getDefaultArgument().getTemplateQualifierLoc();
2370 SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, TemplateArgs);
2371 TemplateName TName = SemaRef.SubstTemplateName(
2372 QualifierLoc, D->getDefaultArgument().getArgument().getAsTemplate(),
2373 D->getDefaultArgument().getTemplateNameLoc(), TemplateArgs);
2374 if (!TName.isNull())
2375 Param->setDefaultArgument(
2377 TemplateArgumentLoc(TemplateArgument(TName),
2378 D->getDefaultArgument().getTemplateQualifierLoc(),
2379 D->getDefaultArgument().getTemplateNameLoc()));
2381 Param->setAccess(AS_public);
2383 // Introduce this template parameter's instantiation into the instantiation
2385 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);
2390 Decl *TemplateDeclInstantiator::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
2391 // Using directives are never dependent (and never contain any types or
2392 // expressions), so they require no explicit instantiation work.
2394 UsingDirectiveDecl *Inst
2395 = UsingDirectiveDecl::Create(SemaRef.Context, Owner, D->getLocation(),
2396 D->getNamespaceKeyLocation(),
2397 D->getQualifierLoc(),
2398 D->getIdentLocation(),
2399 D->getNominatedNamespace(),
2400 D->getCommonAncestor());
2402 // Add the using directive to its declaration context
2403 // only if this is not a function or method.
2404 if (!Owner->isFunctionOrMethod())
2405 Owner->addDecl(Inst);
2410 Decl *TemplateDeclInstantiator::VisitUsingDecl(UsingDecl *D) {
2412 // The nested name specifier may be dependent, for example
2413 // template <typename T> struct t {
2414 // struct s1 { T f1(); };
2415 // struct s2 : s1 { using s1::f1; };
2417 // template struct t<int>;
2418 // Here, in using s1::f1, s1 refers to t<T>::s1;
2419 // we need to substitute for t<int>::s1.
2420 NestedNameSpecifierLoc QualifierLoc
2421 = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(),
2426 // For an inheriting constructor declaration, the name of the using
2427 // declaration is the name of a constructor in this class, not in the
2429 DeclarationNameInfo NameInfo = D->getNameInfo();
2430 if (NameInfo.getName().getNameKind() == DeclarationName::CXXConstructorName)
2431 if (auto *RD = dyn_cast<CXXRecordDecl>(SemaRef.CurContext))
2432 NameInfo.setName(SemaRef.Context.DeclarationNames.getCXXConstructorName(
2433 SemaRef.Context.getCanonicalType(SemaRef.Context.getRecordType(RD))));
2435 // We only need to do redeclaration lookups if we're in a class
2436 // scope (in fact, it's not really even possible in non-class
2438 bool CheckRedeclaration = Owner->isRecord();
2440 LookupResult Prev(SemaRef, NameInfo, Sema::LookupUsingDeclName,
2441 Sema::ForRedeclaration);
2443 UsingDecl *NewUD = UsingDecl::Create(SemaRef.Context, Owner,
2450 SS.Adopt(QualifierLoc);
2451 if (CheckRedeclaration) {
2452 Prev.setHideTags(false);
2453 SemaRef.LookupQualifiedName(Prev, Owner);
2455 // Check for invalid redeclarations.
2456 if (SemaRef.CheckUsingDeclRedeclaration(D->getUsingLoc(),
2457 D->hasTypename(), SS,
2458 D->getLocation(), Prev))
2459 NewUD->setInvalidDecl();
2463 if (!NewUD->isInvalidDecl() &&
2464 SemaRef.CheckUsingDeclQualifier(D->getUsingLoc(), D->hasTypename(),
2465 SS, NameInfo, D->getLocation()))
2466 NewUD->setInvalidDecl();
2468 SemaRef.Context.setInstantiatedFromUsingDecl(NewUD, D);
2469 NewUD->setAccess(D->getAccess());
2470 Owner->addDecl(NewUD);
2472 // Don't process the shadow decls for an invalid decl.
2473 if (NewUD->isInvalidDecl())
2476 if (NameInfo.getName().getNameKind() == DeclarationName::CXXConstructorName)
2477 SemaRef.CheckInheritingConstructorUsingDecl(NewUD);
2479 bool isFunctionScope = Owner->isFunctionOrMethod();
2481 // Process the shadow decls.
2482 for (auto *Shadow : D->shadows()) {
2483 // FIXME: UsingShadowDecl doesn't preserve its immediate target, so
2484 // reconstruct it in the case where it matters.
2485 NamedDecl *OldTarget = Shadow->getTargetDecl();
2486 if (auto *CUSD = dyn_cast<ConstructorUsingShadowDecl>(Shadow))
2487 if (auto *BaseShadow = CUSD->getNominatedBaseClassShadowDecl())
2488 OldTarget = BaseShadow;
2490 NamedDecl *InstTarget =
2491 cast_or_null<NamedDecl>(SemaRef.FindInstantiatedDecl(
2492 Shadow->getLocation(), OldTarget, TemplateArgs));
2496 UsingShadowDecl *PrevDecl = nullptr;
2497 if (CheckRedeclaration) {
2498 if (SemaRef.CheckUsingShadowDecl(NewUD, InstTarget, Prev, PrevDecl))
2500 } else if (UsingShadowDecl *OldPrev =
2501 getPreviousDeclForInstantiation(Shadow)) {
2502 PrevDecl = cast_or_null<UsingShadowDecl>(SemaRef.FindInstantiatedDecl(
2503 Shadow->getLocation(), OldPrev, TemplateArgs));
2506 UsingShadowDecl *InstShadow =
2507 SemaRef.BuildUsingShadowDecl(/*Scope*/nullptr, NewUD, InstTarget,
2509 SemaRef.Context.setInstantiatedFromUsingShadowDecl(InstShadow, Shadow);
2511 if (isFunctionScope)
2512 SemaRef.CurrentInstantiationScope->InstantiatedLocal(Shadow, InstShadow);
2518 Decl *TemplateDeclInstantiator::VisitUsingShadowDecl(UsingShadowDecl *D) {
2519 // Ignore these; we handle them in bulk when processing the UsingDecl.
2523 Decl *TemplateDeclInstantiator::VisitConstructorUsingShadowDecl(
2524 ConstructorUsingShadowDecl *D) {
2525 // Ignore these; we handle them in bulk when processing the UsingDecl.
2529 template <typename T>
2530 Decl *TemplateDeclInstantiator::instantiateUnresolvedUsingDecl(
2531 T *D, bool InstantiatingPackElement) {
2532 // If this is a pack expansion, expand it now.
2533 if (D->isPackExpansion() && !InstantiatingPackElement) {
2534 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
2535 SemaRef.collectUnexpandedParameterPacks(D->getQualifierLoc(), Unexpanded);
2536 SemaRef.collectUnexpandedParameterPacks(D->getNameInfo(), Unexpanded);
2538 // Determine whether the set of unexpanded parameter packs can and should
2541 bool RetainExpansion = false;
2542 Optional<unsigned> NumExpansions;
2543 if (SemaRef.CheckParameterPacksForExpansion(
2544 D->getEllipsisLoc(), D->getSourceRange(), Unexpanded, TemplateArgs,
2545 Expand, RetainExpansion, NumExpansions))
2548 // This declaration cannot appear within a function template signature,
2549 // so we can't have a partial argument list for a parameter pack.
2550 assert(!RetainExpansion &&
2551 "should never need to retain an expansion for UsingPackDecl");
2554 // We cannot fully expand the pack expansion now, so substitute into the
2555 // pattern and create a new pack expansion.
2556 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
2557 return instantiateUnresolvedUsingDecl(D, true);
2560 // Within a function, we don't have any normal way to check for conflicts
2561 // between shadow declarations from different using declarations in the
2562 // same pack expansion, but this is always ill-formed because all expansions
2563 // must produce (conflicting) enumerators.
2565 // Sadly we can't just reject this in the template definition because it
2566 // could be valid if the pack is empty or has exactly one expansion.
2567 if (D->getDeclContext()->isFunctionOrMethod() && *NumExpansions > 1) {
2568 SemaRef.Diag(D->getEllipsisLoc(),
2569 diag::err_using_decl_redeclaration_expansion);
2573 // Instantiate the slices of this pack and build a UsingPackDecl.
2574 SmallVector<NamedDecl*, 8> Expansions;
2575 for (unsigned I = 0; I != *NumExpansions; ++I) {
2576 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
2577 Decl *Slice = instantiateUnresolvedUsingDecl(D, true);
2580 // Note that we can still get unresolved using declarations here, if we
2581 // had arguments for all packs but the pattern also contained other
2582 // template arguments (this only happens during partial substitution, eg
2583 // into the body of a generic lambda in a function template).
2584 Expansions.push_back(cast<NamedDecl>(Slice));
2587 auto *NewD = SemaRef.BuildUsingPackDecl(D, Expansions);
2588 if (isDeclWithinFunction(D))
2589 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewD);
2593 UnresolvedUsingTypenameDecl *TD = dyn_cast<UnresolvedUsingTypenameDecl>(D);
2594 SourceLocation TypenameLoc = TD ? TD->getTypenameLoc() : SourceLocation();
2596 NestedNameSpecifierLoc QualifierLoc
2597 = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(),
2603 SS.Adopt(QualifierLoc);
2605 DeclarationNameInfo NameInfo
2606 = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
2608 // Produce a pack expansion only if we're not instantiating a particular
2609 // slice of a pack expansion.
2610 bool InstantiatingSlice = D->getEllipsisLoc().isValid() &&
2611 SemaRef.ArgumentPackSubstitutionIndex != -1;
2612 SourceLocation EllipsisLoc =
2613 InstantiatingSlice ? SourceLocation() : D->getEllipsisLoc();
2615 NamedDecl *UD = SemaRef.BuildUsingDeclaration(
2616 /*Scope*/ nullptr, D->getAccess(), D->getUsingLoc(),
2617 /*HasTypename*/ TD, TypenameLoc, SS, NameInfo, EllipsisLoc, nullptr,
2618 /*IsInstantiation*/ true);
2620 SemaRef.Context.setInstantiatedFromUsingDecl(UD, D);
2625 Decl *TemplateDeclInstantiator::VisitUnresolvedUsingTypenameDecl(
2626 UnresolvedUsingTypenameDecl *D) {
2627 return instantiateUnresolvedUsingDecl(D);
2630 Decl *TemplateDeclInstantiator::VisitUnresolvedUsingValueDecl(
2631 UnresolvedUsingValueDecl *D) {
2632 return instantiateUnresolvedUsingDecl(D);
2635 Decl *TemplateDeclInstantiator::VisitUsingPackDecl(UsingPackDecl *D) {
2636 SmallVector<NamedDecl*, 8> Expansions;
2637 for (auto *UD : D->expansions()) {
2639 SemaRef.FindInstantiatedDecl(D->getLocation(), UD, TemplateArgs))
2640 Expansions.push_back(cast<NamedDecl>(NewUD));
2645 auto *NewD = SemaRef.BuildUsingPackDecl(D, Expansions);
2646 if (isDeclWithinFunction(D))
2647 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewD);
2651 Decl *TemplateDeclInstantiator::VisitClassScopeFunctionSpecializationDecl(
2652 ClassScopeFunctionSpecializationDecl *Decl) {
2653 CXXMethodDecl *OldFD = Decl->getSpecialization();
2654 CXXMethodDecl *NewFD =
2655 cast_or_null<CXXMethodDecl>(VisitCXXMethodDecl(OldFD, nullptr, true));
2659 LookupResult Previous(SemaRef, NewFD->getNameInfo(), Sema::LookupOrdinaryName,
2660 Sema::ForRedeclaration);
2662 TemplateArgumentListInfo TemplateArgs;
2663 TemplateArgumentListInfo *TemplateArgsPtr = nullptr;
2664 if (Decl->hasExplicitTemplateArgs()) {
2665 TemplateArgs = Decl->templateArgs();
2666 TemplateArgsPtr = &TemplateArgs;
2669 SemaRef.LookupQualifiedName(Previous, SemaRef.CurContext);
2670 if (SemaRef.CheckFunctionTemplateSpecialization(NewFD, TemplateArgsPtr,
2672 NewFD->setInvalidDecl();
2676 // Associate the specialization with the pattern.
2677 FunctionDecl *Specialization = cast<FunctionDecl>(Previous.getFoundDecl());
2678 assert(Specialization && "Class scope Specialization is null");
2679 SemaRef.Context.setClassScopeSpecializationPattern(Specialization, OldFD);
2684 Decl *TemplateDeclInstantiator::VisitOMPThreadPrivateDecl(
2685 OMPThreadPrivateDecl *D) {
2686 SmallVector<Expr *, 5> Vars;
2687 for (auto *I : D->varlists()) {
2688 Expr *Var = SemaRef.SubstExpr(I, TemplateArgs).get();
2689 assert(isa<DeclRefExpr>(Var) && "threadprivate arg is not a DeclRefExpr");
2690 Vars.push_back(Var);
2693 OMPThreadPrivateDecl *TD =
2694 SemaRef.CheckOMPThreadPrivateDecl(D->getLocation(), Vars);
2696 TD->setAccess(AS_public);
2702 Decl *TemplateDeclInstantiator::VisitOMPDeclareReductionDecl(
2703 OMPDeclareReductionDecl *D) {
2704 // Instantiate type and check if it is allowed.
2705 QualType SubstReductionType = SemaRef.ActOnOpenMPDeclareReductionType(
2707 ParsedType::make(SemaRef.SubstType(D->getType(), TemplateArgs,
2708 D->getLocation(), DeclarationName())));
2709 if (SubstReductionType.isNull())
2711 bool IsCorrect = !SubstReductionType.isNull();
2712 // Create instantiated copy.
2713 std::pair<QualType, SourceLocation> ReductionTypes[] = {
2714 std::make_pair(SubstReductionType, D->getLocation())};
2715 auto *PrevDeclInScope = D->getPrevDeclInScope();
2716 if (PrevDeclInScope && !PrevDeclInScope->isInvalidDecl()) {
2717 PrevDeclInScope = cast<OMPDeclareReductionDecl>(
2718 SemaRef.CurrentInstantiationScope->findInstantiationOf(PrevDeclInScope)
2721 auto DRD = SemaRef.ActOnOpenMPDeclareReductionDirectiveStart(
2722 /*S=*/nullptr, Owner, D->getDeclName(), ReductionTypes, D->getAccess(),
2724 auto *NewDRD = cast<OMPDeclareReductionDecl>(DRD.get().getSingleDecl());
2725 if (isDeclWithinFunction(NewDRD))
2726 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewDRD);
2727 Expr *SubstCombiner = nullptr;
2728 Expr *SubstInitializer = nullptr;
2729 // Combiners instantiation sequence.
2730 if (D->getCombiner()) {
2731 SemaRef.ActOnOpenMPDeclareReductionCombinerStart(
2732 /*S=*/nullptr, NewDRD);
2733 const char *Names[] = {"omp_in", "omp_out"};
2734 for (auto &Name : Names) {
2735 DeclarationName DN(&SemaRef.Context.Idents.get(Name));
2736 auto OldLookup = D->lookup(DN);
2737 auto Lookup = NewDRD->lookup(DN);
2738 if (!OldLookup.empty() && !Lookup.empty()) {
2739 assert(Lookup.size() == 1 && OldLookup.size() == 1);
2740 SemaRef.CurrentInstantiationScope->InstantiatedLocal(OldLookup.front(),
2744 SubstCombiner = SemaRef.SubstExpr(D->getCombiner(), TemplateArgs).get();
2745 SemaRef.ActOnOpenMPDeclareReductionCombinerEnd(NewDRD, SubstCombiner);
2746 // Initializers instantiation sequence.
2747 if (D->getInitializer()) {
2748 SemaRef.ActOnOpenMPDeclareReductionInitializerStart(
2749 /*S=*/nullptr, NewDRD);
2750 const char *Names[] = {"omp_orig", "omp_priv"};
2751 for (auto &Name : Names) {
2752 DeclarationName DN(&SemaRef.Context.Idents.get(Name));
2753 auto OldLookup = D->lookup(DN);
2754 auto Lookup = NewDRD->lookup(DN);
2755 if (!OldLookup.empty() && !Lookup.empty()) {
2756 assert(Lookup.size() == 1 && OldLookup.size() == 1);
2757 SemaRef.CurrentInstantiationScope->InstantiatedLocal(
2758 OldLookup.front(), Lookup.front());
2762 SemaRef.SubstExpr(D->getInitializer(), TemplateArgs).get();
2763 SemaRef.ActOnOpenMPDeclareReductionInitializerEnd(NewDRD,
2766 IsCorrect = IsCorrect && SubstCombiner &&
2767 (!D->getInitializer() || SubstInitializer);
2771 (void)SemaRef.ActOnOpenMPDeclareReductionDirectiveEnd(/*S=*/nullptr, DRD,
2777 Decl *TemplateDeclInstantiator::VisitOMPCapturedExprDecl(
2778 OMPCapturedExprDecl * /*D*/) {
2779 llvm_unreachable("Should not be met in templates");
2782 Decl *TemplateDeclInstantiator::VisitFunctionDecl(FunctionDecl *D) {
2783 return VisitFunctionDecl(D, nullptr);
2786 Decl *TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D) {
2787 return VisitCXXMethodDecl(D, nullptr);
2790 Decl *TemplateDeclInstantiator::VisitRecordDecl(RecordDecl *D) {
2791 llvm_unreachable("There are only CXXRecordDecls in C++");
2795 TemplateDeclInstantiator::VisitClassTemplateSpecializationDecl(
2796 ClassTemplateSpecializationDecl *D) {
2797 // As a MS extension, we permit class-scope explicit specialization
2798 // of member class templates.
2799 ClassTemplateDecl *ClassTemplate = D->getSpecializedTemplate();
2800 assert(ClassTemplate->getDeclContext()->isRecord() &&
2801 D->getTemplateSpecializationKind() == TSK_ExplicitSpecialization &&
2802 "can only instantiate an explicit specialization "
2803 "for a member class template");
2805 // Lookup the already-instantiated declaration in the instantiation
2806 // of the class template. FIXME: Diagnose or assert if this fails?
2807 DeclContext::lookup_result Found
2808 = Owner->lookup(ClassTemplate->getDeclName());
2811 ClassTemplateDecl *InstClassTemplate
2812 = dyn_cast<ClassTemplateDecl>(Found.front());
2813 if (!InstClassTemplate)
2816 // Substitute into the template arguments of the class template explicit
2818 TemplateSpecializationTypeLoc Loc = D->getTypeAsWritten()->getTypeLoc().
2819 castAs<TemplateSpecializationTypeLoc>();
2820 TemplateArgumentListInfo InstTemplateArgs(Loc.getLAngleLoc(),
2821 Loc.getRAngleLoc());
2822 SmallVector<TemplateArgumentLoc, 4> ArgLocs;
2823 for (unsigned I = 0; I != Loc.getNumArgs(); ++I)
2824 ArgLocs.push_back(Loc.getArgLoc(I));
2825 if (SemaRef.Subst(ArgLocs.data(), ArgLocs.size(),
2826 InstTemplateArgs, TemplateArgs))
2829 // Check that the template argument list is well-formed for this
2831 SmallVector<TemplateArgument, 4> Converted;
2832 if (SemaRef.CheckTemplateArgumentList(InstClassTemplate,
2839 // Figure out where to insert this class template explicit specialization
2840 // in the member template's set of class template explicit specializations.
2841 void *InsertPos = nullptr;
2842 ClassTemplateSpecializationDecl *PrevDecl =
2843 InstClassTemplate->findSpecialization(Converted, InsertPos);
2845 // Check whether we've already seen a conflicting instantiation of this
2846 // declaration (for instance, if there was a prior implicit instantiation).
2849 SemaRef.CheckSpecializationInstantiationRedecl(D->getLocation(),
2850 D->getSpecializationKind(),
2852 PrevDecl->getSpecializationKind(),
2853 PrevDecl->getPointOfInstantiation(),
2857 // If PrevDecl was a definition and D is also a definition, diagnose.
2858 // This happens in cases like:
2860 // template<typename T, typename U>
2862 // template<typename X> struct Inner;
2863 // template<> struct Inner<T> {};
2864 // template<> struct Inner<U> {};
2867 // Outer<int, int> outer; // error: the explicit specializations of Inner
2868 // // have the same signature.
2869 if (PrevDecl && PrevDecl->getDefinition() &&
2870 D->isThisDeclarationADefinition()) {
2871 SemaRef.Diag(D->getLocation(), diag::err_redefinition) << PrevDecl;
2872 SemaRef.Diag(PrevDecl->getDefinition()->getLocation(),
2873 diag::note_previous_definition);
2877 // Create the class template partial specialization declaration.
2878 ClassTemplateSpecializationDecl *InstD
2879 = ClassTemplateSpecializationDecl::Create(SemaRef.Context,
2888 // Add this partial specialization to the set of class template partial
2891 InstClassTemplate->AddSpecialization(InstD, InsertPos);
2893 // Substitute the nested name specifier, if any.
2894 if (SubstQualifier(D, InstD))
2897 // Build the canonical type that describes the converted template
2898 // arguments of the class template explicit specialization.
2899 QualType CanonType = SemaRef.Context.getTemplateSpecializationType(
2900 TemplateName(InstClassTemplate), Converted,
2901 SemaRef.Context.getRecordType(InstD));
2903 // Build the fully-sugared type for this class template
2904 // specialization as the user wrote in the specialization
2905 // itself. This means that we'll pretty-print the type retrieved
2906 // from the specialization's declaration the way that the user
2907 // actually wrote the specialization, rather than formatting the
2908 // name based on the "canonical" representation used to store the
2909 // template arguments in the specialization.
2910 TypeSourceInfo *WrittenTy = SemaRef.Context.getTemplateSpecializationTypeInfo(
2911 TemplateName(InstClassTemplate), D->getLocation(), InstTemplateArgs,
2914 InstD->setAccess(D->getAccess());
2915 InstD->setInstantiationOfMemberClass(D, TSK_ImplicitInstantiation);
2916 InstD->setSpecializationKind(D->getSpecializationKind());
2917 InstD->setTypeAsWritten(WrittenTy);
2918 InstD->setExternLoc(D->getExternLoc());
2919 InstD->setTemplateKeywordLoc(D->getTemplateKeywordLoc());
2921 Owner->addDecl(InstD);
2923 // Instantiate the members of the class-scope explicit specialization eagerly.
2924 // We don't have support for lazy instantiation of an explicit specialization
2925 // yet, and MSVC eagerly instantiates in this case.
2926 if (D->isThisDeclarationADefinition() &&
2927 SemaRef.InstantiateClass(D->getLocation(), InstD, D, TemplateArgs,
2928 TSK_ImplicitInstantiation,
2935 Decl *TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl(
2936 VarTemplateSpecializationDecl *D) {
2938 TemplateArgumentListInfo VarTemplateArgsInfo;
2939 VarTemplateDecl *VarTemplate = D->getSpecializedTemplate();
2940 assert(VarTemplate &&
2941 "A template specialization without specialized template?");
2943 // Substitute the current template arguments.
2944 const TemplateArgumentListInfo &TemplateArgsInfo = D->getTemplateArgsInfo();
2945 VarTemplateArgsInfo.setLAngleLoc(TemplateArgsInfo.getLAngleLoc());
2946 VarTemplateArgsInfo.setRAngleLoc(TemplateArgsInfo.getRAngleLoc());
2948 if (SemaRef.Subst(TemplateArgsInfo.getArgumentArray(),
2949 TemplateArgsInfo.size(), VarTemplateArgsInfo, TemplateArgs))
2952 // Check that the template argument list is well-formed for this template.
2953 SmallVector<TemplateArgument, 4> Converted;
2954 if (SemaRef.CheckTemplateArgumentList(
2955 VarTemplate, VarTemplate->getLocStart(),
2956 const_cast<TemplateArgumentListInfo &>(VarTemplateArgsInfo), false,
2960 // Find the variable template specialization declaration that
2961 // corresponds to these arguments.
2962 void *InsertPos = nullptr;
2963 if (VarTemplateSpecializationDecl *VarSpec = VarTemplate->findSpecialization(
2964 Converted, InsertPos))
2965 // If we already have a variable template specialization, return it.
2968 return VisitVarTemplateSpecializationDecl(VarTemplate, D, InsertPos,
2969 VarTemplateArgsInfo, Converted);
2972 Decl *TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl(
2973 VarTemplateDecl *VarTemplate, VarDecl *D, void *InsertPos,
2974 const TemplateArgumentListInfo &TemplateArgsInfo,
2975 ArrayRef<TemplateArgument> Converted) {
2977 // Do substitution on the type of the declaration
2978 TypeSourceInfo *DI =
2979 SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs,
2980 D->getTypeSpecStartLoc(), D->getDeclName());
2984 if (DI->getType()->isFunctionType()) {
2985 SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function)
2986 << D->isStaticDataMember() << DI->getType();
2990 // Build the instantiated declaration
2991 VarTemplateSpecializationDecl *Var = VarTemplateSpecializationDecl::Create(
2992 SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
2993 VarTemplate, DI->getType(), DI, D->getStorageClass(), Converted);
2994 Var->setTemplateArgsInfo(TemplateArgsInfo);
2996 VarTemplate->AddSpecialization(Var, InsertPos);
2998 // Substitute the nested name specifier, if any.
2999 if (SubstQualifier(D, Var))
3002 SemaRef.BuildVariableInstantiation(Var, D, TemplateArgs, LateAttrs,
3003 Owner, StartingScope);
3008 Decl *TemplateDeclInstantiator::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) {
3009 llvm_unreachable("@defs is not supported in Objective-C++");
3012 Decl *TemplateDeclInstantiator::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
3013 // FIXME: We need to be able to instantiate FriendTemplateDecls.
3014 unsigned DiagID = SemaRef.getDiagnostics().getCustomDiagID(
3015 DiagnosticsEngine::Error,
3016 "cannot instantiate %0 yet");
3017 SemaRef.Diag(D->getLocation(), DiagID)
3018 << D->getDeclKindName();
3023 Decl *TemplateDeclInstantiator::VisitDecl(Decl *D) {
3024 llvm_unreachable("Unexpected decl");
3027 Decl *Sema::SubstDecl(Decl *D, DeclContext *Owner,
3028 const MultiLevelTemplateArgumentList &TemplateArgs) {
3029 TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs);
3030 if (D->isInvalidDecl())
3033 return Instantiator.Visit(D);
3036 /// \brief Instantiates a nested template parameter list in the current
3037 /// instantiation context.
3039 /// \param L The parameter list to instantiate
3041 /// \returns NULL if there was an error
3042 TemplateParameterList *
3043 TemplateDeclInstantiator::SubstTemplateParams(TemplateParameterList *L) {
3044 // Get errors for all the parameters before bailing out.
3045 bool Invalid = false;
3047 unsigned N = L->size();
3048 typedef SmallVector<NamedDecl *, 8> ParamVector;
3051 for (auto &P : *L) {
3052 NamedDecl *D = cast_or_null<NamedDecl>(Visit(P));
3053 Params.push_back(D);
3054 Invalid = Invalid || !D || D->isInvalidDecl();
3057 // Clean up if we had an error.
3061 // Note: we substitute into associated constraints later
3062 Expr *const UninstantiatedRequiresClause = L->getRequiresClause();
3064 TemplateParameterList *InstL
3065 = TemplateParameterList::Create(SemaRef.Context, L->getTemplateLoc(),
3066 L->getLAngleLoc(), Params,
3068 UninstantiatedRequiresClause);
3072 /// \brief Instantiate the declaration of a class template partial
3075 /// \param ClassTemplate the (instantiated) class template that is partially
3076 // specialized by the instantiation of \p PartialSpec.
3078 /// \param PartialSpec the (uninstantiated) class template partial
3079 /// specialization that we are instantiating.
3081 /// \returns The instantiated partial specialization, if successful; otherwise,
3082 /// NULL to indicate an error.
3083 ClassTemplatePartialSpecializationDecl *
3084 TemplateDeclInstantiator::InstantiateClassTemplatePartialSpecialization(
3085 ClassTemplateDecl *ClassTemplate,
3086 ClassTemplatePartialSpecializationDecl *PartialSpec) {
3087 // Create a local instantiation scope for this class template partial
3088 // specialization, which will contain the instantiations of the template
3090 LocalInstantiationScope Scope(SemaRef);
3092 // Substitute into the template parameters of the class template partial
3094 TemplateParameterList *TempParams = PartialSpec->getTemplateParameters();
3095 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
3099 // Substitute into the template arguments of the class template partial
3101 const ASTTemplateArgumentListInfo *TemplArgInfo
3102 = PartialSpec->getTemplateArgsAsWritten();
3103 TemplateArgumentListInfo InstTemplateArgs(TemplArgInfo->LAngleLoc,
3104 TemplArgInfo->RAngleLoc);
3105 if (SemaRef.Subst(TemplArgInfo->getTemplateArgs(),
3106 TemplArgInfo->NumTemplateArgs,
3107 InstTemplateArgs, TemplateArgs))
3110 // Check that the template argument list is well-formed for this
3112 SmallVector<TemplateArgument, 4> Converted;
3113 if (SemaRef.CheckTemplateArgumentList(ClassTemplate,
3114 PartialSpec->getLocation(),
3120 // Check these arguments are valid for a template partial specialization.
3121 if (SemaRef.CheckTemplatePartialSpecializationArgs(
3122 PartialSpec->getLocation(), ClassTemplate, InstTemplateArgs.size(),
3126 // Figure out where to insert this class template partial specialization
3127 // in the member template's set of class template partial specializations.
3128 void *InsertPos = nullptr;
3129 ClassTemplateSpecializationDecl *PrevDecl
3130 = ClassTemplate->findPartialSpecialization(Converted, InsertPos);
3132 // Build the canonical type that describes the converted template
3133 // arguments of the class template partial specialization.
3135 = SemaRef.Context.getTemplateSpecializationType(TemplateName(ClassTemplate),
3138 // Build the fully-sugared type for this class template
3139 // specialization as the user wrote in the specialization
3140 // itself. This means that we'll pretty-print the type retrieved
3141 // from the specialization's declaration the way that the user
3142 // actually wrote the specialization, rather than formatting the
3143 // name based on the "canonical" representation used to store the
3144 // template arguments in the specialization.
3145 TypeSourceInfo *WrittenTy
3146 = SemaRef.Context.getTemplateSpecializationTypeInfo(
3147 TemplateName(ClassTemplate),
3148 PartialSpec->getLocation(),
3153 // We've already seen a partial specialization with the same template
3154 // parameters and template arguments. This can happen, for example, when
3155 // substituting the outer template arguments ends up causing two
3156 // class template partial specializations of a member class template
3157 // to have identical forms, e.g.,
3159 // template<typename T, typename U>
3161 // template<typename X, typename Y> struct Inner;
3162 // template<typename Y> struct Inner<T, Y>;
3163 // template<typename Y> struct Inner<U, Y>;
3166 // Outer<int, int> outer; // error: the partial specializations of Inner
3167 // // have the same signature.
3168 SemaRef.Diag(PartialSpec->getLocation(), diag::err_partial_spec_redeclared)
3169 << WrittenTy->getType();
3170 SemaRef.Diag(PrevDecl->getLocation(), diag::note_prev_partial_spec_here)
3171 << SemaRef.Context.getTypeDeclType(PrevDecl);
3176 // Create the class template partial specialization declaration.
3177 ClassTemplatePartialSpecializationDecl *InstPartialSpec
3178 = ClassTemplatePartialSpecializationDecl::Create(SemaRef.Context,
3179 PartialSpec->getTagKind(),
3181 PartialSpec->getLocStart(),
3182 PartialSpec->getLocation(),
3189 // Substitute the nested name specifier, if any.
3190 if (SubstQualifier(PartialSpec, InstPartialSpec))
3193 InstPartialSpec->setInstantiatedFromMember(PartialSpec);
3194 InstPartialSpec->setTypeAsWritten(WrittenTy);
3196 // Check the completed partial specialization.
3197 SemaRef.CheckTemplatePartialSpecialization(InstPartialSpec);
3199 // Add this partial specialization to the set of class template partial
3201 ClassTemplate->AddPartialSpecialization(InstPartialSpec,
3202 /*InsertPos=*/nullptr);
3203 return InstPartialSpec;
3206 /// \brief Instantiate the declaration of a variable template partial
3209 /// \param VarTemplate the (instantiated) variable template that is partially
3210 /// specialized by the instantiation of \p PartialSpec.
3212 /// \param PartialSpec the (uninstantiated) variable template partial
3213 /// specialization that we are instantiating.
3215 /// \returns The instantiated partial specialization, if successful; otherwise,
3216 /// NULL to indicate an error.
3217 VarTemplatePartialSpecializationDecl *
3218 TemplateDeclInstantiator::InstantiateVarTemplatePartialSpecialization(
3219 VarTemplateDecl *VarTemplate,
3220 VarTemplatePartialSpecializationDecl *PartialSpec) {
3221 // Create a local instantiation scope for this variable template partial
3222 // specialization, which will contain the instantiations of the template
3224 LocalInstantiationScope Scope(SemaRef);
3226 // Substitute into the template parameters of the variable template partial
3228 TemplateParameterList *TempParams = PartialSpec->getTemplateParameters();
3229 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
3233 // Substitute into the template arguments of the variable template partial
3235 const ASTTemplateArgumentListInfo *TemplArgInfo
3236 = PartialSpec->getTemplateArgsAsWritten();
3237 TemplateArgumentListInfo InstTemplateArgs(TemplArgInfo->LAngleLoc,
3238 TemplArgInfo->RAngleLoc);
3239 if (SemaRef.Subst(TemplArgInfo->getTemplateArgs(),
3240 TemplArgInfo->NumTemplateArgs,
3241 InstTemplateArgs, TemplateArgs))
3244 // Check that the template argument list is well-formed for this
3246 SmallVector<TemplateArgument, 4> Converted;
3247 if (SemaRef.CheckTemplateArgumentList(VarTemplate, PartialSpec->getLocation(),
3248 InstTemplateArgs, false, Converted))
3251 // Check these arguments are valid for a template partial specialization.
3252 if (SemaRef.CheckTemplatePartialSpecializationArgs(
3253 PartialSpec->getLocation(), VarTemplate, InstTemplateArgs.size(),
3257 // Figure out where to insert this variable template partial specialization
3258 // in the member template's set of variable template partial specializations.
3259 void *InsertPos = nullptr;
3260 VarTemplateSpecializationDecl *PrevDecl =
3261 VarTemplate->findPartialSpecialization(Converted, InsertPos);
3263 // Build the canonical type that describes the converted template
3264 // arguments of the variable template partial specialization.
3265 QualType CanonType = SemaRef.Context.getTemplateSpecializationType(
3266 TemplateName(VarTemplate), Converted);
3268 // Build the fully-sugared type for this variable template
3269 // specialization as the user wrote in the specialization
3270 // itself. This means that we'll pretty-print the type retrieved
3271 // from the specialization's declaration the way that the user
3272 // actually wrote the specialization, rather than formatting the
3273 // name based on the "canonical" representation used to store the
3274 // template arguments in the specialization.
3275 TypeSourceInfo *WrittenTy = SemaRef.Context.getTemplateSpecializationTypeInfo(
3276 TemplateName(VarTemplate), PartialSpec->getLocation(), InstTemplateArgs,
3280 // We've already seen a partial specialization with the same template
3281 // parameters and template arguments. This can happen, for example, when
3282 // substituting the outer template arguments ends up causing two
3283 // variable template partial specializations of a member variable template
3284 // to have identical forms, e.g.,
3286 // template<typename T, typename U>
3288 // template<typename X, typename Y> pair<X,Y> p;
3289 // template<typename Y> pair<T, Y> p;
3290 // template<typename Y> pair<U, Y> p;
3293 // Outer<int, int> outer; // error: the partial specializations of Inner
3294 // // have the same signature.
3295 SemaRef.Diag(PartialSpec->getLocation(),
3296 diag::err_var_partial_spec_redeclared)
3297 << WrittenTy->getType();
3298 SemaRef.Diag(PrevDecl->getLocation(),
3299 diag::note_var_prev_partial_spec_here);
3303 // Do substitution on the type of the declaration
3304 TypeSourceInfo *DI = SemaRef.SubstType(
3305 PartialSpec->getTypeSourceInfo(), TemplateArgs,
3306 PartialSpec->getTypeSpecStartLoc(), PartialSpec->getDeclName());
3310 if (DI->getType()->isFunctionType()) {
3311 SemaRef.Diag(PartialSpec->getLocation(),
3312 diag::err_variable_instantiates_to_function)
3313 << PartialSpec->isStaticDataMember() << DI->getType();
3317 // Create the variable template partial specialization declaration.
3318 VarTemplatePartialSpecializationDecl *InstPartialSpec =
3319 VarTemplatePartialSpecializationDecl::Create(
3320 SemaRef.Context, Owner, PartialSpec->getInnerLocStart(),
3321 PartialSpec->getLocation(), InstParams, VarTemplate, DI->getType(),
3322 DI, PartialSpec->getStorageClass(), Converted, InstTemplateArgs);
3324 // Substitute the nested name specifier, if any.
3325 if (SubstQualifier(PartialSpec, InstPartialSpec))
3328 InstPartialSpec->setInstantiatedFromMember(PartialSpec);
3329 InstPartialSpec->setTypeAsWritten(WrittenTy);
3331 // Check the completed partial specialization.
3332 SemaRef.CheckTemplatePartialSpecialization(InstPartialSpec);
3334 // Add this partial specialization to the set of variable template partial
3335 // specializations. The instantiation of the initializer is not necessary.
3336 VarTemplate->AddPartialSpecialization(InstPartialSpec, /*InsertPos=*/nullptr);
3338 SemaRef.BuildVariableInstantiation(InstPartialSpec, PartialSpec, TemplateArgs,
3339 LateAttrs, Owner, StartingScope);
3341 return InstPartialSpec;
3345 TemplateDeclInstantiator::SubstFunctionType(FunctionDecl *D,
3346 SmallVectorImpl<ParmVarDecl *> &Params) {
3347 TypeSourceInfo *OldTInfo = D->getTypeSourceInfo();
3348 assert(OldTInfo && "substituting function without type source info");
3349 assert(Params.empty() && "parameter vector is non-empty at start");
3351 CXXRecordDecl *ThisContext = nullptr;
3352 unsigned ThisTypeQuals = 0;
3353 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
3354 ThisContext = cast<CXXRecordDecl>(Owner);
3355 ThisTypeQuals = Method->getTypeQualifiers();
3358 TypeSourceInfo *NewTInfo
3359 = SemaRef.SubstFunctionDeclType(OldTInfo, TemplateArgs,
3360 D->getTypeSpecStartLoc(),
3362 ThisContext, ThisTypeQuals);
3366 TypeLoc OldTL = OldTInfo->getTypeLoc().IgnoreParens();
3367 if (FunctionProtoTypeLoc OldProtoLoc = OldTL.getAs<FunctionProtoTypeLoc>()) {
3368 if (NewTInfo != OldTInfo) {
3369 // Get parameters from the new type info.
3370 TypeLoc NewTL = NewTInfo->getTypeLoc().IgnoreParens();
3371 FunctionProtoTypeLoc NewProtoLoc = NewTL.castAs<FunctionProtoTypeLoc>();
3372 unsigned NewIdx = 0;
3373 for (unsigned OldIdx = 0, NumOldParams = OldProtoLoc.getNumParams();
3374 OldIdx != NumOldParams; ++OldIdx) {
3375 ParmVarDecl *OldParam = OldProtoLoc.getParam(OldIdx);
3376 LocalInstantiationScope *Scope = SemaRef.CurrentInstantiationScope;
3378 Optional<unsigned> NumArgumentsInExpansion;
3379 if (OldParam->isParameterPack())
3380 NumArgumentsInExpansion =
3381 SemaRef.getNumArgumentsInExpansion(OldParam->getType(),
3383 if (!NumArgumentsInExpansion) {
3384 // Simple case: normal parameter, or a parameter pack that's
3385 // instantiated to a (still-dependent) parameter pack.
3386 ParmVarDecl *NewParam = NewProtoLoc.getParam(NewIdx++);
3387 Params.push_back(NewParam);
3388 Scope->InstantiatedLocal(OldParam, NewParam);
3390 // Parameter pack expansion: make the instantiation an argument pack.
3391 Scope->MakeInstantiatedLocalArgPack(OldParam);
3392 for (unsigned I = 0; I != *NumArgumentsInExpansion; ++I) {
3393 ParmVarDecl *NewParam = NewProtoLoc.getParam(NewIdx++);
3394 Params.push_back(NewParam);
3395 Scope->InstantiatedLocalPackArg(OldParam, NewParam);
3400 // The function type itself was not dependent and therefore no
3401 // substitution occurred. However, we still need to instantiate
3402 // the function parameters themselves.
3403 const FunctionProtoType *OldProto =
3404 cast<FunctionProtoType>(OldProtoLoc.getType());
3405 for (unsigned i = 0, i_end = OldProtoLoc.getNumParams(); i != i_end;
3407 ParmVarDecl *OldParam = OldProtoLoc.getParam(i);
3409 Params.push_back(SemaRef.BuildParmVarDeclForTypedef(
3410 D, D->getLocation(), OldProto->getParamType(i)));
3415 cast_or_null<ParmVarDecl>(VisitParmVarDecl(OldParam));
3418 Params.push_back(Parm);
3422 // If the type of this function, after ignoring parentheses, is not
3423 // *directly* a function type, then we're instantiating a function that
3424 // was declared via a typedef or with attributes, e.g.,
3426 // typedef int functype(int, int);
3428 // int __cdecl meth(int, int);
3430 // In this case, we'll just go instantiate the ParmVarDecls that we
3431 // synthesized in the method declaration.
3432 SmallVector<QualType, 4> ParamTypes;
3433 Sema::ExtParameterInfoBuilder ExtParamInfos;
3434 if (SemaRef.SubstParmTypes(D->getLocation(), D->parameters(), nullptr,
3435 TemplateArgs, ParamTypes, &Params,
3443 /// Introduce the instantiated function parameters into the local
3444 /// instantiation scope, and set the parameter names to those used
3445 /// in the template.
3446 static bool addInstantiatedParametersToScope(Sema &S, FunctionDecl *Function,
3447 const FunctionDecl *PatternDecl,
3448 LocalInstantiationScope &Scope,
3449 const MultiLevelTemplateArgumentList &TemplateArgs) {
3450 unsigned FParamIdx = 0;
3451 for (unsigned I = 0, N = PatternDecl->getNumParams(); I != N; ++I) {
3452 const ParmVarDecl *PatternParam = PatternDecl->getParamDecl(I);
3453 if (!PatternParam->isParameterPack()) {
3454 // Simple case: not a parameter pack.
3455 assert(FParamIdx < Function->getNumParams());
3456 ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx);
3457 FunctionParam->setDeclName(PatternParam->getDeclName());
3458 // If the parameter's type is not dependent, update it to match the type
3459 // in the pattern. They can differ in top-level cv-qualifiers, and we want
3460 // the pattern's type here. If the type is dependent, they can't differ,
3461 // per core issue 1668. Substitute into the type from the pattern, in case
3462 // it's instantiation-dependent.
3463 // FIXME: Updating the type to work around this is at best fragile.
3464 if (!PatternDecl->getType()->isDependentType()) {
3465 QualType T = S.SubstType(PatternParam->getType(), TemplateArgs,
3466 FunctionParam->getLocation(),
3467 FunctionParam->getDeclName());
3470 FunctionParam->setType(T);
3473 Scope.InstantiatedLocal(PatternParam, FunctionParam);
3478 // Expand the parameter pack.
3479 Scope.MakeInstantiatedLocalArgPack(PatternParam);
3480 Optional<unsigned> NumArgumentsInExpansion
3481 = S.getNumArgumentsInExpansion(PatternParam->getType(), TemplateArgs);
3482 assert(NumArgumentsInExpansion &&
3483 "should only be called when all template arguments are known");
3484 QualType PatternType =
3485 PatternParam->getType()->castAs<PackExpansionType>()->getPattern();
3486 for (unsigned Arg = 0; Arg < *NumArgumentsInExpansion; ++Arg) {
3487 ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx);
3488 FunctionParam->setDeclName(PatternParam->getDeclName());
3489 if (!PatternDecl->getType()->isDependentType()) {
3490 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, Arg);
3491 QualType T = S.SubstType(PatternType, TemplateArgs,
3492 FunctionParam->getLocation(),
3493 FunctionParam->getDeclName());
3496 FunctionParam->setType(T);
3499 Scope.InstantiatedLocalPackArg(PatternParam, FunctionParam);
3507 void Sema::InstantiateExceptionSpec(SourceLocation PointOfInstantiation,
3508 FunctionDecl *Decl) {
3509 const FunctionProtoType *Proto = Decl->getType()->castAs<FunctionProtoType>();
3510 if (Proto->getExceptionSpecType() != EST_Uninstantiated)
3513 InstantiatingTemplate Inst(*this, PointOfInstantiation, Decl,
3514 InstantiatingTemplate::ExceptionSpecification());
3515 if (Inst.isInvalid()) {
3516 // We hit the instantiation depth limit. Clear the exception specification
3517 // so that our callers don't have to cope with EST_Uninstantiated.
3518 UpdateExceptionSpec(Decl, EST_None);
3521 if (Inst.isAlreadyInstantiating()) {
3522 // This exception specification indirectly depends on itself. Reject.
3523 // FIXME: Corresponding rule in the standard?
3524 Diag(PointOfInstantiation, diag::err_exception_spec_cycle) << Decl;
3525 UpdateExceptionSpec(Decl, EST_None);
3529 // Enter the scope of this instantiation. We don't use
3530 // PushDeclContext because we don't have a scope.
3531 Sema::ContextRAII savedContext(*this, Decl);
3532 LocalInstantiationScope Scope(*this);
3534 MultiLevelTemplateArgumentList TemplateArgs =
3535 getTemplateInstantiationArgs(Decl, nullptr, /*RelativeToPrimary*/true);
3537 FunctionDecl *Template = Proto->getExceptionSpecTemplate();
3538 if (addInstantiatedParametersToScope(*this, Decl, Template, Scope,
3540 UpdateExceptionSpec(Decl, EST_None);
3544 SubstExceptionSpec(Decl, Template->getType()->castAs<FunctionProtoType>(),
3548 /// \brief Initializes the common fields of an instantiation function
3549 /// declaration (New) from the corresponding fields of its template (Tmpl).
3551 /// \returns true if there was an error
3553 TemplateDeclInstantiator::InitFunctionInstantiation(FunctionDecl *New,
3554 FunctionDecl *Tmpl) {
3555 if (Tmpl->isDeleted())
3556 New->setDeletedAsWritten();
3558 // Forward the mangling number from the template to the instantiated decl.
3559 SemaRef.Context.setManglingNumber(New,
3560 SemaRef.Context.getManglingNumber(Tmpl));
3562 // If we are performing substituting explicitly-specified template arguments
3563 // or deduced template arguments into a function template and we reach this
3564 // point, we are now past the point where SFINAE applies and have committed
3565 // to keeping the new function template specialization. We therefore
3566 // convert the active template instantiation for the function template
3567 // into a template instantiation for this specific function template
3568 // specialization, which is not a SFINAE context, so that we diagnose any
3569 // further errors in the declaration itself.
3570 typedef Sema::ActiveTemplateInstantiation ActiveInstType;
3571 ActiveInstType &ActiveInst = SemaRef.ActiveTemplateInstantiations.back();
3572 if (ActiveInst.Kind == ActiveInstType::ExplicitTemplateArgumentSubstitution ||
3573 ActiveInst.Kind == ActiveInstType::DeducedTemplateArgumentSubstitution) {
3574 if (FunctionTemplateDecl *FunTmpl
3575 = dyn_cast<FunctionTemplateDecl>(ActiveInst.Entity)) {
3576 assert(FunTmpl->getTemplatedDecl() == Tmpl &&
3577 "Deduction from the wrong function template?");
3579 ActiveInst.Kind = ActiveInstType::TemplateInstantiation;
3580 ActiveInst.Entity = New;
3584 const FunctionProtoType *Proto = Tmpl->getType()->getAs<FunctionProtoType>();
3585 assert(Proto && "Function template without prototype?");
3587 if (Proto->hasExceptionSpec() || Proto->getNoReturnAttr()) {
3588 FunctionProtoType::ExtProtoInfo EPI = Proto->getExtProtoInfo();
3590 // DR1330: In C++11, defer instantiation of a non-trivial
3591 // exception specification.
3592 // DR1484: Local classes and their members are instantiated along with the
3593 // containing function.
3594 if (SemaRef.getLangOpts().CPlusPlus11 &&
3595 EPI.ExceptionSpec.Type != EST_None &&
3596 EPI.ExceptionSpec.Type != EST_DynamicNone &&
3597 EPI.ExceptionSpec.Type != EST_BasicNoexcept &&
3598 !Tmpl->isLexicallyWithinFunctionOrMethod()) {
3599 FunctionDecl *ExceptionSpecTemplate = Tmpl;
3600 if (EPI.ExceptionSpec.Type == EST_Uninstantiated)
3601 ExceptionSpecTemplate = EPI.ExceptionSpec.SourceTemplate;
3602 ExceptionSpecificationType NewEST = EST_Uninstantiated;
3603 if (EPI.ExceptionSpec.Type == EST_Unevaluated)
3604 NewEST = EST_Unevaluated;
3606 // Mark the function has having an uninstantiated exception specification.
3607 const FunctionProtoType *NewProto
3608 = New->getType()->getAs<FunctionProtoType>();
3609 assert(NewProto && "Template instantiation without function prototype?");
3610 EPI = NewProto->getExtProtoInfo();
3611 EPI.ExceptionSpec.Type = NewEST;
3612 EPI.ExceptionSpec.SourceDecl = New;
3613 EPI.ExceptionSpec.SourceTemplate = ExceptionSpecTemplate;
3614 New->setType(SemaRef.Context.getFunctionType(
3615 NewProto->getReturnType(), NewProto->getParamTypes(), EPI));
3617 SemaRef.SubstExceptionSpec(New, Proto, TemplateArgs);
3621 // Get the definition. Leaves the variable unchanged if undefined.
3622 const FunctionDecl *Definition = Tmpl;
3623 Tmpl->isDefined(Definition);
3625 SemaRef.InstantiateAttrs(TemplateArgs, Definition, New,
3626 LateAttrs, StartingScope);
3631 /// \brief Initializes common fields of an instantiated method
3632 /// declaration (New) from the corresponding fields of its template
3635 /// \returns true if there was an error
3637 TemplateDeclInstantiator::InitMethodInstantiation(CXXMethodDecl *New,
3638 CXXMethodDecl *Tmpl) {
3639 if (InitFunctionInstantiation(New, Tmpl))
3642 New->setAccess(Tmpl->getAccess());
3643 if (Tmpl->isVirtualAsWritten())
3644 New->setVirtualAsWritten(true);
3646 // FIXME: New needs a pointer to Tmpl
3650 /// In the MS ABI, we need to instantiate default arguments of dllexported
3651 /// default constructors along with the constructor definition. This allows IR
3652 /// gen to emit a constructor closure which calls the default constructor with
3653 /// its default arguments.
3654 static void InstantiateDefaultCtorDefaultArgs(Sema &S,
3655 CXXConstructorDecl *Ctor) {
3656 assert(S.Context.getTargetInfo().getCXXABI().isMicrosoft() &&
3657 Ctor->isDefaultConstructor());
3658 unsigned NumParams = Ctor->getNumParams();
3661 DLLExportAttr *Attr = Ctor->getAttr<DLLExportAttr>();
3664 for (unsigned I = 0; I != NumParams; ++I) {
3665 (void)S.CheckCXXDefaultArgExpr(Attr->getLocation(), Ctor,
3666 Ctor->getParamDecl(I));
3667 S.DiscardCleanupsInEvaluationContext();
3671 /// \brief Instantiate the definition of the given function from its
3674 /// \param PointOfInstantiation the point at which the instantiation was
3675 /// required. Note that this is not precisely a "point of instantiation"
3676 /// for the function, but it's close.
3678 /// \param Function the already-instantiated declaration of a
3679 /// function template specialization or member function of a class template
3682 /// \param Recursive if true, recursively instantiates any functions that
3683 /// are required by this instantiation.
3685 /// \param DefinitionRequired if true, then we are performing an explicit
3686 /// instantiation where the body of the function is required. Complain if
3687 /// there is no such body.
3688 void Sema::InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
3689 FunctionDecl *Function,
3691 bool DefinitionRequired,
3693 if (Function->isInvalidDecl() || Function->isDefined())
3696 // Never instantiate an explicit specialization except if it is a class scope
3697 // explicit specialization.
3698 TemplateSpecializationKind TSK = Function->getTemplateSpecializationKind();
3699 if (TSK == TSK_ExplicitSpecialization &&
3700 !Function->getClassScopeSpecializationPattern())
3703 // Find the function body that we'll be substituting.
3704 const FunctionDecl *PatternDecl = Function->getTemplateInstantiationPattern();
3705 assert(PatternDecl && "instantiating a non-template");
3707 const FunctionDecl *PatternDef = PatternDecl->getDefinition();
3708 Stmt *Pattern = nullptr;
3710 Pattern = PatternDef->getBody(PatternDef);
3711 PatternDecl = PatternDef;
3714 // FIXME: We need to track the instantiation stack in order to know which
3715 // definitions should be visible within this instantiation.
3716 if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Function,
3717 Function->getInstantiatedFromMemberFunction(),
3718 PatternDecl, PatternDef, TSK,
3719 /*Complain*/DefinitionRequired)) {
3720 if (DefinitionRequired)
3721 Function->setInvalidDecl();
3722 else if (TSK == TSK_ExplicitInstantiationDefinition) {
3723 // Try again at the end of the translation unit (at which point a
3724 // definition will be required).
3726 PendingInstantiations.push_back(
3727 std::make_pair(Function, PointOfInstantiation));
3728 } else if (TSK == TSK_ImplicitInstantiation) {
3729 if (AtEndOfTU && !getDiagnostics().hasErrorOccurred()) {
3730 Diag(PointOfInstantiation, diag::warn_func_template_missing)
3732 Diag(PatternDecl->getLocation(), diag::note_forward_template_decl);
3733 if (getLangOpts().CPlusPlus11)
3734 Diag(PointOfInstantiation, diag::note_inst_declaration_hint)
3742 // Postpone late parsed template instantiations.
3743 if (PatternDecl->isLateTemplateParsed() &&
3744 !LateTemplateParser) {
3745 PendingInstantiations.push_back(
3746 std::make_pair(Function, PointOfInstantiation));
3750 // If we're performing recursive template instantiation, create our own
3751 // queue of pending implicit instantiations that we will instantiate later,
3752 // while we're still within our own instantiation context.
3753 // This has to happen before LateTemplateParser below is called, so that
3754 // it marks vtables used in late parsed templates as used.
3755 SavePendingLocalImplicitInstantiationsRAII
3756 SavedPendingLocalImplicitInstantiations(*this);
3757 SavePendingInstantiationsAndVTableUsesRAII
3758 SavePendingInstantiationsAndVTableUses(*this, /*Enabled=*/Recursive);
3760 // Call the LateTemplateParser callback if there is a need to late parse
3761 // a templated function definition.
3762 if (!Pattern && PatternDecl->isLateTemplateParsed() &&
3763 LateTemplateParser) {
3764 // FIXME: Optimize to allow individual templates to be deserialized.
3765 if (PatternDecl->isFromASTFile())
3766 ExternalSource->ReadLateParsedTemplates(LateParsedTemplateMap);
3768 auto LPTIter = LateParsedTemplateMap.find(PatternDecl);
3769 assert(LPTIter != LateParsedTemplateMap.end() &&
3770 "missing LateParsedTemplate");
3771 LateTemplateParser(OpaqueParser, *LPTIter->second);
3772 Pattern = PatternDecl->getBody(PatternDecl);
3775 // Note, we should never try to instantiate a deleted function template.
3776 assert((Pattern || PatternDecl->isDefaulted()) &&
3777 "unexpected kind of function template definition");
3779 // C++1y [temp.explicit]p10:
3780 // Except for inline functions, declarations with types deduced from their
3781 // initializer or return value, and class template specializations, other
3782 // explicit instantiation declarations have the effect of suppressing the
3783 // implicit instantiation of the entity to which they refer.
3784 if (TSK == TSK_ExplicitInstantiationDeclaration &&
3785 !PatternDecl->isInlined() &&
3786 !PatternDecl->getReturnType()->getContainedAutoType())
3789 if (PatternDecl->isInlined()) {
3790 // Function, and all later redeclarations of it (from imported modules,
3791 // for instance), are now implicitly inline.
3792 for (auto *D = Function->getMostRecentDecl(); /**/;
3793 D = D->getPreviousDecl()) {
3794 D->setImplicitlyInline();
3800 InstantiatingTemplate Inst(*this, PointOfInstantiation, Function);
3801 if (Inst.isInvalid() || Inst.isAlreadyInstantiating())
3803 PrettyDeclStackTraceEntry CrashInfo(*this, Function, SourceLocation(),
3804 "instantiating function definition");
3806 // The instantiation is visible here, even if it was first declared in an
3807 // unimported module.
3808 Function->setHidden(false);
3810 // Copy the inner loc start from the pattern.
3811 Function->setInnerLocStart(PatternDecl->getInnerLocStart());
3813 EnterExpressionEvaluationContext EvalContext(*this,
3814 Sema::PotentiallyEvaluated);
3816 // Introduce a new scope where local variable instantiations will be
3817 // recorded, unless we're actually a member function within a local
3818 // class, in which case we need to merge our results with the parent
3819 // scope (of the enclosing function).
3820 bool MergeWithParentScope = false;
3821 if (CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Function->getDeclContext()))
3822 MergeWithParentScope = Rec->isLocalClass();
3824 LocalInstantiationScope Scope(*this, MergeWithParentScope);
3826 if (PatternDecl->isDefaulted())
3827 SetDeclDefaulted(Function, PatternDecl->getLocation());
3829 MultiLevelTemplateArgumentList TemplateArgs =
3830 getTemplateInstantiationArgs(Function, nullptr, false, PatternDecl);
3832 // Substitute into the qualifier; we can get a substitution failure here
3833 // through evil use of alias templates.
3834 // FIXME: Is CurContext correct for this? Should we go to the (instantiation
3835 // of the) lexical context of the pattern?
3836 SubstQualifier(*this, PatternDecl, Function, TemplateArgs);
3838 ActOnStartOfFunctionDef(nullptr, Function);
3840 // Enter the scope of this instantiation. We don't use
3841 // PushDeclContext because we don't have a scope.
3842 Sema::ContextRAII savedContext(*this, Function);
3844 if (addInstantiatedParametersToScope(*this, Function, PatternDecl, Scope,
3848 if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(Function)) {
3849 // If this is a constructor, instantiate the member initializers.
3850 InstantiateMemInitializers(Ctor, cast<CXXConstructorDecl>(PatternDecl),
3853 // If this is an MS ABI dllexport default constructor, instantiate any
3854 // default arguments.
3855 if (Context.getTargetInfo().getCXXABI().isMicrosoft() &&
3856 Ctor->isDefaultConstructor()) {
3857 InstantiateDefaultCtorDefaultArgs(*this, Ctor);
3861 // Instantiate the function body.
3862 StmtResult Body = SubstStmt(Pattern, TemplateArgs);
3864 if (Body.isInvalid())
3865 Function->setInvalidDecl();
3867 ActOnFinishFunctionBody(Function, Body.get(),
3868 /*IsInstantiation=*/true);
3870 PerformDependentDiagnostics(PatternDecl, TemplateArgs);
3872 if (auto *Listener = getASTMutationListener())
3873 Listener->FunctionDefinitionInstantiated(Function);
3878 DeclGroupRef DG(Function);
3879 Consumer.HandleTopLevelDecl(DG);
3881 // This class may have local implicit instantiations that need to be
3882 // instantiation within this scope.
3883 PerformPendingInstantiations(/*LocalOnly=*/true);
3887 // Define any pending vtables.
3888 DefineUsedVTables();
3890 // Instantiate any pending implicit instantiations found during the
3891 // instantiation of this template.
3892 PerformPendingInstantiations();
3894 // PendingInstantiations and VTableUses are restored through
3895 // SavePendingInstantiationsAndVTableUses's destructor.
3899 VarTemplateSpecializationDecl *Sema::BuildVarTemplateInstantiation(
3900 VarTemplateDecl *VarTemplate, VarDecl *FromVar,
3901 const TemplateArgumentList &TemplateArgList,
3902 const TemplateArgumentListInfo &TemplateArgsInfo,
3903 SmallVectorImpl<TemplateArgument> &Converted,
3904 SourceLocation PointOfInstantiation, void *InsertPos,
3905 LateInstantiatedAttrVec *LateAttrs,
3906 LocalInstantiationScope *StartingScope) {
3907 if (FromVar->isInvalidDecl())
3910 InstantiatingTemplate Inst(*this, PointOfInstantiation, FromVar);
3911 if (Inst.isInvalid())
3914 MultiLevelTemplateArgumentList TemplateArgLists;
3915 TemplateArgLists.addOuterTemplateArguments(&TemplateArgList);
3917 // Instantiate the first declaration of the variable template: for a partial
3918 // specialization of a static data member template, the first declaration may
3919 // or may not be the declaration in the class; if it's in the class, we want
3920 // to instantiate a member in the class (a declaration), and if it's outside,
3921 // we want to instantiate a definition.
3923 // If we're instantiating an explicitly-specialized member template or member
3924 // partial specialization, don't do this. The member specialization completely
3925 // replaces the original declaration in this case.
3926 bool IsMemberSpec = false;
3927 if (VarTemplatePartialSpecializationDecl *PartialSpec =
3928 dyn_cast<VarTemplatePartialSpecializationDecl>(FromVar))
3929 IsMemberSpec = PartialSpec->isMemberSpecialization();
3930 else if (VarTemplateDecl *FromTemplate = FromVar->getDescribedVarTemplate())
3931 IsMemberSpec = FromTemplate->isMemberSpecialization();
3933 FromVar = FromVar->getFirstDecl();
3935 MultiLevelTemplateArgumentList MultiLevelList(TemplateArgList);
3936 TemplateDeclInstantiator Instantiator(*this, FromVar->getDeclContext(),
3939 // TODO: Set LateAttrs and StartingScope ...
3941 return cast_or_null<VarTemplateSpecializationDecl>(
3942 Instantiator.VisitVarTemplateSpecializationDecl(
3943 VarTemplate, FromVar, InsertPos, TemplateArgsInfo, Converted));
3946 /// \brief Instantiates a variable template specialization by completing it
3947 /// with appropriate type information and initializer.
3948 VarTemplateSpecializationDecl *Sema::CompleteVarTemplateSpecializationDecl(
3949 VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl,
3950 const MultiLevelTemplateArgumentList &TemplateArgs) {
3952 // Do substitution on the type of the declaration
3953 TypeSourceInfo *DI =
3954 SubstType(PatternDecl->getTypeSourceInfo(), TemplateArgs,
3955 PatternDecl->getTypeSpecStartLoc(), PatternDecl->getDeclName());
3959 // Update the type of this variable template specialization.
3960 VarSpec->setType(DI->getType());
3962 // Instantiate the initializer.
3963 InstantiateVariableInitializer(VarSpec, PatternDecl, TemplateArgs);
3968 /// BuildVariableInstantiation - Used after a new variable has been created.
3969 /// Sets basic variable data and decides whether to postpone the
3970 /// variable instantiation.
3971 void Sema::BuildVariableInstantiation(
3972 VarDecl *NewVar, VarDecl *OldVar,
3973 const MultiLevelTemplateArgumentList &TemplateArgs,
3974 LateInstantiatedAttrVec *LateAttrs, DeclContext *Owner,
3975 LocalInstantiationScope *StartingScope,
3976 bool InstantiatingVarTemplate) {
3978 // If we are instantiating a local extern declaration, the
3979 // instantiation belongs lexically to the containing function.
3980 // If we are instantiating a static data member defined
3981 // out-of-line, the instantiation will have the same lexical
3982 // context (which will be a namespace scope) as the template.
3983 if (OldVar->isLocalExternDecl()) {
3984 NewVar->setLocalExternDecl();
3985 NewVar->setLexicalDeclContext(Owner);
3986 } else if (OldVar->isOutOfLine())
3987 NewVar->setLexicalDeclContext(OldVar->getLexicalDeclContext());
3988 NewVar->setTSCSpec(OldVar->getTSCSpec());
3989 NewVar->setInitStyle(OldVar->getInitStyle());
3990 NewVar->setCXXForRangeDecl(OldVar->isCXXForRangeDecl());
3991 NewVar->setConstexpr(OldVar->isConstexpr());
3992 NewVar->setInitCapture(OldVar->isInitCapture());
3993 NewVar->setPreviousDeclInSameBlockScope(
3994 OldVar->isPreviousDeclInSameBlockScope());
3995 NewVar->setAccess(OldVar->getAccess());
3997 if (!OldVar->isStaticDataMember()) {
3998 if (OldVar->isUsed(false))
3999 NewVar->setIsUsed();
4000 NewVar->setReferenced(OldVar->isReferenced());
4003 InstantiateAttrs(TemplateArgs, OldVar, NewVar, LateAttrs, StartingScope);
4005 LookupResult Previous(
4006 *this, NewVar->getDeclName(), NewVar->getLocation(),
4007 NewVar->isLocalExternDecl() ? Sema::LookupRedeclarationWithLinkage
4008 : Sema::LookupOrdinaryName,
4009 Sema::ForRedeclaration);
4011 if (NewVar->isLocalExternDecl() && OldVar->getPreviousDecl() &&
4012 (!OldVar->getPreviousDecl()->getDeclContext()->isDependentContext() ||
4013 OldVar->getPreviousDecl()->getDeclContext()==OldVar->getDeclContext())) {
4014 // We have a previous declaration. Use that one, so we merge with the
4016 if (NamedDecl *NewPrev = FindInstantiatedDecl(
4017 NewVar->getLocation(), OldVar->getPreviousDecl(), TemplateArgs))
4018 Previous.addDecl(NewPrev);
4019 } else if (!isa<VarTemplateSpecializationDecl>(NewVar) &&
4020 OldVar->hasLinkage())
4021 LookupQualifiedName(Previous, NewVar->getDeclContext(), false);
4022 CheckVariableDeclaration(NewVar, Previous);
4024 if (!InstantiatingVarTemplate) {
4025 NewVar->getLexicalDeclContext()->addHiddenDecl(NewVar);
4026 if (!NewVar->isLocalExternDecl() || !NewVar->getPreviousDecl())
4027 NewVar->getDeclContext()->makeDeclVisibleInContext(NewVar);
4030 if (!OldVar->isOutOfLine()) {
4031 if (NewVar->getDeclContext()->isFunctionOrMethod())
4032 CurrentInstantiationScope->InstantiatedLocal(OldVar, NewVar);
4035 // Link instantiations of static data members back to the template from
4036 // which they were instantiated.
4037 if (NewVar->isStaticDataMember() && !InstantiatingVarTemplate)
4038 NewVar->setInstantiationOfStaticDataMember(OldVar,
4039 TSK_ImplicitInstantiation);
4041 // Forward the mangling number from the template to the instantiated decl.
4042 Context.setManglingNumber(NewVar, Context.getManglingNumber(OldVar));
4043 Context.setStaticLocalNumber(NewVar, Context.getStaticLocalNumber(OldVar));
4045 // Delay instantiation of the initializer for variable templates or inline
4046 // static data members until a definition of the variable is needed. We need
4047 // it right away if the type contains 'auto'.
4048 if ((!isa<VarTemplateSpecializationDecl>(NewVar) &&
4049 !InstantiatingVarTemplate &&
4050 !(OldVar->isInline() && OldVar->isThisDeclarationADefinition())) ||
4051 NewVar->getType()->isUndeducedType())
4052 InstantiateVariableInitializer(NewVar, OldVar, TemplateArgs);
4054 // Diagnose unused local variables with dependent types, where the diagnostic
4055 // will have been deferred.
4056 if (!NewVar->isInvalidDecl() &&
4057 NewVar->getDeclContext()->isFunctionOrMethod() &&
4058 OldVar->getType()->isDependentType())
4059 DiagnoseUnusedDecl(NewVar);
4062 /// \brief Instantiate the initializer of a variable.
4063 void Sema::InstantiateVariableInitializer(
4064 VarDecl *Var, VarDecl *OldVar,
4065 const MultiLevelTemplateArgumentList &TemplateArgs) {
4066 // We propagate the 'inline' flag with the initializer, because it
4067 // would otherwise imply that the variable is a definition for a
4068 // non-static data member.
4069 if (OldVar->isInlineSpecified())
4070 Var->setInlineSpecified();
4071 else if (OldVar->isInline())
4072 Var->setImplicitlyInline();
4074 if (OldVar->getInit()) {
4075 if (Var->isStaticDataMember() && !OldVar->isOutOfLine())
4076 PushExpressionEvaluationContext(Sema::ConstantEvaluated, OldVar);
4078 PushExpressionEvaluationContext(Sema::PotentiallyEvaluated, OldVar);
4080 // Instantiate the initializer.
4084 ContextRAII SwitchContext(*this, Var->getDeclContext());
4085 Init = SubstInitializer(OldVar->getInit(), TemplateArgs,
4086 OldVar->getInitStyle() == VarDecl::CallInit);
4089 if (!Init.isInvalid()) {
4090 Expr *InitExpr = Init.get();
4092 if (Var->hasAttr<DLLImportAttr>() &&
4094 !InitExpr->isConstantInitializer(getASTContext(), false))) {
4095 // Do not dynamically initialize dllimport variables.
4096 } else if (InitExpr) {
4097 bool DirectInit = OldVar->isDirectInit();
4098 AddInitializerToDecl(Var, InitExpr, DirectInit);
4100 ActOnUninitializedDecl(Var);
4102 // FIXME: Not too happy about invalidating the declaration
4103 // because of a bogus initializer.
4104 Var->setInvalidDecl();
4107 PopExpressionEvaluationContext();
4109 if (Var->isStaticDataMember()) {
4110 if (!Var->isOutOfLine())
4113 // If the declaration inside the class had an initializer, don't add
4114 // another one to the out-of-line definition.
4115 if (OldVar->getFirstDecl()->hasInit())
4119 // We'll add an initializer to a for-range declaration later.
4120 if (Var->isCXXForRangeDecl())
4123 ActOnUninitializedDecl(Var);
4127 /// \brief Instantiate the definition of the given variable from its
4130 /// \param PointOfInstantiation the point at which the instantiation was
4131 /// required. Note that this is not precisely a "point of instantiation"
4132 /// for the function, but it's close.
4134 /// \param Var the already-instantiated declaration of a static member
4135 /// variable of a class template specialization.
4137 /// \param Recursive if true, recursively instantiates any functions that
4138 /// are required by this instantiation.
4140 /// \param DefinitionRequired if true, then we are performing an explicit
4141 /// instantiation where an out-of-line definition of the member variable
4142 /// is required. Complain if there is no such definition.
4143 void Sema::InstantiateStaticDataMemberDefinition(
4144 SourceLocation PointOfInstantiation,
4147 bool DefinitionRequired) {
4148 InstantiateVariableDefinition(PointOfInstantiation, Var, Recursive,
4149 DefinitionRequired);
4152 void Sema::InstantiateVariableDefinition(SourceLocation PointOfInstantiation,
4153 VarDecl *Var, bool Recursive,
4154 bool DefinitionRequired, bool AtEndOfTU) {
4155 if (Var->isInvalidDecl())
4158 VarTemplateSpecializationDecl *VarSpec =
4159 dyn_cast<VarTemplateSpecializationDecl>(Var);
4160 VarDecl *PatternDecl = nullptr, *Def = nullptr;
4161 MultiLevelTemplateArgumentList TemplateArgs =
4162 getTemplateInstantiationArgs(Var);
4165 // If this is a variable template specialization, make sure that it is
4166 // non-dependent, then find its instantiation pattern.
4167 bool InstantiationDependent = false;
4168 assert(!TemplateSpecializationType::anyDependentTemplateArguments(
4169 VarSpec->getTemplateArgsInfo(), InstantiationDependent) &&
4170 "Only instantiate variable template specializations that are "
4171 "not type-dependent");
4172 (void)InstantiationDependent;
4174 // Find the variable initialization that we'll be substituting. If the
4175 // pattern was instantiated from a member template, look back further to
4176 // find the real pattern.
4177 assert(VarSpec->getSpecializedTemplate() &&
4178 "Specialization without specialized template?");
4179 llvm::PointerUnion<VarTemplateDecl *,
4180 VarTemplatePartialSpecializationDecl *> PatternPtr =
4181 VarSpec->getSpecializedTemplateOrPartial();
4182 if (PatternPtr.is<VarTemplatePartialSpecializationDecl *>()) {
4183 VarTemplatePartialSpecializationDecl *Tmpl =
4184 PatternPtr.get<VarTemplatePartialSpecializationDecl *>();
4185 while (VarTemplatePartialSpecializationDecl *From =
4186 Tmpl->getInstantiatedFromMember()) {
4187 if (Tmpl->isMemberSpecialization())
4194 VarTemplateDecl *Tmpl = PatternPtr.get<VarTemplateDecl *>();
4195 while (VarTemplateDecl *From =
4196 Tmpl->getInstantiatedFromMemberTemplate()) {
4197 if (Tmpl->isMemberSpecialization())
4202 PatternDecl = Tmpl->getTemplatedDecl();
4205 // If this is a static data member template, there might be an
4206 // uninstantiated initializer on the declaration. If so, instantiate
4208 if (PatternDecl->isStaticDataMember() &&
4209 (PatternDecl = PatternDecl->getFirstDecl())->hasInit() &&
4211 // FIXME: Factor out the duplicated instantiation context setup/tear down
4213 InstantiatingTemplate Inst(*this, PointOfInstantiation, Var);
4214 if (Inst.isInvalid() || Inst.isAlreadyInstantiating())
4216 PrettyDeclStackTraceEntry CrashInfo(*this, Var, SourceLocation(),
4217 "instantiating variable initializer");
4219 // The instantiation is visible here, even if it was first declared in an
4220 // unimported module.
4221 Var->setHidden(false);
4223 // If we're performing recursive template instantiation, create our own
4224 // queue of pending implicit instantiations that we will instantiate
4225 // later, while we're still within our own instantiation context.
4226 SavePendingInstantiationsAndVTableUsesRAII
4227 SavePendingInstantiationsAndVTableUses(*this, /*Enabled=*/Recursive);
4229 LocalInstantiationScope Local(*this);
4231 // Enter the scope of this instantiation. We don't use
4232 // PushDeclContext because we don't have a scope.
4233 ContextRAII PreviousContext(*this, Var->getDeclContext());
4234 InstantiateVariableInitializer(Var, PatternDecl, TemplateArgs);
4235 PreviousContext.pop();
4237 // FIXME: Need to inform the ASTConsumer that we instantiated the
4240 // This variable may have local implicit instantiations that need to be
4241 // instantiated within this scope.
4242 PerformPendingInstantiations(/*LocalOnly=*/true);
4247 // Define any newly required vtables.
4248 DefineUsedVTables();
4250 // Instantiate any pending implicit instantiations found during the
4251 // instantiation of this template.
4252 PerformPendingInstantiations();
4254 // PendingInstantiations and VTableUses are restored through
4255 // SavePendingInstantiationsAndVTableUses's destructor.
4259 // Find actual definition
4260 Def = PatternDecl->getDefinition(getASTContext());
4262 // If this is a static data member, find its out-of-line definition.
4263 assert(Var->isStaticDataMember() && "not a static data member?");
4264 PatternDecl = Var->getInstantiatedFromStaticDataMember();
4266 assert(PatternDecl && "data member was not instantiated from a template?");
4267 assert(PatternDecl->isStaticDataMember() && "not a static data member?");
4268 Def = PatternDecl->getDefinition();
4271 TemplateSpecializationKind TSK = Var->getTemplateSpecializationKind();
4273 // If we don't have a definition of the variable template, we won't perform
4274 // any instantiation. Rather, we rely on the user to instantiate this
4275 // definition (or provide a specialization for it) in another translation
4277 if (!Def && !DefinitionRequired) {
4278 if (TSK == TSK_ExplicitInstantiationDefinition) {
4279 PendingInstantiations.push_back(
4280 std::make_pair(Var, PointOfInstantiation));
4281 } else if (TSK == TSK_ImplicitInstantiation) {
4282 // Warn about missing definition at the end of translation unit.
4283 if (AtEndOfTU && !getDiagnostics().hasErrorOccurred()) {
4284 Diag(PointOfInstantiation, diag::warn_var_template_missing)
4286 Diag(PatternDecl->getLocation(), diag::note_forward_template_decl);
4287 if (getLangOpts().CPlusPlus11)
4288 Diag(PointOfInstantiation, diag::note_inst_declaration_hint) << Var;
4295 // FIXME: We need to track the instantiation stack in order to know which
4296 // definitions should be visible within this instantiation.
4297 // FIXME: Produce diagnostics when Var->getInstantiatedFromStaticDataMember().
4298 if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Var,
4299 /*InstantiatedFromMember*/false,
4300 PatternDecl, Def, TSK,
4301 /*Complain*/DefinitionRequired))
4305 // Never instantiate an explicit specialization.
4306 if (TSK == TSK_ExplicitSpecialization)
4309 // C++11 [temp.explicit]p10:
4310 // Except for inline functions, [...] explicit instantiation declarations
4311 // have the effect of suppressing the implicit instantiation of the entity
4312 // to which they refer.
4313 if (TSK == TSK_ExplicitInstantiationDeclaration)
4316 // Make sure to pass the instantiated variable to the consumer at the end.
4317 struct PassToConsumerRAII {
4318 ASTConsumer &Consumer;
4321 PassToConsumerRAII(ASTConsumer &Consumer, VarDecl *Var)
4322 : Consumer(Consumer), Var(Var) { }
4324 ~PassToConsumerRAII() {
4325 Consumer.HandleCXXStaticMemberVarInstantiation(Var);
4327 } PassToConsumerRAII(Consumer, Var);
4329 // If we already have a definition, we're done.
4330 if (VarDecl *Def = Var->getDefinition()) {
4331 // We may be explicitly instantiating something we've already implicitly
4333 Def->setTemplateSpecializationKind(Var->getTemplateSpecializationKind(),
4334 PointOfInstantiation);
4338 InstantiatingTemplate Inst(*this, PointOfInstantiation, Var);
4339 if (Inst.isInvalid() || Inst.isAlreadyInstantiating())
4341 PrettyDeclStackTraceEntry CrashInfo(*this, Var, SourceLocation(),
4342 "instantiating variable definition");
4344 // If we're performing recursive template instantiation, create our own
4345 // queue of pending implicit instantiations that we will instantiate later,
4346 // while we're still within our own instantiation context.
4347 SavePendingLocalImplicitInstantiationsRAII
4348 SavedPendingLocalImplicitInstantiations(*this);
4349 SavePendingInstantiationsAndVTableUsesRAII
4350 SavePendingInstantiationsAndVTableUses(*this, /*Enabled=*/Recursive);
4352 // Enter the scope of this instantiation. We don't use
4353 // PushDeclContext because we don't have a scope.
4354 ContextRAII PreviousContext(*this, Var->getDeclContext());
4355 LocalInstantiationScope Local(*this);
4357 VarDecl *OldVar = Var;
4358 if (Def->isStaticDataMember() && !Def->isOutOfLine()) {
4359 // We're instantiating an inline static data member whose definition was
4360 // provided inside the class.
4361 // FIXME: Update record?
4362 InstantiateVariableInitializer(Var, Def, TemplateArgs);
4363 } else if (!VarSpec) {
4364 Var = cast_or_null<VarDecl>(SubstDecl(Def, Var->getDeclContext(),
4366 } else if (Var->isStaticDataMember() &&
4367 Var->getLexicalDeclContext()->isRecord()) {
4368 // We need to instantiate the definition of a static data member template,
4369 // and all we have is the in-class declaration of it. Instantiate a separate
4370 // declaration of the definition.
4371 TemplateDeclInstantiator Instantiator(*this, Var->getDeclContext(),
4373 Var = cast_or_null<VarDecl>(Instantiator.VisitVarTemplateSpecializationDecl(
4374 VarSpec->getSpecializedTemplate(), Def, nullptr,
4375 VarSpec->getTemplateArgsInfo(), VarSpec->getTemplateArgs().asArray()));
4377 llvm::PointerUnion<VarTemplateDecl *,
4378 VarTemplatePartialSpecializationDecl *> PatternPtr =
4379 VarSpec->getSpecializedTemplateOrPartial();
4380 if (VarTemplatePartialSpecializationDecl *Partial =
4381 PatternPtr.dyn_cast<VarTemplatePartialSpecializationDecl *>())
4382 cast<VarTemplateSpecializationDecl>(Var)->setInstantiationOf(
4383 Partial, &VarSpec->getTemplateInstantiationArgs());
4385 // Merge the definition with the declaration.
4386 LookupResult R(*this, Var->getDeclName(), Var->getLocation(),
4387 LookupOrdinaryName, ForRedeclaration);
4389 MergeVarDecl(Var, R);
4391 // Attach the initializer.
4392 InstantiateVariableInitializer(Var, Def, TemplateArgs);
4395 // Complete the existing variable's definition with an appropriately
4396 // substituted type and initializer.
4397 Var = CompleteVarTemplateSpecializationDecl(VarSpec, Def, TemplateArgs);
4399 PreviousContext.pop();
4402 PassToConsumerRAII.Var = Var;
4403 Var->setTemplateSpecializationKind(OldVar->getTemplateSpecializationKind(),
4404 OldVar->getPointOfInstantiation());
4407 // This variable may have local implicit instantiations that need to be
4408 // instantiated within this scope.
4409 PerformPendingInstantiations(/*LocalOnly=*/true);
4414 // Define any newly required vtables.
4415 DefineUsedVTables();
4417 // Instantiate any pending implicit instantiations found during the
4418 // instantiation of this template.
4419 PerformPendingInstantiations();
4421 // PendingInstantiations and VTableUses are restored through
4422 // SavePendingInstantiationsAndVTableUses's destructor.
4427 Sema::InstantiateMemInitializers(CXXConstructorDecl *New,
4428 const CXXConstructorDecl *Tmpl,
4429 const MultiLevelTemplateArgumentList &TemplateArgs) {
4431 SmallVector<CXXCtorInitializer*, 4> NewInits;
4432 bool AnyErrors = Tmpl->isInvalidDecl();
4434 // Instantiate all the initializers.
4435 for (const auto *Init : Tmpl->inits()) {
4436 // Only instantiate written initializers, let Sema re-construct implicit
4438 if (!Init->isWritten())
4441 SourceLocation EllipsisLoc;
4443 if (Init->isPackExpansion()) {
4444 // This is a pack expansion. We should expand it now.
4445 TypeLoc BaseTL = Init->getTypeSourceInfo()->getTypeLoc();
4446 SmallVector<UnexpandedParameterPack, 4> Unexpanded;
4447 collectUnexpandedParameterPacks(BaseTL, Unexpanded);
4448 collectUnexpandedParameterPacks(Init->getInit(), Unexpanded);
4449 bool ShouldExpand = false;
4450 bool RetainExpansion = false;
4451 Optional<unsigned> NumExpansions;
4452 if (CheckParameterPacksForExpansion(Init->getEllipsisLoc(),
4453 BaseTL.getSourceRange(),
4455 TemplateArgs, ShouldExpand,
4459 New->setInvalidDecl();
4462 assert(ShouldExpand && "Partial instantiation of base initializer?");
4464 // Loop over all of the arguments in the argument pack(s),
4465 for (unsigned I = 0; I != *NumExpansions; ++I) {
4466 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, I);
4468 // Instantiate the initializer.
4469 ExprResult TempInit = SubstInitializer(Init->getInit(), TemplateArgs,
4470 /*CXXDirectInit=*/true);
4471 if (TempInit.isInvalid()) {
4476 // Instantiate the base type.
4477 TypeSourceInfo *BaseTInfo = SubstType(Init->getTypeSourceInfo(),
4479 Init->getSourceLocation(),
4480 New->getDeclName());
4486 // Build the initializer.
4487 MemInitResult NewInit = BuildBaseInitializer(BaseTInfo->getType(),
4488 BaseTInfo, TempInit.get(),
4491 if (NewInit.isInvalid()) {
4496 NewInits.push_back(NewInit.get());
4502 // Instantiate the initializer.
4503 ExprResult TempInit = SubstInitializer(Init->getInit(), TemplateArgs,
4504 /*CXXDirectInit=*/true);
4505 if (TempInit.isInvalid()) {
4510 MemInitResult NewInit;
4511 if (Init->isDelegatingInitializer() || Init->isBaseInitializer()) {
4512 TypeSourceInfo *TInfo = SubstType(Init->getTypeSourceInfo(),
4514 Init->getSourceLocation(),
4515 New->getDeclName());
4518 New->setInvalidDecl();
4522 if (Init->isBaseInitializer())
4523 NewInit = BuildBaseInitializer(TInfo->getType(), TInfo, TempInit.get(),
4524 New->getParent(), EllipsisLoc);
4526 NewInit = BuildDelegatingInitializer(TInfo, TempInit.get(),
4527 cast<CXXRecordDecl>(CurContext->getParent()));
4528 } else if (Init->isMemberInitializer()) {
4529 FieldDecl *Member = cast_or_null<FieldDecl>(FindInstantiatedDecl(
4530 Init->getMemberLocation(),
4535 New->setInvalidDecl();
4539 NewInit = BuildMemberInitializer(Member, TempInit.get(),
4540 Init->getSourceLocation());
4541 } else if (Init->isIndirectMemberInitializer()) {
4542 IndirectFieldDecl *IndirectMember =
4543 cast_or_null<IndirectFieldDecl>(FindInstantiatedDecl(
4544 Init->getMemberLocation(),
4545 Init->getIndirectMember(), TemplateArgs));
4547 if (!IndirectMember) {
4549 New->setInvalidDecl();
4553 NewInit = BuildMemberInitializer(IndirectMember, TempInit.get(),
4554 Init->getSourceLocation());
4557 if (NewInit.isInvalid()) {
4559 New->setInvalidDecl();
4561 NewInits.push_back(NewInit.get());
4565 // Assign all the initializers to the new constructor.
4566 ActOnMemInitializers(New,
4567 /*FIXME: ColonLoc */
4573 // TODO: this could be templated if the various decl types used the
4574 // same method name.
4575 static bool isInstantiationOf(ClassTemplateDecl *Pattern,
4576 ClassTemplateDecl *Instance) {
4577 Pattern = Pattern->getCanonicalDecl();
4580 Instance = Instance->getCanonicalDecl();
4581 if (Pattern == Instance) return true;
4582 Instance = Instance->getInstantiatedFromMemberTemplate();
4588 static bool isInstantiationOf(FunctionTemplateDecl *Pattern,
4589 FunctionTemplateDecl *Instance) {
4590 Pattern = Pattern->getCanonicalDecl();
4593 Instance = Instance->getCanonicalDecl();
4594 if (Pattern == Instance) return true;
4595 Instance = Instance->getInstantiatedFromMemberTemplate();
4602 isInstantiationOf(ClassTemplatePartialSpecializationDecl *Pattern,
4603 ClassTemplatePartialSpecializationDecl *Instance) {
4605 = cast<ClassTemplatePartialSpecializationDecl>(Pattern->getCanonicalDecl());
4607 Instance = cast<ClassTemplatePartialSpecializationDecl>(
4608 Instance->getCanonicalDecl());
4609 if (Pattern == Instance)
4611 Instance = Instance->getInstantiatedFromMember();
4617 static bool isInstantiationOf(CXXRecordDecl *Pattern,
4618 CXXRecordDecl *Instance) {
4619 Pattern = Pattern->getCanonicalDecl();
4622 Instance = Instance->getCanonicalDecl();
4623 if (Pattern == Instance) return true;
4624 Instance = Instance->getInstantiatedFromMemberClass();
4630 static bool isInstantiationOf(FunctionDecl *Pattern,
4631 FunctionDecl *Instance) {
4632 Pattern = Pattern->getCanonicalDecl();
4635 Instance = Instance->getCanonicalDecl();
4636 if (Pattern == Instance) return true;
4637 Instance = Instance->getInstantiatedFromMemberFunction();
4643 static bool isInstantiationOf(EnumDecl *Pattern,
4644 EnumDecl *Instance) {
4645 Pattern = Pattern->getCanonicalDecl();
4648 Instance = Instance->getCanonicalDecl();
4649 if (Pattern == Instance) return true;
4650 Instance = Instance->getInstantiatedFromMemberEnum();
4656 static bool isInstantiationOf(UsingShadowDecl *Pattern,
4657 UsingShadowDecl *Instance,
4659 return declaresSameEntity(C.getInstantiatedFromUsingShadowDecl(Instance),
4663 static bool isInstantiationOf(UsingDecl *Pattern, UsingDecl *Instance,
4665 return declaresSameEntity(C.getInstantiatedFromUsingDecl(Instance), Pattern);
4668 template<typename T>
4669 static bool isInstantiationOfUnresolvedUsingDecl(T *Pattern, Decl *Other,
4671 // An unresolved using declaration can instantiate to an unresolved using
4672 // declaration, or to a using declaration or a using declaration pack.
4674 // Multiple declarations can claim to be instantiated from an unresolved
4675 // using declaration if it's a pack expansion. We want the UsingPackDecl
4676 // in that case, not the individual UsingDecls within the pack.
4677 bool OtherIsPackExpansion;
4678 NamedDecl *OtherFrom;
4679 if (auto *OtherUUD = dyn_cast<T>(Other)) {
4680 OtherIsPackExpansion = OtherUUD->isPackExpansion();
4681 OtherFrom = Ctx.getInstantiatedFromUsingDecl(OtherUUD);
4682 } else if (auto *OtherUPD = dyn_cast<UsingPackDecl>(Other)) {
4683 OtherIsPackExpansion = true;
4684 OtherFrom = OtherUPD->getInstantiatedFromUsingDecl();
4685 } else if (auto *OtherUD = dyn_cast<UsingDecl>(Other)) {
4686 OtherIsPackExpansion = false;
4687 OtherFrom = Ctx.getInstantiatedFromUsingDecl(OtherUD);
4691 return Pattern->isPackExpansion() == OtherIsPackExpansion &&
4692 declaresSameEntity(OtherFrom, Pattern);
4695 static bool isInstantiationOfStaticDataMember(VarDecl *Pattern,
4696 VarDecl *Instance) {
4697 assert(Instance->isStaticDataMember());
4699 Pattern = Pattern->getCanonicalDecl();
4702 Instance = Instance->getCanonicalDecl();
4703 if (Pattern == Instance) return true;
4704 Instance = Instance->getInstantiatedFromStaticDataMember();
4710 // Other is the prospective instantiation
4711 // D is the prospective pattern
4712 static bool isInstantiationOf(ASTContext &Ctx, NamedDecl *D, Decl *Other) {
4713 if (auto *UUD = dyn_cast<UnresolvedUsingTypenameDecl>(D))
4714 return isInstantiationOfUnresolvedUsingDecl(UUD, Other, Ctx);
4716 if (auto *UUD = dyn_cast<UnresolvedUsingValueDecl>(D))
4717 return isInstantiationOfUnresolvedUsingDecl(UUD, Other, Ctx);
4719 if (D->getKind() != Other->getKind())
4722 if (auto *Record = dyn_cast<CXXRecordDecl>(Other))
4723 return isInstantiationOf(cast<CXXRecordDecl>(D), Record);
4725 if (auto *Function = dyn_cast<FunctionDecl>(Other))
4726 return isInstantiationOf(cast<FunctionDecl>(D), Function);
4728 if (auto *Enum = dyn_cast<EnumDecl>(Other))
4729 return isInstantiationOf(cast<EnumDecl>(D), Enum);
4731 if (auto *Var = dyn_cast<VarDecl>(Other))
4732 if (Var->isStaticDataMember())
4733 return isInstantiationOfStaticDataMember(cast<VarDecl>(D), Var);
4735 if (auto *Temp = dyn_cast<ClassTemplateDecl>(Other))
4736 return isInstantiationOf(cast<ClassTemplateDecl>(D), Temp);
4738 if (auto *Temp = dyn_cast<FunctionTemplateDecl>(Other))
4739 return isInstantiationOf(cast<FunctionTemplateDecl>(D), Temp);
4741 if (auto *PartialSpec =
4742 dyn_cast<ClassTemplatePartialSpecializationDecl>(Other))
4743 return isInstantiationOf(cast<ClassTemplatePartialSpecializationDecl>(D),
4746 if (auto *Field = dyn_cast<FieldDecl>(Other)) {
4747 if (!Field->getDeclName()) {
4748 // This is an unnamed field.
4749 return declaresSameEntity(Ctx.getInstantiatedFromUnnamedFieldDecl(Field),
4750 cast<FieldDecl>(D));
4754 if (auto *Using = dyn_cast<UsingDecl>(Other))
4755 return isInstantiationOf(cast<UsingDecl>(D), Using, Ctx);
4757 if (auto *Shadow = dyn_cast<UsingShadowDecl>(Other))
4758 return isInstantiationOf(cast<UsingShadowDecl>(D), Shadow, Ctx);
4760 return D->getDeclName() &&
4761 D->getDeclName() == cast<NamedDecl>(Other)->getDeclName();
4764 template<typename ForwardIterator>
4765 static NamedDecl *findInstantiationOf(ASTContext &Ctx,
4767 ForwardIterator first,
4768 ForwardIterator last) {
4769 for (; first != last; ++first)
4770 if (isInstantiationOf(Ctx, D, *first))
4771 return cast<NamedDecl>(*first);
4776 /// \brief Finds the instantiation of the given declaration context
4777 /// within the current instantiation.
4779 /// \returns NULL if there was an error
4780 DeclContext *Sema::FindInstantiatedContext(SourceLocation Loc, DeclContext* DC,
4781 const MultiLevelTemplateArgumentList &TemplateArgs) {
4782 if (NamedDecl *D = dyn_cast<NamedDecl>(DC)) {
4783 Decl* ID = FindInstantiatedDecl(Loc, D, TemplateArgs);
4784 return cast_or_null<DeclContext>(ID);
4788 /// \brief Find the instantiation of the given declaration within the
4789 /// current instantiation.
4791 /// This routine is intended to be used when \p D is a declaration
4792 /// referenced from within a template, that needs to mapped into the
4793 /// corresponding declaration within an instantiation. For example,
4797 /// template<typename T>
4800 /// KnownValue = sizeof(T)
4803 /// bool getKind() const { return KnownValue; }
4806 /// template struct X<int>;
4809 /// In the instantiation of <tt>X<int>::getKind()</tt>, we need to map the
4810 /// \p EnumConstantDecl for \p KnownValue (which refers to
4811 /// <tt>X<T>::<Kind>::KnownValue</tt>) to its instantiation
4812 /// (<tt>X<int>::<Kind>::KnownValue</tt>). \p FindInstantiatedDecl performs
4813 /// this mapping from within the instantiation of <tt>X<int></tt>.
4814 NamedDecl *Sema::FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D,
4815 const MultiLevelTemplateArgumentList &TemplateArgs) {
4816 DeclContext *ParentDC = D->getDeclContext();
4817 // FIXME: Parmeters of pointer to functions (y below) that are themselves
4818 // parameters (p below) can have their ParentDC set to the translation-unit
4819 // - thus we can not consistently check if the ParentDC of such a parameter
4820 // is Dependent or/and a FunctionOrMethod.
4821 // For e.g. this code, during Template argument deduction tries to
4822 // find an instantiated decl for (T y) when the ParentDC for y is
4823 // the translation unit.
4824 // e.g. template <class T> void Foo(auto (*p)(T y) -> decltype(y())) {}
4825 // float baz(float(*)()) { return 0.0; }
4827 // The better fix here is perhaps to ensure that a ParmVarDecl, by the time
4828 // it gets here, always has a FunctionOrMethod as its ParentDC??
4830 // - as long as we have a ParmVarDecl whose parent is non-dependent and
4831 // whose type is not instantiation dependent, do nothing to the decl
4832 // - otherwise find its instantiated decl.
4833 if (isa<ParmVarDecl>(D) && !ParentDC->isDependentContext() &&
4834 !cast<ParmVarDecl>(D)->getType()->isInstantiationDependentType())
4836 if (isa<ParmVarDecl>(D) || isa<NonTypeTemplateParmDecl>(D) ||
4837 isa<TemplateTypeParmDecl>(D) || isa<TemplateTemplateParmDecl>(D) ||
4838 (ParentDC->isFunctionOrMethod() && ParentDC->isDependentContext()) ||
4839 (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda())) {
4840 // D is a local of some kind. Look into the map of local
4841 // declarations to their instantiations.
4842 if (CurrentInstantiationScope) {
4843 if (auto Found = CurrentInstantiationScope->findInstantiationOf(D)) {
4844 if (Decl *FD = Found->dyn_cast<Decl *>())
4845 return cast<NamedDecl>(FD);
4847 int PackIdx = ArgumentPackSubstitutionIndex;
4848 assert(PackIdx != -1 &&
4849 "found declaration pack but not pack expanding");
4850 typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
4851 return cast<NamedDecl>((*Found->get<DeclArgumentPack *>())[PackIdx]);
4855 // If we're performing a partial substitution during template argument
4856 // deduction, we may not have values for template parameters yet. They
4857 // just map to themselves.
4858 if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
4859 isa<TemplateTemplateParmDecl>(D))
4862 if (D->isInvalidDecl())
4865 // Normally this function only searches for already instantiated declaration
4866 // however we have to make an exclusion for local types used before
4867 // definition as in the code:
4869 // template<typename T> void f1() {
4870 // void g1(struct x1);
4874 // In this case instantiation of the type of 'g1' requires definition of
4875 // 'x1', which is defined later. Error recovery may produce an enum used
4876 // before definition. In these cases we need to instantiate relevant
4877 // declarations here.
4878 bool NeedInstantiate = false;
4879 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D))
4880 NeedInstantiate = RD->isLocalClass();
4882 NeedInstantiate = isa<EnumDecl>(D);
4883 if (NeedInstantiate) {
4884 Decl *Inst = SubstDecl(D, CurContext, TemplateArgs);
4885 CurrentInstantiationScope->InstantiatedLocal(D, Inst);
4886 return cast<TypeDecl>(Inst);
4889 // If we didn't find the decl, then we must have a label decl that hasn't
4890 // been found yet. Lazily instantiate it and return it now.
4891 assert(isa<LabelDecl>(D));
4893 Decl *Inst = SubstDecl(D, CurContext, TemplateArgs);
4894 assert(Inst && "Failed to instantiate label??");
4896 CurrentInstantiationScope->InstantiatedLocal(D, Inst);
4897 return cast<LabelDecl>(Inst);
4900 // For variable template specializations, update those that are still
4902 if (VarTemplateSpecializationDecl *VarSpec =
4903 dyn_cast<VarTemplateSpecializationDecl>(D)) {
4904 bool InstantiationDependent = false;
4905 const TemplateArgumentListInfo &VarTemplateArgs =
4906 VarSpec->getTemplateArgsInfo();
4907 if (TemplateSpecializationType::anyDependentTemplateArguments(
4908 VarTemplateArgs, InstantiationDependent))
4909 D = cast<NamedDecl>(
4910 SubstDecl(D, VarSpec->getDeclContext(), TemplateArgs));
4914 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
4915 if (!Record->isDependentContext())
4918 // Determine whether this record is the "templated" declaration describing
4919 // a class template or class template partial specialization.
4920 ClassTemplateDecl *ClassTemplate = Record->getDescribedClassTemplate();
4922 ClassTemplate = ClassTemplate->getCanonicalDecl();
4923 else if (ClassTemplatePartialSpecializationDecl *PartialSpec
4924 = dyn_cast<ClassTemplatePartialSpecializationDecl>(Record))
4925 ClassTemplate = PartialSpec->getSpecializedTemplate()->getCanonicalDecl();
4927 // Walk the current context to find either the record or an instantiation of
4929 DeclContext *DC = CurContext;
4930 while (!DC->isFileContext()) {
4931 // If we're performing substitution while we're inside the template
4932 // definition, we'll find our own context. We're done.
4933 if (DC->Equals(Record))
4936 if (CXXRecordDecl *InstRecord = dyn_cast<CXXRecordDecl>(DC)) {
4937 // Check whether we're in the process of instantiating a class template
4938 // specialization of the template we're mapping.
4939 if (ClassTemplateSpecializationDecl *InstSpec
4940 = dyn_cast<ClassTemplateSpecializationDecl>(InstRecord)){
4941 ClassTemplateDecl *SpecTemplate = InstSpec->getSpecializedTemplate();
4942 if (ClassTemplate && isInstantiationOf(ClassTemplate, SpecTemplate))
4946 // Check whether we're in the process of instantiating a member class.
4947 if (isInstantiationOf(Record, InstRecord))
4951 // Move to the outer template scope.
4952 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(DC)) {
4953 if (FD->getFriendObjectKind() && FD->getDeclContext()->isFileContext()){
4954 DC = FD->getLexicalDeclContext();
4959 DC = DC->getParent();
4962 // Fall through to deal with other dependent record types (e.g.,
4963 // anonymous unions in class templates).
4966 if (!ParentDC->isDependentContext())
4969 ParentDC = FindInstantiatedContext(Loc, ParentDC, TemplateArgs);
4973 if (ParentDC != D->getDeclContext()) {
4974 // We performed some kind of instantiation in the parent context,
4975 // so now we need to look into the instantiated parent context to
4976 // find the instantiation of the declaration D.
4978 // If our context used to be dependent, we may need to instantiate
4979 // it before performing lookup into that context.
4980 bool IsBeingInstantiated = false;
4981 if (CXXRecordDecl *Spec = dyn_cast<CXXRecordDecl>(ParentDC)) {
4982 if (!Spec->isDependentContext()) {
4983 QualType T = Context.getTypeDeclType(Spec);
4984 const RecordType *Tag = T->getAs<RecordType>();
4985 assert(Tag && "type of non-dependent record is not a RecordType");
4986 if (Tag->isBeingDefined())
4987 IsBeingInstantiated = true;
4988 if (!Tag->isBeingDefined() &&
4989 RequireCompleteType(Loc, T, diag::err_incomplete_type))
4992 ParentDC = Tag->getDecl();
4996 NamedDecl *Result = nullptr;
4997 // FIXME: If the name is a dependent name, this lookup won't necessarily
4998 // find it. Does that ever matter?
4999 if (auto Name = D->getDeclName()) {
5000 DeclarationNameInfo NameInfo(Name, D->getLocation());
5001 Name = SubstDeclarationNameInfo(NameInfo, TemplateArgs).getName();
5004 DeclContext::lookup_result Found = ParentDC->lookup(Name);
5005 Result = findInstantiationOf(Context, D, Found.begin(), Found.end());
5007 // Since we don't have a name for the entity we're looking for,
5008 // our only option is to walk through all of the declarations to
5009 // find that name. This will occur in a few cases:
5011 // - anonymous struct/union within a template
5012 // - unnamed class/struct/union/enum within a template
5014 // FIXME: Find a better way to find these instantiations!
5015 Result = findInstantiationOf(Context, D,
5016 ParentDC->decls_begin(),
5017 ParentDC->decls_end());
5021 if (isa<UsingShadowDecl>(D)) {
5022 // UsingShadowDecls can instantiate to nothing because of using hiding.
5023 } else if (Diags.hasErrorOccurred()) {
5024 // We've already complained about something, so most likely this
5025 // declaration failed to instantiate. There's no point in complaining
5026 // further, since this is normal in invalid code.
5027 } else if (IsBeingInstantiated) {
5028 // The class in which this member exists is currently being
5029 // instantiated, and we haven't gotten around to instantiating this
5030 // member yet. This can happen when the code uses forward declarations
5031 // of member classes, and introduces ordering dependencies via
5032 // template instantiation.
5033 Diag(Loc, diag::err_member_not_yet_instantiated)
5035 << Context.getTypeDeclType(cast<CXXRecordDecl>(ParentDC));
5036 Diag(D->getLocation(), diag::note_non_instantiated_member_here);
5037 } else if (EnumConstantDecl *ED = dyn_cast<EnumConstantDecl>(D)) {
5038 // This enumeration constant was found when the template was defined,
5039 // but can't be found in the instantiation. This can happen if an
5040 // unscoped enumeration member is explicitly specialized.
5041 EnumDecl *Enum = cast<EnumDecl>(ED->getLexicalDeclContext());
5042 EnumDecl *Spec = cast<EnumDecl>(FindInstantiatedDecl(Loc, Enum,
5044 assert(Spec->getTemplateSpecializationKind() ==
5045 TSK_ExplicitSpecialization);
5046 Diag(Loc, diag::err_enumerator_does_not_exist)
5048 << Context.getTypeDeclType(cast<TypeDecl>(Spec->getDeclContext()));
5049 Diag(Spec->getLocation(), diag::note_enum_specialized_here)
5050 << Context.getTypeDeclType(Spec);
5052 // We should have found something, but didn't.
5053 llvm_unreachable("Unable to find instantiation of declaration!");
5063 /// \brief Performs template instantiation for all implicit template
5064 /// instantiations we have seen until this point.
5065 void Sema::PerformPendingInstantiations(bool LocalOnly) {
5066 while (!PendingLocalImplicitInstantiations.empty() ||
5067 (!LocalOnly && !PendingInstantiations.empty())) {
5068 PendingImplicitInstantiation Inst;
5070 if (PendingLocalImplicitInstantiations.empty()) {
5071 Inst = PendingInstantiations.front();
5072 PendingInstantiations.pop_front();
5074 Inst = PendingLocalImplicitInstantiations.front();
5075 PendingLocalImplicitInstantiations.pop_front();
5078 // Instantiate function definitions
5079 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Inst.first)) {
5080 bool DefinitionRequired = Function->getTemplateSpecializationKind() ==
5081 TSK_ExplicitInstantiationDefinition;
5082 InstantiateFunctionDefinition(/*FIXME:*/Inst.second, Function, true,
5083 DefinitionRequired, true);
5087 // Instantiate variable definitions
5088 VarDecl *Var = cast<VarDecl>(Inst.first);
5090 assert((Var->isStaticDataMember() ||
5091 isa<VarTemplateSpecializationDecl>(Var)) &&
5092 "Not a static data member, nor a variable template"
5093 " specialization?");
5095 // Don't try to instantiate declarations if the most recent redeclaration
5097 if (Var->getMostRecentDecl()->isInvalidDecl())
5100 // Check if the most recent declaration has changed the specialization kind
5101 // and removed the need for implicit instantiation.
5102 switch (Var->getMostRecentDecl()->getTemplateSpecializationKind()) {
5103 case TSK_Undeclared:
5104 llvm_unreachable("Cannot instantitiate an undeclared specialization.");
5105 case TSK_ExplicitInstantiationDeclaration:
5106 case TSK_ExplicitSpecialization:
5107 continue; // No longer need to instantiate this type.
5108 case TSK_ExplicitInstantiationDefinition:
5109 // We only need an instantiation if the pending instantiation *is* the
5110 // explicit instantiation.
5111 if (Var != Var->getMostRecentDecl()) continue;
5112 case TSK_ImplicitInstantiation:
5116 PrettyDeclStackTraceEntry CrashInfo(*this, Var, SourceLocation(),
5117 "instantiating variable definition");
5118 bool DefinitionRequired = Var->getTemplateSpecializationKind() ==
5119 TSK_ExplicitInstantiationDefinition;
5121 // Instantiate static data member definitions or variable template
5123 InstantiateVariableDefinition(/*FIXME:*/ Inst.second, Var, true,
5124 DefinitionRequired, true);
5128 void Sema::PerformDependentDiagnostics(const DeclContext *Pattern,
5129 const MultiLevelTemplateArgumentList &TemplateArgs) {
5130 for (auto DD : Pattern->ddiags()) {
5131 switch (DD->getKind()) {
5132 case DependentDiagnostic::Access:
5133 HandleDependentAccessCheck(*DD, TemplateArgs);