blob: 1deb8638756bf6221c54ae4422e0ac77958aa427 [file] [log] [blame]
Douglas Gregord7e7a512009-03-17 21:15:40 +00001//===--- SemaTemplateInstantiateDecl.cpp - C++ Template Decl Instantiation ===/
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//===----------------------------------------------------------------------===/
8//
9// This file implements C++ template instantiation for declarations.
10//
11//===----------------------------------------------------------------------===/
John McCall83024632010-08-25 22:03:47 +000012#include "clang/Sema/SemaInternal.h"
Douglas Gregor28ad4b52009-05-26 20:50:29 +000013#include "clang/AST/ASTConsumer.h"
Douglas Gregord7e7a512009-03-17 21:15:40 +000014#include "clang/AST/ASTContext.h"
Richard Smithd28ac5b2014-03-22 23:33:22 +000015#include "clang/AST/ASTMutationListener.h"
Douglas Gregord7e7a512009-03-17 21:15:40 +000016#include "clang/AST/DeclTemplate.h"
17#include "clang/AST/DeclVisitor.h"
John McCallc62bb642010-03-24 05:22:00 +000018#include "clang/AST/DependentDiagnostic.h"
Douglas Gregord7e7a512009-03-17 21:15:40 +000019#include "clang/AST/Expr.h"
Douglas Gregor6131b442009-12-12 18:16:41 +000020#include "clang/AST/ExprCXX.h"
John McCall58f10c32010-03-11 09:03:00 +000021#include "clang/AST/TypeLoc.h"
Richard Smith3997b1b2016-08-12 01:55:21 +000022#include "clang/Sema/Initialization.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000023#include "clang/Sema/Lookup.h"
24#include "clang/Sema/PrettyDeclStackTrace.h"
25#include "clang/Sema/Template.h"
Douglas Gregord7e7a512009-03-17 21:15:40 +000026
27using namespace clang;
28
David Majnemer192d1792013-11-27 08:20:38 +000029static bool isDeclWithinFunction(const Decl *D) {
30 const DeclContext *DC = D->getDeclContext();
31 if (DC->isFunctionOrMethod())
32 return true;
33
34 if (DC->isRecord())
35 return cast<CXXRecordDecl>(DC)->isLocalClass();
36
37 return false;
38}
39
Richard Smithcc928662014-10-17 20:37:29 +000040template<typename DeclT>
41static bool SubstQualifier(Sema &SemaRef, const DeclT *OldDecl, DeclT *NewDecl,
42 const MultiLevelTemplateArgumentList &TemplateArgs) {
Douglas Gregor14454802011-02-25 02:25:35 +000043 if (!OldDecl->getQualifierLoc())
44 return false;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +000045
Richard Smithcc928662014-10-17 20:37:29 +000046 assert((NewDecl->getFriendObjectKind() ||
47 !OldDecl->getLexicalDeclContext()->isDependentContext()) &&
48 "non-friend with qualified name defined in dependent context");
49 Sema::ContextRAII SavedContext(
50 SemaRef,
51 const_cast<DeclContext *>(NewDecl->getFriendObjectKind()
52 ? NewDecl->getLexicalDeclContext()
53 : OldDecl->getLexicalDeclContext()));
54
Douglas Gregor14454802011-02-25 02:25:35 +000055 NestedNameSpecifierLoc NewQualifierLoc
Richard Smithcc928662014-10-17 20:37:29 +000056 = SemaRef.SubstNestedNameSpecifierLoc(OldDecl->getQualifierLoc(),
57 TemplateArgs);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +000058
Douglas Gregor14454802011-02-25 02:25:35 +000059 if (!NewQualifierLoc)
John McCall3e11ebe2010-03-15 10:12:16 +000060 return true;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +000061
Douglas Gregor14454802011-02-25 02:25:35 +000062 NewDecl->setQualifierInfo(NewQualifierLoc);
John McCall3e11ebe2010-03-15 10:12:16 +000063 return false;
64}
65
Richard Smithcc928662014-10-17 20:37:29 +000066bool TemplateDeclInstantiator::SubstQualifier(const DeclaratorDecl *OldDecl,
67 DeclaratorDecl *NewDecl) {
68 return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs);
69}
70
John McCall3e11ebe2010-03-15 10:12:16 +000071bool TemplateDeclInstantiator::SubstQualifier(const TagDecl *OldDecl,
72 TagDecl *NewDecl) {
Richard Smithcc928662014-10-17 20:37:29 +000073 return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs);
John McCall3e11ebe2010-03-15 10:12:16 +000074}
75
DeLesley Hutchinsceec3062012-01-20 22:37:06 +000076// Include attribute instantiation code.
77#include "clang/Sema/AttrTemplateInstantiate.inc"
78
Richard Smith44c247f2013-02-22 08:32:16 +000079static 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.
Faisal Valid143a0c2017-04-01 21:30:49 +000084 EnterExpressionEvaluationContext Unevaluated(
85 S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
Richard Smith44c247f2013-02-22 08:32:16 +000086 ExprResult Result = S.SubstExpr(Aligned->getAlignmentExpr(), TemplateArgs);
87 if (!Result.isInvalid())
Nikola Smiljanic01a75982014-05-29 10:55:11 +000088 S.AddAlignedAttr(Aligned->getLocation(), New, Result.getAs<Expr>(),
Richard Smith44c247f2013-02-22 08:32:16 +000089 Aligned->getSpellingListIndex(), IsPackExpansion);
90 } else {
91 TypeSourceInfo *Result = S.SubstType(Aligned->getAlignmentType(),
92 TemplateArgs, Aligned->getLocation(),
93 DeclarationName());
94 if (Result)
95 S.AddAlignedAttr(Aligned->getLocation(), New, Result,
96 Aligned->getSpellingListIndex(), IsPackExpansion);
97 }
98}
99
100static void instantiateDependentAlignedAttr(
101 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
102 const AlignedAttr *Aligned, Decl *New) {
103 if (!Aligned->isPackExpansion()) {
104 instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, false);
105 return;
106 }
107
108 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
109 if (Aligned->isAlignmentExpr())
110 S.collectUnexpandedParameterPacks(Aligned->getAlignmentExpr(),
111 Unexpanded);
112 else
113 S.collectUnexpandedParameterPacks(Aligned->getAlignmentType()->getTypeLoc(),
114 Unexpanded);
115 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
116
117 // Determine whether we can expand this attribute pack yet.
118 bool Expand = true, RetainExpansion = false;
119 Optional<unsigned> NumExpansions;
120 // FIXME: Use the actual location of the ellipsis.
121 SourceLocation EllipsisLoc = Aligned->getLocation();
122 if (S.CheckParameterPacksForExpansion(EllipsisLoc, Aligned->getRange(),
123 Unexpanded, TemplateArgs, Expand,
124 RetainExpansion, NumExpansions))
125 return;
126
127 if (!Expand) {
128 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, -1);
129 instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, true);
130 } else {
131 for (unsigned I = 0; I != *NumExpansions; ++I) {
132 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, I);
133 instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, false);
134 }
135 }
136}
137
Hal Finkelee90a222014-09-26 05:04:30 +0000138static void instantiateDependentAssumeAlignedAttr(
139 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
140 const AssumeAlignedAttr *Aligned, Decl *New) {
141 // The alignment expression is a constant expression.
Faisal Valid143a0c2017-04-01 21:30:49 +0000142 EnterExpressionEvaluationContext Unevaluated(
143 S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
Hal Finkelee90a222014-09-26 05:04:30 +0000144
145 Expr *E, *OE = nullptr;
146 ExprResult Result = S.SubstExpr(Aligned->getAlignment(), TemplateArgs);
147 if (Result.isInvalid())
148 return;
149 E = Result.getAs<Expr>();
150
151 if (Aligned->getOffset()) {
152 Result = S.SubstExpr(Aligned->getOffset(), TemplateArgs);
153 if (Result.isInvalid())
154 return;
155 OE = Result.getAs<Expr>();
156 }
157
158 S.AddAssumeAlignedAttr(Aligned->getLocation(), New, E, OE,
159 Aligned->getSpellingListIndex());
160}
161
Hal Finkel1b0d24e2014-10-02 21:21:25 +0000162static void instantiateDependentAlignValueAttr(
163 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
164 const AlignValueAttr *Aligned, Decl *New) {
165 // The alignment expression is a constant expression.
Faisal Valid143a0c2017-04-01 21:30:49 +0000166 EnterExpressionEvaluationContext Unevaluated(
167 S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
Hal Finkel1b0d24e2014-10-02 21:21:25 +0000168 ExprResult Result = S.SubstExpr(Aligned->getAlignment(), TemplateArgs);
169 if (!Result.isInvalid())
170 S.AddAlignValueAttr(Aligned->getLocation(), New, Result.getAs<Expr>(),
171 Aligned->getSpellingListIndex());
172}
173
Erich Keane623efd82017-03-30 21:48:55 +0000174static void instantiateDependentAllocAlignAttr(
175 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
176 const AllocAlignAttr *Align, Decl *New) {
177 Expr *Param = IntegerLiteral::Create(
178 S.getASTContext(), llvm::APInt(64, Align->getParamIndex()),
179 S.getASTContext().UnsignedLongLongTy, Align->getLocation());
180 S.AddAllocAlignAttr(Align->getLocation(), New, Param,
181 Align->getSpellingListIndex());
182}
183
George Burgess IV177399e2017-01-09 04:12:14 +0000184static Expr *instantiateDependentFunctionAttrCondition(
Nick Lewycky35a6ef42014-01-11 02:50:57 +0000185 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
George Burgess IV177399e2017-01-09 04:12:14 +0000186 const Attr *A, Expr *OldCond, const Decl *Tmpl, FunctionDecl *New) {
Craig Topperc3ec1492014-05-26 06:22:03 +0000187 Expr *Cond = nullptr;
Nick Lewycky35a6ef42014-01-11 02:50:57 +0000188 {
George Burgess IV177399e2017-01-09 04:12:14 +0000189 Sema::ContextRAII SwitchContext(S, New);
Faisal Valid143a0c2017-04-01 21:30:49 +0000190 EnterExpressionEvaluationContext Unevaluated(
191 S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
George Burgess IV177399e2017-01-09 04:12:14 +0000192 ExprResult Result = S.SubstExpr(OldCond, TemplateArgs);
Nick Lewycky35a6ef42014-01-11 02:50:57 +0000193 if (Result.isInvalid())
George Burgess IV177399e2017-01-09 04:12:14 +0000194 return nullptr;
Nikola Smiljanic01a75982014-05-29 10:55:11 +0000195 Cond = Result.getAs<Expr>();
Nick Lewycky35a6ef42014-01-11 02:50:57 +0000196 }
George Burgess IV00431952016-11-17 01:33:54 +0000197 if (!Cond->isTypeDependent()) {
Nick Lewycky35a6ef42014-01-11 02:50:57 +0000198 ExprResult Converted = S.PerformContextuallyConvertToBool(Cond);
199 if (Converted.isInvalid())
George Burgess IV177399e2017-01-09 04:12:14 +0000200 return nullptr;
Nikola Smiljanic01a75982014-05-29 10:55:11 +0000201 Cond = Converted.get();
Nick Lewycky35a6ef42014-01-11 02:50:57 +0000202 }
203
204 SmallVector<PartialDiagnosticAt, 8> Diags;
George Burgess IV177399e2017-01-09 04:12:14 +0000205 if (OldCond->isValueDependent() && !Cond->isValueDependent() &&
206 !Expr::isPotentialConstantExprUnevaluated(Cond, New, Diags)) {
207 S.Diag(A->getLocation(), diag::err_attr_cond_never_constant_expr) << A;
208 for (const auto &P : Diags)
209 S.Diag(P.first, P.second);
210 return nullptr;
Nick Lewycky35a6ef42014-01-11 02:50:57 +0000211 }
George Burgess IV177399e2017-01-09 04:12:14 +0000212 return Cond;
213}
Nick Lewycky35a6ef42014-01-11 02:50:57 +0000214
George Burgess IV177399e2017-01-09 04:12:14 +0000215static void instantiateDependentEnableIfAttr(
216 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
217 const EnableIfAttr *EIA, const Decl *Tmpl, FunctionDecl *New) {
218 Expr *Cond = instantiateDependentFunctionAttrCondition(
219 S, TemplateArgs, EIA, EIA->getCond(), Tmpl, New);
220
221 if (Cond)
222 New->addAttr(new (S.getASTContext()) EnableIfAttr(
223 EIA->getLocation(), S.getASTContext(), Cond, EIA->getMessage(),
224 EIA->getSpellingListIndex()));
225}
226
227static void instantiateDependentDiagnoseIfAttr(
228 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
229 const DiagnoseIfAttr *DIA, const Decl *Tmpl, FunctionDecl *New) {
230 Expr *Cond = instantiateDependentFunctionAttrCondition(
231 S, TemplateArgs, DIA, DIA->getCond(), Tmpl, New);
232
233 if (Cond)
234 New->addAttr(new (S.getASTContext()) DiagnoseIfAttr(
235 DIA->getLocation(), S.getASTContext(), Cond, DIA->getMessage(),
236 DIA->getDiagnosticType(), DIA->getArgDependent(), New,
237 DIA->getSpellingListIndex()));
Nick Lewycky35a6ef42014-01-11 02:50:57 +0000238}
239
Artem Belevich7093e402015-04-21 22:55:54 +0000240// Constructs and adds to New a new instance of CUDALaunchBoundsAttr using
241// template A as the base and arguments from TemplateArgs.
242static void instantiateDependentCUDALaunchBoundsAttr(
243 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
244 const CUDALaunchBoundsAttr &Attr, Decl *New) {
245 // The alignment expression is a constant expression.
Faisal Valid143a0c2017-04-01 21:30:49 +0000246 EnterExpressionEvaluationContext Unevaluated(
247 S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
Artem Belevich7093e402015-04-21 22:55:54 +0000248
249 ExprResult Result = S.SubstExpr(Attr.getMaxThreads(), TemplateArgs);
250 if (Result.isInvalid())
251 return;
252 Expr *MaxThreads = Result.getAs<Expr>();
253
254 Expr *MinBlocks = nullptr;
255 if (Attr.getMinBlocks()) {
256 Result = S.SubstExpr(Attr.getMinBlocks(), TemplateArgs);
257 if (Result.isInvalid())
258 return;
259 MinBlocks = Result.getAs<Expr>();
260 }
261
262 S.AddLaunchBoundsAttr(Attr.getLocation(), New, MaxThreads, MinBlocks,
263 Attr.getSpellingListIndex());
264}
265
Denis Zobnind9e2dcd2016-02-02 13:50:39 +0000266static void
267instantiateDependentModeAttr(Sema &S,
268 const MultiLevelTemplateArgumentList &TemplateArgs,
269 const ModeAttr &Attr, Decl *New) {
270 S.AddModeAttr(Attr.getRange(), New, Attr.getMode(),
271 Attr.getSpellingListIndex(), /*InInstantiation=*/true);
272}
273
Alexey Bataev2af33e32016-04-07 12:45:37 +0000274/// Instantiation of 'declare simd' attribute and its arguments.
275static void instantiateOMPDeclareSimdDeclAttr(
276 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
277 const OMPDeclareSimdDeclAttr &Attr, Decl *New) {
Alexey Bataeve48a5fc2016-04-12 05:28:34 +0000278 // Allow 'this' in clauses with varlists.
279 if (auto *FTD = dyn_cast<FunctionTemplateDecl>(New))
280 New = FTD->getTemplatedDecl();
281 auto *FD = cast<FunctionDecl>(New);
282 auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(FD->getDeclContext());
Alexey Bataevecba70f2016-04-12 11:02:11 +0000283 SmallVector<Expr *, 4> Uniforms, Aligneds, Alignments, Linears, Steps;
284 SmallVector<unsigned, 4> LinModifiers;
Alexey Bataeve48a5fc2016-04-12 05:28:34 +0000285
286 auto &&Subst = [&](Expr *E) -> ExprResult {
287 if (auto *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts()))
288 if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
289 Sema::ContextRAII SavedContext(S, FD);
290 LocalInstantiationScope Local(S);
291 if (FD->getNumParams() > PVD->getFunctionScopeIndex())
292 Local.InstantiatedLocal(
293 PVD, FD->getParamDecl(PVD->getFunctionScopeIndex()));
294 return S.SubstExpr(E, TemplateArgs);
295 }
296 Sema::CXXThisScopeRAII ThisScope(S, ThisContext, /*TypeQuals=*/0,
297 FD->isCXXInstanceMember());
298 return S.SubstExpr(E, TemplateArgs);
299 };
300
Alexey Bataevecba70f2016-04-12 11:02:11 +0000301 ExprResult Simdlen;
302 if (auto *E = Attr.getSimdlen())
303 Simdlen = Subst(E);
304
Alexey Bataeve48a5fc2016-04-12 05:28:34 +0000305 if (Attr.uniforms_size() > 0) {
306 for(auto *E : Attr.uniforms()) {
307 ExprResult Inst = Subst(E);
308 if (Inst.isInvalid())
309 continue;
310 Uniforms.push_back(Inst.get());
311 }
Alexey Bataev2af33e32016-04-07 12:45:37 +0000312 }
313
Alexey Bataevd93d3762016-04-12 09:35:56 +0000314 auto AI = Attr.alignments_begin();
315 for (auto *E : Attr.aligneds()) {
316 ExprResult Inst = Subst(E);
317 if (Inst.isInvalid())
318 continue;
319 Aligneds.push_back(Inst.get());
320 Inst = ExprEmpty();
321 if (*AI)
322 Inst = S.SubstExpr(*AI, TemplateArgs);
323 Alignments.push_back(Inst.get());
324 ++AI;
325 }
Alexey Bataevecba70f2016-04-12 11:02:11 +0000326
327 auto SI = Attr.steps_begin();
328 for (auto *E : Attr.linears()) {
329 ExprResult Inst = Subst(E);
330 if (Inst.isInvalid())
331 continue;
332 Linears.push_back(Inst.get());
333 Inst = ExprEmpty();
334 if (*SI)
335 Inst = S.SubstExpr(*SI, TemplateArgs);
336 Steps.push_back(Inst.get());
337 ++SI;
338 }
339 LinModifiers.append(Attr.modifiers_begin(), Attr.modifiers_end());
Alexey Bataevd93d3762016-04-12 09:35:56 +0000340 (void)S.ActOnOpenMPDeclareSimdDirective(
341 S.ConvertDeclToDeclGroup(New), Attr.getBranchState(), Simdlen.get(),
Alexey Bataevecba70f2016-04-12 11:02:11 +0000342 Uniforms, Aligneds, Alignments, Linears, LinModifiers, Steps,
343 Attr.getRange());
Alexey Bataev2af33e32016-04-07 12:45:37 +0000344}
345
Erich Keanea32910d2017-03-23 18:51:54 +0000346static bool DeclContainsAttr(const Decl *D, const Attr *NewAttr) {
347 if (!D->hasAttrs() || NewAttr->duplicatesAllowed())
348 return false;
349 return llvm::find_if(D->getAttrs(), [NewAttr](const Attr *Attr) {
350 return Attr->getKind() == NewAttr->getKind();
351 }) != D->getAttrs().end();
352}
353
354void Sema::InstantiateAttrsForDecl(
355 const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Tmpl,
356 Decl *New, LateInstantiatedAttrVec *LateAttrs,
357 LocalInstantiationScope *OuterMostScope) {
358 if (NamedDecl *ND = dyn_cast<NamedDecl>(New)) {
359 for (const auto *TmplAttr : Tmpl->attrs()) {
360 // FIXME: If any of the special case versions from InstantiateAttrs become
361 // applicable to template declaration, we'll need to add them here.
362 CXXThisScopeRAII ThisScope(
363 *this, dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext()),
364 /*TypeQuals*/ 0, ND->isCXXInstanceMember());
365
366 Attr *NewAttr = sema::instantiateTemplateAttributeForDecl(
367 TmplAttr, Context, *this, TemplateArgs);
368 if (NewAttr && !DeclContainsAttr(New, NewAttr))
369 New->addAttr(NewAttr);
370 }
371 }
372}
373
John McCall6602bb12010-08-01 02:01:53 +0000374void Sema::InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs,
DeLesley Hutchins30398dd2012-01-20 22:50:54 +0000375 const Decl *Tmpl, Decl *New,
376 LateInstantiatedAttrVec *LateAttrs,
377 LocalInstantiationScope *OuterMostScope) {
Aaron Ballmanb97112e2014-03-08 22:19:01 +0000378 for (const auto *TmplAttr : Tmpl->attrs()) {
Chandler Carruthf40c42f2010-06-25 03:22:07 +0000379 // FIXME: This should be generalized to more than just the AlignedAttr.
Richard Smith44c247f2013-02-22 08:32:16 +0000380 const AlignedAttr *Aligned = dyn_cast<AlignedAttr>(TmplAttr);
381 if (Aligned && Aligned->isAlignmentDependent()) {
382 instantiateDependentAlignedAttr(*this, TemplateArgs, Aligned, New);
383 continue;
Chandler Carruthf40c42f2010-06-25 03:22:07 +0000384 }
385
Hal Finkelee90a222014-09-26 05:04:30 +0000386 const AssumeAlignedAttr *AssumeAligned = dyn_cast<AssumeAlignedAttr>(TmplAttr);
387 if (AssumeAligned) {
388 instantiateDependentAssumeAlignedAttr(*this, TemplateArgs, AssumeAligned, New);
389 continue;
390 }
391
Hal Finkel1b0d24e2014-10-02 21:21:25 +0000392 const AlignValueAttr *AlignValue = dyn_cast<AlignValueAttr>(TmplAttr);
393 if (AlignValue) {
394 instantiateDependentAlignValueAttr(*this, TemplateArgs, AlignValue, New);
395 continue;
396 }
397
Erich Keane623efd82017-03-30 21:48:55 +0000398 if (const auto *AllocAlign = dyn_cast<AllocAlignAttr>(TmplAttr)) {
399 instantiateDependentAllocAlignAttr(*this, TemplateArgs, AllocAlign, New);
400 continue;
401 }
402
403
George Burgess IV00431952016-11-17 01:33:54 +0000404 if (const auto *EnableIf = dyn_cast<EnableIfAttr>(TmplAttr)) {
Nick Lewycky35a6ef42014-01-11 02:50:57 +0000405 instantiateDependentEnableIfAttr(*this, TemplateArgs, EnableIf, Tmpl,
George Burgess IV177399e2017-01-09 04:12:14 +0000406 cast<FunctionDecl>(New));
407 continue;
408 }
409
410 if (const auto *DiagnoseIf = dyn_cast<DiagnoseIfAttr>(TmplAttr)) {
411 instantiateDependentDiagnoseIfAttr(*this, TemplateArgs, DiagnoseIf, Tmpl,
412 cast<FunctionDecl>(New));
Nick Lewycky35a6ef42014-01-11 02:50:57 +0000413 continue;
414 }
415
Artem Belevich7093e402015-04-21 22:55:54 +0000416 if (const CUDALaunchBoundsAttr *CUDALaunchBounds =
417 dyn_cast<CUDALaunchBoundsAttr>(TmplAttr)) {
418 instantiateDependentCUDALaunchBoundsAttr(*this, TemplateArgs,
419 *CUDALaunchBounds, New);
420 continue;
421 }
422
Denis Zobnind9e2dcd2016-02-02 13:50:39 +0000423 if (const ModeAttr *Mode = dyn_cast<ModeAttr>(TmplAttr)) {
424 instantiateDependentModeAttr(*this, TemplateArgs, *Mode, New);
425 continue;
426 }
427
Alexey Bataev2af33e32016-04-07 12:45:37 +0000428 if (const auto *OMPAttr = dyn_cast<OMPDeclareSimdDeclAttr>(TmplAttr)) {
429 instantiateOMPDeclareSimdDeclAttr(*this, TemplateArgs, *OMPAttr, New);
430 continue;
431 }
432
Hans Wennborgc2b7f7a2014-08-24 00:12:36 +0000433 // Existing DLL attribute on the instantiation takes precedence.
434 if (TmplAttr->getKind() == attr::DLLExport ||
435 TmplAttr->getKind() == attr::DLLImport) {
436 if (New->hasAttr<DLLExportAttr>() || New->hasAttr<DLLImportAttr>()) {
437 continue;
438 }
439 }
440
John McCall477f2bb2016-03-03 06:39:32 +0000441 if (auto ABIAttr = dyn_cast<ParameterABIAttr>(TmplAttr)) {
442 AddParameterABIAttr(ABIAttr->getRange(), New, ABIAttr->getABI(),
443 ABIAttr->getSpellingListIndex());
444 continue;
445 }
446
John McCall3b5a8f52016-03-03 00:10:03 +0000447 if (isa<NSConsumedAttr>(TmplAttr) || isa<CFConsumedAttr>(TmplAttr)) {
448 AddNSConsumedAttr(TmplAttr->getRange(), New,
449 TmplAttr->getSpellingListIndex(),
450 isa<NSConsumedAttr>(TmplAttr),
451 /*template instantiation*/ true);
452 continue;
453 }
454
Richard Smith44c247f2013-02-22 08:32:16 +0000455 assert(!TmplAttr->isPackExpansion());
DeLesley Hutchins30398dd2012-01-20 22:50:54 +0000456 if (TmplAttr->isLateParsed() && LateAttrs) {
457 // Late parsed attributes must be instantiated and attached after the
458 // enclosing class has been instantiated. See Sema::InstantiateClass.
Craig Topperc3ec1492014-05-26 06:22:03 +0000459 LocalInstantiationScope *Saved = nullptr;
DeLesley Hutchins30398dd2012-01-20 22:50:54 +0000460 if (CurrentInstantiationScope)
461 Saved = CurrentInstantiationScope->cloneScopes(OuterMostScope);
462 LateAttrs->push_back(LateInstantiatedAttribute(TmplAttr, Saved, New));
463 } else {
Richard Smithc3d2ebb2013-06-07 02:33:37 +0000464 // Allow 'this' within late-parsed attributes.
465 NamedDecl *ND = dyn_cast<NamedDecl>(New);
466 CXXRecordDecl *ThisContext =
467 dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext());
468 CXXThisScopeRAII ThisScope(*this, ThisContext, /*TypeQuals*/0,
469 ND && ND->isCXXInstanceMember());
470
Benjamin Kramerbf8da9d2012-02-06 11:13:08 +0000471 Attr *NewAttr = sema::instantiateTemplateAttribute(TmplAttr, Context,
472 *this, TemplateArgs);
Erich Keanea32910d2017-03-23 18:51:54 +0000473
474 if (NewAttr && !DeclContainsAttr(New, NewAttr))
Rafael Espindola7f90b7d2012-05-15 14:09:55 +0000475 New->addAttr(NewAttr);
DeLesley Hutchins30398dd2012-01-20 22:50:54 +0000476 }
Anders Carlsson3d709752009-11-07 06:07:58 +0000477 }
478}
479
Richard Smith41c79d92014-10-11 00:37:16 +0000480/// Get the previous declaration of a declaration for the purposes of template
481/// instantiation. If this finds a previous declaration, then the previous
482/// declaration of the instantiation of D should be an instantiation of the
483/// result of this function.
484template<typename DeclT>
485static DeclT *getPreviousDeclForInstantiation(DeclT *D) {
486 DeclT *Result = D->getPreviousDecl();
487
488 // If the declaration is within a class, and the previous declaration was
489 // merged from a different definition of that class, then we don't have a
490 // previous declaration for the purpose of template instantiation.
491 if (Result && isa<CXXRecordDecl>(D->getDeclContext()) &&
492 D->getLexicalDeclContext() != Result->getLexicalDeclContext())
493 return nullptr;
494
495 return Result;
496}
497
Douglas Gregor8a655532009-03-25 15:45:12 +0000498Decl *
499TemplateDeclInstantiator::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
David Blaikie83d382b2011-09-23 05:06:16 +0000500 llvm_unreachable("Translation units cannot be instantiated");
Douglas Gregor8a655532009-03-25 15:45:12 +0000501}
502
503Decl *
Nico Weber66220292016-03-02 17:28:48 +0000504TemplateDeclInstantiator::VisitPragmaCommentDecl(PragmaCommentDecl *D) {
505 llvm_unreachable("pragma comment cannot be instantiated");
506}
507
Nico Webercbbaeb12016-03-02 19:28:54 +0000508Decl *TemplateDeclInstantiator::VisitPragmaDetectMismatchDecl(
509 PragmaDetectMismatchDecl *D) {
510 llvm_unreachable("pragma comment cannot be instantiated");
511}
512
Nico Weber66220292016-03-02 17:28:48 +0000513Decl *
Richard Smithf19e1272015-03-07 00:04:49 +0000514TemplateDeclInstantiator::VisitExternCContextDecl(ExternCContextDecl *D) {
515 llvm_unreachable("extern \"C\" context cannot be instantiated");
516}
517
518Decl *
Chris Lattnercab02a62011-02-17 20:34:02 +0000519TemplateDeclInstantiator::VisitLabelDecl(LabelDecl *D) {
520 LabelDecl *Inst = LabelDecl::Create(SemaRef.Context, Owner, D->getLocation(),
521 D->getIdentifier());
522 Owner->addDecl(Inst);
523 return Inst;
524}
525
526Decl *
Douglas Gregor8a655532009-03-25 15:45:12 +0000527TemplateDeclInstantiator::VisitNamespaceDecl(NamespaceDecl *D) {
David Blaikie83d382b2011-09-23 05:06:16 +0000528 llvm_unreachable("Namespaces cannot be instantiated");
Douglas Gregor8a655532009-03-25 15:45:12 +0000529}
530
John McCalld8d0d432010-02-16 06:53:13 +0000531Decl *
532TemplateDeclInstantiator::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
533 NamespaceAliasDecl *Inst
534 = NamespaceAliasDecl::Create(SemaRef.Context, Owner,
535 D->getNamespaceLoc(),
536 D->getAliasLoc(),
Douglas Gregorc05ba2e2011-02-25 17:08:07 +0000537 D->getIdentifier(),
538 D->getQualifierLoc(),
John McCalld8d0d432010-02-16 06:53:13 +0000539 D->getTargetNameLoc(),
540 D->getNamespace());
541 Owner->addDecl(Inst);
542 return Inst;
543}
544
Richard Smith3f1b5d02011-05-05 21:57:07 +0000545Decl *TemplateDeclInstantiator::InstantiateTypedefNameDecl(TypedefNameDecl *D,
546 bool IsTypeAlias) {
Douglas Gregord7e7a512009-03-17 21:15:40 +0000547 bool Invalid = false;
John McCallbcd03502009-12-07 02:54:59 +0000548 TypeSourceInfo *DI = D->getTypeSourceInfo();
Douglas Gregor678d76c2011-07-01 01:22:09 +0000549 if (DI->getType()->isInstantiationDependentType() ||
Douglas Gregor5a5073e2010-05-24 17:22:01 +0000550 DI->getType()->isVariablyModifiedType()) {
John McCall703a3f82009-10-24 08:00:42 +0000551 DI = SemaRef.SubstType(DI, TemplateArgs,
552 D->getLocation(), D->getDeclName());
553 if (!DI) {
Douglas Gregord7e7a512009-03-17 21:15:40 +0000554 Invalid = true;
John McCallbcd03502009-12-07 02:54:59 +0000555 DI = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.Context.IntTy);
Douglas Gregord7e7a512009-03-17 21:15:40 +0000556 }
Douglas Gregor5597ab42010-05-07 23:12:07 +0000557 } else {
558 SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType());
Douglas Gregord7e7a512009-03-17 21:15:40 +0000559 }
Mike Stump11289f42009-09-09 15:08:12 +0000560
Richard Smith2ddcbab2012-10-23 00:32:41 +0000561 // HACK: g++ has a bug where it gets the value kind of ?: wrong.
562 // libstdc++ relies upon this bug in its implementation of common_type.
563 // If we happen to be processing that implementation, fake up the g++ ?:
564 // semantics. See LWG issue 2141 for more information on the bug.
565 const DecltypeType *DT = DI->getType()->getAs<DecltypeType>();
566 CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
567 if (DT && RD && isa<ConditionalOperator>(DT->getUnderlyingExpr()) &&
568 DT->isReferenceType() &&
569 RD->getEnclosingNamespaceContext() == SemaRef.getStdNamespace() &&
570 RD->getIdentifier() && RD->getIdentifier()->isStr("common_type") &&
571 D->getIdentifier() && D->getIdentifier()->isStr("type") &&
572 SemaRef.getSourceManager().isInSystemHeader(D->getLocStart()))
573 // Fold it to the (non-reference) type which g++ would have produced.
574 DI = SemaRef.Context.getTrivialTypeSourceInfo(
575 DI->getType().getNonReferenceType());
576
Douglas Gregord7e7a512009-03-17 21:15:40 +0000577 // Create the new typedef
Richard Smithdda56e42011-04-15 14:24:37 +0000578 TypedefNameDecl *Typedef;
579 if (IsTypeAlias)
580 Typedef = TypeAliasDecl::Create(SemaRef.Context, Owner, D->getLocStart(),
581 D->getLocation(), D->getIdentifier(), DI);
582 else
583 Typedef = TypedefDecl::Create(SemaRef.Context, Owner, D->getLocStart(),
584 D->getLocation(), D->getIdentifier(), DI);
Douglas Gregord7e7a512009-03-17 21:15:40 +0000585 if (Invalid)
586 Typedef->setInvalidDecl();
587
John McCall04fcd0d2011-02-01 08:20:08 +0000588 // If the old typedef was the name for linkage purposes of an anonymous
589 // tag decl, re-establish that relationship for the new typedef.
590 if (const TagType *oldTagType = D->getUnderlyingType()->getAs<TagType>()) {
591 TagDecl *oldTag = oldTagType->getDecl();
Douglas Gregord831d952013-03-08 22:15:15 +0000592 if (oldTag->getTypedefNameForAnonDecl() == D && !Invalid) {
John McCall04fcd0d2011-02-01 08:20:08 +0000593 TagDecl *newTag = DI->getType()->castAs<TagType>()->getDecl();
John McCall5ea95772013-03-09 00:54:27 +0000594 assert(!newTag->hasNameForLinkage());
Richard Smithdda56e42011-04-15 14:24:37 +0000595 newTag->setTypedefNameForAnonDecl(Typedef);
John McCall04fcd0d2011-02-01 08:20:08 +0000596 }
Douglas Gregor83eb5032010-04-23 16:25:07 +0000597 }
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000598
Richard Smith41c79d92014-10-11 00:37:16 +0000599 if (TypedefNameDecl *Prev = getPreviousDeclForInstantiation(D)) {
Douglas Gregora04f2ca2010-03-01 15:56:25 +0000600 NamedDecl *InstPrev = SemaRef.FindInstantiatedDecl(D->getLocation(), Prev,
601 TemplateArgs);
Douglas Gregor55e6b312011-03-04 19:46:35 +0000602 if (!InstPrev)
Craig Topperc3ec1492014-05-26 06:22:03 +0000603 return nullptr;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000604
Rafael Espindolacde2c8f2011-12-26 22:42:47 +0000605 TypedefNameDecl *InstPrevTypedef = cast<TypedefNameDecl>(InstPrev);
606
607 // If the typedef types are not identical, reject them.
608 SemaRef.isIncompatibleTypedef(InstPrevTypedef, Typedef);
609
Rafael Espindola8db352d2013-10-17 15:37:26 +0000610 Typedef->setPreviousDecl(InstPrevTypedef);
John McCall91f1a022009-12-30 00:31:22 +0000611 }
612
John McCall6602bb12010-08-01 02:01:53 +0000613 SemaRef.InstantiateAttrs(TemplateArgs, D, Typedef);
Douglas Gregor83eb5032010-04-23 16:25:07 +0000614
John McCall401982f2010-01-20 21:53:11 +0000615 Typedef->setAccess(D->getAccess());
Mike Stump11289f42009-09-09 15:08:12 +0000616
Douglas Gregord7e7a512009-03-17 21:15:40 +0000617 return Typedef;
618}
619
Richard Smithdda56e42011-04-15 14:24:37 +0000620Decl *TemplateDeclInstantiator::VisitTypedefDecl(TypedefDecl *D) {
Richard Smith3f1b5d02011-05-05 21:57:07 +0000621 Decl *Typedef = InstantiateTypedefNameDecl(D, /*IsTypeAlias=*/false);
Richard Smith41c79d92014-10-11 00:37:16 +0000622 if (Typedef)
623 Owner->addDecl(Typedef);
Richard Smith3f1b5d02011-05-05 21:57:07 +0000624 return Typedef;
Richard Smithdda56e42011-04-15 14:24:37 +0000625}
626
627Decl *TemplateDeclInstantiator::VisitTypeAliasDecl(TypeAliasDecl *D) {
Richard Smith3f1b5d02011-05-05 21:57:07 +0000628 Decl *Typedef = InstantiateTypedefNameDecl(D, /*IsTypeAlias=*/true);
Richard Smith41c79d92014-10-11 00:37:16 +0000629 if (Typedef)
630 Owner->addDecl(Typedef);
Richard Smith3f1b5d02011-05-05 21:57:07 +0000631 return Typedef;
632}
633
634Decl *
635TemplateDeclInstantiator::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
636 // Create a local instantiation scope for this type alias template, which
637 // will contain the instantiations of the template parameters.
638 LocalInstantiationScope Scope(SemaRef);
639
640 TemplateParameterList *TempParams = D->getTemplateParameters();
641 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
642 if (!InstParams)
Craig Topperc3ec1492014-05-26 06:22:03 +0000643 return nullptr;
Richard Smith3f1b5d02011-05-05 21:57:07 +0000644
645 TypeAliasDecl *Pattern = D->getTemplatedDecl();
646
Craig Topperc3ec1492014-05-26 06:22:03 +0000647 TypeAliasTemplateDecl *PrevAliasTemplate = nullptr;
Richard Smith41c79d92014-10-11 00:37:16 +0000648 if (getPreviousDeclForInstantiation<TypedefNameDecl>(Pattern)) {
Richard Smith3f1b5d02011-05-05 21:57:07 +0000649 DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
David Blaikieff7d47a2012-12-19 00:45:41 +0000650 if (!Found.empty()) {
651 PrevAliasTemplate = dyn_cast<TypeAliasTemplateDecl>(Found.front());
Richard Smith3f1b5d02011-05-05 21:57:07 +0000652 }
653 }
654
655 TypeAliasDecl *AliasInst = cast_or_null<TypeAliasDecl>(
656 InstantiateTypedefNameDecl(Pattern, /*IsTypeAlias=*/true));
657 if (!AliasInst)
Craig Topperc3ec1492014-05-26 06:22:03 +0000658 return nullptr;
Richard Smith3f1b5d02011-05-05 21:57:07 +0000659
660 TypeAliasTemplateDecl *Inst
661 = TypeAliasTemplateDecl::Create(SemaRef.Context, Owner, D->getLocation(),
662 D->getDeclName(), InstParams, AliasInst);
Richard Smith43ccec8e2014-08-26 03:52:16 +0000663 AliasInst->setDescribedAliasTemplate(Inst);
Richard Smith3f1b5d02011-05-05 21:57:07 +0000664 if (PrevAliasTemplate)
Rafael Espindola8db352d2013-10-17 15:37:26 +0000665 Inst->setPreviousDecl(PrevAliasTemplate);
Richard Smith3f1b5d02011-05-05 21:57:07 +0000666
667 Inst->setAccess(D->getAccess());
668
669 if (!PrevAliasTemplate)
670 Inst->setInstantiatedFromMemberTemplate(D);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000671
Richard Smith3f1b5d02011-05-05 21:57:07 +0000672 Owner->addDecl(Inst);
673
674 return Inst;
Richard Smithdda56e42011-04-15 14:24:37 +0000675}
676
Richard Smithbdb84f32016-07-22 23:36:59 +0000677Decl *TemplateDeclInstantiator::VisitBindingDecl(BindingDecl *D) {
Richard Smith3997b1b2016-08-12 01:55:21 +0000678 auto *NewBD = BindingDecl::Create(SemaRef.Context, Owner, D->getLocation(),
679 D->getIdentifier());
Richard Smith81df9eb2017-10-02 22:43:36 +0000680 NewBD->setReferenced(D->isReferenced());
Richard Smith3997b1b2016-08-12 01:55:21 +0000681 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewBD);
682 return NewBD;
Richard Smithbdb84f32016-07-22 23:36:59 +0000683}
684
685Decl *TemplateDeclInstantiator::VisitDecompositionDecl(DecompositionDecl *D) {
Richard Smith3997b1b2016-08-12 01:55:21 +0000686 // Transform the bindings first.
687 SmallVector<BindingDecl*, 16> NewBindings;
688 for (auto *OldBD : D->bindings())
689 NewBindings.push_back(cast<BindingDecl>(VisitBindingDecl(OldBD)));
690 ArrayRef<BindingDecl*> NewBindingArray = NewBindings;
691
692 auto *NewDD = cast_or_null<DecompositionDecl>(
693 VisitVarDecl(D, /*InstantiatingVarTemplate=*/false, &NewBindingArray));
694
695 if (!NewDD || NewDD->isInvalidDecl())
696 for (auto *NewBD : NewBindings)
697 NewBD->setInvalidDecl();
698
699 return NewDD;
Richard Smithbdb84f32016-07-22 23:36:59 +0000700}
701
Douglas Gregoref1a09a2009-03-25 23:32:15 +0000702Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D) {
Larisse Voufo72caf2b2013-08-22 00:59:14 +0000703 return VisitVarDecl(D, /*InstantiatingVarTemplate=*/false);
Larisse Voufo39a1e502013-08-06 01:03:05 +0000704}
705
Larisse Voufo72caf2b2013-08-22 00:59:14 +0000706Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D,
Richard Smith3997b1b2016-08-12 01:55:21 +0000707 bool InstantiatingVarTemplate,
708 ArrayRef<BindingDecl*> *Bindings) {
Larisse Voufo39a1e502013-08-06 01:03:05 +0000709
John McCall76d824f2009-08-25 22:02:44 +0000710 // Do substitution on the type of the declaration
Richard Smithee579842017-01-30 20:39:26 +0000711 TypeSourceInfo *DI = SemaRef.SubstType(
712 D->getTypeSourceInfo(), TemplateArgs, D->getTypeSpecStartLoc(),
713 D->getDeclName(), /*AllowDeducedTST*/true);
John McCallf1abcdc2009-10-21 02:39:02 +0000714 if (!DI)
Craig Topperc3ec1492014-05-26 06:22:03 +0000715 return nullptr;
Douglas Gregoref1a09a2009-03-25 23:32:15 +0000716
Douglas Gregor61623342010-09-12 07:37:24 +0000717 if (DI->getType()->isFunctionType()) {
718 SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function)
719 << D->isStaticDataMember() << DI->getType();
Craig Topperc3ec1492014-05-26 06:22:03 +0000720 return nullptr;
Douglas Gregor61623342010-09-12 07:37:24 +0000721 }
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000722
Richard Smith541b38b2013-09-20 01:15:31 +0000723 DeclContext *DC = Owner;
724 if (D->isLocalExternDecl())
725 SemaRef.adjustContextForLocalExternDecl(DC);
726
Larisse Voufo39a1e502013-08-06 01:03:05 +0000727 // Build the instantiated declaration.
Richard Smith3997b1b2016-08-12 01:55:21 +0000728 VarDecl *Var;
729 if (Bindings)
730 Var = DecompositionDecl::Create(SemaRef.Context, DC, D->getInnerLocStart(),
731 D->getLocation(), DI->getType(), DI,
732 D->getStorageClass(), *Bindings);
733 else
734 Var = VarDecl::Create(SemaRef.Context, DC, D->getInnerLocStart(),
735 D->getLocation(), D->getIdentifier(), DI->getType(),
736 DI, D->getStorageClass());
Mike Stump11289f42009-09-09 15:08:12 +0000737
Douglas Gregor8ca0c642011-12-10 01:22:52 +0000738 // In ARC, infer 'retaining' for variables of retainable type.
David Blaikiebbafb8a2012-03-11 07:00:24 +0000739 if (SemaRef.getLangOpts().ObjCAutoRefCount &&
Douglas Gregor8ca0c642011-12-10 01:22:52 +0000740 SemaRef.inferObjCARCLifetime(Var))
741 Var->setInvalidDecl();
742
Larisse Voufo39a1e502013-08-06 01:03:05 +0000743 // Substitute the nested name specifier, if any.
744 if (SubstQualifier(D, Var))
Craig Topperc3ec1492014-05-26 06:22:03 +0000745 return nullptr;
Mike Stump11289f42009-09-09 15:08:12 +0000746
Richard Smith541b38b2013-09-20 01:15:31 +0000747 SemaRef.BuildVariableInstantiation(Var, D, TemplateArgs, LateAttrs, Owner,
Larisse Voufo72caf2b2013-08-22 00:59:14 +0000748 StartingScope, InstantiatingVarTemplate);
Nick Lewyckyd78f92f2014-05-03 00:41:18 +0000749
750 if (D->isNRVOVariable()) {
751 QualType ReturnType = cast<FunctionDecl>(DC)->getReturnType();
752 if (SemaRef.isCopyElisionCandidate(ReturnType, Var, false))
753 Var->setNRVOVariable(true);
754 }
755
Alexander Kornienko83a4e182014-05-27 21:29:22 +0000756 Var->setImplicit(D->isImplicit());
757
Douglas Gregoref1a09a2009-03-25 23:32:15 +0000758 return Var;
759}
760
Abramo Bagnarad7340582010-06-05 05:09:32 +0000761Decl *TemplateDeclInstantiator::VisitAccessSpecDecl(AccessSpecDecl *D) {
762 AccessSpecDecl* AD
763 = AccessSpecDecl::Create(SemaRef.Context, D->getAccess(), Owner,
764 D->getAccessSpecifierLoc(), D->getColonLoc());
765 Owner->addHiddenDecl(AD);
766 return AD;
767}
768
Douglas Gregord7e7a512009-03-17 21:15:40 +0000769Decl *TemplateDeclInstantiator::VisitFieldDecl(FieldDecl *D) {
770 bool Invalid = false;
John McCallbcd03502009-12-07 02:54:59 +0000771 TypeSourceInfo *DI = D->getTypeSourceInfo();
Douglas Gregor678d76c2011-07-01 01:22:09 +0000772 if (DI->getType()->isInstantiationDependentType() ||
Douglas Gregor5a5073e2010-05-24 17:22:01 +0000773 DI->getType()->isVariablyModifiedType()) {
John McCall90459c52009-10-22 23:33:21 +0000774 DI = SemaRef.SubstType(DI, TemplateArgs,
775 D->getLocation(), D->getDeclName());
776 if (!DI) {
John McCallbcd03502009-12-07 02:54:59 +0000777 DI = D->getTypeSourceInfo();
John McCall90459c52009-10-22 23:33:21 +0000778 Invalid = true;
779 } else if (DI->getType()->isFunctionType()) {
Douglas Gregord7e7a512009-03-17 21:15:40 +0000780 // C++ [temp.arg.type]p3:
781 // If a declaration acquires a function type through a type
782 // dependent on a template-parameter and this causes a
783 // declaration that does not use the syntactic form of a
784 // function declarator to have function type, the program is
785 // ill-formed.
786 SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function)
John McCall90459c52009-10-22 23:33:21 +0000787 << DI->getType();
Douglas Gregord7e7a512009-03-17 21:15:40 +0000788 Invalid = true;
789 }
Douglas Gregor5597ab42010-05-07 23:12:07 +0000790 } else {
791 SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType());
Douglas Gregord7e7a512009-03-17 21:15:40 +0000792 }
793
794 Expr *BitWidth = D->getBitWidth();
795 if (Invalid)
Craig Topperc3ec1492014-05-26 06:22:03 +0000796 BitWidth = nullptr;
Douglas Gregord7e7a512009-03-17 21:15:40 +0000797 else if (BitWidth) {
Richard Smith764d2fe2011-12-20 02:08:33 +0000798 // The bit-width expression is a constant expression.
Faisal Valid143a0c2017-04-01 21:30:49 +0000799 EnterExpressionEvaluationContext Unevaluated(
800 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
Mike Stump11289f42009-09-09 15:08:12 +0000801
John McCalldadc5752010-08-24 06:29:42 +0000802 ExprResult InstantiatedBitWidth
John McCall76d824f2009-08-25 22:02:44 +0000803 = SemaRef.SubstExpr(BitWidth, TemplateArgs);
Douglas Gregord7e7a512009-03-17 21:15:40 +0000804 if (InstantiatedBitWidth.isInvalid()) {
805 Invalid = true;
Craig Topperc3ec1492014-05-26 06:22:03 +0000806 BitWidth = nullptr;
Douglas Gregord7e7a512009-03-17 21:15:40 +0000807 } else
Nikola Smiljanic01a75982014-05-29 10:55:11 +0000808 BitWidth = InstantiatedBitWidth.getAs<Expr>();
Douglas Gregord7e7a512009-03-17 21:15:40 +0000809 }
810
John McCall90459c52009-10-22 23:33:21 +0000811 FieldDecl *Field = SemaRef.CheckFieldDecl(D->getDeclName(),
812 DI->getType(), DI,
Mike Stump11289f42009-09-09 15:08:12 +0000813 cast<RecordDecl>(Owner),
Douglas Gregord7e7a512009-03-17 21:15:40 +0000814 D->getLocation(),
815 D->isMutable(),
816 BitWidth,
Richard Smith2b013182012-06-10 03:12:00 +0000817 D->getInClassInitStyle(),
Richard Smith47ad0172012-05-23 04:22:22 +0000818 D->getInnerLocStart(),
Douglas Gregord7e7a512009-03-17 21:15:40 +0000819 D->getAccess(),
Craig Topperc3ec1492014-05-26 06:22:03 +0000820 nullptr);
Douglas Gregor3c74d412009-10-14 20:14:33 +0000821 if (!Field) {
822 cast<Decl>(Owner)->setInvalidDecl();
Craig Topperc3ec1492014-05-26 06:22:03 +0000823 return nullptr;
Douglas Gregor3c74d412009-10-14 20:14:33 +0000824 }
Mike Stump11289f42009-09-09 15:08:12 +0000825
DeLesley Hutchins30398dd2012-01-20 22:50:54 +0000826 SemaRef.InstantiateAttrs(TemplateArgs, D, Field, LateAttrs, StartingScope);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000827
Richard Smith848e1f12013-02-01 08:12:08 +0000828 if (Field->hasAttrs())
829 SemaRef.CheckAlignasUnderalignment(Field);
830
Anders Carlsson2e56cc62009-09-02 19:17:55 +0000831 if (Invalid)
832 Field->setInvalidDecl();
Mike Stump11289f42009-09-09 15:08:12 +0000833
Anders Carlsson2e56cc62009-09-02 19:17:55 +0000834 if (!Field->getDeclName()) {
835 // Keep track of where this decl came from.
836 SemaRef.Context.setInstantiatedFromUnnamedFieldDecl(Field, D);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000837 }
Douglas Gregor04163182010-05-21 00:31:19 +0000838 if (CXXRecordDecl *Parent= dyn_cast<CXXRecordDecl>(Field->getDeclContext())) {
839 if (Parent->isAnonymousStructOrUnion() &&
Sebastian Redl50c68252010-08-31 00:36:30 +0000840 Parent->getRedeclContext()->isFunctionOrMethod())
Douglas Gregor04163182010-05-21 00:31:19 +0000841 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Field);
Douglas Gregord7e7a512009-03-17 21:15:40 +0000842 }
Mike Stump11289f42009-09-09 15:08:12 +0000843
Anders Carlsson2e56cc62009-09-02 19:17:55 +0000844 Field->setImplicit(D->isImplicit());
John McCall401982f2010-01-20 21:53:11 +0000845 Field->setAccess(D->getAccess());
Anders Carlsson2e56cc62009-09-02 19:17:55 +0000846 Owner->addDecl(Field);
Douglas Gregord7e7a512009-03-17 21:15:40 +0000847
848 return Field;
849}
850
John McCall5e77d762013-04-16 07:28:30 +0000851Decl *TemplateDeclInstantiator::VisitMSPropertyDecl(MSPropertyDecl *D) {
852 bool Invalid = false;
853 TypeSourceInfo *DI = D->getTypeSourceInfo();
854
855 if (DI->getType()->isVariablyModifiedType()) {
856 SemaRef.Diag(D->getLocation(), diag::err_property_is_variably_modified)
Aaron Ballman1bda4592014-01-03 01:09:27 +0000857 << D;
John McCall5e77d762013-04-16 07:28:30 +0000858 Invalid = true;
859 } else if (DI->getType()->isInstantiationDependentType()) {
860 DI = SemaRef.SubstType(DI, TemplateArgs,
861 D->getLocation(), D->getDeclName());
862 if (!DI) {
863 DI = D->getTypeSourceInfo();
864 Invalid = true;
865 } else if (DI->getType()->isFunctionType()) {
866 // C++ [temp.arg.type]p3:
867 // If a declaration acquires a function type through a type
868 // dependent on a template-parameter and this causes a
869 // declaration that does not use the syntactic form of a
870 // function declarator to have function type, the program is
871 // ill-formed.
872 SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function)
873 << DI->getType();
874 Invalid = true;
875 }
876 } else {
877 SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType());
878 }
879
Richard Smithf7981722013-11-22 09:01:48 +0000880 MSPropertyDecl *Property = MSPropertyDecl::Create(
881 SemaRef.Context, Owner, D->getLocation(), D->getDeclName(), DI->getType(),
882 DI, D->getLocStart(), D->getGetterId(), D->getSetterId());
John McCall5e77d762013-04-16 07:28:30 +0000883
884 SemaRef.InstantiateAttrs(TemplateArgs, D, Property, LateAttrs,
885 StartingScope);
886
887 if (Invalid)
888 Property->setInvalidDecl();
889
890 Property->setAccess(D->getAccess());
891 Owner->addDecl(Property);
892
893 return Property;
894}
895
Francois Pichet783dd6e2010-11-21 06:08:52 +0000896Decl *TemplateDeclInstantiator::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
897 NamedDecl **NamedChain =
898 new (SemaRef.Context)NamedDecl*[D->getChainingSize()];
899
900 int i = 0;
Aaron Ballman29c94602014-03-07 18:36:15 +0000901 for (auto *PI : D->chain()) {
Aaron Ballman13916082014-03-07 18:11:58 +0000902 NamedDecl *Next = SemaRef.FindInstantiatedDecl(D->getLocation(), PI,
Douglas Gregor55e6b312011-03-04 19:46:35 +0000903 TemplateArgs);
904 if (!Next)
Craig Topperc3ec1492014-05-26 06:22:03 +0000905 return nullptr;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000906
Douglas Gregor55e6b312011-03-04 19:46:35 +0000907 NamedChain[i++] = Next;
908 }
Francois Pichet783dd6e2010-11-21 06:08:52 +0000909
Francois Pichetdbafc192010-12-09 10:07:54 +0000910 QualType T = cast<FieldDecl>(NamedChain[i-1])->getType();
Aaron Ballman260995b2014-10-15 16:58:18 +0000911 IndirectFieldDecl *IndirectField = IndirectFieldDecl::Create(
912 SemaRef.Context, Owner, D->getLocation(), D->getIdentifier(), T,
David Majnemer59f77922016-06-24 04:05:48 +0000913 {NamedChain, D->getChainingSize()});
Francois Pichet783dd6e2010-11-21 06:08:52 +0000914
NAKAMURA Takumi729be142014-10-27 12:37:26 +0000915 for (const auto *Attr : D->attrs())
916 IndirectField->addAttr(Attr->clone(SemaRef.Context));
Francois Pichet783dd6e2010-11-21 06:08:52 +0000917
918 IndirectField->setImplicit(D->isImplicit());
919 IndirectField->setAccess(D->getAccess());
920 Owner->addDecl(IndirectField);
921 return IndirectField;
922}
923
John McCallaa74a0c2009-08-28 07:59:38 +0000924Decl *TemplateDeclInstantiator::VisitFriendDecl(FriendDecl *D) {
John McCallaa74a0c2009-08-28 07:59:38 +0000925 // Handle friend type expressions by simply substituting template
Douglas Gregor3b4abb62010-04-07 17:57:12 +0000926 // parameters into the pattern type and checking the result.
John McCall15ad0962010-03-25 18:04:51 +0000927 if (TypeSourceInfo *Ty = D->getFriendType()) {
Chandler Carruth08836322011-05-01 00:51:33 +0000928 TypeSourceInfo *InstTy;
929 // If this is an unsupported friend, don't bother substituting template
930 // arguments into it. The actual type referred to won't be used by any
931 // parts of Clang, and may not be valid for instantiating. Just use the
932 // same info for the instantiated friend.
933 if (D->isUnsupportedFriend()) {
934 InstTy = Ty;
935 } else {
936 InstTy = SemaRef.SubstType(Ty, TemplateArgs,
937 D->getLocation(), DeclarationName());
938 }
939 if (!InstTy)
Craig Topperc3ec1492014-05-26 06:22:03 +0000940 return nullptr;
John McCallaa74a0c2009-08-28 07:59:38 +0000941
Richard Smitha31a89a2012-09-20 01:31:00 +0000942 FriendDecl *FD = SemaRef.CheckFriendTypeDecl(D->getLocStart(),
Abramo Bagnara254b6302011-10-29 20:52:52 +0000943 D->getFriendLoc(), InstTy);
Douglas Gregor3b4abb62010-04-07 17:57:12 +0000944 if (!FD)
Craig Topperc3ec1492014-05-26 06:22:03 +0000945 return nullptr;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000946
Douglas Gregor3b4abb62010-04-07 17:57:12 +0000947 FD->setAccess(AS_public);
John McCallace48cd2010-10-19 01:40:49 +0000948 FD->setUnsupportedFriend(D->isUnsupportedFriend());
Douglas Gregor3b4abb62010-04-07 17:57:12 +0000949 Owner->addDecl(FD);
950 return FD;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000951 }
952
Douglas Gregor3b4abb62010-04-07 17:57:12 +0000953 NamedDecl *ND = D->getFriendDecl();
954 assert(ND && "friend decl must be a decl or a type!");
955
John McCallb9c78482010-04-08 09:05:18 +0000956 // All of the Visit implementations for the various potential friend
957 // declarations have to be carefully written to work for friend
958 // objects, with the most important detail being that the target
959 // decl should almost certainly not be placed in Owner.
960 Decl *NewND = Visit(ND);
Craig Topperc3ec1492014-05-26 06:22:03 +0000961 if (!NewND) return nullptr;
Mike Stump11289f42009-09-09 15:08:12 +0000962
John McCallaa74a0c2009-08-28 07:59:38 +0000963 FriendDecl *FD =
NAKAMURA Takumi82a35112011-10-08 11:31:46 +0000964 FriendDecl::Create(SemaRef.Context, Owner, D->getLocation(),
Douglas Gregor3b4abb62010-04-07 17:57:12 +0000965 cast<NamedDecl>(NewND), D->getFriendLoc());
John McCall75c03bb2009-08-29 03:50:18 +0000966 FD->setAccess(AS_public);
John McCallace48cd2010-10-19 01:40:49 +0000967 FD->setUnsupportedFriend(D->isUnsupportedFriend());
John McCallaa74a0c2009-08-28 07:59:38 +0000968 Owner->addDecl(FD);
969 return FD;
John McCall58de3582009-08-14 02:03:10 +0000970}
971
Douglas Gregord7e7a512009-03-17 21:15:40 +0000972Decl *TemplateDeclInstantiator::VisitStaticAssertDecl(StaticAssertDecl *D) {
973 Expr *AssertExpr = D->getAssertExpr();
Mike Stump11289f42009-09-09 15:08:12 +0000974
Richard Smith764d2fe2011-12-20 02:08:33 +0000975 // The expression in a static assertion is a constant expression.
Faisal Valid143a0c2017-04-01 21:30:49 +0000976 EnterExpressionEvaluationContext Unevaluated(
977 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
Mike Stump11289f42009-09-09 15:08:12 +0000978
John McCalldadc5752010-08-24 06:29:42 +0000979 ExprResult InstantiatedAssertExpr
John McCall76d824f2009-08-25 22:02:44 +0000980 = SemaRef.SubstExpr(AssertExpr, TemplateArgs);
Douglas Gregord7e7a512009-03-17 21:15:40 +0000981 if (InstantiatedAssertExpr.isInvalid())
Craig Topperc3ec1492014-05-26 06:22:03 +0000982 return nullptr;
Douglas Gregord7e7a512009-03-17 21:15:40 +0000983
Richard Smithded9c2e2012-07-11 22:37:56 +0000984 return SemaRef.BuildStaticAssertDeclaration(D->getLocation(),
John McCallb268a282010-08-23 23:25:46 +0000985 InstantiatedAssertExpr.get(),
Richard Smithded9c2e2012-07-11 22:37:56 +0000986 D->getMessage(),
987 D->getRParenLoc(),
988 D->isFailed());
Douglas Gregord7e7a512009-03-17 21:15:40 +0000989}
990
991Decl *TemplateDeclInstantiator::VisitEnumDecl(EnumDecl *D) {
Craig Topperc3ec1492014-05-26 06:22:03 +0000992 EnumDecl *PrevDecl = nullptr;
Richard Smith41c79d92014-10-11 00:37:16 +0000993 if (EnumDecl *PatternPrev = getPreviousDeclForInstantiation(D)) {
Richard Smith2e6610a2012-03-26 04:58:10 +0000994 NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(),
Richard Smith41c79d92014-10-11 00:37:16 +0000995 PatternPrev,
Richard Smith2e6610a2012-03-26 04:58:10 +0000996 TemplateArgs);
Craig Topperc3ec1492014-05-26 06:22:03 +0000997 if (!Prev) return nullptr;
Richard Smith2e6610a2012-03-26 04:58:10 +0000998 PrevDecl = cast<EnumDecl>(Prev);
999 }
1000
Abramo Bagnara29c2d462011-03-09 14:09:51 +00001001 EnumDecl *Enum = EnumDecl::Create(SemaRef.Context, Owner, D->getLocStart(),
Douglas Gregord7e7a512009-03-17 21:15:40 +00001002 D->getLocation(), D->getIdentifier(),
Richard Smith2e6610a2012-03-26 04:58:10 +00001003 PrevDecl, D->isScoped(),
Abramo Bagnara0e05e242010-12-03 18:54:17 +00001004 D->isScopedUsingClassTag(), D->isFixed());
Douglas Gregor0bf31402010-10-08 23:50:27 +00001005 if (D->isFixed()) {
Richard Smith4b38ded2012-03-14 23:13:10 +00001006 if (TypeSourceInfo *TI = D->getIntegerTypeSourceInfo()) {
Douglas Gregor0bf31402010-10-08 23:50:27 +00001007 // If we have type source information for the underlying type, it means it
1008 // has been explicitly set by the user. Perform substitution on it before
1009 // moving on.
1010 SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
Richard Smith4b38ded2012-03-14 23:13:10 +00001011 TypeSourceInfo *NewTI = SemaRef.SubstType(TI, TemplateArgs, UnderlyingLoc,
1012 DeclarationName());
1013 if (!NewTI || SemaRef.CheckEnumUnderlyingType(NewTI))
Douglas Gregor0bf31402010-10-08 23:50:27 +00001014 Enum->setIntegerType(SemaRef.Context.IntTy);
Richard Smith4b38ded2012-03-14 23:13:10 +00001015 else
1016 Enum->setIntegerTypeSourceInfo(NewTI);
1017 } else {
Douglas Gregor0bf31402010-10-08 23:50:27 +00001018 assert(!D->getIntegerType()->isDependentType()
1019 && "Dependent type without type source info");
1020 Enum->setIntegerType(D->getIntegerType());
1021 }
1022 }
1023
John McCall811a0f52010-10-22 23:36:17 +00001024 SemaRef.InstantiateAttrs(TemplateArgs, D, Enum);
1025
Richard Smith4b38ded2012-03-14 23:13:10 +00001026 Enum->setInstantiationOfMemberEnum(D, TSK_ImplicitInstantiation);
Douglas Gregor6c2adff2009-03-25 22:00:53 +00001027 Enum->setAccess(D->getAccess());
David Majnemerdbc0c8f2013-12-04 09:01:55 +00001028 // Forward the mangling number from the template to the instantiated decl.
1029 SemaRef.Context.setManglingNumber(Enum, SemaRef.Context.getManglingNumber(D));
David Majnemer00350522015-08-31 18:48:39 +00001030 // See if the old tag was defined along with a declarator.
1031 // If it did, mark the new tag as being associated with that declarator.
1032 if (DeclaratorDecl *DD = SemaRef.Context.getDeclaratorForUnnamedTagDecl(D))
1033 SemaRef.Context.addDeclaratorForUnnamedTagDecl(Enum, DD);
1034 // See if the old tag was defined along with a typedef.
1035 // If it did, mark the new tag as being associated with that typedef.
1036 if (TypedefNameDecl *TND = SemaRef.Context.getTypedefNameForUnnamedTagDecl(D))
1037 SemaRef.Context.addTypedefNameForUnnamedTagDecl(Enum, TND);
Craig Topperc3ec1492014-05-26 06:22:03 +00001038 if (SubstQualifier(D, Enum)) return nullptr;
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00001039 Owner->addDecl(Enum);
Richard Smith4b38ded2012-03-14 23:13:10 +00001040
Richard Smith258a7442012-03-26 04:08:46 +00001041 EnumDecl *Def = D->getDefinition();
1042 if (Def && Def != D) {
1043 // If this is an out-of-line definition of an enum member template, check
1044 // that the underlying types match in the instantiation of both
1045 // declarations.
1046 if (TypeSourceInfo *TI = Def->getIntegerTypeSourceInfo()) {
1047 SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
1048 QualType DefnUnderlying =
1049 SemaRef.SubstType(TI->getType(), TemplateArgs,
1050 UnderlyingLoc, DeclarationName());
1051 SemaRef.CheckEnumRedeclaration(Def->getLocation(), Def->isScoped(),
David Majnemerdc9be212015-10-08 10:04:46 +00001052 DefnUnderlying,
1053 /*EnumUnderlyingIsImplicit=*/false, Enum);
Richard Smith258a7442012-03-26 04:08:46 +00001054 }
1055 }
Douglas Gregord7e7a512009-03-17 21:15:40 +00001056
Richard Smith4b38ded2012-03-14 23:13:10 +00001057 // C++11 [temp.inst]p1: The implicit instantiation of a class template
1058 // specialization causes the implicit instantiation of the declarations, but
1059 // not the definitions of scoped member enumerations.
David Majnemer192d1792013-11-27 08:20:38 +00001060 //
1061 // DR1484 clarifies that enumeration definitions inside of a template
1062 // declaration aren't considered entities that can be separately instantiated
1063 // from the rest of the entity they are declared inside of.
1064 if (isDeclWithinFunction(D) ? D == Def : Def && !Enum->isScoped()) {
1065 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Enum);
Richard Smith258a7442012-03-26 04:08:46 +00001066 InstantiateEnumDefinition(Enum, Def);
David Majnemer192d1792013-11-27 08:20:38 +00001067 }
Richard Smith4b38ded2012-03-14 23:13:10 +00001068
1069 return Enum;
1070}
1071
1072void TemplateDeclInstantiator::InstantiateEnumDefinition(
1073 EnumDecl *Enum, EnumDecl *Pattern) {
1074 Enum->startDefinition();
1075
Richard Smith7d137e32012-03-23 03:33:32 +00001076 // Update the location to refer to the definition.
1077 Enum->setLocation(Pattern->getLocation());
1078
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001079 SmallVector<Decl*, 4> Enumerators;
Douglas Gregord7e7a512009-03-17 21:15:40 +00001080
Craig Topperc3ec1492014-05-26 06:22:03 +00001081 EnumConstantDecl *LastEnumConst = nullptr;
Aaron Ballman23a6dcb2014-03-08 18:45:14 +00001082 for (auto *EC : Pattern->enumerators()) {
Douglas Gregord7e7a512009-03-17 21:15:40 +00001083 // The specified value for the enumerator.
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00001084 ExprResult Value((Expr *)nullptr);
Douglas Gregor0b6a6242009-06-22 20:57:11 +00001085 if (Expr *UninstValue = EC->getInitExpr()) {
Richard Smith764d2fe2011-12-20 02:08:33 +00001086 // The enumerator's value expression is a constant expression.
Faisal Valid143a0c2017-04-01 21:30:49 +00001087 EnterExpressionEvaluationContext Unevaluated(
1088 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
Mike Stump11289f42009-09-09 15:08:12 +00001089
John McCall76d824f2009-08-25 22:02:44 +00001090 Value = SemaRef.SubstExpr(UninstValue, TemplateArgs);
Douglas Gregor0b6a6242009-06-22 20:57:11 +00001091 }
Douglas Gregord7e7a512009-03-17 21:15:40 +00001092
1093 // Drop the initial value and continue.
1094 bool isInvalid = false;
1095 if (Value.isInvalid()) {
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00001096 Value = nullptr;
Douglas Gregord7e7a512009-03-17 21:15:40 +00001097 isInvalid = true;
1098 }
1099
Mike Stump11289f42009-09-09 15:08:12 +00001100 EnumConstantDecl *EnumConst
Douglas Gregord7e7a512009-03-17 21:15:40 +00001101 = SemaRef.CheckEnumConstant(Enum, LastEnumConst,
1102 EC->getLocation(), EC->getIdentifier(),
John McCallb268a282010-08-23 23:25:46 +00001103 Value.get());
Douglas Gregord7e7a512009-03-17 21:15:40 +00001104
1105 if (isInvalid) {
1106 if (EnumConst)
1107 EnumConst->setInvalidDecl();
1108 Enum->setInvalidDecl();
1109 }
1110
1111 if (EnumConst) {
Aaron Ballman23a6dcb2014-03-08 18:45:14 +00001112 SemaRef.InstantiateAttrs(TemplateArgs, EC, EnumConst);
John McCall811a0f52010-10-22 23:36:17 +00001113
John McCallf9b528c2010-01-23 22:37:59 +00001114 EnumConst->setAccess(Enum->getAccess());
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00001115 Enum->addDecl(EnumConst);
John McCall48871652010-08-21 09:40:31 +00001116 Enumerators.push_back(EnumConst);
Douglas Gregord7e7a512009-03-17 21:15:40 +00001117 LastEnumConst = EnumConst;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001118
Richard Smith4b38ded2012-03-14 23:13:10 +00001119 if (Pattern->getDeclContext()->isFunctionOrMethod() &&
1120 !Enum->isScoped()) {
Douglas Gregoraff9c1a2010-03-01 19:00:07 +00001121 // If the enumeration is within a function or method, record the enum
1122 // constant as a local.
Aaron Ballman23a6dcb2014-03-08 18:45:14 +00001123 SemaRef.CurrentInstantiationScope->InstantiatedLocal(EC, EnumConst);
Douglas Gregoraff9c1a2010-03-01 19:00:07 +00001124 }
Douglas Gregord7e7a512009-03-17 21:15:40 +00001125 }
1126 }
Mike Stump11289f42009-09-09 15:08:12 +00001127
Argyrios Kyrtzidisd798c052016-07-15 18:11:33 +00001128 SemaRef.ActOnEnumBody(Enum->getLocation(), Enum->getBraceRange(), Enum,
Dmitri Gribenkoe5fde992013-04-27 20:23:52 +00001129 Enumerators,
Craig Topperc3ec1492014-05-26 06:22:03 +00001130 nullptr, nullptr);
Douglas Gregord7e7a512009-03-17 21:15:40 +00001131}
1132
Douglas Gregor9106b822009-03-25 15:04:13 +00001133Decl *TemplateDeclInstantiator::VisitEnumConstantDecl(EnumConstantDecl *D) {
David Blaikie83d382b2011-09-23 05:06:16 +00001134 llvm_unreachable("EnumConstantDecls can only occur within EnumDecls.");
Douglas Gregor9106b822009-03-25 15:04:13 +00001135}
1136
David Majnemerd9b1a4f2015-11-04 03:40:30 +00001137Decl *
1138TemplateDeclInstantiator::VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D) {
1139 llvm_unreachable("BuiltinTemplateDecls cannot be instantiated.");
1140}
1141
John McCall87a44eb2009-08-20 01:44:21 +00001142Decl *TemplateDeclInstantiator::VisitClassTemplateDecl(ClassTemplateDecl *D) {
John McCall598b4402010-03-25 06:39:04 +00001143 bool isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
1144
Douglas Gregor954de172009-10-31 17:21:17 +00001145 // Create a local instantiation scope for this class template, which
1146 // will contain the instantiations of the template parameters.
John McCall19c1bfd2010-08-25 05:32:35 +00001147 LocalInstantiationScope Scope(SemaRef);
John McCall87a44eb2009-08-20 01:44:21 +00001148 TemplateParameterList *TempParams = D->getTemplateParameters();
John McCall76d824f2009-08-25 22:02:44 +00001149 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
Mike Stump11289f42009-09-09 15:08:12 +00001150 if (!InstParams)
Craig Topperc3ec1492014-05-26 06:22:03 +00001151 return nullptr;
John McCall87a44eb2009-08-20 01:44:21 +00001152
1153 CXXRecordDecl *Pattern = D->getTemplatedDecl();
John McCall598b4402010-03-25 06:39:04 +00001154
1155 // Instantiate the qualifier. We have to do this first in case
1156 // we're a friend declaration, because if we are then we need to put
1157 // the new declaration in the appropriate context.
Douglas Gregor14454802011-02-25 02:25:35 +00001158 NestedNameSpecifierLoc QualifierLoc = Pattern->getQualifierLoc();
1159 if (QualifierLoc) {
1160 QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
1161 TemplateArgs);
1162 if (!QualifierLoc)
Craig Topperc3ec1492014-05-26 06:22:03 +00001163 return nullptr;
John McCall598b4402010-03-25 06:39:04 +00001164 }
1165
Craig Topperc3ec1492014-05-26 06:22:03 +00001166 CXXRecordDecl *PrevDecl = nullptr;
1167 ClassTemplateDecl *PrevClassTemplate = nullptr;
John McCall598b4402010-03-25 06:39:04 +00001168
Richard Smith41c79d92014-10-11 00:37:16 +00001169 if (!isFriend && getPreviousDeclForInstantiation(Pattern)) {
Nick Lewycky61478912010-11-08 23:29:42 +00001170 DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
David Blaikieff7d47a2012-12-19 00:45:41 +00001171 if (!Found.empty()) {
1172 PrevClassTemplate = dyn_cast<ClassTemplateDecl>(Found.front());
Nick Lewycky61478912010-11-08 23:29:42 +00001173 if (PrevClassTemplate)
1174 PrevDecl = PrevClassTemplate->getTemplatedDecl();
1175 }
1176 }
1177
John McCall598b4402010-03-25 06:39:04 +00001178 // If this isn't a friend, then it's a member template, in which
1179 // case we just want to build the instantiation in the
1180 // specialization. If it is a friend, we want to build it in
1181 // the appropriate context.
1182 DeclContext *DC = Owner;
1183 if (isFriend) {
Douglas Gregor14454802011-02-25 02:25:35 +00001184 if (QualifierLoc) {
John McCall598b4402010-03-25 06:39:04 +00001185 CXXScopeSpec SS;
Douglas Gregor14454802011-02-25 02:25:35 +00001186 SS.Adopt(QualifierLoc);
John McCall598b4402010-03-25 06:39:04 +00001187 DC = SemaRef.computeDeclContext(SS);
Craig Topperc3ec1492014-05-26 06:22:03 +00001188 if (!DC) return nullptr;
John McCall598b4402010-03-25 06:39:04 +00001189 } else {
1190 DC = SemaRef.FindInstantiatedContext(Pattern->getLocation(),
1191 Pattern->getDeclContext(),
1192 TemplateArgs);
1193 }
1194
1195 // Look for a previous declaration of the template in the owning
1196 // context.
1197 LookupResult R(SemaRef, Pattern->getDeclName(), Pattern->getLocation(),
Richard Smithbecb92d2017-10-10 22:33:17 +00001198 Sema::LookupOrdinaryName,
1199 SemaRef.forRedeclarationInCurContext());
John McCall598b4402010-03-25 06:39:04 +00001200 SemaRef.LookupQualifiedName(R, DC);
1201
1202 if (R.isSingleResult()) {
1203 PrevClassTemplate = R.getAsSingle<ClassTemplateDecl>();
1204 if (PrevClassTemplate)
1205 PrevDecl = PrevClassTemplate->getTemplatedDecl();
1206 }
1207
Douglas Gregor14454802011-02-25 02:25:35 +00001208 if (!PrevClassTemplate && QualifierLoc) {
John McCall598b4402010-03-25 06:39:04 +00001209 SemaRef.Diag(Pattern->getLocation(), diag::err_not_tag_in_scope)
Douglas Gregorf5af3582010-03-31 23:17:41 +00001210 << D->getTemplatedDecl()->getTagKind() << Pattern->getDeclName() << DC
Douglas Gregor14454802011-02-25 02:25:35 +00001211 << QualifierLoc.getSourceRange();
Craig Topperc3ec1492014-05-26 06:22:03 +00001212 return nullptr;
John McCall598b4402010-03-25 06:39:04 +00001213 }
1214
Douglas Gregor01e09d92010-04-08 18:16:15 +00001215 bool AdoptedPreviousTemplateParams = false;
John McCall598b4402010-03-25 06:39:04 +00001216 if (PrevClassTemplate) {
Douglas Gregor01e09d92010-04-08 18:16:15 +00001217 bool Complain = true;
1218
1219 // HACK: libstdc++ 4.2.1 contains an ill-formed friend class
1220 // template for struct std::tr1::__detail::_Map_base, where the
1221 // template parameters of the friend declaration don't match the
1222 // template parameters of the original declaration. In this one
1223 // case, we don't complain about the ill-formed friend
1224 // declaration.
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001225 if (isFriend && Pattern->getIdentifier() &&
Douglas Gregor01e09d92010-04-08 18:16:15 +00001226 Pattern->getIdentifier()->isStr("_Map_base") &&
1227 DC->isNamespace() &&
1228 cast<NamespaceDecl>(DC)->getIdentifier() &&
1229 cast<NamespaceDecl>(DC)->getIdentifier()->isStr("__detail")) {
1230 DeclContext *DCParent = DC->getParent();
1231 if (DCParent->isNamespace() &&
1232 cast<NamespaceDecl>(DCParent)->getIdentifier() &&
1233 cast<NamespaceDecl>(DCParent)->getIdentifier()->isStr("tr1")) {
Richard Trieuc771d5d2014-05-28 02:16:01 +00001234 if (cast<Decl>(DCParent)->isInStdNamespace())
Douglas Gregor01e09d92010-04-08 18:16:15 +00001235 Complain = false;
1236 }
1237 }
1238
John McCall598b4402010-03-25 06:39:04 +00001239 TemplateParameterList *PrevParams
1240 = PrevClassTemplate->getTemplateParameters();
1241
1242 // Make sure the parameter lists match.
1243 if (!SemaRef.TemplateParameterListsAreEqual(InstParams, PrevParams,
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001244 Complain,
Douglas Gregor01e09d92010-04-08 18:16:15 +00001245 Sema::TPL_TemplateMatch)) {
1246 if (Complain)
Craig Topperc3ec1492014-05-26 06:22:03 +00001247 return nullptr;
Douglas Gregor01e09d92010-04-08 18:16:15 +00001248
1249 AdoptedPreviousTemplateParams = true;
1250 InstParams = PrevParams;
1251 }
John McCall598b4402010-03-25 06:39:04 +00001252
1253 // Do some additional validation, then merge default arguments
1254 // from the existing declarations.
Douglas Gregor01e09d92010-04-08 18:16:15 +00001255 if (!AdoptedPreviousTemplateParams &&
1256 SemaRef.CheckTemplateParameterList(InstParams, PrevParams,
John McCall598b4402010-03-25 06:39:04 +00001257 Sema::TPC_ClassTemplate))
Craig Topperc3ec1492014-05-26 06:22:03 +00001258 return nullptr;
John McCall598b4402010-03-25 06:39:04 +00001259 }
1260 }
1261
John McCall87a44eb2009-08-20 01:44:21 +00001262 CXXRecordDecl *RecordInst
John McCall598b4402010-03-25 06:39:04 +00001263 = CXXRecordDecl::Create(SemaRef.Context, Pattern->getTagKind(), DC,
Abramo Bagnara29c2d462011-03-09 14:09:51 +00001264 Pattern->getLocStart(), Pattern->getLocation(),
1265 Pattern->getIdentifier(), PrevDecl,
Douglas Gregoref06ccf2009-10-12 23:11:44 +00001266 /*DelayTypeCreation=*/true);
John McCall87a44eb2009-08-20 01:44:21 +00001267
Douglas Gregor14454802011-02-25 02:25:35 +00001268 if (QualifierLoc)
1269 RecordInst->setQualifierInfo(QualifierLoc);
John McCall3e11ebe2010-03-15 10:12:16 +00001270
John McCall87a44eb2009-08-20 01:44:21 +00001271 ClassTemplateDecl *Inst
John McCall598b4402010-03-25 06:39:04 +00001272 = ClassTemplateDecl::Create(SemaRef.Context, DC, D->getLocation(),
Vassil Vassilev352e4412017-01-12 09:16:26 +00001273 D->getIdentifier(), InstParams, RecordInst);
1274 assert(!(isFriend && Owner->isDependentContext()));
1275 Inst->setPreviousDecl(PrevClassTemplate);
1276
John McCall87a44eb2009-08-20 01:44:21 +00001277 RecordInst->setDescribedClassTemplate(Inst);
John McCall17762b82010-04-08 20:25:50 +00001278
John McCall598b4402010-03-25 06:39:04 +00001279 if (isFriend) {
John McCall17762b82010-04-08 20:25:50 +00001280 if (PrevClassTemplate)
1281 Inst->setAccess(PrevClassTemplate->getAccess());
1282 else
1283 Inst->setAccess(D->getAccess());
1284
Richard Smith64017682013-07-17 23:53:16 +00001285 Inst->setObjectOfFriendDecl();
John McCall598b4402010-03-25 06:39:04 +00001286 // TODO: do we want to track the instantiation progeny of this
1287 // friend target decl?
1288 } else {
Douglas Gregor412e8bc2009-10-30 21:07:27 +00001289 Inst->setAccess(D->getAccess());
Nick Lewycky61478912010-11-08 23:29:42 +00001290 if (!PrevClassTemplate)
1291 Inst->setInstantiatedFromMemberTemplate(D);
John McCall598b4402010-03-25 06:39:04 +00001292 }
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001293
Douglas Gregoref06ccf2009-10-12 23:11:44 +00001294 // Trigger creation of the type for the instantiation.
John McCalle78aac42010-03-10 03:28:59 +00001295 SemaRef.Context.getInjectedClassNameType(RecordInst,
Douglas Gregor9961ce92010-07-08 18:37:38 +00001296 Inst->getInjectedClassNameSpecialization());
John McCall17762b82010-04-08 20:25:50 +00001297
Douglas Gregorbb3b46e2009-10-30 22:42:42 +00001298 // Finish handling of friends.
John McCall598b4402010-03-25 06:39:04 +00001299 if (isFriend) {
Richard Smith05afe5e2012-03-13 03:12:56 +00001300 DC->makeDeclVisibleInContext(Inst);
Abramo Bagnaraedf99ff2011-11-26 13:33:46 +00001301 Inst->setLexicalDeclContext(Owner);
1302 RecordInst->setLexicalDeclContext(Owner);
Douglas Gregor412e8bc2009-10-30 21:07:27 +00001303 return Inst;
Douglas Gregorbb3b46e2009-10-30 22:42:42 +00001304 }
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001305
Abramo Bagnaraedf99ff2011-11-26 13:33:46 +00001306 if (D->isOutOfLine()) {
1307 Inst->setLexicalDeclContext(D->getLexicalDeclContext());
1308 RecordInst->setLexicalDeclContext(D->getLexicalDeclContext());
1309 }
1310
John McCall87a44eb2009-08-20 01:44:21 +00001311 Owner->addDecl(Inst);
Douglas Gregor869853e2010-11-10 19:44:59 +00001312
1313 if (!PrevClassTemplate) {
1314 // Queue up any out-of-line partial specializations of this member
1315 // class template; the client will force their instantiation once
1316 // the enclosing class has been instantiated.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001317 SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs;
Douglas Gregor869853e2010-11-10 19:44:59 +00001318 D->getPartialSpecializations(PartialSpecs);
1319 for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
Rafael Espindola8db352d2013-10-17 15:37:26 +00001320 if (PartialSpecs[I]->getFirstDecl()->isOutOfLine())
Douglas Gregor869853e2010-11-10 19:44:59 +00001321 OutOfLinePartialSpecs.push_back(std::make_pair(Inst, PartialSpecs[I]));
1322 }
1323
John McCall87a44eb2009-08-20 01:44:21 +00001324 return Inst;
1325}
1326
Douglas Gregore704c9d2009-08-27 16:57:43 +00001327Decl *
Douglas Gregore4b05162009-10-07 17:21:34 +00001328TemplateDeclInstantiator::VisitClassTemplatePartialSpecializationDecl(
1329 ClassTemplatePartialSpecializationDecl *D) {
Douglas Gregor21610382009-10-29 00:04:11 +00001330 ClassTemplateDecl *ClassTemplate = D->getSpecializedTemplate();
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001331
Douglas Gregor21610382009-10-29 00:04:11 +00001332 // Lookup the already-instantiated declaration in the instantiation
1333 // of the class template and return that.
1334 DeclContext::lookup_result Found
1335 = Owner->lookup(ClassTemplate->getDeclName());
David Blaikieff7d47a2012-12-19 00:45:41 +00001336 if (Found.empty())
Craig Topperc3ec1492014-05-26 06:22:03 +00001337 return nullptr;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001338
Douglas Gregor21610382009-10-29 00:04:11 +00001339 ClassTemplateDecl *InstClassTemplate
David Blaikieff7d47a2012-12-19 00:45:41 +00001340 = dyn_cast<ClassTemplateDecl>(Found.front());
Douglas Gregor21610382009-10-29 00:04:11 +00001341 if (!InstClassTemplate)
Craig Topperc3ec1492014-05-26 06:22:03 +00001342 return nullptr;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001343
Douglas Gregor869853e2010-11-10 19:44:59 +00001344 if (ClassTemplatePartialSpecializationDecl *Result
1345 = InstClassTemplate->findPartialSpecInstantiatedFromMember(D))
1346 return Result;
1347
1348 return InstantiateClassTemplatePartialSpecialization(InstClassTemplate, D);
Douglas Gregore4b05162009-10-07 17:21:34 +00001349}
1350
Larisse Voufo39a1e502013-08-06 01:03:05 +00001351Decl *TemplateDeclInstantiator::VisitVarTemplateDecl(VarTemplateDecl *D) {
1352 assert(D->getTemplatedDecl()->isStaticDataMember() &&
1353 "Only static data member templates are allowed.");
Larisse Voufo39a1e502013-08-06 01:03:05 +00001354
1355 // Create a local instantiation scope for this variable template, which
1356 // will contain the instantiations of the template parameters.
1357 LocalInstantiationScope Scope(SemaRef);
1358 TemplateParameterList *TempParams = D->getTemplateParameters();
1359 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
1360 if (!InstParams)
Craig Topperc3ec1492014-05-26 06:22:03 +00001361 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00001362
1363 VarDecl *Pattern = D->getTemplatedDecl();
Craig Topperc3ec1492014-05-26 06:22:03 +00001364 VarTemplateDecl *PrevVarTemplate = nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00001365
Richard Smith41c79d92014-10-11 00:37:16 +00001366 if (getPreviousDeclForInstantiation(Pattern)) {
Larisse Voufo39a1e502013-08-06 01:03:05 +00001367 DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
1368 if (!Found.empty())
1369 PrevVarTemplate = dyn_cast<VarTemplateDecl>(Found.front());
1370 }
1371
Richard Smith1c34fb72013-08-13 18:18:50 +00001372 VarDecl *VarInst =
Larisse Voufo72caf2b2013-08-22 00:59:14 +00001373 cast_or_null<VarDecl>(VisitVarDecl(Pattern,
1374 /*InstantiatingVarTemplate=*/true));
Nick Lewycky6ca07ca2015-08-10 21:54:08 +00001375 if (!VarInst) return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00001376
1377 DeclContext *DC = Owner;
1378
Larisse Voufo39a1e502013-08-06 01:03:05 +00001379 VarTemplateDecl *Inst = VarTemplateDecl::Create(
1380 SemaRef.Context, DC, D->getLocation(), D->getIdentifier(), InstParams,
Richard Smithbeef3452014-01-16 23:39:20 +00001381 VarInst);
Larisse Voufo39a1e502013-08-06 01:03:05 +00001382 VarInst->setDescribedVarTemplate(Inst);
Richard Smithbeef3452014-01-16 23:39:20 +00001383 Inst->setPreviousDecl(PrevVarTemplate);
Larisse Voufo39a1e502013-08-06 01:03:05 +00001384
1385 Inst->setAccess(D->getAccess());
1386 if (!PrevVarTemplate)
1387 Inst->setInstantiatedFromMemberTemplate(D);
1388
1389 if (D->isOutOfLine()) {
1390 Inst->setLexicalDeclContext(D->getLexicalDeclContext());
1391 VarInst->setLexicalDeclContext(D->getLexicalDeclContext());
1392 }
1393
1394 Owner->addDecl(Inst);
1395
1396 if (!PrevVarTemplate) {
1397 // Queue up any out-of-line partial specializations of this member
1398 // variable template; the client will force their instantiation once
1399 // the enclosing class has been instantiated.
1400 SmallVector<VarTemplatePartialSpecializationDecl *, 4> PartialSpecs;
1401 D->getPartialSpecializations(PartialSpecs);
1402 for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
Rafael Espindola8db352d2013-10-17 15:37:26 +00001403 if (PartialSpecs[I]->getFirstDecl()->isOutOfLine())
Larisse Voufo39a1e502013-08-06 01:03:05 +00001404 OutOfLineVarPartialSpecs.push_back(
1405 std::make_pair(Inst, PartialSpecs[I]));
1406 }
1407
1408 return Inst;
1409}
1410
1411Decl *TemplateDeclInstantiator::VisitVarTemplatePartialSpecializationDecl(
1412 VarTemplatePartialSpecializationDecl *D) {
1413 assert(D->isStaticDataMember() &&
1414 "Only static data member templates are allowed.");
Larisse Voufo39a1e502013-08-06 01:03:05 +00001415
1416 VarTemplateDecl *VarTemplate = D->getSpecializedTemplate();
1417
1418 // Lookup the already-instantiated declaration and return that.
1419 DeclContext::lookup_result Found = Owner->lookup(VarTemplate->getDeclName());
1420 assert(!Found.empty() && "Instantiation found nothing?");
1421
1422 VarTemplateDecl *InstVarTemplate = dyn_cast<VarTemplateDecl>(Found.front());
1423 assert(InstVarTemplate && "Instantiation did not find a variable template?");
1424
1425 if (VarTemplatePartialSpecializationDecl *Result =
1426 InstVarTemplate->findPartialSpecInstantiatedFromMember(D))
1427 return Result;
1428
1429 return InstantiateVarTemplatePartialSpecialization(InstVarTemplate, D);
1430}
1431
Douglas Gregore4b05162009-10-07 17:21:34 +00001432Decl *
Douglas Gregore704c9d2009-08-27 16:57:43 +00001433TemplateDeclInstantiator::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
Douglas Gregor954de172009-10-31 17:21:17 +00001434 // Create a local instantiation scope for this function template, which
1435 // will contain the instantiations of the template parameters and then get
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001436 // merged with the local instantiation scope for the function template
Douglas Gregor954de172009-10-31 17:21:17 +00001437 // itself.
John McCall19c1bfd2010-08-25 05:32:35 +00001438 LocalInstantiationScope Scope(SemaRef);
Douglas Gregor14cf7522010-04-30 18:55:50 +00001439
Douglas Gregore704c9d2009-08-27 16:57:43 +00001440 TemplateParameterList *TempParams = D->getTemplateParameters();
1441 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
Mike Stump11289f42009-09-09 15:08:12 +00001442 if (!InstParams)
Craig Topperc3ec1492014-05-26 06:22:03 +00001443 return nullptr;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001444
Craig Topperc3ec1492014-05-26 06:22:03 +00001445 FunctionDecl *Instantiated = nullptr;
Douglas Gregor3a88c1d2009-10-13 14:39:41 +00001446 if (CXXMethodDecl *DMethod = dyn_cast<CXXMethodDecl>(D->getTemplatedDecl()))
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001447 Instantiated = cast_or_null<FunctionDecl>(VisitCXXMethodDecl(DMethod,
Douglas Gregor3a88c1d2009-10-13 14:39:41 +00001448 InstParams));
1449 else
1450 Instantiated = cast_or_null<FunctionDecl>(VisitFunctionDecl(
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001451 D->getTemplatedDecl(),
Douglas Gregor3a88c1d2009-10-13 14:39:41 +00001452 InstParams));
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001453
Douglas Gregor3a88c1d2009-10-13 14:39:41 +00001454 if (!Instantiated)
Craig Topperc3ec1492014-05-26 06:22:03 +00001455 return nullptr;
Douglas Gregore704c9d2009-08-27 16:57:43 +00001456
Mike Stump11289f42009-09-09 15:08:12 +00001457 // Link the instantiated function template declaration to the function
Douglas Gregore704c9d2009-08-27 16:57:43 +00001458 // template from which it was instantiated.
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001459 FunctionTemplateDecl *InstTemplate
Douglas Gregor3a88c1d2009-10-13 14:39:41 +00001460 = Instantiated->getDescribedFunctionTemplate();
Douglas Gregorca027af2009-10-12 22:27:17 +00001461 InstTemplate->setAccess(D->getAccess());
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001462 assert(InstTemplate &&
Douglas Gregor3a88c1d2009-10-13 14:39:41 +00001463 "VisitFunctionDecl/CXXMethodDecl didn't create a template!");
John McCall2079d0b2009-12-14 23:19:40 +00001464
John McCall30837102010-03-26 23:10:15 +00001465 bool isFriend = (InstTemplate->getFriendObjectKind() != Decl::FOK_None);
1466
John McCall2079d0b2009-12-14 23:19:40 +00001467 // Link the instantiation back to the pattern *unless* this is a
1468 // non-definition friend declaration.
1469 if (!InstTemplate->getInstantiatedFromMemberTemplate() &&
John McCall30837102010-03-26 23:10:15 +00001470 !(isFriend && !D->getTemplatedDecl()->isThisDeclarationADefinition()))
Douglas Gregor3a88c1d2009-10-13 14:39:41 +00001471 InstTemplate->setInstantiatedFromMemberTemplate(D);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001472
John McCall30837102010-03-26 23:10:15 +00001473 // Make declarations visible in the appropriate context.
John McCalla0a96892012-08-10 03:15:35 +00001474 if (!isFriend) {
Douglas Gregor3a88c1d2009-10-13 14:39:41 +00001475 Owner->addDecl(InstTemplate);
John McCalla0a96892012-08-10 03:15:35 +00001476 } else if (InstTemplate->getDeclContext()->isRecord() &&
Richard Smith41c79d92014-10-11 00:37:16 +00001477 !getPreviousDeclForInstantiation(D)) {
John McCalla0a96892012-08-10 03:15:35 +00001478 SemaRef.CheckFriendAccess(InstTemplate);
1479 }
John McCall30837102010-03-26 23:10:15 +00001480
Douglas Gregore704c9d2009-08-27 16:57:43 +00001481 return InstTemplate;
1482}
1483
Douglas Gregor8ea8fd42009-03-25 21:17:03 +00001484Decl *TemplateDeclInstantiator::VisitCXXRecordDecl(CXXRecordDecl *D) {
Craig Topperc3ec1492014-05-26 06:22:03 +00001485 CXXRecordDecl *PrevDecl = nullptr;
Douglas Gregor8ea8fd42009-03-25 21:17:03 +00001486 if (D->isInjectedClassName())
1487 PrevDecl = cast<CXXRecordDecl>(Owner);
Richard Smith41c79d92014-10-11 00:37:16 +00001488 else if (CXXRecordDecl *PatternPrev = getPreviousDeclForInstantiation(D)) {
Douglas Gregora04f2ca2010-03-01 15:56:25 +00001489 NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(),
Richard Smith41c79d92014-10-11 00:37:16 +00001490 PatternPrev,
John McCalle9f92a02009-12-15 22:29:06 +00001491 TemplateArgs);
Craig Topperc3ec1492014-05-26 06:22:03 +00001492 if (!Prev) return nullptr;
John McCalle9f92a02009-12-15 22:29:06 +00001493 PrevDecl = cast<CXXRecordDecl>(Prev);
1494 }
Douglas Gregor8ea8fd42009-03-25 21:17:03 +00001495
1496 CXXRecordDecl *Record
Mike Stump11289f42009-09-09 15:08:12 +00001497 = CXXRecordDecl::Create(SemaRef.Context, D->getTagKind(), Owner,
Abramo Bagnara29c2d462011-03-09 14:09:51 +00001498 D->getLocStart(), D->getLocation(),
1499 D->getIdentifier(), PrevDecl);
John McCall3e11ebe2010-03-15 10:12:16 +00001500
1501 // Substitute the nested name specifier, if any.
1502 if (SubstQualifier(D, Record))
Craig Topperc3ec1492014-05-26 06:22:03 +00001503 return nullptr;
John McCall3e11ebe2010-03-15 10:12:16 +00001504
Douglas Gregor8ea8fd42009-03-25 21:17:03 +00001505 Record->setImplicit(D->isImplicit());
Eli Friedmanbda4ef12009-08-27 19:11:42 +00001506 // FIXME: Check against AS_none is an ugly hack to work around the issue that
1507 // the tag decls introduced by friend class declarations don't have an access
1508 // specifier. Remove once this area of the code gets sorted out.
1509 if (D->getAccess() != AS_none)
1510 Record->setAccess(D->getAccess());
Douglas Gregor8ea8fd42009-03-25 21:17:03 +00001511 if (!D->isInjectedClassName())
Douglas Gregorbbe8f462009-10-08 15:14:33 +00001512 Record->setInstantiationOfMemberClass(D, TSK_ImplicitInstantiation);
Douglas Gregor8ea8fd42009-03-25 21:17:03 +00001513
John McCallaa74a0c2009-08-28 07:59:38 +00001514 // If the original function was part of a friend declaration,
1515 // inherit its namespace state.
Richard Smith64017682013-07-17 23:53:16 +00001516 if (D->getFriendObjectKind())
1517 Record->setObjectOfFriendDecl();
John McCallaa74a0c2009-08-28 07:59:38 +00001518
Douglas Gregor04163182010-05-21 00:31:19 +00001519 // Make sure that anonymous structs and unions are recorded.
David Majnemer192d1792013-11-27 08:20:38 +00001520 if (D->isAnonymousStructOrUnion())
Douglas Gregor04163182010-05-21 00:31:19 +00001521 Record->setAnonymousStructOrUnion(true);
David Majnemer192d1792013-11-27 08:20:38 +00001522
1523 if (D->isLocalClass())
1524 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Record);
Anders Carlsson5da84842009-09-01 04:26:58 +00001525
David Majnemerdbc0c8f2013-12-04 09:01:55 +00001526 // Forward the mangling number from the template to the instantiated decl.
1527 SemaRef.Context.setManglingNumber(Record,
1528 SemaRef.Context.getManglingNumber(D));
1529
David Majnemer00350522015-08-31 18:48:39 +00001530 // See if the old tag was defined along with a declarator.
1531 // If it did, mark the new tag as being associated with that declarator.
1532 if (DeclaratorDecl *DD = SemaRef.Context.getDeclaratorForUnnamedTagDecl(D))
1533 SemaRef.Context.addDeclaratorForUnnamedTagDecl(Record, DD);
1534
1535 // See if the old tag was defined along with a typedef.
1536 // If it did, mark the new tag as being associated with that typedef.
1537 if (TypedefNameDecl *TND = SemaRef.Context.getTypedefNameForUnnamedTagDecl(D))
1538 SemaRef.Context.addTypedefNameForUnnamedTagDecl(Record, TND);
1539
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00001540 Owner->addDecl(Record);
David Majnemer192d1792013-11-27 08:20:38 +00001541
1542 // DR1484 clarifies that the members of a local class are instantiated as part
1543 // of the instantiation of their enclosing entity.
1544 if (D->isCompleteDefinition() && D->isLocalClass()) {
Richard Smith4f3e3812017-05-20 01:36:41 +00001545 Sema::LocalEagerInstantiationScope LocalInstantiations(SemaRef);
Richard Smithb0b68012015-05-11 23:09:06 +00001546
David Majnemera64cb5a2014-02-22 00:17:46 +00001547 SemaRef.InstantiateClass(D->getLocation(), Record, D, TemplateArgs,
1548 TSK_ImplicitInstantiation,
1549 /*Complain=*/true);
Richard Smithb0b68012015-05-11 23:09:06 +00001550
Richard Smithece47582017-01-04 23:45:01 +00001551 // For nested local classes, we will instantiate the members when we
1552 // reach the end of the outermost (non-nested) local class.
1553 if (!D->isCXXClassMember())
1554 SemaRef.InstantiateClassMembers(D->getLocation(), Record, TemplateArgs,
1555 TSK_ImplicitInstantiation);
Richard Smithb0b68012015-05-11 23:09:06 +00001556
1557 // This class may have local implicit instantiations that need to be
1558 // performed within this scope.
Richard Smith4f3e3812017-05-20 01:36:41 +00001559 LocalInstantiations.perform();
David Majnemer192d1792013-11-27 08:20:38 +00001560 }
Nico Weber72889432014-09-06 01:25:55 +00001561
1562 SemaRef.DiagnoseUnusedNestedTypedefs(Record);
1563
Douglas Gregor8ea8fd42009-03-25 21:17:03 +00001564 return Record;
1565}
1566
Douglas Gregor89f593a2012-09-13 21:56:43 +00001567/// \brief Adjust the given function type for an instantiation of the
1568/// given declaration, to cope with modifications to the function's type that
1569/// aren't reflected in the type-source information.
1570///
1571/// \param D The declaration we're instantiating.
1572/// \param TInfo The already-instantiated type.
1573static QualType adjustFunctionTypeForInstantiation(ASTContext &Context,
1574 FunctionDecl *D,
1575 TypeSourceInfo *TInfo) {
Douglas Gregor1af8ad42012-09-13 22:01:49 +00001576 const FunctionProtoType *OrigFunc
1577 = D->getType()->castAs<FunctionProtoType>();
1578 const FunctionProtoType *NewFunc
1579 = TInfo->getType()->castAs<FunctionProtoType>();
1580 if (OrigFunc->getExtInfo() == NewFunc->getExtInfo())
1581 return TInfo->getType();
1582
1583 FunctionProtoType::ExtProtoInfo NewEPI = NewFunc->getExtProtoInfo();
1584 NewEPI.ExtInfo = OrigFunc->getExtInfo();
Alp Toker314cc812014-01-25 16:55:45 +00001585 return Context.getFunctionType(NewFunc->getReturnType(),
Alp Toker9cacbab2014-01-20 20:26:09 +00001586 NewFunc->getParamTypes(), NewEPI);
Douglas Gregor89f593a2012-09-13 21:56:43 +00001587}
1588
John McCallaa74a0c2009-08-28 07:59:38 +00001589/// Normal class members are of more specific types and therefore
Richard Smith4fa145152017-12-21 19:43:39 +00001590/// don't make it here. This function serves three purposes:
John McCallaa74a0c2009-08-28 07:59:38 +00001591/// 1) instantiating function templates
1592/// 2) substituting friend declarations
Richard Smith4fa145152017-12-21 19:43:39 +00001593/// 3) substituting deduction guide declarations for nested class templates
Douglas Gregor33636e62009-12-24 20:56:24 +00001594Decl *TemplateDeclInstantiator::VisitFunctionDecl(FunctionDecl *D,
Douglas Gregor3a88c1d2009-10-13 14:39:41 +00001595 TemplateParameterList *TemplateParams) {
Douglas Gregor8f5d4422009-06-29 20:59:39 +00001596 // Check whether there is already a function template specialization for
1597 // this declaration.
1598 FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate();
John McCall2f88d7d2010-03-27 05:57:59 +00001599 if (FunctionTemplate && !TemplateParams) {
Richard Smith47752e42013-05-03 23:46:09 +00001600 ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
Mike Stump11289f42009-09-09 15:08:12 +00001601
Craig Topperc3ec1492014-05-26 06:22:03 +00001602 void *InsertPos = nullptr;
Argyrios Kyrtzidisdde57902010-07-20 13:59:58 +00001603 FunctionDecl *SpecFunc
Craig Topper7e0daca2014-06-26 04:58:53 +00001604 = FunctionTemplate->findSpecialization(Innermost, InsertPos);
Mike Stump11289f42009-09-09 15:08:12 +00001605
Douglas Gregor8f5d4422009-06-29 20:59:39 +00001606 // If we already have a function template specialization, return it.
Argyrios Kyrtzidisdde57902010-07-20 13:59:58 +00001607 if (SpecFunc)
1608 return SpecFunc;
Douglas Gregor8f5d4422009-06-29 20:59:39 +00001609 }
Mike Stump11289f42009-09-09 15:08:12 +00001610
John McCall2f88d7d2010-03-27 05:57:59 +00001611 bool isFriend;
1612 if (FunctionTemplate)
1613 isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None);
1614 else
1615 isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
1616
Craig Topperc3ec1492014-05-26 06:22:03 +00001617 bool MergeWithParentScope = (TemplateParams != nullptr) ||
Douglas Gregor9f44d142010-05-21 21:25:08 +00001618 Owner->isFunctionOrMethod() ||
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001619 !(isa<Decl>(Owner) &&
Douglas Gregorf5974fa2010-01-16 20:21:20 +00001620 cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
John McCall19c1bfd2010-08-25 05:32:35 +00001621 LocalInstantiationScope Scope(SemaRef, MergeWithParentScope);
Mike Stump11289f42009-09-09 15:08:12 +00001622
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001623 SmallVector<ParmVarDecl *, 4> Params;
David Blaikie4d142962011-11-10 05:42:04 +00001624 TypeSourceInfo *TInfo = SubstFunctionType(D, Params);
John McCall58f10c32010-03-11 09:03:00 +00001625 if (!TInfo)
Craig Topperc3ec1492014-05-26 06:22:03 +00001626 return nullptr;
Douglas Gregor89f593a2012-09-13 21:56:43 +00001627 QualType T = adjustFunctionTypeForInstantiation(SemaRef.Context, D, TInfo);
John McCall58de3582009-08-14 02:03:10 +00001628
Douglas Gregor14454802011-02-25 02:25:35 +00001629 NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
1630 if (QualifierLoc) {
1631 QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
1632 TemplateArgs);
1633 if (!QualifierLoc)
Craig Topperc3ec1492014-05-26 06:22:03 +00001634 return nullptr;
John McCalle0b2ddb2010-03-26 04:53:08 +00001635 }
1636
John McCallce410662010-02-06 01:50:47 +00001637 // If we're instantiating a local function declaration, put the result
Richard Smith541b38b2013-09-20 01:15:31 +00001638 // in the enclosing namespace; otherwise we need to find the instantiated
1639 // context.
John McCallce410662010-02-06 01:50:47 +00001640 DeclContext *DC;
Richard Smith541b38b2013-09-20 01:15:31 +00001641 if (D->isLocalExternDecl()) {
John McCallce410662010-02-06 01:50:47 +00001642 DC = Owner;
Richard Smith541b38b2013-09-20 01:15:31 +00001643 SemaRef.adjustContextForLocalExternDecl(DC);
1644 } else if (isFriend && QualifierLoc) {
John McCalle0b2ddb2010-03-26 04:53:08 +00001645 CXXScopeSpec SS;
Douglas Gregor14454802011-02-25 02:25:35 +00001646 SS.Adopt(QualifierLoc);
John McCalle0b2ddb2010-03-26 04:53:08 +00001647 DC = SemaRef.computeDeclContext(SS);
Craig Topperc3ec1492014-05-26 06:22:03 +00001648 if (!DC) return nullptr;
John McCalle0b2ddb2010-03-26 04:53:08 +00001649 } else {
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001650 DC = SemaRef.FindInstantiatedContext(D->getLocation(), D->getDeclContext(),
Douglas Gregora04f2ca2010-03-01 15:56:25 +00001651 TemplateArgs);
John McCalle0b2ddb2010-03-26 04:53:08 +00001652 }
John McCallce410662010-02-06 01:50:47 +00001653
Richard Smith4fa145152017-12-21 19:43:39 +00001654 DeclarationNameInfo NameInfo
1655 = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
1656
Richard Smithbc491202017-02-17 20:05:37 +00001657 FunctionDecl *Function;
Faisal Vali81b756e2017-10-22 14:45:08 +00001658 if (auto *DGuide = dyn_cast<CXXDeductionGuideDecl>(D)) {
Richard Smithbc491202017-02-17 20:05:37 +00001659 Function = CXXDeductionGuideDecl::Create(
Faisal Vali81b756e2017-10-22 14:45:08 +00001660 SemaRef.Context, DC, D->getInnerLocStart(), DGuide->isExplicit(),
Richard Smith4fa145152017-12-21 19:43:39 +00001661 NameInfo, T, TInfo, D->getSourceRange().getEnd());
Faisal Vali81b756e2017-10-22 14:45:08 +00001662 if (DGuide->isCopyDeductionCandidate())
1663 cast<CXXDeductionGuideDecl>(Function)->setIsCopyDeductionCandidate();
1664 } else {
Richard Smithbc491202017-02-17 20:05:37 +00001665 Function = FunctionDecl::Create(
Richard Smith4fa145152017-12-21 19:43:39 +00001666 SemaRef.Context, DC, D->getInnerLocStart(), NameInfo, T, TInfo,
Richard Smithbc491202017-02-17 20:05:37 +00001667 D->getCanonicalDecl()->getStorageClass(), D->isInlineSpecified(),
1668 D->hasWrittenPrototype(), D->isConstexpr());
1669 Function->setRangeEnd(D->getSourceRange().getEnd());
1670 }
John McCall3e11ebe2010-03-15 10:12:16 +00001671
Richard Smithf3814ad2013-01-25 00:08:28 +00001672 if (D->isInlined())
1673 Function->setImplicitlyInline();
1674
Douglas Gregor14454802011-02-25 02:25:35 +00001675 if (QualifierLoc)
1676 Function->setQualifierInfo(QualifierLoc);
John McCall3e11ebe2010-03-15 10:12:16 +00001677
Richard Smith541b38b2013-09-20 01:15:31 +00001678 if (D->isLocalExternDecl())
1679 Function->setLocalExternDecl();
1680
John McCall30837102010-03-26 23:10:15 +00001681 DeclContext *LexicalDC = Owner;
Richard Smith541b38b2013-09-20 01:15:31 +00001682 if (!isFriend && D->isOutOfLine() && !D->isLocalExternDecl()) {
John McCall30837102010-03-26 23:10:15 +00001683 assert(D->getDeclContext()->isFileContext());
1684 LexicalDC = D->getDeclContext();
1685 }
1686
1687 Function->setLexicalDeclContext(LexicalDC);
Mike Stump11289f42009-09-09 15:08:12 +00001688
Douglas Gregorad3f2fc2009-06-25 22:08:12 +00001689 // Attach the parameters
Reid Klecknera09e44c2013-07-31 21:00:18 +00001690 for (unsigned P = 0; P < Params.size(); ++P)
1691 if (Params[P])
1692 Params[P]->setOwningFunction(Function);
David Blaikie9c70e042011-09-21 18:16:56 +00001693 Function->setParams(Params);
John McCallaa74a0c2009-08-28 07:59:38 +00001694
Douglas Gregor3a88c1d2009-10-13 14:39:41 +00001695 if (TemplateParams) {
1696 // Our resulting instantiation is actually a function template, since we
1697 // are substituting only the outer template parameters. For example, given
1698 //
1699 // template<typename T>
1700 // struct X {
1701 // template<typename U> friend void f(T, U);
1702 // };
1703 //
1704 // X<int> x;
1705 //
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001706 // We are instantiating the friend function template "f" within X<int>,
Douglas Gregor3a88c1d2009-10-13 14:39:41 +00001707 // which means substituting int for T, but leaving "f" as a friend function
1708 // template.
1709 // Build the function template itself.
John McCalle0b2ddb2010-03-26 04:53:08 +00001710 FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, DC,
Douglas Gregor3a88c1d2009-10-13 14:39:41 +00001711 Function->getLocation(),
1712 Function->getDeclName(),
1713 TemplateParams, Function);
1714 Function->setDescribedFunctionTemplate(FunctionTemplate);
John McCall30837102010-03-26 23:10:15 +00001715
1716 FunctionTemplate->setLexicalDeclContext(LexicalDC);
John McCalle0b2ddb2010-03-26 04:53:08 +00001717
1718 if (isFriend && D->isThisDeclarationADefinition()) {
John McCalle0b2ddb2010-03-26 04:53:08 +00001719 FunctionTemplate->setInstantiatedFromMemberTemplate(
1720 D->getDescribedFunctionTemplate());
1721 }
Douglas Gregorffe14e32009-11-14 01:20:54 +00001722 } else if (FunctionTemplate) {
1723 // Record this function template specialization.
Richard Smith47752e42013-05-03 23:46:09 +00001724 ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
Douglas Gregord5058122010-02-11 01:19:42 +00001725 Function->setFunctionTemplateSpecialization(FunctionTemplate,
Douglas Gregor1ccc8412010-11-07 23:05:16 +00001726 TemplateArgumentList::CreateCopy(SemaRef.Context,
David Majnemer8b622692016-07-03 21:17:51 +00001727 Innermost),
Craig Topperc3ec1492014-05-26 06:22:03 +00001728 /*InsertPos=*/nullptr);
Richard Smith152bcd22017-01-28 02:56:07 +00001729 } else if (isFriend && D->isThisDeclarationADefinition()) {
1730 // Do not connect the friend to the template unless it's actually a
1731 // definition. We don't want non-template functions to be marked as being
1732 // template instantiations.
John McCalle0b2ddb2010-03-26 04:53:08 +00001733 Function->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation);
John McCallaa74a0c2009-08-28 07:59:38 +00001734 }
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001735
Douglas Gregorad3f2fc2009-06-25 22:08:12 +00001736 if (InitFunctionInstantiation(Function, D))
1737 Function->setInvalidDecl();
Mike Stump11289f42009-09-09 15:08:12 +00001738
John McCallb9c78482010-04-08 09:05:18 +00001739 bool isExplicitSpecialization = false;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001740
Richard Smith541b38b2013-09-20 01:15:31 +00001741 LookupResult Previous(
1742 SemaRef, Function->getDeclName(), SourceLocation(),
1743 D->isLocalExternDecl() ? Sema::LookupRedeclarationWithLinkage
1744 : Sema::LookupOrdinaryName,
Richard Smithbecb92d2017-10-10 22:33:17 +00001745 D->isLocalExternDecl() ? Sema::ForExternalRedeclaration
1746 : SemaRef.forRedeclarationInCurContext());
John McCall1f82f242009-11-18 22:49:29 +00001747
John McCallb9c78482010-04-08 09:05:18 +00001748 if (DependentFunctionTemplateSpecializationInfo *Info
1749 = D->getDependentSpecializationInfo()) {
1750 assert(isFriend && "non-friend has dependent specialization info?");
1751
1752 // This needs to be set now for future sanity.
Richard Smith64017682013-07-17 23:53:16 +00001753 Function->setObjectOfFriendDecl();
John McCallb9c78482010-04-08 09:05:18 +00001754
1755 // Instantiate the explicit template arguments.
1756 TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(),
1757 Info->getRAngleLoc());
Douglas Gregor0f3feb42010-12-22 21:19:48 +00001758 if (SemaRef.Subst(Info->getTemplateArgs(), Info->getNumTemplateArgs(),
1759 ExplicitArgs, TemplateArgs))
Craig Topperc3ec1492014-05-26 06:22:03 +00001760 return nullptr;
John McCallb9c78482010-04-08 09:05:18 +00001761
1762 // Map the candidate templates to their instantiations.
1763 for (unsigned I = 0, E = Info->getNumTemplates(); I != E; ++I) {
1764 Decl *Temp = SemaRef.FindInstantiatedDecl(D->getLocation(),
1765 Info->getTemplate(I),
1766 TemplateArgs);
Craig Topperc3ec1492014-05-26 06:22:03 +00001767 if (!Temp) return nullptr;
John McCallb9c78482010-04-08 09:05:18 +00001768
1769 Previous.addDecl(cast<FunctionTemplateDecl>(Temp));
1770 }
1771
1772 if (SemaRef.CheckFunctionTemplateSpecialization(Function,
1773 &ExplicitArgs,
1774 Previous))
1775 Function->setInvalidDecl();
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001776
John McCallb9c78482010-04-08 09:05:18 +00001777 isExplicitSpecialization = true;
1778
1779 } else if (TemplateParams || !FunctionTemplate) {
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001780 // Look only into the namespace where the friend would be declared to
1781 // find a previous declaration. This is the innermost enclosing namespace,
Douglas Gregor3a88c1d2009-10-13 14:39:41 +00001782 // as described in ActOnFriendFunctionDecl.
John McCall1f82f242009-11-18 22:49:29 +00001783 SemaRef.LookupQualifiedName(Previous, DC);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001784
Douglas Gregor3a88c1d2009-10-13 14:39:41 +00001785 // In C++, the previous declaration we find might be a tag type
1786 // (class or enum). In this case, the new declaration will hide the
1787 // tag type. Note that this does does not apply if we're declaring a
1788 // typedef (C++ [dcl.typedef]p4).
John McCall1f82f242009-11-18 22:49:29 +00001789 if (Previous.isSingleTagDecl())
1790 Previous.clear();
Douglas Gregor3a88c1d2009-10-13 14:39:41 +00001791 }
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001792
Serge Pavlov25dbe1a2017-06-21 12:46:57 +00001793 if (isFriend)
1794 Function->setObjectOfFriendDecl();
1795
Craig Topperc3ec1492014-05-26 06:22:03 +00001796 SemaRef.CheckFunctionDeclaration(/*Scope*/ nullptr, Function, Previous,
Kaelyn Uhrain4dc695d2011-10-11 00:28:45 +00001797 isExplicitSpecialization);
Douglas Gregorf4f296d2009-03-23 23:06:20 +00001798
John McCallb9467b62010-04-24 01:30:58 +00001799 NamedDecl *PrincipalDecl = (TemplateParams
1800 ? cast<NamedDecl>(FunctionTemplate)
1801 : Function);
1802
Douglas Gregor3a88c1d2009-10-13 14:39:41 +00001803 // If the original function was part of a friend declaration,
1804 // inherit its namespace state and add it to the owner.
John McCalle0b2ddb2010-03-26 04:53:08 +00001805 if (isFriend) {
Serge Pavlova4ab1b12017-06-14 10:57:56 +00001806 PrincipalDecl->setObjectOfFriendDecl();
Richard Smith05afe5e2012-03-13 03:12:56 +00001807 DC->makeDeclVisibleInContext(PrincipalDecl);
Gabor Greif718d5152010-08-30 21:10:05 +00001808
Richard Smith91dfaac2014-02-03 02:37:59 +00001809 bool QueuedInstantiation = false;
Gabor Greif718d5152010-08-30 21:10:05 +00001810
Richard Smith91dfaac2014-02-03 02:37:59 +00001811 // C++11 [temp.friend]p4 (DR329):
1812 // When a function is defined in a friend function declaration in a class
1813 // template, the function is instantiated when the function is odr-used.
1814 // The same restrictions on multiple declarations and definitions that
1815 // apply to non-template function declarations and definitions also apply
1816 // to these implicit definitions.
1817 if (D->isThisDeclarationADefinition()) {
Douglas Gregorb92ea592010-05-18 05:45:02 +00001818 // Check for a function body.
Craig Topperc3ec1492014-05-26 06:22:03 +00001819 const FunctionDecl *Definition = nullptr;
Alexis Hunt4a8ea102011-05-06 20:44:56 +00001820 if (Function->isDefined(Definition) &&
Douglas Gregorb92ea592010-05-18 05:45:02 +00001821 Definition->getTemplateSpecializationKind() == TSK_Undeclared) {
Richard Smith91dfaac2014-02-03 02:37:59 +00001822 SemaRef.Diag(Function->getLocation(), diag::err_redefinition)
1823 << Function->getDeclName();
Douglas Gregorb92ea592010-05-18 05:45:02 +00001824 SemaRef.Diag(Definition->getLocation(), diag::note_previous_definition);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001825 }
Douglas Gregorb92ea592010-05-18 05:45:02 +00001826 // Check for redefinitions due to other instantiations of this or
1827 // a similar friend function.
Aaron Ballman86c93902014-03-06 23:45:36 +00001828 else for (auto R : Function->redecls()) {
1829 if (R == Function)
Gabor Greif122f1eb2010-08-28 15:42:30 +00001830 continue;
Richard Smith91dfaac2014-02-03 02:37:59 +00001831
1832 // If some prior declaration of this function has been used, we need
1833 // to instantiate its definition.
1834 if (!QueuedInstantiation && R->isUsed(false)) {
1835 if (MemberSpecializationInfo *MSInfo =
1836 Function->getMemberSpecializationInfo()) {
1837 if (MSInfo->getPointOfInstantiation().isInvalid()) {
1838 SourceLocation Loc = R->getLocation(); // FIXME
1839 MSInfo->setPointOfInstantiation(Loc);
1840 SemaRef.PendingLocalImplicitInstantiations.push_back(
1841 std::make_pair(Function, Loc));
1842 QueuedInstantiation = true;
Gabor Greif718d5152010-08-30 21:10:05 +00001843 }
1844 }
Richard Smith91dfaac2014-02-03 02:37:59 +00001845 }
1846
1847 // If some prior declaration of this function was a friend with an
1848 // uninstantiated definition, reject it.
1849 if (R->getFriendObjectKind()) {
1850 if (const FunctionDecl *RPattern =
1851 R->getTemplateInstantiationPattern()) {
Alexis Hunt4a8ea102011-05-06 20:44:56 +00001852 if (RPattern->isDefined(RPattern)) {
Richard Smith91dfaac2014-02-03 02:37:59 +00001853 SemaRef.Diag(Function->getLocation(), diag::err_redefinition)
Douglas Gregorb92ea592010-05-18 05:45:02 +00001854 << Function->getDeclName();
Gabor Greifae849e42010-08-28 15:46:56 +00001855 SemaRef.Diag(R->getLocation(), diag::note_previous_definition);
Douglas Gregorb92ea592010-05-18 05:45:02 +00001856 break;
1857 }
Richard Smith91dfaac2014-02-03 02:37:59 +00001858 }
Douglas Gregorb92ea592010-05-18 05:45:02 +00001859 }
1860 }
1861 }
Richard Smithf3597652017-05-10 00:01:13 +00001862
1863 // Check the template parameter list against the previous declaration. The
1864 // goal here is to pick up default arguments added since the friend was
1865 // declared; we know the template parameter lists match, since otherwise
1866 // we would not have picked this template as the previous declaration.
1867 if (TemplateParams && FunctionTemplate->getPreviousDecl()) {
1868 SemaRef.CheckTemplateParameterList(
1869 TemplateParams,
1870 FunctionTemplate->getPreviousDecl()->getTemplateParameters(),
1871 Function->isThisDeclarationADefinition()
1872 ? Sema::TPC_FriendFunctionTemplateDefinition
1873 : Sema::TPC_FriendFunctionTemplate);
1874 }
Douglas Gregor3a88c1d2009-10-13 14:39:41 +00001875 }
1876
Richard Smith541b38b2013-09-20 01:15:31 +00001877 if (Function->isLocalExternDecl() && !Function->getPreviousDecl())
1878 DC->makeDeclVisibleInContext(PrincipalDecl);
1879
John McCallb9467b62010-04-24 01:30:58 +00001880 if (Function->isOverloadedOperator() && !DC->isRecord() &&
1881 PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
1882 PrincipalDecl->setNonMemberOperator();
1883
Alexis Hunt1fb4e762011-05-23 21:07:59 +00001884 assert(!D->isDefaulted() && "only methods should be defaulted");
Douglas Gregorad3f2fc2009-06-25 22:08:12 +00001885 return Function;
1886}
1887
Douglas Gregore704c9d2009-08-27 16:57:43 +00001888Decl *
1889TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D,
Francois Pichet00c7e6c2011-08-14 03:52:19 +00001890 TemplateParameterList *TemplateParams,
1891 bool IsClassScopeSpecialization) {
Douglas Gregor97628d62009-08-21 00:16:32 +00001892 FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate();
Douglas Gregore704c9d2009-08-27 16:57:43 +00001893 if (FunctionTemplate && !TemplateParams) {
Mike Stump11289f42009-09-09 15:08:12 +00001894 // We are creating a function template specialization from a function
1895 // template. Check whether there is already a function template
Douglas Gregore704c9d2009-08-27 16:57:43 +00001896 // specialization for this particular set of template arguments.
Richard Smith47752e42013-05-03 23:46:09 +00001897 ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
Mike Stump11289f42009-09-09 15:08:12 +00001898
Craig Topperc3ec1492014-05-26 06:22:03 +00001899 void *InsertPos = nullptr;
Argyrios Kyrtzidisdde57902010-07-20 13:59:58 +00001900 FunctionDecl *SpecFunc
Craig Topper7e0daca2014-06-26 04:58:53 +00001901 = FunctionTemplate->findSpecialization(Innermost, InsertPos);
Mike Stump11289f42009-09-09 15:08:12 +00001902
Douglas Gregor97628d62009-08-21 00:16:32 +00001903 // If we already have a function template specialization, return it.
Argyrios Kyrtzidisdde57902010-07-20 13:59:58 +00001904 if (SpecFunc)
1905 return SpecFunc;
Douglas Gregor97628d62009-08-21 00:16:32 +00001906 }
1907
John McCall2f88d7d2010-03-27 05:57:59 +00001908 bool isFriend;
1909 if (FunctionTemplate)
1910 isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None);
1911 else
1912 isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
1913
Craig Topperc3ec1492014-05-26 06:22:03 +00001914 bool MergeWithParentScope = (TemplateParams != nullptr) ||
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001915 !(isa<Decl>(Owner) &&
Douglas Gregorf5974fa2010-01-16 20:21:20 +00001916 cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
John McCall19c1bfd2010-08-25 05:32:35 +00001917 LocalInstantiationScope Scope(SemaRef, MergeWithParentScope);
Douglas Gregor37256522009-05-14 21:44:34 +00001918
John McCalld0e23ec2010-10-19 02:26:41 +00001919 // Instantiate enclosing template arguments for friends.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001920 SmallVector<TemplateParameterList *, 4> TempParamLists;
John McCalld0e23ec2010-10-19 02:26:41 +00001921 unsigned NumTempParamLists = 0;
1922 if (isFriend && (NumTempParamLists = D->getNumTemplateParameterLists())) {
Benjamin Kramer9dc549b2015-08-04 14:46:06 +00001923 TempParamLists.resize(NumTempParamLists);
John McCalld0e23ec2010-10-19 02:26:41 +00001924 for (unsigned I = 0; I != NumTempParamLists; ++I) {
1925 TemplateParameterList *TempParams = D->getTemplateParameterList(I);
1926 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
1927 if (!InstParams)
Craig Topperc3ec1492014-05-26 06:22:03 +00001928 return nullptr;
John McCalld0e23ec2010-10-19 02:26:41 +00001929 TempParamLists[I] = InstParams;
1930 }
1931 }
1932
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001933 SmallVector<ParmVarDecl *, 4> Params;
Benjamin Kramer1dd48bc2012-01-20 14:42:32 +00001934 TypeSourceInfo *TInfo = SubstFunctionType(D, Params);
John McCall58f10c32010-03-11 09:03:00 +00001935 if (!TInfo)
Craig Topperc3ec1492014-05-26 06:22:03 +00001936 return nullptr;
Douglas Gregor89f593a2012-09-13 21:56:43 +00001937 QualType T = adjustFunctionTypeForInstantiation(SemaRef.Context, D, TInfo);
Douglas Gregorf4f296d2009-03-23 23:06:20 +00001938
Douglas Gregor14454802011-02-25 02:25:35 +00001939 NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
1940 if (QualifierLoc) {
1941 QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
John McCall2f88d7d2010-03-27 05:57:59 +00001942 TemplateArgs);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00001943 if (!QualifierLoc)
Craig Topperc3ec1492014-05-26 06:22:03 +00001944 return nullptr;
John McCall2f88d7d2010-03-27 05:57:59 +00001945 }
1946
1947 DeclContext *DC = Owner;
1948 if (isFriend) {
Douglas Gregor14454802011-02-25 02:25:35 +00001949 if (QualifierLoc) {
John McCall2f88d7d2010-03-27 05:57:59 +00001950 CXXScopeSpec SS;
Douglas Gregor14454802011-02-25 02:25:35 +00001951 SS.Adopt(QualifierLoc);
John McCall2f88d7d2010-03-27 05:57:59 +00001952 DC = SemaRef.computeDeclContext(SS);
John McCall1a1b53e2010-10-19 05:01:53 +00001953
1954 if (DC && SemaRef.RequireCompleteDeclContext(SS, DC))
Craig Topperc3ec1492014-05-26 06:22:03 +00001955 return nullptr;
John McCall2f88d7d2010-03-27 05:57:59 +00001956 } else {
1957 DC = SemaRef.FindInstantiatedContext(D->getLocation(),
1958 D->getDeclContext(),
1959 TemplateArgs);
1960 }
Craig Topperc3ec1492014-05-26 06:22:03 +00001961 if (!DC) return nullptr;
John McCall2f88d7d2010-03-27 05:57:59 +00001962 }
1963
Douglas Gregorf4f296d2009-03-23 23:06:20 +00001964 // Build the instantiated method declaration.
John McCall2f88d7d2010-03-27 05:57:59 +00001965 CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
Craig Topperc3ec1492014-05-26 06:22:03 +00001966 CXXMethodDecl *Method = nullptr;
Mike Stump11289f42009-09-09 15:08:12 +00001967
Abramo Bagnaradff19302011-03-08 08:55:46 +00001968 SourceLocation StartLoc = D->getInnerLocStart();
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001969 DeclarationNameInfo NameInfo
1970 = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
Douglas Gregore8394862009-08-21 22:43:28 +00001971 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
Mike Stump11289f42009-09-09 15:08:12 +00001972 Method = CXXConstructorDecl::Create(SemaRef.Context, Record,
Abramo Bagnaradff19302011-03-08 08:55:46 +00001973 StartLoc, NameInfo, T, TInfo,
Mike Stump11289f42009-09-09 15:08:12 +00001974 Constructor->isExplicit(),
Reid Kleckner0f764e52015-04-07 20:46:51 +00001975 Constructor->isInlineSpecified(),
Richard Smith3607ffe2012-02-13 03:54:03 +00001976 false, Constructor->isConstexpr());
Malcolm Parsons57ae8572016-11-28 11:11:34 +00001977 Method->setRangeEnd(Constructor->getLocEnd());
Douglas Gregore8394862009-08-21 22:43:28 +00001978 } else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(D)) {
Douglas Gregore8394862009-08-21 22:43:28 +00001979 Method = CXXDestructorDecl::Create(SemaRef.Context, Record,
Abramo Bagnaradff19302011-03-08 08:55:46 +00001980 StartLoc, NameInfo, T, TInfo,
Reid Kleckner0f764e52015-04-07 20:46:51 +00001981 Destructor->isInlineSpecified(),
Douglas Gregorc4df4072010-04-19 22:54:31 +00001982 false);
Malcolm Parsons57ae8572016-11-28 11:11:34 +00001983 Method->setRangeEnd(Destructor->getLocEnd());
Douglas Gregor05155d82009-08-21 23:19:43 +00001984 } else if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) {
Douglas Gregor05155d82009-08-21 23:19:43 +00001985 Method = CXXConversionDecl::Create(SemaRef.Context, Record,
Abramo Bagnaradff19302011-03-08 08:55:46 +00001986 StartLoc, NameInfo, T, TInfo,
Reid Kleckner0f764e52015-04-07 20:46:51 +00001987 Conversion->isInlineSpecified(),
Douglas Gregorf2f08062011-03-08 17:10:18 +00001988 Conversion->isExplicit(),
Richard Smith3607ffe2012-02-13 03:54:03 +00001989 Conversion->isConstexpr(),
Richard Smitheb3c10c2011-10-01 02:31:28 +00001990 Conversion->getLocEnd());
Douglas Gregor5ed5ae42009-08-21 18:42:58 +00001991 } else {
Rafael Espindola29cda592013-04-15 12:38:20 +00001992 StorageClass SC = D->isStatic() ? SC_Static : SC_None;
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001993 Method = CXXMethodDecl::Create(SemaRef.Context, Record,
Abramo Bagnaradff19302011-03-08 08:55:46 +00001994 StartLoc, NameInfo, T, TInfo,
Reid Kleckner0f764e52015-04-07 20:46:51 +00001995 SC, D->isInlineSpecified(),
Richard Smith3607ffe2012-02-13 03:54:03 +00001996 D->isConstexpr(), D->getLocEnd());
Douglas Gregor5ed5ae42009-08-21 18:42:58 +00001997 }
Douglas Gregor97628d62009-08-21 00:16:32 +00001998
Richard Smithf3814ad2013-01-25 00:08:28 +00001999 if (D->isInlined())
2000 Method->setImplicitlyInline();
2001
Douglas Gregor14454802011-02-25 02:25:35 +00002002 if (QualifierLoc)
2003 Method->setQualifierInfo(QualifierLoc);
John McCall3e11ebe2010-03-15 10:12:16 +00002004
Douglas Gregore704c9d2009-08-27 16:57:43 +00002005 if (TemplateParams) {
2006 // Our resulting instantiation is actually a function template, since we
2007 // are substituting only the outer template parameters. For example, given
Mike Stump11289f42009-09-09 15:08:12 +00002008 //
Douglas Gregore704c9d2009-08-27 16:57:43 +00002009 // template<typename T>
2010 // struct X {
2011 // template<typename U> void f(T, U);
2012 // };
2013 //
2014 // X<int> x;
2015 //
2016 // We are instantiating the member template "f" within X<int>, which means
2017 // substituting int for T, but leaving "f" as a member function template.
2018 // Build the function template itself.
2019 FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, Record,
2020 Method->getLocation(),
Mike Stump11289f42009-09-09 15:08:12 +00002021 Method->getDeclName(),
Douglas Gregore704c9d2009-08-27 16:57:43 +00002022 TemplateParams, Method);
John McCall2f88d7d2010-03-27 05:57:59 +00002023 if (isFriend) {
2024 FunctionTemplate->setLexicalDeclContext(Owner);
Richard Smith64017682013-07-17 23:53:16 +00002025 FunctionTemplate->setObjectOfFriendDecl();
John McCall2f88d7d2010-03-27 05:57:59 +00002026 } else if (D->isOutOfLine())
Mike Stump11289f42009-09-09 15:08:12 +00002027 FunctionTemplate->setLexicalDeclContext(D->getLexicalDeclContext());
Douglas Gregore704c9d2009-08-27 16:57:43 +00002028 Method->setDescribedFunctionTemplate(FunctionTemplate);
Douglas Gregorffe14e32009-11-14 01:20:54 +00002029 } else if (FunctionTemplate) {
2030 // Record this function template specialization.
Richard Smith47752e42013-05-03 23:46:09 +00002031 ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
Douglas Gregord5058122010-02-11 01:19:42 +00002032 Method->setFunctionTemplateSpecialization(FunctionTemplate,
Douglas Gregor1ccc8412010-11-07 23:05:16 +00002033 TemplateArgumentList::CreateCopy(SemaRef.Context,
David Majnemer8b622692016-07-03 21:17:51 +00002034 Innermost),
Craig Topperc3ec1492014-05-26 06:22:03 +00002035 /*InsertPos=*/nullptr);
John McCall2f88d7d2010-03-27 05:57:59 +00002036 } else if (!isFriend) {
Douglas Gregorffe14e32009-11-14 01:20:54 +00002037 // Record that this is an instantiation of a member function.
Douglas Gregord801b062009-10-07 23:56:10 +00002038 Method->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation);
Douglas Gregorffe14e32009-11-14 01:20:54 +00002039 }
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002040
Mike Stump11289f42009-09-09 15:08:12 +00002041 // If we are instantiating a member function defined
Douglas Gregora6ef8f02009-07-24 20:34:43 +00002042 // out-of-line, the instantiation will have the same lexical
2043 // context (which will be a namespace scope) as the template.
John McCall2f88d7d2010-03-27 05:57:59 +00002044 if (isFriend) {
John McCalld0e23ec2010-10-19 02:26:41 +00002045 if (NumTempParamLists)
Benjamin Kramer9cc210652015-08-05 09:40:49 +00002046 Method->setTemplateParameterListsInfo(
2047 SemaRef.Context,
2048 llvm::makeArrayRef(TempParamLists.data(), NumTempParamLists));
John McCalld0e23ec2010-10-19 02:26:41 +00002049
John McCall2f88d7d2010-03-27 05:57:59 +00002050 Method->setLexicalDeclContext(Owner);
Richard Smith64017682013-07-17 23:53:16 +00002051 Method->setObjectOfFriendDecl();
John McCall2f88d7d2010-03-27 05:57:59 +00002052 } else if (D->isOutOfLine())
Douglas Gregora6ef8f02009-07-24 20:34:43 +00002053 Method->setLexicalDeclContext(D->getLexicalDeclContext());
Mike Stump11289f42009-09-09 15:08:12 +00002054
Douglas Gregor21342092009-03-24 00:38:23 +00002055 // Attach the parameters
2056 for (unsigned P = 0; P < Params.size(); ++P)
2057 Params[P]->setOwningFunction(Method);
David Blaikie9c70e042011-09-21 18:16:56 +00002058 Method->setParams(Params);
Douglas Gregor21342092009-03-24 00:38:23 +00002059
2060 if (InitMethodInstantiation(Method, D))
2061 Method->setInvalidDecl();
Douglas Gregorf4f296d2009-03-23 23:06:20 +00002062
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00002063 LookupResult Previous(SemaRef, NameInfo, Sema::LookupOrdinaryName,
Richard Smithbecb92d2017-10-10 22:33:17 +00002064 Sema::ForExternalRedeclaration);
Mike Stump11289f42009-09-09 15:08:12 +00002065
John McCall2f88d7d2010-03-27 05:57:59 +00002066 if (!FunctionTemplate || TemplateParams || isFriend) {
2067 SemaRef.LookupQualifiedName(Previous, Record);
Mike Stump11289f42009-09-09 15:08:12 +00002068
Douglas Gregor5ed5ae42009-08-21 18:42:58 +00002069 // In C++, the previous declaration we find might be a tag type
2070 // (class or enum). In this case, the new declaration will hide the
2071 // tag type. Note that this does does not apply if we're declaring a
2072 // typedef (C++ [dcl.typedef]p4).
John McCall1f82f242009-11-18 22:49:29 +00002073 if (Previous.isSingleTagDecl())
2074 Previous.clear();
Douglas Gregor5ed5ae42009-08-21 18:42:58 +00002075 }
Douglas Gregorf4f296d2009-03-23 23:06:20 +00002076
Francois Pichet00c7e6c2011-08-14 03:52:19 +00002077 if (!IsClassScopeSpecialization)
Craig Topperc3ec1492014-05-26 06:22:03 +00002078 SemaRef.CheckFunctionDeclaration(nullptr, Method, Previous, false);
Douglas Gregor05155d82009-08-21 23:19:43 +00002079
Douglas Gregor21920e372009-12-01 17:24:26 +00002080 if (D->isPure())
2081 SemaRef.CheckPureMethod(Method, SourceRange());
2082
John McCalla0a96892012-08-10 03:15:35 +00002083 // Propagate access. For a non-friend declaration, the access is
2084 // whatever we're propagating from. For a friend, it should be the
2085 // previous declaration we just found.
2086 if (isFriend && Method->getPreviousDecl())
2087 Method->setAccess(Method->getPreviousDecl()->getAccess());
2088 else
2089 Method->setAccess(D->getAccess());
2090 if (FunctionTemplate)
2091 FunctionTemplate->setAccess(Method->getAccess());
John McCall401982f2010-01-20 21:53:11 +00002092
Anders Carlsson7c812f52011-01-20 06:52:44 +00002093 SemaRef.CheckOverrideControl(Method);
2094
Eli Friedman41340732011-11-15 22:39:08 +00002095 // If a function is defined as defaulted or deleted, mark it as such now.
Richard Smith92f241f2012-12-08 02:53:02 +00002096 if (D->isExplicitlyDefaulted())
2097 SemaRef.SetDeclDefaulted(Method, Method->getLocation());
Eli Friedman41340732011-11-15 22:39:08 +00002098 if (D->isDeletedAsWritten())
Richard Smith92f241f2012-12-08 02:53:02 +00002099 SemaRef.SetDeclDeleted(Method, Method->getLocation());
Eli Friedman41340732011-11-15 22:39:08 +00002100
John McCalla0a96892012-08-10 03:15:35 +00002101 // If there's a function template, let our caller handle it.
John McCall2f88d7d2010-03-27 05:57:59 +00002102 if (FunctionTemplate) {
John McCalla0a96892012-08-10 03:15:35 +00002103 // do nothing
2104
2105 // Don't hide a (potentially) valid declaration with an invalid one.
John McCall2f88d7d2010-03-27 05:57:59 +00002106 } else if (Method->isInvalidDecl() && !Previous.empty()) {
John McCalla0a96892012-08-10 03:15:35 +00002107 // do nothing
2108
2109 // Otherwise, check access to friends and make them visible.
2110 } else if (isFriend) {
2111 // We only need to re-check access for methods which we didn't
2112 // manage to match during parsing.
2113 if (!D->getPreviousDecl())
2114 SemaRef.CheckFriendAccess(Method);
2115
2116 Record->makeDeclVisibleInContext(Method);
2117
2118 // Otherwise, add the declaration. We don't need to do this for
2119 // class-scope specializations because we'll have matched them with
2120 // the appropriate template.
2121 } else if (!IsClassScopeSpecialization) {
2122 Owner->addDecl(Method);
John McCall2f88d7d2010-03-27 05:57:59 +00002123 }
Alexis Hunt1fb4e762011-05-23 21:07:59 +00002124
Douglas Gregorf4f296d2009-03-23 23:06:20 +00002125 return Method;
2126}
2127
Douglas Gregor4044d992009-03-24 16:43:20 +00002128Decl *TemplateDeclInstantiator::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
Douglas Gregor5ed5ae42009-08-21 18:42:58 +00002129 return VisitCXXMethodDecl(D);
Douglas Gregor4044d992009-03-24 16:43:20 +00002130}
2131
Douglas Gregor654b07e2009-03-24 00:15:49 +00002132Decl *TemplateDeclInstantiator::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
Douglas Gregore8394862009-08-21 22:43:28 +00002133 return VisitCXXMethodDecl(D);
Douglas Gregor654b07e2009-03-24 00:15:49 +00002134}
2135
Douglas Gregor1880ba52009-03-25 00:34:44 +00002136Decl *TemplateDeclInstantiator::VisitCXXConversionDecl(CXXConversionDecl *D) {
Douglas Gregor05155d82009-08-21 23:19:43 +00002137 return VisitCXXMethodDecl(D);
Douglas Gregor1880ba52009-03-25 00:34:44 +00002138}
2139
Eli Friedmancb9cd6c2013-06-27 23:21:55 +00002140Decl *TemplateDeclInstantiator::VisitParmVarDecl(ParmVarDecl *D) {
David Blaikie7a30dc52013-02-21 01:47:18 +00002141 return SemaRef.SubstParmVarDecl(D, TemplateArgs, /*indexAdjustment*/ 0, None,
2142 /*ExpectParameterPack=*/ false);
Douglas Gregorf4f296d2009-03-23 23:06:20 +00002143}
2144
John McCall87a44eb2009-08-20 01:44:21 +00002145Decl *TemplateDeclInstantiator::VisitTemplateTypeParmDecl(
2146 TemplateTypeParmDecl *D) {
2147 // TODO: don't always clone when decls are refcounted.
Chandler Carruth08836322011-05-01 00:51:33 +00002148 assert(D->getTypeForDecl()->isTemplateTypeParmType());
Mike Stump11289f42009-09-09 15:08:12 +00002149
Richard Smithb4f96252017-02-21 06:30:38 +00002150 TemplateTypeParmDecl *Inst = TemplateTypeParmDecl::Create(
2151 SemaRef.Context, Owner, D->getLocStart(), D->getLocation(),
2152 D->getDepth() - TemplateArgs.getNumSubstitutedLevels(), D->getIndex(),
2153 D->getIdentifier(), D->wasDeclaredWithTypename(), D->isParameterPack());
Douglas Gregorfd7c2252011-03-04 17:52:15 +00002154 Inst->setAccess(AS_public);
John McCall87a44eb2009-08-20 01:44:21 +00002155
Richard Smith52933792015-06-16 21:57:05 +00002156 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
David Majnemer89189202013-08-28 23:48:32 +00002157 TypeSourceInfo *InstantiatedDefaultArg =
2158 SemaRef.SubstType(D->getDefaultArgumentInfo(), TemplateArgs,
2159 D->getDefaultArgumentLoc(), D->getDeclName());
2160 if (InstantiatedDefaultArg)
Richard Smith1469b912015-06-10 00:29:03 +00002161 Inst->setDefaultArgument(InstantiatedDefaultArg);
David Majnemer89189202013-08-28 23:48:32 +00002162 }
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002163
2164 // Introduce this template parameter's instantiation into the instantiation
Douglas Gregor954de172009-10-31 17:21:17 +00002165 // scope.
2166 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Inst);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002167
John McCall87a44eb2009-08-20 01:44:21 +00002168 return Inst;
2169}
2170
Douglas Gregor6b815c82009-10-23 23:25:44 +00002171Decl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl(
2172 NonTypeTemplateParmDecl *D) {
2173 // Substitute into the type of the non-type template parameter.
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002174 TypeLoc TL = D->getTypeSourceInfo()->getTypeLoc();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002175 SmallVector<TypeSourceInfo *, 4> ExpandedParameterPackTypesAsWritten;
2176 SmallVector<QualType, 4> ExpandedParameterPackTypes;
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002177 bool IsExpandedParameterPack = false;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002178 TypeSourceInfo *DI;
Douglas Gregor6b815c82009-10-23 23:25:44 +00002179 QualType T;
Douglas Gregor6b815c82009-10-23 23:25:44 +00002180 bool Invalid = false;
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002181
2182 if (D->isExpandedParameterPack()) {
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002183 // The non-type template parameter pack is an already-expanded pack
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002184 // expansion of types. Substitute into each of the expanded types.
2185 ExpandedParameterPackTypes.reserve(D->getNumExpansionTypes());
2186 ExpandedParameterPackTypesAsWritten.reserve(D->getNumExpansionTypes());
2187 for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
Richard Smith15361a22016-12-28 06:27:18 +00002188 TypeSourceInfo *NewDI =
2189 SemaRef.SubstType(D->getExpansionTypeSourceInfo(I), TemplateArgs,
2190 D->getLocation(), D->getDeclName());
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002191 if (!NewDI)
Craig Topperc3ec1492014-05-26 06:22:03 +00002192 return nullptr;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002193
Richard Smith15361a22016-12-28 06:27:18 +00002194 QualType NewT =
2195 SemaRef.CheckNonTypeTemplateParameterType(NewDI, D->getLocation());
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002196 if (NewT.isNull())
Craig Topperc3ec1492014-05-26 06:22:03 +00002197 return nullptr;
Richard Smith15361a22016-12-28 06:27:18 +00002198
2199 ExpandedParameterPackTypesAsWritten.push_back(NewDI);
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002200 ExpandedParameterPackTypes.push_back(NewT);
2201 }
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002202
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002203 IsExpandedParameterPack = true;
2204 DI = D->getTypeSourceInfo();
2205 T = DI->getType();
Richard Smith1fde8ec2012-09-07 02:06:42 +00002206 } else if (D->isPackExpansion()) {
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002207 // The non-type template parameter pack's type is a pack expansion of types.
2208 // Determine whether we need to expand this parameter pack into separate
2209 // types.
David Blaikie6adc78e2013-02-18 22:06:02 +00002210 PackExpansionTypeLoc Expansion = TL.castAs<PackExpansionTypeLoc>();
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002211 TypeLoc Pattern = Expansion.getPatternLoc();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002212 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002213 SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002214
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002215 // Determine whether the set of unexpanded parameter packs can and should
2216 // be expanded.
2217 bool Expand = true;
2218 bool RetainExpansion = false;
David Blaikie05785d12013-02-20 22:23:23 +00002219 Optional<unsigned> OrigNumExpansions
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002220 = Expansion.getTypePtr()->getNumExpansions();
David Blaikie05785d12013-02-20 22:23:23 +00002221 Optional<unsigned> NumExpansions = OrigNumExpansions;
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002222 if (SemaRef.CheckParameterPacksForExpansion(Expansion.getEllipsisLoc(),
2223 Pattern.getSourceRange(),
David Blaikieb9c168a2011-09-22 02:34:54 +00002224 Unexpanded,
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002225 TemplateArgs,
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002226 Expand, RetainExpansion,
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002227 NumExpansions))
Craig Topperc3ec1492014-05-26 06:22:03 +00002228 return nullptr;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002229
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002230 if (Expand) {
2231 for (unsigned I = 0; I != *NumExpansions; ++I) {
2232 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
2233 TypeSourceInfo *NewDI = SemaRef.SubstType(Pattern, TemplateArgs,
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002234 D->getLocation(),
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002235 D->getDeclName());
2236 if (!NewDI)
Craig Topperc3ec1492014-05-26 06:22:03 +00002237 return nullptr;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002238
Richard Smith15361a22016-12-28 06:27:18 +00002239 QualType NewT =
2240 SemaRef.CheckNonTypeTemplateParameterType(NewDI, D->getLocation());
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002241 if (NewT.isNull())
Craig Topperc3ec1492014-05-26 06:22:03 +00002242 return nullptr;
Richard Smith15361a22016-12-28 06:27:18 +00002243
2244 ExpandedParameterPackTypesAsWritten.push_back(NewDI);
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002245 ExpandedParameterPackTypes.push_back(NewT);
2246 }
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002247
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002248 // Note that we have an expanded parameter pack. The "type" of this
2249 // expanded parameter pack is the original expansion type, but callers
2250 // will end up using the expanded parameter pack types for type-checking.
2251 IsExpandedParameterPack = true;
2252 DI = D->getTypeSourceInfo();
2253 T = DI->getType();
2254 } else {
2255 // We cannot fully expand the pack expansion now, so substitute into the
2256 // pattern and create a new pack expansion type.
2257 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
2258 TypeSourceInfo *NewPattern = SemaRef.SubstType(Pattern, TemplateArgs,
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002259 D->getLocation(),
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002260 D->getDeclName());
2261 if (!NewPattern)
Craig Topperc3ec1492014-05-26 06:22:03 +00002262 return nullptr;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002263
Richard Smith15361a22016-12-28 06:27:18 +00002264 SemaRef.CheckNonTypeTemplateParameterType(NewPattern, D->getLocation());
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002265 DI = SemaRef.CheckPackExpansion(NewPattern, Expansion.getEllipsisLoc(),
2266 NumExpansions);
2267 if (!DI)
Craig Topperc3ec1492014-05-26 06:22:03 +00002268 return nullptr;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002269
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002270 T = DI->getType();
2271 }
2272 } else {
2273 // Simple case: substitution into a parameter that is not a parameter pack.
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002274 DI = SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs,
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002275 D->getLocation(), D->getDeclName());
2276 if (!DI)
Craig Topperc3ec1492014-05-26 06:22:03 +00002277 return nullptr;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002278
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002279 // Check that this type is acceptable for a non-type template parameter.
Richard Smith15361a22016-12-28 06:27:18 +00002280 T = SemaRef.CheckNonTypeTemplateParameterType(DI, D->getLocation());
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002281 if (T.isNull()) {
2282 T = SemaRef.Context.IntTy;
2283 Invalid = true;
2284 }
Douglas Gregor6b815c82009-10-23 23:25:44 +00002285 }
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002286
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002287 NonTypeTemplateParmDecl *Param;
2288 if (IsExpandedParameterPack)
David Majnemerdfecf1a2016-07-06 04:19:16 +00002289 Param = NonTypeTemplateParmDecl::Create(
2290 SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
Richard Smithb4f96252017-02-21 06:30:38 +00002291 D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
2292 D->getPosition(), D->getIdentifier(), T, DI, ExpandedParameterPackTypes,
David Majnemerdfecf1a2016-07-06 04:19:16 +00002293 ExpandedParameterPackTypesAsWritten);
Douglas Gregor0231d8d2011-01-19 20:10:05 +00002294 else
Richard Smithb4f96252017-02-21 06:30:38 +00002295 Param = NonTypeTemplateParmDecl::Create(
2296 SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
2297 D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
2298 D->getPosition(), D->getIdentifier(), T, D->isParameterPack(), DI);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002299
Douglas Gregorfd7c2252011-03-04 17:52:15 +00002300 Param->setAccess(AS_public);
Douglas Gregor6b815c82009-10-23 23:25:44 +00002301 if (Invalid)
2302 Param->setInvalidDecl();
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002303
Richard Smith52933792015-06-16 21:57:05 +00002304 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
Faisal Valid143a0c2017-04-01 21:30:49 +00002305 EnterExpressionEvaluationContext ConstantEvaluated(
2306 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
David Majnemer89189202013-08-28 23:48:32 +00002307 ExprResult Value = SemaRef.SubstExpr(D->getDefaultArgument(), TemplateArgs);
2308 if (!Value.isInvalid())
Richard Smith1469b912015-06-10 00:29:03 +00002309 Param->setDefaultArgument(Value.get());
David Majnemer89189202013-08-28 23:48:32 +00002310 }
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002311
2312 // Introduce this template parameter's instantiation into the instantiation
Douglas Gregor954de172009-10-31 17:21:17 +00002313 // scope.
2314 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);
Douglas Gregor6b815c82009-10-23 23:25:44 +00002315 return Param;
2316}
2317
Richard Smith1fde8ec2012-09-07 02:06:42 +00002318static void collectUnexpandedParameterPacks(
2319 Sema &S,
2320 TemplateParameterList *Params,
2321 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
Davide Italiano18960b92015-07-02 19:20:11 +00002322 for (const auto &P : *Params) {
2323 if (P->isTemplateParameterPack())
Richard Smith1fde8ec2012-09-07 02:06:42 +00002324 continue;
Davide Italiano18960b92015-07-02 19:20:11 +00002325 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P))
Richard Smith1fde8ec2012-09-07 02:06:42 +00002326 S.collectUnexpandedParameterPacks(NTTP->getTypeSourceInfo()->getTypeLoc(),
2327 Unexpanded);
Davide Italiano18960b92015-07-02 19:20:11 +00002328 if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
Richard Smith1fde8ec2012-09-07 02:06:42 +00002329 collectUnexpandedParameterPacks(S, TTP->getTemplateParameters(),
2330 Unexpanded);
2331 }
2332}
2333
Anders Carlsson4bd78752009-08-28 15:18:15 +00002334Decl *
Douglas Gregor38fee962009-11-11 16:58:32 +00002335TemplateDeclInstantiator::VisitTemplateTemplateParmDecl(
2336 TemplateTemplateParmDecl *D) {
2337 // Instantiate the template parameter list of the template template parameter.
2338 TemplateParameterList *TempParams = D->getTemplateParameters();
2339 TemplateParameterList *InstParams;
Richard Smith1fde8ec2012-09-07 02:06:42 +00002340 SmallVector<TemplateParameterList*, 8> ExpandedParams;
2341
2342 bool IsExpandedParameterPack = false;
2343
2344 if (D->isExpandedParameterPack()) {
2345 // The template template parameter pack is an already-expanded pack
2346 // expansion of template parameters. Substitute into each of the expanded
2347 // parameters.
2348 ExpandedParams.reserve(D->getNumExpansionTemplateParameters());
2349 for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
2350 I != N; ++I) {
2351 LocalInstantiationScope Scope(SemaRef);
2352 TemplateParameterList *Expansion =
2353 SubstTemplateParams(D->getExpansionTemplateParameters(I));
2354 if (!Expansion)
Craig Topperc3ec1492014-05-26 06:22:03 +00002355 return nullptr;
Richard Smith1fde8ec2012-09-07 02:06:42 +00002356 ExpandedParams.push_back(Expansion);
2357 }
2358
2359 IsExpandedParameterPack = true;
2360 InstParams = TempParams;
2361 } else if (D->isPackExpansion()) {
2362 // The template template parameter pack expands to a pack of template
2363 // template parameters. Determine whether we need to expand this parameter
2364 // pack into separate parameters.
2365 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
2366 collectUnexpandedParameterPacks(SemaRef, D->getTemplateParameters(),
2367 Unexpanded);
2368
2369 // Determine whether the set of unexpanded parameter packs can and should
2370 // be expanded.
2371 bool Expand = true;
2372 bool RetainExpansion = false;
David Blaikie05785d12013-02-20 22:23:23 +00002373 Optional<unsigned> NumExpansions;
Richard Smith1fde8ec2012-09-07 02:06:42 +00002374 if (SemaRef.CheckParameterPacksForExpansion(D->getLocation(),
2375 TempParams->getSourceRange(),
2376 Unexpanded,
2377 TemplateArgs,
2378 Expand, RetainExpansion,
2379 NumExpansions))
Craig Topperc3ec1492014-05-26 06:22:03 +00002380 return nullptr;
Richard Smith1fde8ec2012-09-07 02:06:42 +00002381
2382 if (Expand) {
2383 for (unsigned I = 0; I != *NumExpansions; ++I) {
2384 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
2385 LocalInstantiationScope Scope(SemaRef);
2386 TemplateParameterList *Expansion = SubstTemplateParams(TempParams);
2387 if (!Expansion)
Craig Topperc3ec1492014-05-26 06:22:03 +00002388 return nullptr;
Richard Smith1fde8ec2012-09-07 02:06:42 +00002389 ExpandedParams.push_back(Expansion);
2390 }
2391
2392 // Note that we have an expanded parameter pack. The "type" of this
2393 // expanded parameter pack is the original expansion type, but callers
2394 // will end up using the expanded parameter pack types for type-checking.
2395 IsExpandedParameterPack = true;
2396 InstParams = TempParams;
2397 } else {
2398 // We cannot fully expand the pack expansion now, so just substitute
2399 // into the pattern.
2400 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
2401
2402 LocalInstantiationScope Scope(SemaRef);
2403 InstParams = SubstTemplateParams(TempParams);
2404 if (!InstParams)
Craig Topperc3ec1492014-05-26 06:22:03 +00002405 return nullptr;
Richard Smith1fde8ec2012-09-07 02:06:42 +00002406 }
2407 } else {
Douglas Gregor38fee962009-11-11 16:58:32 +00002408 // Perform the actual substitution of template parameters within a new,
2409 // local instantiation scope.
John McCall19c1bfd2010-08-25 05:32:35 +00002410 LocalInstantiationScope Scope(SemaRef);
Douglas Gregor38fee962009-11-11 16:58:32 +00002411 InstParams = SubstTemplateParams(TempParams);
2412 if (!InstParams)
Craig Topperc3ec1492014-05-26 06:22:03 +00002413 return nullptr;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002414 }
2415
Douglas Gregor38fee962009-11-11 16:58:32 +00002416 // Build the template template parameter.
Richard Smith1fde8ec2012-09-07 02:06:42 +00002417 TemplateTemplateParmDecl *Param;
2418 if (IsExpandedParameterPack)
Richard Smithb4f96252017-02-21 06:30:38 +00002419 Param = TemplateTemplateParmDecl::Create(
2420 SemaRef.Context, Owner, D->getLocation(),
2421 D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
2422 D->getPosition(), D->getIdentifier(), InstParams, ExpandedParams);
Richard Smith1fde8ec2012-09-07 02:06:42 +00002423 else
Richard Smithb4f96252017-02-21 06:30:38 +00002424 Param = TemplateTemplateParmDecl::Create(
2425 SemaRef.Context, Owner, D->getLocation(),
2426 D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
2427 D->getPosition(), D->isParameterPack(), D->getIdentifier(), InstParams);
Richard Smith52933792015-06-16 21:57:05 +00002428 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
David Majnemer89189202013-08-28 23:48:32 +00002429 NestedNameSpecifierLoc QualifierLoc =
2430 D->getDefaultArgument().getTemplateQualifierLoc();
2431 QualifierLoc =
2432 SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, TemplateArgs);
2433 TemplateName TName = SemaRef.SubstTemplateName(
2434 QualifierLoc, D->getDefaultArgument().getArgument().getAsTemplate(),
2435 D->getDefaultArgument().getTemplateNameLoc(), TemplateArgs);
2436 if (!TName.isNull())
2437 Param->setDefaultArgument(
Richard Smith1469b912015-06-10 00:29:03 +00002438 SemaRef.Context,
David Majnemer89189202013-08-28 23:48:32 +00002439 TemplateArgumentLoc(TemplateArgument(TName),
2440 D->getDefaultArgument().getTemplateQualifierLoc(),
Richard Smith1469b912015-06-10 00:29:03 +00002441 D->getDefaultArgument().getTemplateNameLoc()));
David Majnemer89189202013-08-28 23:48:32 +00002442 }
Douglas Gregorfd7c2252011-03-04 17:52:15 +00002443 Param->setAccess(AS_public);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002444
2445 // Introduce this template parameter's instantiation into the instantiation
Douglas Gregor38fee962009-11-11 16:58:32 +00002446 // scope.
2447 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002448
Douglas Gregor38fee962009-11-11 16:58:32 +00002449 return Param;
2450}
2451
Douglas Gregore0b28662009-11-17 06:07:40 +00002452Decl *TemplateDeclInstantiator::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
Douglas Gregor12441b32011-02-25 16:33:46 +00002453 // Using directives are never dependent (and never contain any types or
2454 // expressions), so they require no explicit instantiation work.
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002455
Douglas Gregore0b28662009-11-17 06:07:40 +00002456 UsingDirectiveDecl *Inst
2457 = UsingDirectiveDecl::Create(SemaRef.Context, Owner, D->getLocation(),
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002458 D->getNamespaceKeyLocation(),
Douglas Gregor12441b32011-02-25 16:33:46 +00002459 D->getQualifierLoc(),
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002460 D->getIdentLocation(),
2461 D->getNominatedNamespace(),
Douglas Gregore0b28662009-11-17 06:07:40 +00002462 D->getCommonAncestor());
Abramo Bagnara8843f9f2012-09-05 09:55:10 +00002463
2464 // Add the using directive to its declaration context
2465 // only if this is not a function or method.
2466 if (!Owner->isFunctionOrMethod())
2467 Owner->addDecl(Inst);
2468
Douglas Gregore0b28662009-11-17 06:07:40 +00002469 return Inst;
2470}
2471
John McCallb96ec562009-12-04 22:46:56 +00002472Decl *TemplateDeclInstantiator::VisitUsingDecl(UsingDecl *D) {
Douglas Gregorac2e4302010-09-29 17:58:28 +00002473
2474 // The nested name specifier may be dependent, for example
2475 // template <typename T> struct t {
2476 // struct s1 { T f1(); };
2477 // struct s2 : s1 { using s1::f1; };
2478 // };
2479 // template struct t<int>;
2480 // Here, in using s1::f1, s1 refers to t<T>::s1;
2481 // we need to substitute for t<int>::s1.
Douglas Gregor0499ab62011-02-25 15:54:31 +00002482 NestedNameSpecifierLoc QualifierLoc
2483 = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(),
2484 TemplateArgs);
2485 if (!QualifierLoc)
Craig Topperc3ec1492014-05-26 06:22:03 +00002486 return nullptr;
Douglas Gregorac2e4302010-09-29 17:58:28 +00002487
Richard Smith5179eb72016-06-28 19:03:57 +00002488 // For an inheriting constructor declaration, the name of the using
2489 // declaration is the name of a constructor in this class, not in the
2490 // base class.
Abramo Bagnara8de74e92010-08-12 11:46:03 +00002491 DeclarationNameInfo NameInfo = D->getNameInfo();
Richard Smith5179eb72016-06-28 19:03:57 +00002492 if (NameInfo.getName().getNameKind() == DeclarationName::CXXConstructorName)
2493 if (auto *RD = dyn_cast<CXXRecordDecl>(SemaRef.CurContext))
2494 NameInfo.setName(SemaRef.Context.DeclarationNames.getCXXConstructorName(
2495 SemaRef.Context.getCanonicalType(SemaRef.Context.getRecordType(RD))));
John McCallb96ec562009-12-04 22:46:56 +00002496
John McCall84d87672009-12-10 09:41:52 +00002497 // We only need to do redeclaration lookups if we're in a class
2498 // scope (in fact, it's not really even possible in non-class
2499 // scopes).
2500 bool CheckRedeclaration = Owner->isRecord();
2501
Abramo Bagnara8de74e92010-08-12 11:46:03 +00002502 LookupResult Prev(SemaRef, NameInfo, Sema::LookupUsingDeclName,
Richard Smithbecb92d2017-10-10 22:33:17 +00002503 Sema::ForVisibleRedeclaration);
John McCall84d87672009-12-10 09:41:52 +00002504
John McCallb96ec562009-12-04 22:46:56 +00002505 UsingDecl *NewUD = UsingDecl::Create(SemaRef.Context, Owner,
Enea Zaffanellae05a3cf2013-07-22 10:54:09 +00002506 D->getUsingLoc(),
Douglas Gregor0499ab62011-02-25 15:54:31 +00002507 QualifierLoc,
Abramo Bagnara8de74e92010-08-12 11:46:03 +00002508 NameInfo,
Enea Zaffanellae05a3cf2013-07-22 10:54:09 +00002509 D->hasTypename());
John McCallb96ec562009-12-04 22:46:56 +00002510
Douglas Gregor0499ab62011-02-25 15:54:31 +00002511 CXXScopeSpec SS;
2512 SS.Adopt(QualifierLoc);
John McCall84d87672009-12-10 09:41:52 +00002513 if (CheckRedeclaration) {
2514 Prev.setHideTags(false);
2515 SemaRef.LookupQualifiedName(Prev, Owner);
2516
2517 // Check for invalid redeclarations.
Enea Zaffanellae05a3cf2013-07-22 10:54:09 +00002518 if (SemaRef.CheckUsingDeclRedeclaration(D->getUsingLoc(),
2519 D->hasTypename(), SS,
John McCall84d87672009-12-10 09:41:52 +00002520 D->getLocation(), Prev))
2521 NewUD->setInvalidDecl();
2522
2523 }
2524
2525 if (!NewUD->isInvalidDecl() &&
Richard Smithd8a9e372016-12-18 21:39:37 +00002526 SemaRef.CheckUsingDeclQualifier(D->getUsingLoc(), D->hasTypename(),
2527 SS, NameInfo, D->getLocation()))
John McCallb96ec562009-12-04 22:46:56 +00002528 NewUD->setInvalidDecl();
John McCall84d87672009-12-10 09:41:52 +00002529
John McCallb96ec562009-12-04 22:46:56 +00002530 SemaRef.Context.setInstantiatedFromUsingDecl(NewUD, D);
2531 NewUD->setAccess(D->getAccess());
2532 Owner->addDecl(NewUD);
2533
John McCall84d87672009-12-10 09:41:52 +00002534 // Don't process the shadow decls for an invalid decl.
2535 if (NewUD->isInvalidDecl())
2536 return NewUD;
2537
Richard Smith5179eb72016-06-28 19:03:57 +00002538 if (NameInfo.getName().getNameKind() == DeclarationName::CXXConstructorName)
Richard Smith09d5b3a2014-05-01 00:35:04 +00002539 SemaRef.CheckInheritingConstructorUsingDecl(NewUD);
Richard Smith23d55872012-04-02 01:30:27 +00002540
John McCalla1d85502009-12-22 22:26:37 +00002541 bool isFunctionScope = Owner->isFunctionOrMethod();
2542
John McCall84d87672009-12-10 09:41:52 +00002543 // Process the shadow decls.
Aaron Ballman91cdc282014-03-13 18:07:29 +00002544 for (auto *Shadow : D->shadows()) {
Richard Smith5179eb72016-06-28 19:03:57 +00002545 // FIXME: UsingShadowDecl doesn't preserve its immediate target, so
2546 // reconstruct it in the case where it matters.
2547 NamedDecl *OldTarget = Shadow->getTargetDecl();
2548 if (auto *CUSD = dyn_cast<ConstructorUsingShadowDecl>(Shadow))
2549 if (auto *BaseShadow = CUSD->getNominatedBaseClassShadowDecl())
2550 OldTarget = BaseShadow;
2551
John McCall84d87672009-12-10 09:41:52 +00002552 NamedDecl *InstTarget =
Richard Smithfd8634a2013-10-23 02:17:46 +00002553 cast_or_null<NamedDecl>(SemaRef.FindInstantiatedDecl(
Richard Smith5179eb72016-06-28 19:03:57 +00002554 Shadow->getLocation(), OldTarget, TemplateArgs));
Douglas Gregor55e6b312011-03-04 19:46:35 +00002555 if (!InstTarget)
Craig Topperc3ec1492014-05-26 06:22:03 +00002556 return nullptr;
John McCall84d87672009-12-10 09:41:52 +00002557
Craig Topperc3ec1492014-05-26 06:22:03 +00002558 UsingShadowDecl *PrevDecl = nullptr;
Richard Smithfd8634a2013-10-23 02:17:46 +00002559 if (CheckRedeclaration) {
2560 if (SemaRef.CheckUsingShadowDecl(NewUD, InstTarget, Prev, PrevDecl))
2561 continue;
Richard Smith41c79d92014-10-11 00:37:16 +00002562 } else if (UsingShadowDecl *OldPrev =
2563 getPreviousDeclForInstantiation(Shadow)) {
Richard Smithfd8634a2013-10-23 02:17:46 +00002564 PrevDecl = cast_or_null<UsingShadowDecl>(SemaRef.FindInstantiatedDecl(
2565 Shadow->getLocation(), OldPrev, TemplateArgs));
2566 }
John McCall84d87672009-12-10 09:41:52 +00002567
Richard Smithfd8634a2013-10-23 02:17:46 +00002568 UsingShadowDecl *InstShadow =
Craig Topperc3ec1492014-05-26 06:22:03 +00002569 SemaRef.BuildUsingShadowDecl(/*Scope*/nullptr, NewUD, InstTarget,
2570 PrevDecl);
John McCall84d87672009-12-10 09:41:52 +00002571 SemaRef.Context.setInstantiatedFromUsingShadowDecl(InstShadow, Shadow);
John McCalla1d85502009-12-22 22:26:37 +00002572
2573 if (isFunctionScope)
2574 SemaRef.CurrentInstantiationScope->InstantiatedLocal(Shadow, InstShadow);
John McCall84d87672009-12-10 09:41:52 +00002575 }
John McCallb96ec562009-12-04 22:46:56 +00002576
2577 return NewUD;
2578}
2579
2580Decl *TemplateDeclInstantiator::VisitUsingShadowDecl(UsingShadowDecl *D) {
John McCall84d87672009-12-10 09:41:52 +00002581 // Ignore these; we handle them in bulk when processing the UsingDecl.
Craig Topperc3ec1492014-05-26 06:22:03 +00002582 return nullptr;
John McCallb96ec562009-12-04 22:46:56 +00002583}
2584
Richard Smith5179eb72016-06-28 19:03:57 +00002585Decl *TemplateDeclInstantiator::VisitConstructorUsingShadowDecl(
2586 ConstructorUsingShadowDecl *D) {
2587 // Ignore these; we handle them in bulk when processing the UsingDecl.
2588 return nullptr;
2589}
2590
Richard Smith151c4562016-12-20 21:35:28 +00002591template <typename T>
2592Decl *TemplateDeclInstantiator::instantiateUnresolvedUsingDecl(
2593 T *D, bool InstantiatingPackElement) {
2594 // If this is a pack expansion, expand it now.
2595 if (D->isPackExpansion() && !InstantiatingPackElement) {
2596 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
2597 SemaRef.collectUnexpandedParameterPacks(D->getQualifierLoc(), Unexpanded);
2598 SemaRef.collectUnexpandedParameterPacks(D->getNameInfo(), Unexpanded);
2599
2600 // Determine whether the set of unexpanded parameter packs can and should
2601 // be expanded.
2602 bool Expand = true;
2603 bool RetainExpansion = false;
2604 Optional<unsigned> NumExpansions;
2605 if (SemaRef.CheckParameterPacksForExpansion(
2606 D->getEllipsisLoc(), D->getSourceRange(), Unexpanded, TemplateArgs,
2607 Expand, RetainExpansion, NumExpansions))
2608 return nullptr;
2609
2610 // This declaration cannot appear within a function template signature,
2611 // so we can't have a partial argument list for a parameter pack.
2612 assert(!RetainExpansion &&
2613 "should never need to retain an expansion for UsingPackDecl");
2614
2615 if (!Expand) {
2616 // We cannot fully expand the pack expansion now, so substitute into the
2617 // pattern and create a new pack expansion.
2618 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
2619 return instantiateUnresolvedUsingDecl(D, true);
2620 }
2621
2622 // Within a function, we don't have any normal way to check for conflicts
2623 // between shadow declarations from different using declarations in the
2624 // same pack expansion, but this is always ill-formed because all expansions
2625 // must produce (conflicting) enumerators.
2626 //
2627 // Sadly we can't just reject this in the template definition because it
2628 // could be valid if the pack is empty or has exactly one expansion.
2629 if (D->getDeclContext()->isFunctionOrMethod() && *NumExpansions > 1) {
2630 SemaRef.Diag(D->getEllipsisLoc(),
2631 diag::err_using_decl_redeclaration_expansion);
2632 return nullptr;
2633 }
2634
2635 // Instantiate the slices of this pack and build a UsingPackDecl.
2636 SmallVector<NamedDecl*, 8> Expansions;
2637 for (unsigned I = 0; I != *NumExpansions; ++I) {
2638 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
2639 Decl *Slice = instantiateUnresolvedUsingDecl(D, true);
2640 if (!Slice)
2641 return nullptr;
2642 // Note that we can still get unresolved using declarations here, if we
2643 // had arguments for all packs but the pattern also contained other
2644 // template arguments (this only happens during partial substitution, eg
2645 // into the body of a generic lambda in a function template).
2646 Expansions.push_back(cast<NamedDecl>(Slice));
2647 }
2648
2649 auto *NewD = SemaRef.BuildUsingPackDecl(D, Expansions);
2650 if (isDeclWithinFunction(D))
2651 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewD);
2652 return NewD;
2653 }
2654
2655 UnresolvedUsingTypenameDecl *TD = dyn_cast<UnresolvedUsingTypenameDecl>(D);
2656 SourceLocation TypenameLoc = TD ? TD->getTypenameLoc() : SourceLocation();
2657
Douglas Gregor0499ab62011-02-25 15:54:31 +00002658 NestedNameSpecifierLoc QualifierLoc
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00002659 = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(),
Douglas Gregor0499ab62011-02-25 15:54:31 +00002660 TemplateArgs);
2661 if (!QualifierLoc)
Craig Topperc3ec1492014-05-26 06:22:03 +00002662 return nullptr;
Mike Stump11289f42009-09-09 15:08:12 +00002663
Anders Carlsson4bd78752009-08-28 15:18:15 +00002664 CXXScopeSpec SS;
Douglas Gregor0499ab62011-02-25 15:54:31 +00002665 SS.Adopt(QualifierLoc);
Mike Stump11289f42009-09-09 15:08:12 +00002666
Daniel Jasper9949ead2016-12-19 10:09:25 +00002667 DeclarationNameInfo NameInfo
2668 = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
2669
Richard Smith151c4562016-12-20 21:35:28 +00002670 // Produce a pack expansion only if we're not instantiating a particular
2671 // slice of a pack expansion.
2672 bool InstantiatingSlice = D->getEllipsisLoc().isValid() &&
2673 SemaRef.ArgumentPackSubstitutionIndex != -1;
2674 SourceLocation EllipsisLoc =
2675 InstantiatingSlice ? SourceLocation() : D->getEllipsisLoc();
2676
2677 NamedDecl *UD = SemaRef.BuildUsingDeclaration(
2678 /*Scope*/ nullptr, D->getAccess(), D->getUsingLoc(),
2679 /*HasTypename*/ TD, TypenameLoc, SS, NameInfo, EllipsisLoc, nullptr,
2680 /*IsInstantiation*/ true);
Daniel Jasper9949ead2016-12-19 10:09:25 +00002681 if (UD)
2682 SemaRef.Context.setInstantiatedFromUsingDecl(UD, D);
2683
2684 return UD;
Richard Smith22a250c2016-12-19 04:08:53 +00002685}
2686
Richard Smith151c4562016-12-20 21:35:28 +00002687Decl *TemplateDeclInstantiator::VisitUnresolvedUsingTypenameDecl(
2688 UnresolvedUsingTypenameDecl *D) {
2689 return instantiateUnresolvedUsingDecl(D);
2690}
2691
2692Decl *TemplateDeclInstantiator::VisitUnresolvedUsingValueDecl(
2693 UnresolvedUsingValueDecl *D) {
2694 return instantiateUnresolvedUsingDecl(D);
2695}
2696
2697Decl *TemplateDeclInstantiator::VisitUsingPackDecl(UsingPackDecl *D) {
2698 SmallVector<NamedDecl*, 8> Expansions;
2699 for (auto *UD : D->expansions()) {
2700 if (auto *NewUD =
2701 SemaRef.FindInstantiatedDecl(D->getLocation(), UD, TemplateArgs))
2702 Expansions.push_back(cast<NamedDecl>(NewUD));
2703 else
2704 return nullptr;
2705 }
2706
2707 auto *NewD = SemaRef.BuildUsingPackDecl(D, Expansions);
2708 if (isDeclWithinFunction(D))
2709 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewD);
2710 return NewD;
2711}
Francois Pichet00c7e6c2011-08-14 03:52:19 +00002712
2713Decl *TemplateDeclInstantiator::VisitClassScopeFunctionSpecializationDecl(
2714 ClassScopeFunctionSpecializationDecl *Decl) {
2715 CXXMethodDecl *OldFD = Decl->getSpecialization();
Nick Lewycky0b727732015-01-02 01:33:12 +00002716 CXXMethodDecl *NewFD =
2717 cast_or_null<CXXMethodDecl>(VisitCXXMethodDecl(OldFD, nullptr, true));
2718 if (!NewFD)
2719 return nullptr;
Francois Pichet00c7e6c2011-08-14 03:52:19 +00002720
2721 LookupResult Previous(SemaRef, NewFD->getNameInfo(), Sema::LookupOrdinaryName,
Richard Smithbecb92d2017-10-10 22:33:17 +00002722 Sema::ForExternalRedeclaration);
Francois Pichet00c7e6c2011-08-14 03:52:19 +00002723
Nico Weber7b5a7162012-06-25 17:21:05 +00002724 TemplateArgumentListInfo TemplateArgs;
Craig Topperc3ec1492014-05-26 06:22:03 +00002725 TemplateArgumentListInfo *TemplateArgsPtr = nullptr;
Nico Weber7b5a7162012-06-25 17:21:05 +00002726 if (Decl->hasExplicitTemplateArgs()) {
2727 TemplateArgs = Decl->templateArgs();
2728 TemplateArgsPtr = &TemplateArgs;
2729 }
2730
Francois Pichet00c7e6c2011-08-14 03:52:19 +00002731 SemaRef.LookupQualifiedName(Previous, SemaRef.CurContext);
Nico Weber7b5a7162012-06-25 17:21:05 +00002732 if (SemaRef.CheckFunctionTemplateSpecialization(NewFD, TemplateArgsPtr,
2733 Previous)) {
Francois Pichet00c7e6c2011-08-14 03:52:19 +00002734 NewFD->setInvalidDecl();
2735 return NewFD;
2736 }
2737
2738 // Associate the specialization with the pattern.
2739 FunctionDecl *Specialization = cast<FunctionDecl>(Previous.getFoundDecl());
2740 assert(Specialization && "Class scope Specialization is null");
2741 SemaRef.Context.setClassScopeSpecializationPattern(Specialization, OldFD);
2742
2743 return NewFD;
2744}
2745
Alexey Bataeva769e072013-03-22 06:34:35 +00002746Decl *TemplateDeclInstantiator::VisitOMPThreadPrivateDecl(
2747 OMPThreadPrivateDecl *D) {
Alexey Bataev6f6f3b42013-05-13 04:18:18 +00002748 SmallVector<Expr *, 5> Vars;
Aaron Ballman2205d2a2014-03-14 15:55:35 +00002749 for (auto *I : D->varlists()) {
Nikola Smiljanic01a75982014-05-29 10:55:11 +00002750 Expr *Var = SemaRef.SubstExpr(I, TemplateArgs).get();
Alexey Bataeva769e072013-03-22 06:34:35 +00002751 assert(isa<DeclRefExpr>(Var) && "threadprivate arg is not a DeclRefExpr");
Alexey Bataev6f6f3b42013-05-13 04:18:18 +00002752 Vars.push_back(Var);
Alexey Bataeva769e072013-03-22 06:34:35 +00002753 }
2754
2755 OMPThreadPrivateDecl *TD =
2756 SemaRef.CheckOMPThreadPrivateDecl(D->getLocation(), Vars);
2757
Alexey Bataevd3db6ac2014-03-07 09:46:29 +00002758 TD->setAccess(AS_public);
2759 Owner->addDecl(TD);
2760
Alexey Bataeva769e072013-03-22 06:34:35 +00002761 return TD;
2762}
2763
Alexey Bataev94a4f0c2016-03-03 05:21:39 +00002764Decl *TemplateDeclInstantiator::VisitOMPDeclareReductionDecl(
2765 OMPDeclareReductionDecl *D) {
2766 // Instantiate type and check if it is allowed.
2767 QualType SubstReductionType = SemaRef.ActOnOpenMPDeclareReductionType(
2768 D->getLocation(),
2769 ParsedType::make(SemaRef.SubstType(D->getType(), TemplateArgs,
2770 D->getLocation(), DeclarationName())));
2771 if (SubstReductionType.isNull())
2772 return nullptr;
2773 bool IsCorrect = !SubstReductionType.isNull();
2774 // Create instantiated copy.
2775 std::pair<QualType, SourceLocation> ReductionTypes[] = {
2776 std::make_pair(SubstReductionType, D->getLocation())};
2777 auto *PrevDeclInScope = D->getPrevDeclInScope();
2778 if (PrevDeclInScope && !PrevDeclInScope->isInvalidDecl()) {
2779 PrevDeclInScope = cast<OMPDeclareReductionDecl>(
2780 SemaRef.CurrentInstantiationScope->findInstantiationOf(PrevDeclInScope)
2781 ->get<Decl *>());
2782 }
2783 auto DRD = SemaRef.ActOnOpenMPDeclareReductionDirectiveStart(
2784 /*S=*/nullptr, Owner, D->getDeclName(), ReductionTypes, D->getAccess(),
2785 PrevDeclInScope);
2786 auto *NewDRD = cast<OMPDeclareReductionDecl>(DRD.get().getSingleDecl());
2787 if (isDeclWithinFunction(NewDRD))
2788 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewDRD);
2789 Expr *SubstCombiner = nullptr;
2790 Expr *SubstInitializer = nullptr;
2791 // Combiners instantiation sequence.
2792 if (D->getCombiner()) {
2793 SemaRef.ActOnOpenMPDeclareReductionCombinerStart(
2794 /*S=*/nullptr, NewDRD);
2795 const char *Names[] = {"omp_in", "omp_out"};
2796 for (auto &Name : Names) {
2797 DeclarationName DN(&SemaRef.Context.Idents.get(Name));
2798 auto OldLookup = D->lookup(DN);
2799 auto Lookup = NewDRD->lookup(DN);
2800 if (!OldLookup.empty() && !Lookup.empty()) {
2801 assert(Lookup.size() == 1 && OldLookup.size() == 1);
2802 SemaRef.CurrentInstantiationScope->InstantiatedLocal(OldLookup.front(),
2803 Lookup.front());
2804 }
2805 }
2806 SubstCombiner = SemaRef.SubstExpr(D->getCombiner(), TemplateArgs).get();
2807 SemaRef.ActOnOpenMPDeclareReductionCombinerEnd(NewDRD, SubstCombiner);
2808 // Initializers instantiation sequence.
2809 if (D->getInitializer()) {
Alexey Bataev070f43a2017-09-06 14:49:58 +00002810 VarDecl *OmpPrivParm =
2811 SemaRef.ActOnOpenMPDeclareReductionInitializerStart(
2812 /*S=*/nullptr, NewDRD);
Alexey Bataev94a4f0c2016-03-03 05:21:39 +00002813 const char *Names[] = {"omp_orig", "omp_priv"};
2814 for (auto &Name : Names) {
2815 DeclarationName DN(&SemaRef.Context.Idents.get(Name));
2816 auto OldLookup = D->lookup(DN);
2817 auto Lookup = NewDRD->lookup(DN);
2818 if (!OldLookup.empty() && !Lookup.empty()) {
2819 assert(Lookup.size() == 1 && OldLookup.size() == 1);
Alexey Bataev070f43a2017-09-06 14:49:58 +00002820 auto *OldVD = cast<VarDecl>(OldLookup.front());
2821 auto *NewVD = cast<VarDecl>(Lookup.front());
2822 SemaRef.InstantiateVariableInitializer(NewVD, OldVD, TemplateArgs);
2823 SemaRef.CurrentInstantiationScope->InstantiatedLocal(OldVD, NewVD);
Alexey Bataev94a4f0c2016-03-03 05:21:39 +00002824 }
2825 }
Alexey Bataev070f43a2017-09-06 14:49:58 +00002826 if (D->getInitializerKind() == OMPDeclareReductionDecl::CallInit) {
2827 SubstInitializer =
2828 SemaRef.SubstExpr(D->getInitializer(), TemplateArgs).get();
2829 } else {
2830 IsCorrect = IsCorrect && OmpPrivParm->hasInit();
2831 }
2832 SemaRef.ActOnOpenMPDeclareReductionInitializerEnd(
2833 NewDRD, SubstInitializer, OmpPrivParm);
Alexey Bataev94a4f0c2016-03-03 05:21:39 +00002834 }
Alexey Bataev070f43a2017-09-06 14:49:58 +00002835 IsCorrect =
2836 IsCorrect && SubstCombiner &&
2837 (!D->getInitializer() ||
2838 (D->getInitializerKind() == OMPDeclareReductionDecl::CallInit &&
2839 SubstInitializer) ||
2840 (D->getInitializerKind() != OMPDeclareReductionDecl::CallInit &&
2841 !SubstInitializer && !SubstInitializer));
Alexey Bataev94a4f0c2016-03-03 05:21:39 +00002842 } else
2843 IsCorrect = false;
2844
2845 (void)SemaRef.ActOnOpenMPDeclareReductionDirectiveEnd(/*S=*/nullptr, DRD,
2846 IsCorrect);
2847
2848 return NewDRD;
2849}
2850
Alexey Bataev4244be22016-02-11 05:35:55 +00002851Decl *TemplateDeclInstantiator::VisitOMPCapturedExprDecl(
2852 OMPCapturedExprDecl * /*D*/) {
Alexey Bataev90c228f2016-02-08 09:29:13 +00002853 llvm_unreachable("Should not be met in templates");
2854}
2855
Eli Friedmancb9cd6c2013-06-27 23:21:55 +00002856Decl *TemplateDeclInstantiator::VisitFunctionDecl(FunctionDecl *D) {
Craig Topperc3ec1492014-05-26 06:22:03 +00002857 return VisitFunctionDecl(D, nullptr);
Eli Friedmancb9cd6c2013-06-27 23:21:55 +00002858}
2859
Richard Smithbc491202017-02-17 20:05:37 +00002860Decl *
2861TemplateDeclInstantiator::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {
2862 return VisitFunctionDecl(D, nullptr);
2863}
2864
Eli Friedmancb9cd6c2013-06-27 23:21:55 +00002865Decl *TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D) {
Craig Topperc3ec1492014-05-26 06:22:03 +00002866 return VisitCXXMethodDecl(D, nullptr);
Eli Friedmancb9cd6c2013-06-27 23:21:55 +00002867}
2868
2869Decl *TemplateDeclInstantiator::VisitRecordDecl(RecordDecl *D) {
2870 llvm_unreachable("There are only CXXRecordDecls in C++");
2871}
2872
2873Decl *
2874TemplateDeclInstantiator::VisitClassTemplateSpecializationDecl(
2875 ClassTemplateSpecializationDecl *D) {
Richard Smith8a0dde72013-12-14 01:04:22 +00002876 // As a MS extension, we permit class-scope explicit specialization
2877 // of member class templates.
2878 ClassTemplateDecl *ClassTemplate = D->getSpecializedTemplate();
2879 assert(ClassTemplate->getDeclContext()->isRecord() &&
2880 D->getTemplateSpecializationKind() == TSK_ExplicitSpecialization &&
2881 "can only instantiate an explicit specialization "
2882 "for a member class template");
2883
2884 // Lookup the already-instantiated declaration in the instantiation
2885 // of the class template. FIXME: Diagnose or assert if this fails?
2886 DeclContext::lookup_result Found
2887 = Owner->lookup(ClassTemplate->getDeclName());
2888 if (Found.empty())
Craig Topperc3ec1492014-05-26 06:22:03 +00002889 return nullptr;
Richard Smith8a0dde72013-12-14 01:04:22 +00002890 ClassTemplateDecl *InstClassTemplate
2891 = dyn_cast<ClassTemplateDecl>(Found.front());
2892 if (!InstClassTemplate)
Craig Topperc3ec1492014-05-26 06:22:03 +00002893 return nullptr;
Richard Smith8a0dde72013-12-14 01:04:22 +00002894
2895 // Substitute into the template arguments of the class template explicit
2896 // specialization.
2897 TemplateSpecializationTypeLoc Loc = D->getTypeAsWritten()->getTypeLoc().
2898 castAs<TemplateSpecializationTypeLoc>();
2899 TemplateArgumentListInfo InstTemplateArgs(Loc.getLAngleLoc(),
2900 Loc.getRAngleLoc());
2901 SmallVector<TemplateArgumentLoc, 4> ArgLocs;
2902 for (unsigned I = 0; I != Loc.getNumArgs(); ++I)
2903 ArgLocs.push_back(Loc.getArgLoc(I));
2904 if (SemaRef.Subst(ArgLocs.data(), ArgLocs.size(),
2905 InstTemplateArgs, TemplateArgs))
Craig Topperc3ec1492014-05-26 06:22:03 +00002906 return nullptr;
Richard Smith8a0dde72013-12-14 01:04:22 +00002907
2908 // Check that the template argument list is well-formed for this
2909 // class template.
2910 SmallVector<TemplateArgument, 4> Converted;
2911 if (SemaRef.CheckTemplateArgumentList(InstClassTemplate,
2912 D->getLocation(),
2913 InstTemplateArgs,
2914 false,
2915 Converted))
Craig Topperc3ec1492014-05-26 06:22:03 +00002916 return nullptr;
Richard Smith8a0dde72013-12-14 01:04:22 +00002917
2918 // Figure out where to insert this class template explicit specialization
2919 // in the member template's set of class template explicit specializations.
Craig Topperc3ec1492014-05-26 06:22:03 +00002920 void *InsertPos = nullptr;
Richard Smith8a0dde72013-12-14 01:04:22 +00002921 ClassTemplateSpecializationDecl *PrevDecl =
Craig Topper7e0daca2014-06-26 04:58:53 +00002922 InstClassTemplate->findSpecialization(Converted, InsertPos);
Richard Smith8a0dde72013-12-14 01:04:22 +00002923
2924 // Check whether we've already seen a conflicting instantiation of this
2925 // declaration (for instance, if there was a prior implicit instantiation).
2926 bool Ignored;
2927 if (PrevDecl &&
2928 SemaRef.CheckSpecializationInstantiationRedecl(D->getLocation(),
2929 D->getSpecializationKind(),
2930 PrevDecl,
2931 PrevDecl->getSpecializationKind(),
2932 PrevDecl->getPointOfInstantiation(),
2933 Ignored))
Craig Topperc3ec1492014-05-26 06:22:03 +00002934 return nullptr;
Richard Smith8a0dde72013-12-14 01:04:22 +00002935
2936 // If PrevDecl was a definition and D is also a definition, diagnose.
2937 // This happens in cases like:
2938 //
2939 // template<typename T, typename U>
2940 // struct Outer {
2941 // template<typename X> struct Inner;
2942 // template<> struct Inner<T> {};
2943 // template<> struct Inner<U> {};
2944 // };
2945 //
2946 // Outer<int, int> outer; // error: the explicit specializations of Inner
2947 // // have the same signature.
2948 if (PrevDecl && PrevDecl->getDefinition() &&
2949 D->isThisDeclarationADefinition()) {
2950 SemaRef.Diag(D->getLocation(), diag::err_redefinition) << PrevDecl;
2951 SemaRef.Diag(PrevDecl->getDefinition()->getLocation(),
2952 diag::note_previous_definition);
Craig Topperc3ec1492014-05-26 06:22:03 +00002953 return nullptr;
Richard Smith8a0dde72013-12-14 01:04:22 +00002954 }
2955
2956 // Create the class template partial specialization declaration.
2957 ClassTemplateSpecializationDecl *InstD
2958 = ClassTemplateSpecializationDecl::Create(SemaRef.Context,
2959 D->getTagKind(),
2960 Owner,
2961 D->getLocStart(),
2962 D->getLocation(),
2963 InstClassTemplate,
David Majnemer8b622692016-07-03 21:17:51 +00002964 Converted,
Richard Smith8a0dde72013-12-14 01:04:22 +00002965 PrevDecl);
2966
2967 // Add this partial specialization to the set of class template partial
2968 // specializations.
2969 if (!PrevDecl)
2970 InstClassTemplate->AddSpecialization(InstD, InsertPos);
2971
2972 // Substitute the nested name specifier, if any.
2973 if (SubstQualifier(D, InstD))
Craig Topperc3ec1492014-05-26 06:22:03 +00002974 return nullptr;
Richard Smith8a0dde72013-12-14 01:04:22 +00002975
2976 // Build the canonical type that describes the converted template
2977 // arguments of the class template explicit specialization.
2978 QualType CanonType = SemaRef.Context.getTemplateSpecializationType(
David Majnemer6fbeee32016-07-07 04:43:07 +00002979 TemplateName(InstClassTemplate), Converted,
Richard Smith8a0dde72013-12-14 01:04:22 +00002980 SemaRef.Context.getRecordType(InstD));
2981
2982 // Build the fully-sugared type for this class template
2983 // specialization as the user wrote in the specialization
2984 // itself. This means that we'll pretty-print the type retrieved
2985 // from the specialization's declaration the way that the user
2986 // actually wrote the specialization, rather than formatting the
2987 // name based on the "canonical" representation used to store the
2988 // template arguments in the specialization.
2989 TypeSourceInfo *WrittenTy = SemaRef.Context.getTemplateSpecializationTypeInfo(
2990 TemplateName(InstClassTemplate), D->getLocation(), InstTemplateArgs,
2991 CanonType);
2992
2993 InstD->setAccess(D->getAccess());
2994 InstD->setInstantiationOfMemberClass(D, TSK_ImplicitInstantiation);
2995 InstD->setSpecializationKind(D->getSpecializationKind());
2996 InstD->setTypeAsWritten(WrittenTy);
2997 InstD->setExternLoc(D->getExternLoc());
2998 InstD->setTemplateKeywordLoc(D->getTemplateKeywordLoc());
2999
3000 Owner->addDecl(InstD);
3001
3002 // Instantiate the members of the class-scope explicit specialization eagerly.
3003 // We don't have support for lazy instantiation of an explicit specialization
3004 // yet, and MSVC eagerly instantiates in this case.
3005 if (D->isThisDeclarationADefinition() &&
3006 SemaRef.InstantiateClass(D->getLocation(), InstD, D, TemplateArgs,
3007 TSK_ImplicitInstantiation,
3008 /*Complain=*/true))
Craig Topperc3ec1492014-05-26 06:22:03 +00003009 return nullptr;
Richard Smith8a0dde72013-12-14 01:04:22 +00003010
3011 return InstD;
Eli Friedmancb9cd6c2013-06-27 23:21:55 +00003012}
3013
Larisse Voufo39a1e502013-08-06 01:03:05 +00003014Decl *TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl(
3015 VarTemplateSpecializationDecl *D) {
3016
3017 TemplateArgumentListInfo VarTemplateArgsInfo;
3018 VarTemplateDecl *VarTemplate = D->getSpecializedTemplate();
3019 assert(VarTemplate &&
3020 "A template specialization without specialized template?");
3021
3022 // Substitute the current template arguments.
3023 const TemplateArgumentListInfo &TemplateArgsInfo = D->getTemplateArgsInfo();
3024 VarTemplateArgsInfo.setLAngleLoc(TemplateArgsInfo.getLAngleLoc());
3025 VarTemplateArgsInfo.setRAngleLoc(TemplateArgsInfo.getRAngleLoc());
3026
3027 if (SemaRef.Subst(TemplateArgsInfo.getArgumentArray(),
3028 TemplateArgsInfo.size(), VarTemplateArgsInfo, TemplateArgs))
Craig Topperc3ec1492014-05-26 06:22:03 +00003029 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00003030
3031 // Check that the template argument list is well-formed for this template.
3032 SmallVector<TemplateArgument, 4> Converted;
Larisse Voufo39a1e502013-08-06 01:03:05 +00003033 if (SemaRef.CheckTemplateArgumentList(
3034 VarTemplate, VarTemplate->getLocStart(),
3035 const_cast<TemplateArgumentListInfo &>(VarTemplateArgsInfo), false,
Richard Smith83b11aa2014-01-09 02:22:22 +00003036 Converted))
Craig Topperc3ec1492014-05-26 06:22:03 +00003037 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00003038
3039 // Find the variable template specialization declaration that
3040 // corresponds to these arguments.
Craig Topperc3ec1492014-05-26 06:22:03 +00003041 void *InsertPos = nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00003042 if (VarTemplateSpecializationDecl *VarSpec = VarTemplate->findSpecialization(
Craig Topper7e0daca2014-06-26 04:58:53 +00003043 Converted, InsertPos))
Larisse Voufo39a1e502013-08-06 01:03:05 +00003044 // If we already have a variable template specialization, return it.
3045 return VarSpec;
3046
3047 return VisitVarTemplateSpecializationDecl(VarTemplate, D, InsertPos,
3048 VarTemplateArgsInfo, Converted);
3049}
3050
3051Decl *TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl(
3052 VarTemplateDecl *VarTemplate, VarDecl *D, void *InsertPos,
3053 const TemplateArgumentListInfo &TemplateArgsInfo,
Craig Topper00bbdcf2014-06-28 23:22:23 +00003054 ArrayRef<TemplateArgument> Converted) {
Larisse Voufo39a1e502013-08-06 01:03:05 +00003055
Larisse Voufo39a1e502013-08-06 01:03:05 +00003056 // Do substitution on the type of the declaration
3057 TypeSourceInfo *DI =
3058 SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs,
3059 D->getTypeSpecStartLoc(), D->getDeclName());
3060 if (!DI)
Craig Topperc3ec1492014-05-26 06:22:03 +00003061 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00003062
3063 if (DI->getType()->isFunctionType()) {
3064 SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function)
3065 << D->isStaticDataMember() << DI->getType();
Craig Topperc3ec1492014-05-26 06:22:03 +00003066 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00003067 }
3068
3069 // Build the instantiated declaration
3070 VarTemplateSpecializationDecl *Var = VarTemplateSpecializationDecl::Create(
3071 SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
David Majnemer8b622692016-07-03 21:17:51 +00003072 VarTemplate, DI->getType(), DI, D->getStorageClass(), Converted);
Larisse Voufo39a1e502013-08-06 01:03:05 +00003073 Var->setTemplateArgsInfo(TemplateArgsInfo);
Richard Smith8809a0c2013-09-27 20:14:12 +00003074 if (InsertPos)
3075 VarTemplate->AddSpecialization(Var, InsertPos);
Larisse Voufo39a1e502013-08-06 01:03:05 +00003076
3077 // Substitute the nested name specifier, if any.
3078 if (SubstQualifier(D, Var))
Craig Topperc3ec1492014-05-26 06:22:03 +00003079 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00003080
3081 SemaRef.BuildVariableInstantiation(Var, D, TemplateArgs, LateAttrs,
Richard Smith541b38b2013-09-20 01:15:31 +00003082 Owner, StartingScope);
Larisse Voufo39a1e502013-08-06 01:03:05 +00003083
3084 return Var;
3085}
3086
Eli Friedmancb9cd6c2013-06-27 23:21:55 +00003087Decl *TemplateDeclInstantiator::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) {
3088 llvm_unreachable("@defs is not supported in Objective-C++");
3089}
3090
3091Decl *TemplateDeclInstantiator::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
3092 // FIXME: We need to be able to instantiate FriendTemplateDecls.
3093 unsigned DiagID = SemaRef.getDiagnostics().getCustomDiagID(
3094 DiagnosticsEngine::Error,
3095 "cannot instantiate %0 yet");
3096 SemaRef.Diag(D->getLocation(), DiagID)
3097 << D->getDeclKindName();
3098
Craig Topperc3ec1492014-05-26 06:22:03 +00003099 return nullptr;
Eli Friedmancb9cd6c2013-06-27 23:21:55 +00003100}
3101
3102Decl *TemplateDeclInstantiator::VisitDecl(Decl *D) {
3103 llvm_unreachable("Unexpected decl");
3104}
3105
John McCall76d824f2009-08-25 22:02:44 +00003106Decl *Sema::SubstDecl(Decl *D, DeclContext *Owner,
Douglas Gregor01afeef2009-08-28 20:31:08 +00003107 const MultiLevelTemplateArgumentList &TemplateArgs) {
Douglas Gregord002c7b2009-05-11 23:53:27 +00003108 TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs);
Douglas Gregor71ad4772010-02-16 19:28:15 +00003109 if (D->isInvalidDecl())
Craig Topperc3ec1492014-05-26 06:22:03 +00003110 return nullptr;
Douglas Gregor71ad4772010-02-16 19:28:15 +00003111
Douglas Gregord7e7a512009-03-17 21:15:40 +00003112 return Instantiator.Visit(D);
3113}
3114
John McCall87a44eb2009-08-20 01:44:21 +00003115/// \brief Instantiates a nested template parameter list in the current
3116/// instantiation context.
3117///
3118/// \param L The parameter list to instantiate
3119///
3120/// \returns NULL if there was an error
3121TemplateParameterList *
John McCall76d824f2009-08-25 22:02:44 +00003122TemplateDeclInstantiator::SubstTemplateParams(TemplateParameterList *L) {
John McCall87a44eb2009-08-20 01:44:21 +00003123 // Get errors for all the parameters before bailing out.
3124 bool Invalid = false;
3125
3126 unsigned N = L->size();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003127 typedef SmallVector<NamedDecl *, 8> ParamVector;
John McCall87a44eb2009-08-20 01:44:21 +00003128 ParamVector Params;
3129 Params.reserve(N);
Davide Italiano18960b92015-07-02 19:20:11 +00003130 for (auto &P : *L) {
3131 NamedDecl *D = cast_or_null<NamedDecl>(Visit(P));
John McCall87a44eb2009-08-20 01:44:21 +00003132 Params.push_back(D);
Douglas Gregore62e6a02009-11-11 19:13:48 +00003133 Invalid = Invalid || !D || D->isInvalidDecl();
John McCall87a44eb2009-08-20 01:44:21 +00003134 }
3135
3136 // Clean up if we had an error.
Douglas Gregorb412e172010-07-25 18:17:45 +00003137 if (Invalid)
Craig Topperc3ec1492014-05-26 06:22:03 +00003138 return nullptr;
John McCall87a44eb2009-08-20 01:44:21 +00003139
Hubert Tonge4a0c0e2016-07-30 22:33:34 +00003140 // Note: we substitute into associated constraints later
3141 Expr *const UninstantiatedRequiresClause = L->getRequiresClause();
3142
John McCall87a44eb2009-08-20 01:44:21 +00003143 TemplateParameterList *InstL
3144 = TemplateParameterList::Create(SemaRef.Context, L->getTemplateLoc(),
David Majnemer902f8c62015-12-27 07:16:27 +00003145 L->getLAngleLoc(), Params,
Hubert Tonge4a0c0e2016-07-30 22:33:34 +00003146 L->getRAngleLoc(),
3147 UninstantiatedRequiresClause);
John McCall87a44eb2009-08-20 01:44:21 +00003148 return InstL;
Mike Stump11289f42009-09-09 15:08:12 +00003149}
John McCall87a44eb2009-08-20 01:44:21 +00003150
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00003151/// \brief Instantiate the declaration of a class template partial
Douglas Gregor21610382009-10-29 00:04:11 +00003152/// specialization.
3153///
3154/// \param ClassTemplate the (instantiated) class template that is partially
3155// specialized by the instantiation of \p PartialSpec.
3156///
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00003157/// \param PartialSpec the (uninstantiated) class template partial
Douglas Gregor21610382009-10-29 00:04:11 +00003158/// specialization that we are instantiating.
3159///
Douglas Gregor869853e2010-11-10 19:44:59 +00003160/// \returns The instantiated partial specialization, if successful; otherwise,
3161/// NULL to indicate an error.
3162ClassTemplatePartialSpecializationDecl *
Douglas Gregor21610382009-10-29 00:04:11 +00003163TemplateDeclInstantiator::InstantiateClassTemplatePartialSpecialization(
3164 ClassTemplateDecl *ClassTemplate,
3165 ClassTemplatePartialSpecializationDecl *PartialSpec) {
Douglas Gregor954de172009-10-31 17:21:17 +00003166 // Create a local instantiation scope for this class template partial
3167 // specialization, which will contain the instantiations of the template
3168 // parameters.
John McCall19c1bfd2010-08-25 05:32:35 +00003169 LocalInstantiationScope Scope(SemaRef);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00003170
Douglas Gregor21610382009-10-29 00:04:11 +00003171 // Substitute into the template parameters of the class template partial
3172 // specialization.
3173 TemplateParameterList *TempParams = PartialSpec->getTemplateParameters();
3174 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
3175 if (!InstParams)
Craig Topperc3ec1492014-05-26 06:22:03 +00003176 return nullptr;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00003177
Douglas Gregor21610382009-10-29 00:04:11 +00003178 // Substitute into the template arguments of the class template partial
3179 // specialization.
Enea Zaffanella6dbe1872013-08-10 07:24:53 +00003180 const ASTTemplateArgumentListInfo *TemplArgInfo
3181 = PartialSpec->getTemplateArgsAsWritten();
3182 TemplateArgumentListInfo InstTemplateArgs(TemplArgInfo->LAngleLoc,
3183 TemplArgInfo->RAngleLoc);
3184 if (SemaRef.Subst(TemplArgInfo->getTemplateArgs(),
3185 TemplArgInfo->NumTemplateArgs,
Douglas Gregor0f3feb42010-12-22 21:19:48 +00003186 InstTemplateArgs, TemplateArgs))
Craig Topperc3ec1492014-05-26 06:22:03 +00003187 return nullptr;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00003188
Douglas Gregor21610382009-10-29 00:04:11 +00003189 // Check that the template argument list is well-formed for this
3190 // class template.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003191 SmallVector<TemplateArgument, 4> Converted;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00003192 if (SemaRef.CheckTemplateArgumentList(ClassTemplate,
Douglas Gregor21610382009-10-29 00:04:11 +00003193 PartialSpec->getLocation(),
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00003194 InstTemplateArgs,
Douglas Gregor21610382009-10-29 00:04:11 +00003195 false,
3196 Converted))
Craig Topperc3ec1492014-05-26 06:22:03 +00003197 return nullptr;
Douglas Gregor21610382009-10-29 00:04:11 +00003198
Richard Smith57aae072016-12-28 02:37:25 +00003199 // Check these arguments are valid for a template partial specialization.
3200 if (SemaRef.CheckTemplatePartialSpecializationArgs(
3201 PartialSpec->getLocation(), ClassTemplate, InstTemplateArgs.size(),
3202 Converted))
3203 return nullptr;
3204
Douglas Gregor21610382009-10-29 00:04:11 +00003205 // Figure out where to insert this class template partial specialization
3206 // in the member template's set of class template partial specializations.
Craig Topperc3ec1492014-05-26 06:22:03 +00003207 void *InsertPos = nullptr;
Douglas Gregor21610382009-10-29 00:04:11 +00003208 ClassTemplateSpecializationDecl *PrevDecl
Craig Topper7e0daca2014-06-26 04:58:53 +00003209 = ClassTemplate->findPartialSpecialization(Converted, InsertPos);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00003210
Douglas Gregor21610382009-10-29 00:04:11 +00003211 // Build the canonical type that describes the converted template
3212 // arguments of the class template partial specialization.
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00003213 QualType CanonType
Douglas Gregor21610382009-10-29 00:04:11 +00003214 = SemaRef.Context.getTemplateSpecializationType(TemplateName(ClassTemplate),
David Majnemer6fbeee32016-07-07 04:43:07 +00003215 Converted);
Douglas Gregor21610382009-10-29 00:04:11 +00003216
3217 // Build the fully-sugared type for this class template
3218 // specialization as the user wrote in the specialization
3219 // itself. This means that we'll pretty-print the type retrieved
3220 // from the specialization's declaration the way that the user
3221 // actually wrote the specialization, rather than formatting the
3222 // name based on the "canonical" representation used to store the
3223 // template arguments in the specialization.
John McCalle78aac42010-03-10 03:28:59 +00003224 TypeSourceInfo *WrittenTy
3225 = SemaRef.Context.getTemplateSpecializationTypeInfo(
3226 TemplateName(ClassTemplate),
3227 PartialSpec->getLocation(),
John McCall6b51f282009-11-23 01:53:49 +00003228 InstTemplateArgs,
Douglas Gregor21610382009-10-29 00:04:11 +00003229 CanonType);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00003230
Douglas Gregor21610382009-10-29 00:04:11 +00003231 if (PrevDecl) {
3232 // We've already seen a partial specialization with the same template
3233 // parameters and template arguments. This can happen, for example, when
3234 // substituting the outer template arguments ends up causing two
3235 // class template partial specializations of a member class template
3236 // to have identical forms, e.g.,
3237 //
3238 // template<typename T, typename U>
3239 // struct Outer {
3240 // template<typename X, typename Y> struct Inner;
3241 // template<typename Y> struct Inner<T, Y>;
3242 // template<typename Y> struct Inner<U, Y>;
3243 // };
3244 //
3245 // Outer<int, int> outer; // error: the partial specializations of Inner
3246 // // have the same signature.
3247 SemaRef.Diag(PartialSpec->getLocation(), diag::err_partial_spec_redeclared)
Douglas Gregor869853e2010-11-10 19:44:59 +00003248 << WrittenTy->getType();
Douglas Gregor21610382009-10-29 00:04:11 +00003249 SemaRef.Diag(PrevDecl->getLocation(), diag::note_prev_partial_spec_here)
3250 << SemaRef.Context.getTypeDeclType(PrevDecl);
Craig Topperc3ec1492014-05-26 06:22:03 +00003251 return nullptr;
Douglas Gregor21610382009-10-29 00:04:11 +00003252 }
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00003253
3254
Douglas Gregor21610382009-10-29 00:04:11 +00003255 // Create the class template partial specialization declaration.
3256 ClassTemplatePartialSpecializationDecl *InstPartialSpec
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00003257 = ClassTemplatePartialSpecializationDecl::Create(SemaRef.Context,
Douglas Gregore9029562010-05-06 00:28:52 +00003258 PartialSpec->getTagKind(),
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00003259 Owner,
Abramo Bagnara29c2d462011-03-09 14:09:51 +00003260 PartialSpec->getLocStart(),
3261 PartialSpec->getLocation(),
Douglas Gregor21610382009-10-29 00:04:11 +00003262 InstParams,
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00003263 ClassTemplate,
David Majnemer8b622692016-07-03 21:17:51 +00003264 Converted,
John McCall6b51f282009-11-23 01:53:49 +00003265 InstTemplateArgs,
John McCalle78aac42010-03-10 03:28:59 +00003266 CanonType,
Craig Topperc3ec1492014-05-26 06:22:03 +00003267 nullptr);
John McCall3e11ebe2010-03-15 10:12:16 +00003268 // Substitute the nested name specifier, if any.
3269 if (SubstQualifier(PartialSpec, InstPartialSpec))
Craig Topperc3ec1492014-05-26 06:22:03 +00003270 return nullptr;
John McCall3e11ebe2010-03-15 10:12:16 +00003271
Douglas Gregor21610382009-10-29 00:04:11 +00003272 InstPartialSpec->setInstantiatedFromMember(PartialSpec);
Douglas Gregor6044d692010-05-19 17:02:24 +00003273 InstPartialSpec->setTypeAsWritten(WrittenTy);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00003274
Richard Smith57aae072016-12-28 02:37:25 +00003275 // Check the completed partial specialization.
3276 SemaRef.CheckTemplatePartialSpecialization(InstPartialSpec);
3277
Douglas Gregor21610382009-10-29 00:04:11 +00003278 // Add this partial specialization to the set of class template partial
3279 // specializations.
Craig Topperc3ec1492014-05-26 06:22:03 +00003280 ClassTemplate->AddPartialSpecialization(InstPartialSpec,
3281 /*InsertPos=*/nullptr);
Douglas Gregor869853e2010-11-10 19:44:59 +00003282 return InstPartialSpec;
Douglas Gregor21610382009-10-29 00:04:11 +00003283}
3284
Larisse Voufo39a1e502013-08-06 01:03:05 +00003285/// \brief Instantiate the declaration of a variable template partial
3286/// specialization.
3287///
3288/// \param VarTemplate the (instantiated) variable template that is partially
3289/// specialized by the instantiation of \p PartialSpec.
3290///
3291/// \param PartialSpec the (uninstantiated) variable template partial
3292/// specialization that we are instantiating.
3293///
3294/// \returns The instantiated partial specialization, if successful; otherwise,
3295/// NULL to indicate an error.
3296VarTemplatePartialSpecializationDecl *
3297TemplateDeclInstantiator::InstantiateVarTemplatePartialSpecialization(
3298 VarTemplateDecl *VarTemplate,
3299 VarTemplatePartialSpecializationDecl *PartialSpec) {
3300 // Create a local instantiation scope for this variable template partial
3301 // specialization, which will contain the instantiations of the template
3302 // parameters.
3303 LocalInstantiationScope Scope(SemaRef);
3304
3305 // Substitute into the template parameters of the variable template partial
3306 // specialization.
3307 TemplateParameterList *TempParams = PartialSpec->getTemplateParameters();
3308 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
3309 if (!InstParams)
Craig Topperc3ec1492014-05-26 06:22:03 +00003310 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00003311
3312 // Substitute into the template arguments of the variable template partial
3313 // specialization.
Enea Zaffanella6dbe1872013-08-10 07:24:53 +00003314 const ASTTemplateArgumentListInfo *TemplArgInfo
3315 = PartialSpec->getTemplateArgsAsWritten();
3316 TemplateArgumentListInfo InstTemplateArgs(TemplArgInfo->LAngleLoc,
3317 TemplArgInfo->RAngleLoc);
3318 if (SemaRef.Subst(TemplArgInfo->getTemplateArgs(),
3319 TemplArgInfo->NumTemplateArgs,
Larisse Voufo39a1e502013-08-06 01:03:05 +00003320 InstTemplateArgs, TemplateArgs))
Craig Topperc3ec1492014-05-26 06:22:03 +00003321 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00003322
3323 // Check that the template argument list is well-formed for this
3324 // class template.
3325 SmallVector<TemplateArgument, 4> Converted;
3326 if (SemaRef.CheckTemplateArgumentList(VarTemplate, PartialSpec->getLocation(),
3327 InstTemplateArgs, false, Converted))
Craig Topperc3ec1492014-05-26 06:22:03 +00003328 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00003329
Richard Smith57aae072016-12-28 02:37:25 +00003330 // Check these arguments are valid for a template partial specialization.
3331 if (SemaRef.CheckTemplatePartialSpecializationArgs(
3332 PartialSpec->getLocation(), VarTemplate, InstTemplateArgs.size(),
3333 Converted))
3334 return nullptr;
3335
Larisse Voufo39a1e502013-08-06 01:03:05 +00003336 // Figure out where to insert this variable template partial specialization
3337 // in the member template's set of variable template partial specializations.
Craig Topperc3ec1492014-05-26 06:22:03 +00003338 void *InsertPos = nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00003339 VarTemplateSpecializationDecl *PrevDecl =
Craig Topper7e0daca2014-06-26 04:58:53 +00003340 VarTemplate->findPartialSpecialization(Converted, InsertPos);
Larisse Voufo39a1e502013-08-06 01:03:05 +00003341
3342 // Build the canonical type that describes the converted template
3343 // arguments of the variable template partial specialization.
3344 QualType CanonType = SemaRef.Context.getTemplateSpecializationType(
David Majnemer6fbeee32016-07-07 04:43:07 +00003345 TemplateName(VarTemplate), Converted);
Larisse Voufo39a1e502013-08-06 01:03:05 +00003346
3347 // Build the fully-sugared type for this variable template
3348 // specialization as the user wrote in the specialization
3349 // itself. This means that we'll pretty-print the type retrieved
3350 // from the specialization's declaration the way that the user
3351 // actually wrote the specialization, rather than formatting the
3352 // name based on the "canonical" representation used to store the
3353 // template arguments in the specialization.
3354 TypeSourceInfo *WrittenTy = SemaRef.Context.getTemplateSpecializationTypeInfo(
3355 TemplateName(VarTemplate), PartialSpec->getLocation(), InstTemplateArgs,
3356 CanonType);
3357
3358 if (PrevDecl) {
3359 // We've already seen a partial specialization with the same template
3360 // parameters and template arguments. This can happen, for example, when
3361 // substituting the outer template arguments ends up causing two
3362 // variable template partial specializations of a member variable template
3363 // to have identical forms, e.g.,
3364 //
3365 // template<typename T, typename U>
3366 // struct Outer {
3367 // template<typename X, typename Y> pair<X,Y> p;
3368 // template<typename Y> pair<T, Y> p;
3369 // template<typename Y> pair<U, Y> p;
3370 // };
3371 //
3372 // Outer<int, int> outer; // error: the partial specializations of Inner
3373 // // have the same signature.
3374 SemaRef.Diag(PartialSpec->getLocation(),
3375 diag::err_var_partial_spec_redeclared)
3376 << WrittenTy->getType();
3377 SemaRef.Diag(PrevDecl->getLocation(),
3378 diag::note_var_prev_partial_spec_here);
Craig Topperc3ec1492014-05-26 06:22:03 +00003379 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00003380 }
3381
3382 // Do substitution on the type of the declaration
3383 TypeSourceInfo *DI = SemaRef.SubstType(
3384 PartialSpec->getTypeSourceInfo(), TemplateArgs,
3385 PartialSpec->getTypeSpecStartLoc(), PartialSpec->getDeclName());
3386 if (!DI)
Craig Topperc3ec1492014-05-26 06:22:03 +00003387 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00003388
3389 if (DI->getType()->isFunctionType()) {
3390 SemaRef.Diag(PartialSpec->getLocation(),
3391 diag::err_variable_instantiates_to_function)
3392 << PartialSpec->isStaticDataMember() << DI->getType();
Craig Topperc3ec1492014-05-26 06:22:03 +00003393 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00003394 }
3395
3396 // Create the variable template partial specialization declaration.
3397 VarTemplatePartialSpecializationDecl *InstPartialSpec =
3398 VarTemplatePartialSpecializationDecl::Create(
3399 SemaRef.Context, Owner, PartialSpec->getInnerLocStart(),
3400 PartialSpec->getLocation(), InstParams, VarTemplate, DI->getType(),
David Majnemer8b622692016-07-03 21:17:51 +00003401 DI, PartialSpec->getStorageClass(), Converted, InstTemplateArgs);
Larisse Voufo39a1e502013-08-06 01:03:05 +00003402
3403 // Substitute the nested name specifier, if any.
3404 if (SubstQualifier(PartialSpec, InstPartialSpec))
Craig Topperc3ec1492014-05-26 06:22:03 +00003405 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00003406
3407 InstPartialSpec->setInstantiatedFromMember(PartialSpec);
3408 InstPartialSpec->setTypeAsWritten(WrittenTy);
3409
Richard Smith57aae072016-12-28 02:37:25 +00003410 // Check the completed partial specialization.
3411 SemaRef.CheckTemplatePartialSpecialization(InstPartialSpec);
3412
Larisse Voufo39a1e502013-08-06 01:03:05 +00003413 // Add this partial specialization to the set of variable template partial
3414 // specializations. The instantiation of the initializer is not necessary.
Craig Topperc3ec1492014-05-26 06:22:03 +00003415 VarTemplate->AddPartialSpecialization(InstPartialSpec, /*InsertPos=*/nullptr);
Larisse Voufo4cda4612013-08-22 00:28:27 +00003416
Larisse Voufo4cda4612013-08-22 00:28:27 +00003417 SemaRef.BuildVariableInstantiation(InstPartialSpec, PartialSpec, TemplateArgs,
Richard Smith541b38b2013-09-20 01:15:31 +00003418 LateAttrs, Owner, StartingScope);
Larisse Voufo4cda4612013-08-22 00:28:27 +00003419
Larisse Voufo39a1e502013-08-06 01:03:05 +00003420 return InstPartialSpec;
3421}
3422
John McCall58f10c32010-03-11 09:03:00 +00003423TypeSourceInfo*
John McCall76d824f2009-08-25 22:02:44 +00003424TemplateDeclInstantiator::SubstFunctionType(FunctionDecl *D,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003425 SmallVectorImpl<ParmVarDecl *> &Params) {
John McCall58f10c32010-03-11 09:03:00 +00003426 TypeSourceInfo *OldTInfo = D->getTypeSourceInfo();
3427 assert(OldTInfo && "substituting function without type source info");
3428 assert(Params.empty() && "parameter vector is non-empty at start");
Craig Topperc3ec1492014-05-26 06:22:03 +00003429
3430 CXXRecordDecl *ThisContext = nullptr;
Douglas Gregor3024f072012-04-16 07:05:22 +00003431 unsigned ThisTypeQuals = 0;
3432 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
Richard Smithc3d2ebb2013-06-07 02:33:37 +00003433 ThisContext = cast<CXXRecordDecl>(Owner);
Douglas Gregor3024f072012-04-16 07:05:22 +00003434 ThisTypeQuals = Method->getTypeQualifiers();
3435 }
3436
John McCallb29f78f2010-04-09 17:38:44 +00003437 TypeSourceInfo *NewTInfo
3438 = SemaRef.SubstFunctionDeclType(OldTInfo, TemplateArgs,
3439 D->getTypeSpecStartLoc(),
Douglas Gregor3024f072012-04-16 07:05:22 +00003440 D->getDeclName(),
3441 ThisContext, ThisTypeQuals);
John McCall58f10c32010-03-11 09:03:00 +00003442 if (!NewTInfo)
Craig Topperc3ec1492014-05-26 06:22:03 +00003443 return nullptr;
Douglas Gregor21342092009-03-24 00:38:23 +00003444
Reid Klecknera09e44c2013-07-31 21:00:18 +00003445 TypeLoc OldTL = OldTInfo->getTypeLoc().IgnoreParens();
3446 if (FunctionProtoTypeLoc OldProtoLoc = OldTL.getAs<FunctionProtoTypeLoc>()) {
3447 if (NewTInfo != OldTInfo) {
3448 // Get parameters from the new type info.
Abramo Bagnaraa44c9022010-12-13 22:27:55 +00003449 TypeLoc NewTL = NewTInfo->getTypeLoc().IgnoreParens();
David Blaikie6adc78e2013-02-18 22:06:02 +00003450 FunctionProtoTypeLoc NewProtoLoc = NewTL.castAs<FunctionProtoTypeLoc>();
Richard Smith198223b2012-07-18 01:29:05 +00003451 unsigned NewIdx = 0;
Alp Tokerb3fd5cf2014-01-21 00:32:38 +00003452 for (unsigned OldIdx = 0, NumOldParams = OldProtoLoc.getNumParams();
Douglas Gregorf3010112011-01-07 16:43:16 +00003453 OldIdx != NumOldParams; ++OldIdx) {
Alp Tokerb3fd5cf2014-01-21 00:32:38 +00003454 ParmVarDecl *OldParam = OldProtoLoc.getParam(OldIdx);
Richard Smith198223b2012-07-18 01:29:05 +00003455 LocalInstantiationScope *Scope = SemaRef.CurrentInstantiationScope;
3456
David Blaikie05785d12013-02-20 22:23:23 +00003457 Optional<unsigned> NumArgumentsInExpansion;
Richard Smith198223b2012-07-18 01:29:05 +00003458 if (OldParam->isParameterPack())
3459 NumArgumentsInExpansion =
3460 SemaRef.getNumArgumentsInExpansion(OldParam->getType(),
3461 TemplateArgs);
3462 if (!NumArgumentsInExpansion) {
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00003463 // Simple case: normal parameter, or a parameter pack that's
Douglas Gregorf3010112011-01-07 16:43:16 +00003464 // instantiated to a (still-dependent) parameter pack.
Alp Tokerb3fd5cf2014-01-21 00:32:38 +00003465 ParmVarDecl *NewParam = NewProtoLoc.getParam(NewIdx++);
Douglas Gregorf3010112011-01-07 16:43:16 +00003466 Params.push_back(NewParam);
Richard Smith198223b2012-07-18 01:29:05 +00003467 Scope->InstantiatedLocal(OldParam, NewParam);
3468 } else {
3469 // Parameter pack expansion: make the instantiation an argument pack.
3470 Scope->MakeInstantiatedLocalArgPack(OldParam);
3471 for (unsigned I = 0; I != *NumArgumentsInExpansion; ++I) {
Alp Tokerb3fd5cf2014-01-21 00:32:38 +00003472 ParmVarDecl *NewParam = NewProtoLoc.getParam(NewIdx++);
Richard Smith198223b2012-07-18 01:29:05 +00003473 Params.push_back(NewParam);
3474 Scope->InstantiatedLocalPackArg(OldParam, NewParam);
3475 }
Douglas Gregorf3010112011-01-07 16:43:16 +00003476 }
Douglas Gregor95c70ec2010-05-03 15:32:18 +00003477 }
Reid Klecknera09e44c2013-07-31 21:00:18 +00003478 } else {
3479 // The function type itself was not dependent and therefore no
3480 // substitution occurred. However, we still need to instantiate
3481 // the function parameters themselves.
3482 const FunctionProtoType *OldProto =
3483 cast<FunctionProtoType>(OldProtoLoc.getType());
Alp Tokerb3fd5cf2014-01-21 00:32:38 +00003484 for (unsigned i = 0, i_end = OldProtoLoc.getNumParams(); i != i_end;
3485 ++i) {
3486 ParmVarDecl *OldParam = OldProtoLoc.getParam(i);
Reid Klecknera09e44c2013-07-31 21:00:18 +00003487 if (!OldParam) {
3488 Params.push_back(SemaRef.BuildParmVarDeclForTypedef(
Alp Toker9cacbab2014-01-20 20:26:09 +00003489 D, D->getLocation(), OldProto->getParamType(i)));
Reid Klecknera09e44c2013-07-31 21:00:18 +00003490 continue;
3491 }
3492
Eli Friedmancb9cd6c2013-06-27 23:21:55 +00003493 ParmVarDecl *Parm =
Reid Klecknera09e44c2013-07-31 21:00:18 +00003494 cast_or_null<ParmVarDecl>(VisitParmVarDecl(OldParam));
Douglas Gregor95c70ec2010-05-03 15:32:18 +00003495 if (!Parm)
Craig Topperc3ec1492014-05-26 06:22:03 +00003496 return nullptr;
Douglas Gregor95c70ec2010-05-03 15:32:18 +00003497 Params.push_back(Parm);
3498 }
Douglas Gregor940bca72010-04-12 07:48:19 +00003499 }
Reid Klecknera09e44c2013-07-31 21:00:18 +00003500 } else {
3501 // If the type of this function, after ignoring parentheses, is not
3502 // *directly* a function type, then we're instantiating a function that
3503 // was declared via a typedef or with attributes, e.g.,
3504 //
3505 // typedef int functype(int, int);
3506 // functype func;
3507 // int __cdecl meth(int, int);
3508 //
3509 // In this case, we'll just go instantiate the ParmVarDecls that we
3510 // synthesized in the method declaration.
3511 SmallVector<QualType, 4> ParamTypes;
John McCallc8e321d2016-03-01 02:09:25 +00003512 Sema::ExtParameterInfoBuilder ExtParamInfos;
David Majnemer59f77922016-06-24 04:05:48 +00003513 if (SemaRef.SubstParmTypes(D->getLocation(), D->parameters(), nullptr,
3514 TemplateArgs, ParamTypes, &Params,
3515 ExtParamInfos))
Craig Topperc3ec1492014-05-26 06:22:03 +00003516 return nullptr;
Douglas Gregor940bca72010-04-12 07:48:19 +00003517 }
Reid Klecknera09e44c2013-07-31 21:00:18 +00003518
John McCall58f10c32010-03-11 09:03:00 +00003519 return NewTInfo;
Douglas Gregor21342092009-03-24 00:38:23 +00003520}
3521
Richard Smithf623c962012-04-17 00:58:00 +00003522/// Introduce the instantiated function parameters into the local
3523/// instantiation scope, and set the parameter names to those used
3524/// in the template.
Richard Smith2e321552014-11-12 02:00:47 +00003525static bool addInstantiatedParametersToScope(Sema &S, FunctionDecl *Function,
Richard Smithf623c962012-04-17 00:58:00 +00003526 const FunctionDecl *PatternDecl,
3527 LocalInstantiationScope &Scope,
3528 const MultiLevelTemplateArgumentList &TemplateArgs) {
3529 unsigned FParamIdx = 0;
3530 for (unsigned I = 0, N = PatternDecl->getNumParams(); I != N; ++I) {
3531 const ParmVarDecl *PatternParam = PatternDecl->getParamDecl(I);
3532 if (!PatternParam->isParameterPack()) {
3533 // Simple case: not a parameter pack.
3534 assert(FParamIdx < Function->getNumParams());
3535 ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx);
Richard Smith2e321552014-11-12 02:00:47 +00003536 FunctionParam->setDeclName(PatternParam->getDeclName());
Richard Smithaae40582014-03-13 00:28:45 +00003537 // If the parameter's type is not dependent, update it to match the type
3538 // in the pattern. They can differ in top-level cv-qualifiers, and we want
3539 // the pattern's type here. If the type is dependent, they can't differ,
Richard Smith2e321552014-11-12 02:00:47 +00003540 // per core issue 1668. Substitute into the type from the pattern, in case
3541 // it's instantiation-dependent.
Richard Smithaae40582014-03-13 00:28:45 +00003542 // FIXME: Updating the type to work around this is at best fragile.
Richard Smith2e321552014-11-12 02:00:47 +00003543 if (!PatternDecl->getType()->isDependentType()) {
3544 QualType T = S.SubstType(PatternParam->getType(), TemplateArgs,
3545 FunctionParam->getLocation(),
3546 FunctionParam->getDeclName());
3547 if (T.isNull())
3548 return true;
3549 FunctionParam->setType(T);
3550 }
Richard Smithaae40582014-03-13 00:28:45 +00003551
Richard Smithf623c962012-04-17 00:58:00 +00003552 Scope.InstantiatedLocal(PatternParam, FunctionParam);
3553 ++FParamIdx;
3554 continue;
3555 }
3556
3557 // Expand the parameter pack.
3558 Scope.MakeInstantiatedLocalArgPack(PatternParam);
David Blaikie05785d12013-02-20 22:23:23 +00003559 Optional<unsigned> NumArgumentsInExpansion
Richard Smithf623c962012-04-17 00:58:00 +00003560 = S.getNumArgumentsInExpansion(PatternParam->getType(), TemplateArgs);
Richard Smith198223b2012-07-18 01:29:05 +00003561 assert(NumArgumentsInExpansion &&
3562 "should only be called when all template arguments are known");
Richard Smith2e321552014-11-12 02:00:47 +00003563 QualType PatternType =
3564 PatternParam->getType()->castAs<PackExpansionType>()->getPattern();
Richard Smith198223b2012-07-18 01:29:05 +00003565 for (unsigned Arg = 0; Arg < *NumArgumentsInExpansion; ++Arg) {
Richard Smithf623c962012-04-17 00:58:00 +00003566 ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx);
NAKAMURA Takumi23224152014-10-17 12:48:37 +00003567 FunctionParam->setDeclName(PatternParam->getDeclName());
Richard Smith2e321552014-11-12 02:00:47 +00003568 if (!PatternDecl->getType()->isDependentType()) {
3569 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, Arg);
3570 QualType T = S.SubstType(PatternType, TemplateArgs,
3571 FunctionParam->getLocation(),
3572 FunctionParam->getDeclName());
3573 if (T.isNull())
3574 return true;
3575 FunctionParam->setType(T);
3576 }
3577
Richard Smithf623c962012-04-17 00:58:00 +00003578 Scope.InstantiatedLocalPackArg(PatternParam, FunctionParam);
3579 ++FParamIdx;
3580 }
3581 }
Richard Smithf623c962012-04-17 00:58:00 +00003582
Richard Smith2e321552014-11-12 02:00:47 +00003583 return false;
Richard Smithf623c962012-04-17 00:58:00 +00003584}
3585
3586void Sema::InstantiateExceptionSpec(SourceLocation PointOfInstantiation,
3587 FunctionDecl *Decl) {
Richard Smithd3729422012-04-19 00:08:28 +00003588 const FunctionProtoType *Proto = Decl->getType()->castAs<FunctionProtoType>();
3589 if (Proto->getExceptionSpecType() != EST_Uninstantiated)
Richard Smithf623c962012-04-17 00:58:00 +00003590 return;
3591
3592 InstantiatingTemplate Inst(*this, PointOfInstantiation, Decl,
3593 InstantiatingTemplate::ExceptionSpecification());
Alp Tokerd4a72d52013-10-08 08:09:04 +00003594 if (Inst.isInvalid()) {
Richard Smithd3b5c9082012-07-27 04:22:15 +00003595 // We hit the instantiation depth limit. Clear the exception specification
3596 // so that our callers don't have to cope with EST_Uninstantiated.
Richard Smith8acb4282014-07-31 21:57:55 +00003597 UpdateExceptionSpec(Decl, EST_None);
Richard Smithf623c962012-04-17 00:58:00 +00003598 return;
Richard Smithd3b5c9082012-07-27 04:22:15 +00003599 }
Richard Smith54f18e82016-08-31 02:15:21 +00003600 if (Inst.isAlreadyInstantiating()) {
3601 // This exception specification indirectly depends on itself. Reject.
3602 // FIXME: Corresponding rule in the standard?
3603 Diag(PointOfInstantiation, diag::err_exception_spec_cycle) << Decl;
3604 UpdateExceptionSpec(Decl, EST_None);
3605 return;
3606 }
Richard Smithf623c962012-04-17 00:58:00 +00003607
3608 // Enter the scope of this instantiation. We don't use
3609 // PushDeclContext because we don't have a scope.
3610 Sema::ContextRAII savedContext(*this, Decl);
3611 LocalInstantiationScope Scope(*this);
3612
3613 MultiLevelTemplateArgumentList TemplateArgs =
Craig Topperc3ec1492014-05-26 06:22:03 +00003614 getTemplateInstantiationArgs(Decl, nullptr, /*RelativeToPrimary*/true);
Richard Smithf623c962012-04-17 00:58:00 +00003615
Richard Smithd3729422012-04-19 00:08:28 +00003616 FunctionDecl *Template = Proto->getExceptionSpecTemplate();
Richard Smith2e321552014-11-12 02:00:47 +00003617 if (addInstantiatedParametersToScope(*this, Decl, Template, Scope,
3618 TemplateArgs)) {
3619 UpdateExceptionSpec(Decl, EST_None);
3620 return;
3621 }
Richard Smithf623c962012-04-17 00:58:00 +00003622
Richard Smith2e321552014-11-12 02:00:47 +00003623 SubstExceptionSpec(Decl, Template->getType()->castAs<FunctionProtoType>(),
3624 TemplateArgs);
Richard Smithf623c962012-04-17 00:58:00 +00003625}
3626
Mike Stump11289f42009-09-09 15:08:12 +00003627/// \brief Initializes the common fields of an instantiation function
Douglas Gregorad3f2fc2009-06-25 22:08:12 +00003628/// declaration (New) from the corresponding fields of its template (Tmpl).
3629///
3630/// \returns true if there was an error
Mike Stump11289f42009-09-09 15:08:12 +00003631bool
3632TemplateDeclInstantiator::InitFunctionInstantiation(FunctionDecl *New,
Douglas Gregorad3f2fc2009-06-25 22:08:12 +00003633 FunctionDecl *Tmpl) {
David Blaikie5a0956e2012-07-16 18:50:45 +00003634 if (Tmpl->isDeleted())
Alexis Hunt4a8ea102011-05-06 20:44:56 +00003635 New->setDeletedAsWritten();
Mike Stump11289f42009-09-09 15:08:12 +00003636
Richard Smith32918772017-02-14 00:25:28 +00003637 New->setImplicit(Tmpl->isImplicit());
3638
David Majnemerdbc0c8f2013-12-04 09:01:55 +00003639 // Forward the mangling number from the template to the instantiated decl.
3640 SemaRef.Context.setManglingNumber(New,
3641 SemaRef.Context.getManglingNumber(Tmpl));
3642
Douglas Gregorff6cbdf2009-07-01 22:01:06 +00003643 // If we are performing substituting explicitly-specified template arguments
3644 // or deduced template arguments into a function template and we reach this
3645 // point, we are now past the point where SFINAE applies and have committed
Mike Stump11289f42009-09-09 15:08:12 +00003646 // to keeping the new function template specialization. We therefore
3647 // convert the active template instantiation for the function template
Douglas Gregorff6cbdf2009-07-01 22:01:06 +00003648 // into a template instantiation for this specific function template
3649 // specialization, which is not a SFINAE context, so that we diagnose any
3650 // further errors in the declaration itself.
Richard Smith696e3122017-02-23 01:43:54 +00003651 typedef Sema::CodeSynthesisContext ActiveInstType;
3652 ActiveInstType &ActiveInst = SemaRef.CodeSynthesisContexts.back();
Douglas Gregorff6cbdf2009-07-01 22:01:06 +00003653 if (ActiveInst.Kind == ActiveInstType::ExplicitTemplateArgumentSubstitution ||
3654 ActiveInst.Kind == ActiveInstType::DeducedTemplateArgumentSubstitution) {
Mike Stump11289f42009-09-09 15:08:12 +00003655 if (FunctionTemplateDecl *FunTmpl
Nick Lewyckycc8990f2012-11-16 08:40:59 +00003656 = dyn_cast<FunctionTemplateDecl>(ActiveInst.Entity)) {
Mike Stump11289f42009-09-09 15:08:12 +00003657 assert(FunTmpl->getTemplatedDecl() == Tmpl &&
Douglas Gregorff6cbdf2009-07-01 22:01:06 +00003658 "Deduction from the wrong function template?");
Daniel Dunbar54c59642009-07-16 22:10:11 +00003659 (void) FunTmpl;
Douglas Gregorff6cbdf2009-07-01 22:01:06 +00003660 ActiveInst.Kind = ActiveInstType::TemplateInstantiation;
Nick Lewyckycc8990f2012-11-16 08:40:59 +00003661 ActiveInst.Entity = New;
Douglas Gregorff6cbdf2009-07-01 22:01:06 +00003662 }
3663 }
Mike Stump11289f42009-09-09 15:08:12 +00003664
Douglas Gregor049bdca2009-12-08 17:45:32 +00003665 const FunctionProtoType *Proto = Tmpl->getType()->getAs<FunctionProtoType>();
3666 assert(Proto && "Function template without prototype?");
3667
Sebastian Redlfa453cf2011-03-12 11:50:43 +00003668 if (Proto->hasExceptionSpec() || Proto->getNoReturnAttr()) {
John McCalldb40c7f2010-12-14 08:05:40 +00003669 FunctionProtoType::ExtProtoInfo EPI = Proto->getExtProtoInfo();
John McCalldb40c7f2010-12-14 08:05:40 +00003670
Richard Smithf623c962012-04-17 00:58:00 +00003671 // DR1330: In C++11, defer instantiation of a non-trivial
3672 // exception specification.
Serge Pavlov3739f5e72015-06-29 17:50:19 +00003673 // DR1484: Local classes and their members are instantiated along with the
3674 // containing function.
Richard Smith2bf7fdb2013-01-02 11:42:31 +00003675 if (SemaRef.getLangOpts().CPlusPlus11 &&
Richard Smith8acb4282014-07-31 21:57:55 +00003676 EPI.ExceptionSpec.Type != EST_None &&
3677 EPI.ExceptionSpec.Type != EST_DynamicNone &&
Serge Pavlov3739f5e72015-06-29 17:50:19 +00003678 EPI.ExceptionSpec.Type != EST_BasicNoexcept &&
Serge Pavlov73c6a242015-08-23 10:22:28 +00003679 !Tmpl->isLexicallyWithinFunctionOrMethod()) {
Richard Smithd3729422012-04-19 00:08:28 +00003680 FunctionDecl *ExceptionSpecTemplate = Tmpl;
Richard Smith8acb4282014-07-31 21:57:55 +00003681 if (EPI.ExceptionSpec.Type == EST_Uninstantiated)
3682 ExceptionSpecTemplate = EPI.ExceptionSpec.SourceTemplate;
Richard Smith185be182013-04-10 05:48:59 +00003683 ExceptionSpecificationType NewEST = EST_Uninstantiated;
Richard Smith8acb4282014-07-31 21:57:55 +00003684 if (EPI.ExceptionSpec.Type == EST_Unevaluated)
Richard Smith185be182013-04-10 05:48:59 +00003685 NewEST = EST_Unevaluated;
Richard Smithd3729422012-04-19 00:08:28 +00003686
Richard Smithf623c962012-04-17 00:58:00 +00003687 // Mark the function has having an uninstantiated exception specification.
3688 const FunctionProtoType *NewProto
3689 = New->getType()->getAs<FunctionProtoType>();
3690 assert(NewProto && "Template instantiation without function prototype?");
3691 EPI = NewProto->getExtProtoInfo();
Richard Smith8acb4282014-07-31 21:57:55 +00003692 EPI.ExceptionSpec.Type = NewEST;
3693 EPI.ExceptionSpec.SourceDecl = New;
3694 EPI.ExceptionSpec.SourceTemplate = ExceptionSpecTemplate;
Reid Kleckner896b32f2013-06-10 20:51:09 +00003695 New->setType(SemaRef.Context.getFunctionType(
Alp Toker314cc812014-01-25 16:55:45 +00003696 NewProto->getReturnType(), NewProto->getParamTypes(), EPI));
Richard Smithf623c962012-04-17 00:58:00 +00003697 } else {
Faisal Vali40fd4ce2017-05-09 04:17:15 +00003698 Sema::ContextRAII SwitchContext(SemaRef, New);
Richard Smith2e321552014-11-12 02:00:47 +00003699 SemaRef.SubstExceptionSpec(New, Proto, TemplateArgs);
Richard Smithf623c962012-04-17 00:58:00 +00003700 }
Douglas Gregor049bdca2009-12-08 17:45:32 +00003701 }
3702
Rafael Espindolaba195cf2011-07-06 15:46:09 +00003703 // Get the definition. Leaves the variable unchanged if undefined.
Richard Smithf623c962012-04-17 00:58:00 +00003704 const FunctionDecl *Definition = Tmpl;
Rafael Espindolaba195cf2011-07-06 15:46:09 +00003705 Tmpl->isDefined(Definition);
3706
DeLesley Hutchins30398dd2012-01-20 22:50:54 +00003707 SemaRef.InstantiateAttrs(TemplateArgs, Definition, New,
3708 LateAttrs, StartingScope);
Douglas Gregor08329632010-06-15 17:05:35 +00003709
Douglas Gregorad3f2fc2009-06-25 22:08:12 +00003710 return false;
3711}
3712
Douglas Gregor21342092009-03-24 00:38:23 +00003713/// \brief Initializes common fields of an instantiated method
3714/// declaration (New) from the corresponding fields of its template
3715/// (Tmpl).
3716///
3717/// \returns true if there was an error
Mike Stump11289f42009-09-09 15:08:12 +00003718bool
3719TemplateDeclInstantiator::InitMethodInstantiation(CXXMethodDecl *New,
Douglas Gregor21342092009-03-24 00:38:23 +00003720 CXXMethodDecl *Tmpl) {
Douglas Gregorad3f2fc2009-06-25 22:08:12 +00003721 if (InitFunctionInstantiation(New, Tmpl))
3722 return true;
Mike Stump11289f42009-09-09 15:08:12 +00003723
Douglas Gregor21342092009-03-24 00:38:23 +00003724 New->setAccess(Tmpl->getAccess());
Fariborz Jahanian6dfc1972009-12-03 18:44:40 +00003725 if (Tmpl->isVirtualAsWritten())
Douglas Gregor11c024b2010-09-28 20:50:54 +00003726 New->setVirtualAsWritten(true);
Douglas Gregor21342092009-03-24 00:38:23 +00003727
Douglas Gregor21342092009-03-24 00:38:23 +00003728 // FIXME: New needs a pointer to Tmpl
3729 return false;
3730}
Douglas Gregorbbbb02d2009-05-13 20:28:22 +00003731
Reid Kleckner61195e12017-01-05 01:08:22 +00003732/// In the MS ABI, we need to instantiate default arguments of dllexported
3733/// default constructors along with the constructor definition. This allows IR
3734/// gen to emit a constructor closure which calls the default constructor with
3735/// its default arguments.
3736static void InstantiateDefaultCtorDefaultArgs(Sema &S,
3737 CXXConstructorDecl *Ctor) {
3738 assert(S.Context.getTargetInfo().getCXXABI().isMicrosoft() &&
3739 Ctor->isDefaultConstructor());
3740 unsigned NumParams = Ctor->getNumParams();
3741 if (NumParams == 0)
3742 return;
3743 DLLExportAttr *Attr = Ctor->getAttr<DLLExportAttr>();
3744 if (!Attr)
3745 return;
3746 for (unsigned I = 0; I != NumParams; ++I) {
3747 (void)S.CheckCXXDefaultArgExpr(Attr->getLocation(), Ctor,
3748 Ctor->getParamDecl(I));
3749 S.DiscardCleanupsInEvaluationContext();
3750 }
3751}
3752
Douglas Gregorbbbb02d2009-05-13 20:28:22 +00003753/// \brief Instantiate the definition of the given function from its
3754/// template.
3755///
Douglas Gregordda7ced2009-06-30 17:20:14 +00003756/// \param PointOfInstantiation the point at which the instantiation was
3757/// required. Note that this is not precisely a "point of instantiation"
3758/// for the function, but it's close.
3759///
Douglas Gregorbbbb02d2009-05-13 20:28:22 +00003760/// \param Function the already-instantiated declaration of a
Douglas Gregordda7ced2009-06-30 17:20:14 +00003761/// function template specialization or member function of a class template
3762/// specialization.
3763///
3764/// \param Recursive if true, recursively instantiates any functions that
3765/// are required by this instantiation.
Douglas Gregora8b89d22009-10-15 14:05:49 +00003766///
3767/// \param DefinitionRequired if true, then we are performing an explicit
3768/// instantiation where the body of the function is required. Complain if
3769/// there is no such body.
Douglas Gregor85673582009-05-18 17:01:57 +00003770void Sema::InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
Douglas Gregordda7ced2009-06-30 17:20:14 +00003771 FunctionDecl *Function,
Douglas Gregora8b89d22009-10-15 14:05:49 +00003772 bool Recursive,
Serge Pavlov7dcc97e2016-04-19 06:19:52 +00003773 bool DefinitionRequired,
3774 bool AtEndOfTU) {
Richard Smithcb189572017-10-28 01:15:00 +00003775 if (Function->isInvalidDecl() || Function->isDefined() ||
3776 isa<CXXDeductionGuideDecl>(Function))
Douglas Gregorb4850462009-05-14 23:26:13 +00003777 return;
3778
Francois Pichet00c7e6c2011-08-14 03:52:19 +00003779 // Never instantiate an explicit specialization except if it is a class scope
3780 // explicit specialization.
Vassil Vassilevb21ee082016-08-18 22:01:25 +00003781 TemplateSpecializationKind TSK = Function->getTemplateSpecializationKind();
3782 if (TSK == TSK_ExplicitSpecialization &&
Francois Pichet00c7e6c2011-08-14 03:52:19 +00003783 !Function->getClassScopeSpecializationPattern())
Douglas Gregor86d142a2009-10-08 07:24:58 +00003784 return;
Douglas Gregor69f6a362010-05-17 17:34:56 +00003785
Douglas Gregor24c332b2009-05-14 21:06:31 +00003786 // Find the function body that we'll be substituting.
Douglas Gregorafca3b42009-10-27 20:53:28 +00003787 const FunctionDecl *PatternDecl = Function->getTemplateInstantiationPattern();
Alexis Hunt23f6b832011-05-27 20:00:14 +00003788 assert(PatternDecl && "instantiating a non-template");
3789
Richard Smith6f4e2e02016-08-23 19:41:39 +00003790 const FunctionDecl *PatternDef = PatternDecl->getDefinition();
Richard Smith3f6865a82016-08-23 21:12:54 +00003791 Stmt *Pattern = nullptr;
3792 if (PatternDef) {
3793 Pattern = PatternDef->getBody(PatternDef);
Richard Smith6f4e2e02016-08-23 19:41:39 +00003794 PatternDecl = PatternDef;
Richard Smith6c7161162017-08-12 01:46:03 +00003795 if (PatternDef->willHaveBody())
3796 PatternDef = nullptr;
Richard Smith3f6865a82016-08-23 21:12:54 +00003797 }
Douglas Gregor24c332b2009-05-14 21:06:31 +00003798
Vassil Vassilevb21ee082016-08-18 22:01:25 +00003799 // FIXME: We need to track the instantiation stack in order to know which
3800 // definitions should be visible within this instantiation.
3801 if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Function,
3802 Function->getInstantiatedFromMemberFunction(),
Richard Smith6f4e2e02016-08-23 19:41:39 +00003803 PatternDecl, PatternDef, TSK,
3804 /*Complain*/DefinitionRequired)) {
3805 if (DefinitionRequired)
3806 Function->setInvalidDecl();
3807 else if (TSK == TSK_ExplicitInstantiationDefinition) {
3808 // Try again at the end of the translation unit (at which point a
3809 // definition will be required).
3810 assert(!Recursive);
Sunil Srivastava15ed2922017-06-20 22:08:44 +00003811 Function->setInstantiationIsPending(true);
Richard Smith6f4e2e02016-08-23 19:41:39 +00003812 PendingInstantiations.push_back(
3813 std::make_pair(Function, PointOfInstantiation));
3814 } else if (TSK == TSK_ImplicitInstantiation) {
Richard Smith152bcd22017-01-28 02:56:07 +00003815 if (AtEndOfTU && !getDiagnostics().hasErrorOccurred()) {
Richard Smith6f4e2e02016-08-23 19:41:39 +00003816 Diag(PointOfInstantiation, diag::warn_func_template_missing)
3817 << Function;
3818 Diag(PatternDecl->getLocation(), diag::note_forward_template_decl);
3819 if (getLangOpts().CPlusPlus11)
3820 Diag(PointOfInstantiation, diag::note_inst_declaration_hint)
3821 << Function;
3822 }
3823 }
Vassil Vassilevb21ee082016-08-18 22:01:25 +00003824
Richard Smith6f4e2e02016-08-23 19:41:39 +00003825 return;
3826 }
Vassil Vassilevb21ee082016-08-18 22:01:25 +00003827
Francois Pichet1c229c02011-04-22 22:18:13 +00003828 // Postpone late parsed template instantiations.
Alexis Hunt23f6b832011-05-27 20:00:14 +00003829 if (PatternDecl->isLateTemplateParsed() &&
Nick Lewycky610128e2011-05-12 03:51:24 +00003830 !LateTemplateParser) {
Sunil Srivastava15ed2922017-06-20 22:08:44 +00003831 Function->setInstantiationIsPending(true);
Francois Pichet1c229c02011-04-22 22:18:13 +00003832 PendingInstantiations.push_back(
3833 std::make_pair(Function, PointOfInstantiation));
3834 return;
3835 }
3836
Nico Weberae4bb8c2014-08-15 23:21:41 +00003837 // If we're performing recursive template instantiation, create our own
3838 // queue of pending implicit instantiations that we will instantiate later,
3839 // while we're still within our own instantiation context.
3840 // This has to happen before LateTemplateParser below is called, so that
3841 // it marks vtables used in late parsed templates as used.
Richard Smith4f3e3812017-05-20 01:36:41 +00003842 GlobalEagerInstantiationScope GlobalInstantiations(*this,
3843 /*Enabled=*/Recursive);
3844 LocalEagerInstantiationScope LocalInstantiations(*this);
Nico Weberae4bb8c2014-08-15 23:21:41 +00003845
David Majnemerf0a84f22013-08-16 08:29:13 +00003846 // Call the LateTemplateParser callback if there is a need to late parse
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00003847 // a templated function definition.
Alexis Hunt23f6b832011-05-27 20:00:14 +00003848 if (!Pattern && PatternDecl->isLateTemplateParsed() &&
Francois Pichet1c229c02011-04-22 22:18:13 +00003849 LateTemplateParser) {
Richard Smithe40f2ba2013-08-07 21:41:30 +00003850 // FIXME: Optimize to allow individual templates to be deserialized.
3851 if (PatternDecl->isFromASTFile())
3852 ExternalSource->ReadLateParsedTemplates(LateParsedTemplateMap);
3853
Justin Lebar28f09c52016-10-10 16:26:08 +00003854 auto LPTIter = LateParsedTemplateMap.find(PatternDecl);
3855 assert(LPTIter != LateParsedTemplateMap.end() &&
3856 "missing LateParsedTemplate");
3857 LateTemplateParser(OpaqueParser, *LPTIter->second);
Francois Pichet1c229c02011-04-22 22:18:13 +00003858 Pattern = PatternDecl->getBody(PatternDecl);
3859 }
3860
Richard Smith6f4e2e02016-08-23 19:41:39 +00003861 // Note, we should never try to instantiate a deleted function template.
Ilya Biryukova27eca22017-12-20 14:32:38 +00003862 assert((Pattern || PatternDecl->isDefaulted() ||
3863 PatternDecl->hasSkippedBody()) &&
Richard Smith6f4e2e02016-08-23 19:41:39 +00003864 "unexpected kind of function template definition");
Douglas Gregor24c332b2009-05-14 21:06:31 +00003865
Richard Smith2a7d4812013-05-04 07:00:32 +00003866 // C++1y [temp.explicit]p10:
3867 // Except for inline functions, declarations with types deduced from their
3868 // initializer or return value, and class template specializations, other
3869 // explicit instantiation declarations have the effect of suppressing the
3870 // implicit instantiation of the entity to which they refer.
Vassil Vassilevb21ee082016-08-18 22:01:25 +00003871 if (TSK == TSK_ExplicitInstantiationDeclaration &&
Richard Smith2a7d4812013-05-04 07:00:32 +00003872 !PatternDecl->isInlined() &&
Alp Toker314cc812014-01-25 16:55:45 +00003873 !PatternDecl->getReturnType()->getContainedAutoType())
Douglas Gregor34ec2ef2009-09-04 22:48:11 +00003874 return;
Mike Stump11289f42009-09-09 15:08:12 +00003875
Richard Smith195d8ef2014-05-29 03:15:31 +00003876 if (PatternDecl->isInlined()) {
3877 // Function, and all later redeclarations of it (from imported modules,
3878 // for instance), are now implicitly inline.
3879 for (auto *D = Function->getMostRecentDecl(); /**/;
3880 D = D->getPreviousDecl()) {
3881 D->setImplicitlyInline();
3882 if (D == Function)
3883 break;
3884 }
3885 }
Richard Smithf3814ad2013-01-25 00:08:28 +00003886
Douglas Gregor85673582009-05-18 17:01:57 +00003887 InstantiatingTemplate Inst(*this, PointOfInstantiation, Function);
Richard Smith54f18e82016-08-31 02:15:21 +00003888 if (Inst.isInvalid() || Inst.isAlreadyInstantiating())
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00003889 return;
Richard Smithe19b95d2016-05-26 20:23:13 +00003890 PrettyDeclStackTraceEntry CrashInfo(*this, Function, SourceLocation(),
3891 "instantiating function definition");
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00003892
Vassil Vassilevb21ee082016-08-18 22:01:25 +00003893 // The instantiation is visible here, even if it was first declared in an
3894 // unimported module.
Richard Smith90dc5252017-06-23 01:04:34 +00003895 Function->setVisibleDespiteOwningModule();
Vassil Vassilevb21ee082016-08-18 22:01:25 +00003896
Abramo Bagnara12dcbf32011-11-18 08:08:52 +00003897 // Copy the inner loc start from the pattern.
3898 Function->setInnerLocStart(PatternDecl->getInnerLocStart());
3899
Faisal Valid143a0c2017-04-01 21:30:49 +00003900 EnterExpressionEvaluationContext EvalContext(
3901 *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
Douglas Gregor67da0d92009-05-15 17:59:04 +00003902
Douglas Gregorb4850462009-05-14 23:26:13 +00003903 // Introduce a new scope where local variable instantiations will be
Douglas Gregor7f792cf2010-01-16 22:29:39 +00003904 // recorded, unless we're actually a member function within a local
3905 // class, in which case we need to merge our results with the parent
3906 // scope (of the enclosing function).
3907 bool MergeWithParentScope = false;
3908 if (CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Function->getDeclContext()))
3909 MergeWithParentScope = Rec->isLocalClass();
3910
3911 LocalInstantiationScope Scope(*this, MergeWithParentScope);
Mike Stump11289f42009-09-09 15:08:12 +00003912
Richard Smithbd305122012-12-11 01:14:52 +00003913 if (PatternDecl->isDefaulted())
Alexis Hunt61ae8d32011-05-23 23:14:04 +00003914 SetDeclDefaulted(Function, PatternDecl->getLocation());
Richard Smithbd305122012-12-11 01:14:52 +00003915 else {
Richard Smithcc928662014-10-17 20:37:29 +00003916 MultiLevelTemplateArgumentList TemplateArgs =
3917 getTemplateInstantiationArgs(Function, nullptr, false, PatternDecl);
3918
3919 // Substitute into the qualifier; we can get a substitution failure here
3920 // through evil use of alias templates.
3921 // FIXME: Is CurContext correct for this? Should we go to the (instantiation
3922 // of the) lexical context of the pattern?
3923 SubstQualifier(*this, PatternDecl, Function, TemplateArgs);
3924
Craig Topperc3ec1492014-05-26 06:22:03 +00003925 ActOnStartOfFunctionDef(nullptr, Function);
Richard Smithbd305122012-12-11 01:14:52 +00003926
3927 // Enter the scope of this instantiation. We don't use
3928 // PushDeclContext because we don't have a scope.
3929 Sema::ContextRAII savedContext(*this, Function);
3930
Richard Smith2e321552014-11-12 02:00:47 +00003931 if (addInstantiatedParametersToScope(*this, Function, PatternDecl, Scope,
3932 TemplateArgs))
3933 return;
Richard Smithbd305122012-12-11 01:14:52 +00003934
Reid Kleckner61195e12017-01-05 01:08:22 +00003935 if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(Function)) {
3936 // If this is a constructor, instantiate the member initializers.
3937 InstantiateMemInitializers(Ctor, cast<CXXConstructorDecl>(PatternDecl),
Alexis Hunt61ae8d32011-05-23 23:14:04 +00003938 TemplateArgs);
Reid Kleckner61195e12017-01-05 01:08:22 +00003939
3940 // If this is an MS ABI dllexport default constructor, instantiate any
3941 // default arguments.
3942 if (Context.getTargetInfo().getCXXABI().isMicrosoft() &&
3943 Ctor->isDefaultConstructor()) {
3944 InstantiateDefaultCtorDefaultArgs(*this, Ctor);
3945 }
Alexis Hunt61ae8d32011-05-23 23:14:04 +00003946 }
3947
Ilya Biryukova27eca22017-12-20 14:32:38 +00003948 if (PatternDecl->hasSkippedBody()) {
3949 ActOnSkippedFunctionBody(Function);
3950 } else {
3951 // Instantiate the function body.
3952 StmtResult Body = SubstStmt(Pattern, TemplateArgs);
Alexis Hunt61ae8d32011-05-23 23:14:04 +00003953
Ilya Biryukova27eca22017-12-20 14:32:38 +00003954 if (Body.isInvalid())
3955 Function->setInvalidDecl();
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00003956
Ilya Biryukova27eca22017-12-20 14:32:38 +00003957 // FIXME: finishing the function body while in an expression evaluation
3958 // context seems wrong. Investigate more.
3959 ActOnFinishFunctionBody(Function, Body.get(),
3960 /*IsInstantiation=*/true);
3961 }
Richard Smithbd305122012-12-11 01:14:52 +00003962
3963 PerformDependentDiagnostics(PatternDecl, TemplateArgs);
3964
Richard Smithd28ac5b2014-03-22 23:33:22 +00003965 if (auto *Listener = getASTMutationListener())
3966 Listener->FunctionDefinitionInstantiated(Function);
Richard Smith0ac1b8f2014-03-22 01:43:32 +00003967
Richard Smithbd305122012-12-11 01:14:52 +00003968 savedContext.pop();
Mike Stump11289f42009-09-09 15:08:12 +00003969 }
3970
Douglas Gregor28ad4b52009-05-26 20:50:29 +00003971 DeclGroupRef DG(Function);
3972 Consumer.HandleTopLevelDecl(DG);
Mike Stump11289f42009-09-09 15:08:12 +00003973
Douglas Gregor7f792cf2010-01-16 22:29:39 +00003974 // This class may have local implicit instantiations that need to be
3975 // instantiation within this scope.
Richard Smith4f3e3812017-05-20 01:36:41 +00003976 LocalInstantiations.perform();
Douglas Gregor7f792cf2010-01-16 22:29:39 +00003977 Scope.Exit();
Richard Smith4f3e3812017-05-20 01:36:41 +00003978 GlobalInstantiations.perform();
Douglas Gregorbbbb02d2009-05-13 20:28:22 +00003979}
3980
Larisse Voufo39a1e502013-08-06 01:03:05 +00003981VarTemplateSpecializationDecl *Sema::BuildVarTemplateInstantiation(
3982 VarTemplateDecl *VarTemplate, VarDecl *FromVar,
3983 const TemplateArgumentList &TemplateArgList,
3984 const TemplateArgumentListInfo &TemplateArgsInfo,
3985 SmallVectorImpl<TemplateArgument> &Converted,
3986 SourceLocation PointOfInstantiation, void *InsertPos,
3987 LateInstantiatedAttrVec *LateAttrs,
3988 LocalInstantiationScope *StartingScope) {
3989 if (FromVar->isInvalidDecl())
Craig Topperc3ec1492014-05-26 06:22:03 +00003990 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00003991
3992 InstantiatingTemplate Inst(*this, PointOfInstantiation, FromVar);
Alp Tokerd4a72d52013-10-08 08:09:04 +00003993 if (Inst.isInvalid())
Craig Topperc3ec1492014-05-26 06:22:03 +00003994 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00003995
3996 MultiLevelTemplateArgumentList TemplateArgLists;
3997 TemplateArgLists.addOuterTemplateArguments(&TemplateArgList);
3998
Richard Smith8809a0c2013-09-27 20:14:12 +00003999 // Instantiate the first declaration of the variable template: for a partial
4000 // specialization of a static data member template, the first declaration may
4001 // or may not be the declaration in the class; if it's in the class, we want
4002 // to instantiate a member in the class (a declaration), and if it's outside,
4003 // we want to instantiate a definition.
Richard Smithbeef3452014-01-16 23:39:20 +00004004 //
4005 // If we're instantiating an explicitly-specialized member template or member
4006 // partial specialization, don't do this. The member specialization completely
4007 // replaces the original declaration in this case.
4008 bool IsMemberSpec = false;
4009 if (VarTemplatePartialSpecializationDecl *PartialSpec =
4010 dyn_cast<VarTemplatePartialSpecializationDecl>(FromVar))
4011 IsMemberSpec = PartialSpec->isMemberSpecialization();
4012 else if (VarTemplateDecl *FromTemplate = FromVar->getDescribedVarTemplate())
4013 IsMemberSpec = FromTemplate->isMemberSpecialization();
4014 if (!IsMemberSpec)
4015 FromVar = FromVar->getFirstDecl();
Richard Smith8809a0c2013-09-27 20:14:12 +00004016
Manuel Klimek5843add2013-09-30 13:29:01 +00004017 MultiLevelTemplateArgumentList MultiLevelList(TemplateArgList);
4018 TemplateDeclInstantiator Instantiator(*this, FromVar->getDeclContext(),
4019 MultiLevelList);
Larisse Voufo39a1e502013-08-06 01:03:05 +00004020
4021 // TODO: Set LateAttrs and StartingScope ...
4022
4023 return cast_or_null<VarTemplateSpecializationDecl>(
4024 Instantiator.VisitVarTemplateSpecializationDecl(
4025 VarTemplate, FromVar, InsertPos, TemplateArgsInfo, Converted));
4026}
4027
4028/// \brief Instantiates a variable template specialization by completing it
4029/// with appropriate type information and initializer.
4030VarTemplateSpecializationDecl *Sema::CompleteVarTemplateSpecializationDecl(
4031 VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl,
4032 const MultiLevelTemplateArgumentList &TemplateArgs) {
Richard Smith435e6472017-12-02 02:48:42 +00004033 assert(PatternDecl->isThisDeclarationADefinition() &&
4034 "don't have a definition to instantiate from");
Larisse Voufo39a1e502013-08-06 01:03:05 +00004035
4036 // Do substitution on the type of the declaration
4037 TypeSourceInfo *DI =
Richard Smith8809a0c2013-09-27 20:14:12 +00004038 SubstType(PatternDecl->getTypeSourceInfo(), TemplateArgs,
Larisse Voufo39a1e502013-08-06 01:03:05 +00004039 PatternDecl->getTypeSpecStartLoc(), PatternDecl->getDeclName());
4040 if (!DI)
Craig Topperc3ec1492014-05-26 06:22:03 +00004041 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00004042
4043 // Update the type of this variable template specialization.
4044 VarSpec->setType(DI->getType());
4045
Richard Smith435e6472017-12-02 02:48:42 +00004046 // Convert the declaration into a definition now.
4047 VarSpec->setCompleteDefinition();
4048
Larisse Voufo39a1e502013-08-06 01:03:05 +00004049 // Instantiate the initializer.
4050 InstantiateVariableInitializer(VarSpec, PatternDecl, TemplateArgs);
4051
4052 return VarSpec;
4053}
4054
4055/// BuildVariableInstantiation - Used after a new variable has been created.
4056/// Sets basic variable data and decides whether to postpone the
4057/// variable instantiation.
4058void Sema::BuildVariableInstantiation(
4059 VarDecl *NewVar, VarDecl *OldVar,
4060 const MultiLevelTemplateArgumentList &TemplateArgs,
Richard Smith541b38b2013-09-20 01:15:31 +00004061 LateInstantiatedAttrVec *LateAttrs, DeclContext *Owner,
4062 LocalInstantiationScope *StartingScope,
Larisse Voufo72caf2b2013-08-22 00:59:14 +00004063 bool InstantiatingVarTemplate) {
Larisse Voufo39a1e502013-08-06 01:03:05 +00004064
Richard Smith541b38b2013-09-20 01:15:31 +00004065 // If we are instantiating a local extern declaration, the
4066 // instantiation belongs lexically to the containing function.
Larisse Voufo39a1e502013-08-06 01:03:05 +00004067 // If we are instantiating a static data member defined
4068 // out-of-line, the instantiation will have the same lexical
4069 // context (which will be a namespace scope) as the template.
Richard Smith541b38b2013-09-20 01:15:31 +00004070 if (OldVar->isLocalExternDecl()) {
4071 NewVar->setLocalExternDecl();
4072 NewVar->setLexicalDeclContext(Owner);
4073 } else if (OldVar->isOutOfLine())
Larisse Voufo39a1e502013-08-06 01:03:05 +00004074 NewVar->setLexicalDeclContext(OldVar->getLexicalDeclContext());
4075 NewVar->setTSCSpec(OldVar->getTSCSpec());
4076 NewVar->setInitStyle(OldVar->getInitStyle());
4077 NewVar->setCXXForRangeDecl(OldVar->isCXXForRangeDecl());
4078 NewVar->setConstexpr(OldVar->isConstexpr());
Richard Smithbb13c9a2013-09-28 04:02:39 +00004079 NewVar->setInitCapture(OldVar->isInitCapture());
Richard Smith1c34fb72013-08-13 18:18:50 +00004080 NewVar->setPreviousDeclInSameBlockScope(
4081 OldVar->isPreviousDeclInSameBlockScope());
Larisse Voufo39a1e502013-08-06 01:03:05 +00004082 NewVar->setAccess(OldVar->getAccess());
4083
Richard Smith0b551192013-09-23 23:12:22 +00004084 if (!OldVar->isStaticDataMember()) {
Rafael Espindolae4865d22013-10-23 16:46:34 +00004085 if (OldVar->isUsed(false))
4086 NewVar->setIsUsed();
Larisse Voufo39a1e502013-08-06 01:03:05 +00004087 NewVar->setReferenced(OldVar->isReferenced());
4088 }
4089
4090 InstantiateAttrs(TemplateArgs, OldVar, NewVar, LateAttrs, StartingScope);
4091
Richard Smith541b38b2013-09-20 01:15:31 +00004092 LookupResult Previous(
4093 *this, NewVar->getDeclName(), NewVar->getLocation(),
4094 NewVar->isLocalExternDecl() ? Sema::LookupRedeclarationWithLinkage
4095 : Sema::LookupOrdinaryName,
Richard Smithbecb92d2017-10-10 22:33:17 +00004096 NewVar->isLocalExternDecl() ? Sema::ForExternalRedeclaration
4097 : forRedeclarationInCurContext());
Larisse Voufo39a1e502013-08-06 01:03:05 +00004098
Argyrios Kyrtzidis91486222013-11-27 08:34:14 +00004099 if (NewVar->isLocalExternDecl() && OldVar->getPreviousDecl() &&
4100 (!OldVar->getPreviousDecl()->getDeclContext()->isDependentContext() ||
4101 OldVar->getPreviousDecl()->getDeclContext()==OldVar->getDeclContext())) {
Richard Smith1c34fb72013-08-13 18:18:50 +00004102 // We have a previous declaration. Use that one, so we merge with the
4103 // right type.
4104 if (NamedDecl *NewPrev = FindInstantiatedDecl(
4105 NewVar->getLocation(), OldVar->getPreviousDecl(), TemplateArgs))
4106 Previous.addDecl(NewPrev);
4107 } else if (!isa<VarTemplateSpecializationDecl>(NewVar) &&
4108 OldVar->hasLinkage())
Larisse Voufo39a1e502013-08-06 01:03:05 +00004109 LookupQualifiedName(Previous, NewVar->getDeclContext(), false);
Larisse Voufo72caf2b2013-08-22 00:59:14 +00004110 CheckVariableDeclaration(NewVar, Previous);
Larisse Voufo39a1e502013-08-06 01:03:05 +00004111
Richard Smith541b38b2013-09-20 01:15:31 +00004112 if (!InstantiatingVarTemplate) {
4113 NewVar->getLexicalDeclContext()->addHiddenDecl(NewVar);
4114 if (!NewVar->isLocalExternDecl() || !NewVar->getPreviousDecl())
Larisse Voufo39a1e502013-08-06 01:03:05 +00004115 NewVar->getDeclContext()->makeDeclVisibleInContext(NewVar);
Richard Smith541b38b2013-09-20 01:15:31 +00004116 }
4117
4118 if (!OldVar->isOutOfLine()) {
Larisse Voufo39a1e502013-08-06 01:03:05 +00004119 if (NewVar->getDeclContext()->isFunctionOrMethod())
4120 CurrentInstantiationScope->InstantiatedLocal(OldVar, NewVar);
4121 }
4122
4123 // Link instantiations of static data members back to the template from
4124 // which they were instantiated.
Larisse Voufo72caf2b2013-08-22 00:59:14 +00004125 if (NewVar->isStaticDataMember() && !InstantiatingVarTemplate)
Larisse Voufo39a1e502013-08-06 01:03:05 +00004126 NewVar->setInstantiationOfStaticDataMember(OldVar,
4127 TSK_ImplicitInstantiation);
4128
David Majnemerdbc0c8f2013-12-04 09:01:55 +00004129 // Forward the mangling number from the template to the instantiated decl.
4130 Context.setManglingNumber(NewVar, Context.getManglingNumber(OldVar));
David Majnemer2206bf52014-03-05 08:57:59 +00004131 Context.setStaticLocalNumber(NewVar, Context.getStaticLocalNumber(OldVar));
David Majnemerdbc0c8f2013-12-04 09:01:55 +00004132
Richard Smith62f19e72016-06-25 00:15:56 +00004133 // Delay instantiation of the initializer for variable templates or inline
4134 // static data members until a definition of the variable is needed. We need
4135 // it right away if the type contains 'auto'.
Richard Smithd292b242014-03-16 01:00:40 +00004136 if ((!isa<VarTemplateSpecializationDecl>(NewVar) &&
Richard Smith62f19e72016-06-25 00:15:56 +00004137 !InstantiatingVarTemplate &&
4138 !(OldVar->isInline() && OldVar->isThisDeclarationADefinition())) ||
Richard Smithd292b242014-03-16 01:00:40 +00004139 NewVar->getType()->isUndeducedType())
Larisse Voufo39a1e502013-08-06 01:03:05 +00004140 InstantiateVariableInitializer(NewVar, OldVar, TemplateArgs);
4141
4142 // Diagnose unused local variables with dependent types, where the diagnostic
4143 // will have been deferred.
4144 if (!NewVar->isInvalidDecl() &&
Nico Weber72889432014-09-06 01:25:55 +00004145 NewVar->getDeclContext()->isFunctionOrMethod() &&
Larisse Voufo39a1e502013-08-06 01:03:05 +00004146 OldVar->getType()->isDependentType())
4147 DiagnoseUnusedDecl(NewVar);
4148}
4149
4150/// \brief Instantiate the initializer of a variable.
4151void Sema::InstantiateVariableInitializer(
4152 VarDecl *Var, VarDecl *OldVar,
4153 const MultiLevelTemplateArgumentList &TemplateArgs) {
Richard Smith891fc7f2017-12-05 01:31:47 +00004154 if (ASTMutationListener *L = getASTContext().getASTMutationListener())
4155 L->VariableDefinitionInstantiated(Var);
4156
Richard Smith62f19e72016-06-25 00:15:56 +00004157 // We propagate the 'inline' flag with the initializer, because it
4158 // would otherwise imply that the variable is a definition for a
4159 // non-static data member.
4160 if (OldVar->isInlineSpecified())
4161 Var->setInlineSpecified();
4162 else if (OldVar->isInline())
4163 Var->setImplicitlyInline();
Larisse Voufo39a1e502013-08-06 01:03:05 +00004164
Larisse Voufo39a1e502013-08-06 01:03:05 +00004165 if (OldVar->getInit()) {
Richard Smithc95d2c52017-09-22 04:25:05 +00004166 EnterExpressionEvaluationContext Evaluated(
4167 *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated, Var);
Larisse Voufo39a1e502013-08-06 01:03:05 +00004168
4169 // Instantiate the initializer.
Akira Hatanakab87faff2016-04-28 23:50:12 +00004170 ExprResult Init;
4171
4172 {
4173 ContextRAII SwitchContext(*this, Var->getDeclContext());
4174 Init = SubstInitializer(OldVar->getInit(), TemplateArgs,
4175 OldVar->getInitStyle() == VarDecl::CallInit);
4176 }
4177
Larisse Voufo39a1e502013-08-06 01:03:05 +00004178 if (!Init.isInvalid()) {
Hans Wennborg91ebe6e2014-06-10 00:55:51 +00004179 Expr *InitExpr = Init.get();
4180
Richard Smith95b83e92014-07-10 20:53:43 +00004181 if (Var->hasAttr<DLLImportAttr>() &&
4182 (!InitExpr ||
4183 !InitExpr->isConstantInitializer(getASTContext(), false))) {
Hans Wennborg91ebe6e2014-06-10 00:55:51 +00004184 // Do not dynamically initialize dllimport variables.
Hans Wennborg91ebe6e2014-06-10 00:55:51 +00004185 } else if (InitExpr) {
Larisse Voufo39a1e502013-08-06 01:03:05 +00004186 bool DirectInit = OldVar->isDirectInit();
Richard Smith3beb7c62017-01-12 02:27:38 +00004187 AddInitializerToDecl(Var, InitExpr, DirectInit);
Larisse Voufo39a1e502013-08-06 01:03:05 +00004188 } else
Richard Smith3beb7c62017-01-12 02:27:38 +00004189 ActOnUninitializedDecl(Var);
Larisse Voufo39a1e502013-08-06 01:03:05 +00004190 } else {
4191 // FIXME: Not too happy about invalidating the declaration
4192 // because of a bogus initializer.
4193 Var->setInvalidDecl();
4194 }
Richard Smith54f18e82016-08-31 02:15:21 +00004195 } else {
4196 if (Var->isStaticDataMember()) {
4197 if (!Var->isOutOfLine())
4198 return;
4199
4200 // If the declaration inside the class had an initializer, don't add
4201 // another one to the out-of-line definition.
4202 if (OldVar->getFirstDecl()->hasInit())
4203 return;
4204 }
4205
4206 // We'll add an initializer to a for-range declaration later.
4207 if (Var->isCXXForRangeDecl())
4208 return;
4209
Richard Smith3beb7c62017-01-12 02:27:38 +00004210 ActOnUninitializedDecl(Var);
Richard Smith54f18e82016-08-31 02:15:21 +00004211 }
Larisse Voufo39a1e502013-08-06 01:03:05 +00004212}
4213
Douglas Gregorbbbb02d2009-05-13 20:28:22 +00004214/// \brief Instantiate the definition of the given variable from its
4215/// template.
4216///
Douglas Gregora6ef8f02009-07-24 20:34:43 +00004217/// \param PointOfInstantiation the point at which the instantiation was
4218/// required. Note that this is not precisely a "point of instantiation"
Richard Smith891fc7f2017-12-05 01:31:47 +00004219/// for the variable, but it's close.
Douglas Gregora6ef8f02009-07-24 20:34:43 +00004220///
Richard Smith891fc7f2017-12-05 01:31:47 +00004221/// \param Var the already-instantiated declaration of a templated variable.
Douglas Gregora6ef8f02009-07-24 20:34:43 +00004222///
4223/// \param Recursive if true, recursively instantiates any functions that
4224/// are required by this instantiation.
Douglas Gregora8b89d22009-10-15 14:05:49 +00004225///
4226/// \param DefinitionRequired if true, then we are performing an explicit
Richard Smith891fc7f2017-12-05 01:31:47 +00004227/// instantiation where a definition of the variable is required. Complain
4228/// if there is no such definition.
Larisse Voufo39a1e502013-08-06 01:03:05 +00004229void Sema::InstantiateVariableDefinition(SourceLocation PointOfInstantiation,
4230 VarDecl *Var, bool Recursive,
Serge Pavlov7dcc97e2016-04-19 06:19:52 +00004231 bool DefinitionRequired, bool AtEndOfTU) {
Douglas Gregora6ef8f02009-07-24 20:34:43 +00004232 if (Var->isInvalidDecl())
4233 return;
Mike Stump11289f42009-09-09 15:08:12 +00004234
Larisse Voufo39a1e502013-08-06 01:03:05 +00004235 VarTemplateSpecializationDecl *VarSpec =
4236 dyn_cast<VarTemplateSpecializationDecl>(Var);
Craig Topperc3ec1492014-05-26 06:22:03 +00004237 VarDecl *PatternDecl = nullptr, *Def = nullptr;
Richard Smith8809a0c2013-09-27 20:14:12 +00004238 MultiLevelTemplateArgumentList TemplateArgs =
4239 getTemplateInstantiationArgs(Var);
Mike Stump11289f42009-09-09 15:08:12 +00004240
Larisse Voufo39a1e502013-08-06 01:03:05 +00004241 if (VarSpec) {
Richard Smith8809a0c2013-09-27 20:14:12 +00004242 // If this is a variable template specialization, make sure that it is
4243 // non-dependent, then find its instantiation pattern.
Larisse Voufo39a1e502013-08-06 01:03:05 +00004244 bool InstantiationDependent = false;
4245 assert(!TemplateSpecializationType::anyDependentTemplateArguments(
4246 VarSpec->getTemplateArgsInfo(), InstantiationDependent) &&
4247 "Only instantiate variable template specializations that are "
4248 "not type-dependent");
Larisse Voufo4154f462013-08-06 03:57:41 +00004249 (void)InstantiationDependent;
Larisse Voufo39a1e502013-08-06 01:03:05 +00004250
Richard Smith8809a0c2013-09-27 20:14:12 +00004251 // Find the variable initialization that we'll be substituting. If the
4252 // pattern was instantiated from a member template, look back further to
4253 // find the real pattern.
Larisse Voufo39a1e502013-08-06 01:03:05 +00004254 assert(VarSpec->getSpecializedTemplate() &&
4255 "Specialization without specialized template?");
4256 llvm::PointerUnion<VarTemplateDecl *,
4257 VarTemplatePartialSpecializationDecl *> PatternPtr =
4258 VarSpec->getSpecializedTemplateOrPartial();
Larisse Voufoa11bd8a2013-08-13 02:02:26 +00004259 if (PatternPtr.is<VarTemplatePartialSpecializationDecl *>()) {
Richard Smith8809a0c2013-09-27 20:14:12 +00004260 VarTemplatePartialSpecializationDecl *Tmpl =
4261 PatternPtr.get<VarTemplatePartialSpecializationDecl *>();
4262 while (VarTemplatePartialSpecializationDecl *From =
4263 Tmpl->getInstantiatedFromMember()) {
4264 if (Tmpl->isMemberSpecialization())
4265 break;
Larisse Voufoa11bd8a2013-08-13 02:02:26 +00004266
Richard Smith8809a0c2013-09-27 20:14:12 +00004267 Tmpl = From;
4268 }
4269 PatternDecl = Tmpl;
Larisse Voufoa11bd8a2013-08-13 02:02:26 +00004270 } else {
Richard Smith8809a0c2013-09-27 20:14:12 +00004271 VarTemplateDecl *Tmpl = PatternPtr.get<VarTemplateDecl *>();
4272 while (VarTemplateDecl *From =
4273 Tmpl->getInstantiatedFromMemberTemplate()) {
4274 if (Tmpl->isMemberSpecialization())
4275 break;
Larisse Voufoa11bd8a2013-08-13 02:02:26 +00004276
Richard Smith8809a0c2013-09-27 20:14:12 +00004277 Tmpl = From;
4278 }
4279 PatternDecl = Tmpl->getTemplatedDecl();
Larisse Voufoa11bd8a2013-08-13 02:02:26 +00004280 }
Richard Smith8809a0c2013-09-27 20:14:12 +00004281
4282 // If this is a static data member template, there might be an
4283 // uninstantiated initializer on the declaration. If so, instantiate
4284 // it now.
Richard Smith891fc7f2017-12-05 01:31:47 +00004285 //
4286 // FIXME: This largely duplicates what we would do below. The difference
4287 // is that along this path we may instantiate an initializer from an
4288 // in-class declaration of the template and instantiate the definition
4289 // from a separate out-of-class definition.
Richard Smith8809a0c2013-09-27 20:14:12 +00004290 if (PatternDecl->isStaticDataMember() &&
Rafael Espindola8db352d2013-10-17 15:37:26 +00004291 (PatternDecl = PatternDecl->getFirstDecl())->hasInit() &&
Richard Smith8809a0c2013-09-27 20:14:12 +00004292 !Var->hasInit()) {
4293 // FIXME: Factor out the duplicated instantiation context setup/tear down
4294 // code here.
4295 InstantiatingTemplate Inst(*this, PointOfInstantiation, Var);
Richard Smith54f18e82016-08-31 02:15:21 +00004296 if (Inst.isInvalid() || Inst.isAlreadyInstantiating())
Richard Smith8809a0c2013-09-27 20:14:12 +00004297 return;
Richard Smithe19b95d2016-05-26 20:23:13 +00004298 PrettyDeclStackTraceEntry CrashInfo(*this, Var, SourceLocation(),
4299 "instantiating variable initializer");
Richard Smith8809a0c2013-09-27 20:14:12 +00004300
Richard Smithedbc6e92016-10-14 21:41:24 +00004301 // The instantiation is visible here, even if it was first declared in an
4302 // unimported module.
Richard Smith90dc5252017-06-23 01:04:34 +00004303 Var->setVisibleDespiteOwningModule();
Richard Smithedbc6e92016-10-14 21:41:24 +00004304
Richard Smith8809a0c2013-09-27 20:14:12 +00004305 // If we're performing recursive template instantiation, create our own
4306 // queue of pending implicit instantiations that we will instantiate
4307 // later, while we're still within our own instantiation context.
Richard Smith4f3e3812017-05-20 01:36:41 +00004308 GlobalEagerInstantiationScope GlobalInstantiations(*this,
4309 /*Enabled=*/Recursive);
Richard Smith8809a0c2013-09-27 20:14:12 +00004310 LocalInstantiationScope Local(*this);
Richard Smith4f3e3812017-05-20 01:36:41 +00004311 LocalEagerInstantiationScope LocalInstantiations(*this);
Richard Smith8809a0c2013-09-27 20:14:12 +00004312
4313 // Enter the scope of this instantiation. We don't use
4314 // PushDeclContext because we don't have a scope.
4315 ContextRAII PreviousContext(*this, Var->getDeclContext());
4316 InstantiateVariableInitializer(Var, PatternDecl, TemplateArgs);
4317 PreviousContext.pop();
4318
Richard Smith8809a0c2013-09-27 20:14:12 +00004319 // This variable may have local implicit instantiations that need to be
4320 // instantiated within this scope.
Richard Smith4f3e3812017-05-20 01:36:41 +00004321 LocalInstantiations.perform();
Richard Smith8809a0c2013-09-27 20:14:12 +00004322 Local.Exit();
Richard Smith4f3e3812017-05-20 01:36:41 +00004323 GlobalInstantiations.perform();
Richard Smith8809a0c2013-09-27 20:14:12 +00004324 }
4325
4326 // Find actual definition
4327 Def = PatternDecl->getDefinition(getASTContext());
4328 } else {
4329 // If this is a static data member, find its out-of-line definition.
4330 assert(Var->isStaticDataMember() && "not a static data member?");
4331 PatternDecl = Var->getInstantiatedFromStaticDataMember();
4332
4333 assert(PatternDecl && "data member was not instantiated from a template?");
4334 assert(PatternDecl->isStaticDataMember() && "not a static data member?");
Richard Smith62f19e72016-06-25 00:15:56 +00004335 Def = PatternDecl->getDefinition();
Larisse Voufo39a1e502013-08-06 01:03:05 +00004336 }
4337
Richard Smithedbc6e92016-10-14 21:41:24 +00004338 TemplateSpecializationKind TSK = Var->getTemplateSpecializationKind();
Richard Smith6739a102016-05-05 00:56:12 +00004339
Richard Smith8809a0c2013-09-27 20:14:12 +00004340 // If we don't have a definition of the variable template, we won't perform
4341 // any instantiation. Rather, we rely on the user to instantiate this
4342 // definition (or provide a specialization for it) in another translation
4343 // unit.
Richard Smithedbc6e92016-10-14 21:41:24 +00004344 if (!Def && !DefinitionRequired) {
4345 if (TSK == TSK_ExplicitInstantiationDefinition) {
Chandler Carruth54080172010-08-25 08:44:16 +00004346 PendingInstantiations.push_back(
Chandler Carruthcfe41db2010-08-25 08:27:02 +00004347 std::make_pair(Var, PointOfInstantiation));
Richard Smithedbc6e92016-10-14 21:41:24 +00004348 } else if (TSK == TSK_ImplicitInstantiation) {
Serge Pavlov7dcc97e2016-04-19 06:19:52 +00004349 // Warn about missing definition at the end of translation unit.
4350 if (AtEndOfTU && !getDiagnostics().hasErrorOccurred()) {
4351 Diag(PointOfInstantiation, diag::warn_var_template_missing)
4352 << Var;
4353 Diag(PatternDecl->getLocation(), diag::note_forward_template_decl);
4354 if (getLangOpts().CPlusPlus11)
4355 Diag(PointOfInstantiation, diag::note_inst_declaration_hint) << Var;
4356 }
Richard Smithedbc6e92016-10-14 21:41:24 +00004357 return;
Chandler Carruthcfe41db2010-08-25 08:27:02 +00004358 }
4359
Douglas Gregora6ef8f02009-07-24 20:34:43 +00004360 }
4361
Richard Smithedbc6e92016-10-14 21:41:24 +00004362 // FIXME: We need to track the instantiation stack in order to know which
4363 // definitions should be visible within this instantiation.
4364 // FIXME: Produce diagnostics when Var->getInstantiatedFromStaticDataMember().
4365 if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Var,
4366 /*InstantiatedFromMember*/false,
4367 PatternDecl, Def, TSK,
4368 /*Complain*/DefinitionRequired))
4369 return;
4370
Rafael Espindola189fa742012-03-05 10:54:55 +00004371
Douglas Gregor86d142a2009-10-08 07:24:58 +00004372 // Never instantiate an explicit specialization.
Rafael Espindola189fa742012-03-05 10:54:55 +00004373 if (TSK == TSK_ExplicitSpecialization)
Douglas Gregor86d142a2009-10-08 07:24:58 +00004374 return;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00004375
Larisse Voufo39a1e502013-08-06 01:03:05 +00004376 // C++11 [temp.explicit]p10:
Richard Smith4309b662017-10-18 22:45:01 +00004377 // Except for inline functions, const variables of literal types, variables
4378 // of reference types, [...] explicit instantiation declarations
Larisse Voufo39a1e502013-08-06 01:03:05 +00004379 // have the effect of suppressing the implicit instantiation of the entity
4380 // to which they refer.
Richard Smith4309b662017-10-18 22:45:01 +00004381 if (TSK == TSK_ExplicitInstantiationDeclaration &&
4382 !Var->isUsableInConstantExpressions(getASTContext()))
Douglas Gregor86d142a2009-10-08 07:24:58 +00004383 return;
Mike Stump11289f42009-09-09 15:08:12 +00004384
Argyrios Kyrtzidis8a27b2b2013-02-24 00:05:01 +00004385 // Make sure to pass the instantiated variable to the consumer at the end.
4386 struct PassToConsumerRAII {
4387 ASTConsumer &Consumer;
4388 VarDecl *Var;
4389
4390 PassToConsumerRAII(ASTConsumer &Consumer, VarDecl *Var)
4391 : Consumer(Consumer), Var(Var) { }
4392
4393 ~PassToConsumerRAII() {
Richard Smith8809a0c2013-09-27 20:14:12 +00004394 Consumer.HandleCXXStaticMemberVarInstantiation(Var);
Argyrios Kyrtzidis8a27b2b2013-02-24 00:05:01 +00004395 }
4396 } PassToConsumerRAII(Consumer, Var);
Rafael Espindoladf88f6f2012-03-08 15:51:03 +00004397
Reid Klecknere07140e2015-04-15 01:08:06 +00004398 // If we already have a definition, we're done.
4399 if (VarDecl *Def = Var->getDefinition()) {
4400 // We may be explicitly instantiating something we've already implicitly
4401 // instantiated.
4402 Def->setTemplateSpecializationKind(Var->getTemplateSpecializationKind(),
4403 PointOfInstantiation);
Richard Smith8809a0c2013-09-27 20:14:12 +00004404 return;
Reid Klecknere07140e2015-04-15 01:08:06 +00004405 }
Douglas Gregor57d4f972011-06-03 03:35:07 +00004406
Douglas Gregora6ef8f02009-07-24 20:34:43 +00004407 InstantiatingTemplate Inst(*this, PointOfInstantiation, Var);
Richard Smith54f18e82016-08-31 02:15:21 +00004408 if (Inst.isInvalid() || Inst.isAlreadyInstantiating())
Douglas Gregora6ef8f02009-07-24 20:34:43 +00004409 return;
Richard Smithe19b95d2016-05-26 20:23:13 +00004410 PrettyDeclStackTraceEntry CrashInfo(*this, Var, SourceLocation(),
4411 "instantiating variable definition");
Mike Stump11289f42009-09-09 15:08:12 +00004412
Douglas Gregora6ef8f02009-07-24 20:34:43 +00004413 // If we're performing recursive template instantiation, create our own
4414 // queue of pending implicit instantiations that we will instantiate later,
4415 // while we're still within our own instantiation context.
Richard Smith4f3e3812017-05-20 01:36:41 +00004416 GlobalEagerInstantiationScope GlobalInstantiations(*this,
4417 /*Enabled=*/Recursive);
Mike Stump11289f42009-09-09 15:08:12 +00004418
Douglas Gregora6ef8f02009-07-24 20:34:43 +00004419 // Enter the scope of this instantiation. We don't use
4420 // PushDeclContext because we don't have a scope.
Larisse Voufo39a1e502013-08-06 01:03:05 +00004421 ContextRAII PreviousContext(*this, Var->getDeclContext());
Douglas Gregora86bc002012-02-16 21:36:18 +00004422 LocalInstantiationScope Local(*this);
John McCall2957e3e2011-02-14 20:37:25 +00004423
Richard Smith4f3e3812017-05-20 01:36:41 +00004424 LocalEagerInstantiationScope LocalInstantiations(*this);
4425
Larisse Voufo39a1e502013-08-06 01:03:05 +00004426 VarDecl *OldVar = Var;
Richard Smith62f19e72016-06-25 00:15:56 +00004427 if (Def->isStaticDataMember() && !Def->isOutOfLine()) {
4428 // We're instantiating an inline static data member whose definition was
4429 // provided inside the class.
Richard Smith62f19e72016-06-25 00:15:56 +00004430 InstantiateVariableInitializer(Var, Def, TemplateArgs);
4431 } else if (!VarSpec) {
Larisse Voufo39a1e502013-08-06 01:03:05 +00004432 Var = cast_or_null<VarDecl>(SubstDecl(Def, Var->getDeclContext(),
Richard Smith8809a0c2013-09-27 20:14:12 +00004433 TemplateArgs));
Richard Smith62f19e72016-06-25 00:15:56 +00004434 } else if (Var->isStaticDataMember() &&
4435 Var->getLexicalDeclContext()->isRecord()) {
Richard Smith8809a0c2013-09-27 20:14:12 +00004436 // We need to instantiate the definition of a static data member template,
4437 // and all we have is the in-class declaration of it. Instantiate a separate
4438 // declaration of the definition.
4439 TemplateDeclInstantiator Instantiator(*this, Var->getDeclContext(),
4440 TemplateArgs);
4441 Var = cast_or_null<VarDecl>(Instantiator.VisitVarTemplateSpecializationDecl(
Craig Topperc3ec1492014-05-26 06:22:03 +00004442 VarSpec->getSpecializedTemplate(), Def, nullptr,
Richard Smith8809a0c2013-09-27 20:14:12 +00004443 VarSpec->getTemplateArgsInfo(), VarSpec->getTemplateArgs().asArray()));
4444 if (Var) {
4445 llvm::PointerUnion<VarTemplateDecl *,
4446 VarTemplatePartialSpecializationDecl *> PatternPtr =
4447 VarSpec->getSpecializedTemplateOrPartial();
4448 if (VarTemplatePartialSpecializationDecl *Partial =
4449 PatternPtr.dyn_cast<VarTemplatePartialSpecializationDecl *>())
4450 cast<VarTemplateSpecializationDecl>(Var)->setInstantiationOf(
4451 Partial, &VarSpec->getTemplateInstantiationArgs());
4452
4453 // Merge the definition with the declaration.
4454 LookupResult R(*this, Var->getDeclName(), Var->getLocation(),
Richard Smithbecb92d2017-10-10 22:33:17 +00004455 LookupOrdinaryName, forRedeclarationInCurContext());
Richard Smith8809a0c2013-09-27 20:14:12 +00004456 R.addDecl(OldVar);
4457 MergeVarDecl(Var, R);
4458
4459 // Attach the initializer.
4460 InstantiateVariableInitializer(Var, Def, TemplateArgs);
4461 }
4462 } else
4463 // Complete the existing variable's definition with an appropriately
4464 // substituted type and initializer.
4465 Var = CompleteVarTemplateSpecializationDecl(VarSpec, Def, TemplateArgs);
Larisse Voufo39a1e502013-08-06 01:03:05 +00004466
4467 PreviousContext.pop();
Douglas Gregora6ef8f02009-07-24 20:34:43 +00004468
4469 if (Var) {
Larisse Voufo39a1e502013-08-06 01:03:05 +00004470 PassToConsumerRAII.Var = Var;
Richard Smith8809a0c2013-09-27 20:14:12 +00004471 Var->setTemplateSpecializationKind(OldVar->getTemplateSpecializationKind(),
4472 OldVar->getPointOfInstantiation());
Douglas Gregora6ef8f02009-07-24 20:34:43 +00004473 }
Larisse Voufo39a1e502013-08-06 01:03:05 +00004474
4475 // This variable may have local implicit instantiations that need to be
4476 // instantiated within this scope.
Richard Smith4f3e3812017-05-20 01:36:41 +00004477 LocalInstantiations.perform();
Douglas Gregora86bc002012-02-16 21:36:18 +00004478 Local.Exit();
Richard Smith4f3e3812017-05-20 01:36:41 +00004479 GlobalInstantiations.perform();
Douglas Gregorbbbb02d2009-05-13 20:28:22 +00004480}
Douglas Gregor51783312009-05-27 05:35:12 +00004481
Anders Carlsson70553942009-08-29 05:16:22 +00004482void
4483Sema::InstantiateMemInitializers(CXXConstructorDecl *New,
4484 const CXXConstructorDecl *Tmpl,
4485 const MultiLevelTemplateArgumentList &TemplateArgs) {
Mike Stump11289f42009-09-09 15:08:12 +00004486
Richard Trieu9becef62011-09-09 03:18:59 +00004487 SmallVector<CXXCtorInitializer*, 4> NewInits;
Richard Smith60f2e1e2012-09-25 00:23:05 +00004488 bool AnyErrors = Tmpl->isInvalidDecl();
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00004489
Anders Carlsson70553942009-08-29 05:16:22 +00004490 // Instantiate all the initializers.
Aaron Ballman0ad78302014-03-13 17:34:31 +00004491 for (const auto *Init : Tmpl->inits()) {
Chandler Carruthf92bd8c2010-09-03 21:54:20 +00004492 // Only instantiate written initializers, let Sema re-construct implicit
4493 // ones.
4494 if (!Init->isWritten())
4495 continue;
4496
Douglas Gregor44e7df62011-01-04 00:32:56 +00004497 SourceLocation EllipsisLoc;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00004498
Douglas Gregor44e7df62011-01-04 00:32:56 +00004499 if (Init->isPackExpansion()) {
4500 // This is a pack expansion. We should expand it now.
Douglas Gregord73f3dd2011-11-01 01:16:03 +00004501 TypeLoc BaseTL = Init->getTypeSourceInfo()->getTypeLoc();
Nick Lewycky2c308502013-06-13 00:45:47 +00004502 SmallVector<UnexpandedParameterPack, 4> Unexpanded;
Douglas Gregor44e7df62011-01-04 00:32:56 +00004503 collectUnexpandedParameterPacks(BaseTL, Unexpanded);
Nick Lewycky2c308502013-06-13 00:45:47 +00004504 collectUnexpandedParameterPacks(Init->getInit(), Unexpanded);
Douglas Gregor44e7df62011-01-04 00:32:56 +00004505 bool ShouldExpand = false;
Douglas Gregora8bac7f2011-01-10 07:32:04 +00004506 bool RetainExpansion = false;
David Blaikie05785d12013-02-20 22:23:23 +00004507 Optional<unsigned> NumExpansions;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00004508 if (CheckParameterPacksForExpansion(Init->getEllipsisLoc(),
Douglas Gregor44e7df62011-01-04 00:32:56 +00004509 BaseTL.getSourceRange(),
David Blaikieb9c168a2011-09-22 02:34:54 +00004510 Unexpanded,
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00004511 TemplateArgs, ShouldExpand,
Douglas Gregora8bac7f2011-01-10 07:32:04 +00004512 RetainExpansion,
Douglas Gregor44e7df62011-01-04 00:32:56 +00004513 NumExpansions)) {
4514 AnyErrors = true;
4515 New->setInvalidDecl();
4516 continue;
4517 }
4518 assert(ShouldExpand && "Partial instantiation of base initializer?");
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00004519
4520 // Loop over all of the arguments in the argument pack(s),
Douglas Gregor0dca5fd2011-01-14 17:04:44 +00004521 for (unsigned I = 0; I != *NumExpansions; ++I) {
Douglas Gregor44e7df62011-01-04 00:32:56 +00004522 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, I);
4523
4524 // Instantiate the initializer.
Sebastian Redla9351792012-02-11 23:51:47 +00004525 ExprResult TempInit = SubstInitializer(Init->getInit(), TemplateArgs,
4526 /*CXXDirectInit=*/true);
4527 if (TempInit.isInvalid()) {
Douglas Gregor44e7df62011-01-04 00:32:56 +00004528 AnyErrors = true;
4529 break;
4530 }
4531
4532 // Instantiate the base type.
Douglas Gregord73f3dd2011-11-01 01:16:03 +00004533 TypeSourceInfo *BaseTInfo = SubstType(Init->getTypeSourceInfo(),
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00004534 TemplateArgs,
4535 Init->getSourceLocation(),
Douglas Gregor44e7df62011-01-04 00:32:56 +00004536 New->getDeclName());
4537 if (!BaseTInfo) {
4538 AnyErrors = true;
4539 break;
4540 }
4541
4542 // Build the initializer.
Sebastian Redla74948d2011-09-24 17:48:25 +00004543 MemInitResult NewInit = BuildBaseInitializer(BaseTInfo->getType(),
Nikola Smiljanic01a75982014-05-29 10:55:11 +00004544 BaseTInfo, TempInit.get(),
Douglas Gregor44e7df62011-01-04 00:32:56 +00004545 New->getParent(),
4546 SourceLocation());
4547 if (NewInit.isInvalid()) {
4548 AnyErrors = true;
4549 break;
4550 }
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00004551
Douglas Gregor44e7df62011-01-04 00:32:56 +00004552 NewInits.push_back(NewInit.get());
Douglas Gregor44e7df62011-01-04 00:32:56 +00004553 }
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00004554
Douglas Gregor44e7df62011-01-04 00:32:56 +00004555 continue;
4556 }
4557
Douglas Gregorb30f22b2010-03-02 07:38:39 +00004558 // Instantiate the initializer.
Sebastian Redla9351792012-02-11 23:51:47 +00004559 ExprResult TempInit = SubstInitializer(Init->getInit(), TemplateArgs,
4560 /*CXXDirectInit=*/true);
4561 if (TempInit.isInvalid()) {
Douglas Gregorb30f22b2010-03-02 07:38:39 +00004562 AnyErrors = true;
4563 continue;
Anders Carlsson70553942009-08-29 05:16:22 +00004564 }
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00004565
Anders Carlsson70553942009-08-29 05:16:22 +00004566 MemInitResult NewInit;
Douglas Gregord73f3dd2011-11-01 01:16:03 +00004567 if (Init->isDelegatingInitializer() || Init->isBaseInitializer()) {
4568 TypeSourceInfo *TInfo = SubstType(Init->getTypeSourceInfo(),
4569 TemplateArgs,
4570 Init->getSourceLocation(),
4571 New->getDeclName());
4572 if (!TInfo) {
Douglas Gregor7ae2d772010-01-31 09:12:51 +00004573 AnyErrors = true;
Douglas Gregorc8c44b5d2009-12-02 22:36:29 +00004574 New->setInvalidDecl();
4575 continue;
4576 }
Sebastian Redla74948d2011-09-24 17:48:25 +00004577
Douglas Gregord73f3dd2011-11-01 01:16:03 +00004578 if (Init->isBaseInitializer())
Nikola Smiljanic01a75982014-05-29 10:55:11 +00004579 NewInit = BuildBaseInitializer(TInfo->getType(), TInfo, TempInit.get(),
Douglas Gregord73f3dd2011-11-01 01:16:03 +00004580 New->getParent(), EllipsisLoc);
4581 else
Nikola Smiljanic01a75982014-05-29 10:55:11 +00004582 NewInit = BuildDelegatingInitializer(TInfo, TempInit.get(),
Douglas Gregord73f3dd2011-11-01 01:16:03 +00004583 cast<CXXRecordDecl>(CurContext->getParent()));
Anders Carlsson70553942009-08-29 05:16:22 +00004584 } else if (Init->isMemberInitializer()) {
Douglas Gregor55e6b312011-03-04 19:46:35 +00004585 FieldDecl *Member = cast_or_null<FieldDecl>(FindInstantiatedDecl(
Francois Pichetd583da02010-12-04 09:14:42 +00004586 Init->getMemberLocation(),
4587 Init->getMember(),
4588 TemplateArgs));
Douglas Gregor55e6b312011-03-04 19:46:35 +00004589 if (!Member) {
4590 AnyErrors = true;
4591 New->setInvalidDecl();
4592 continue;
4593 }
Mike Stump11289f42009-09-09 15:08:12 +00004594
Nikola Smiljanic01a75982014-05-29 10:55:11 +00004595 NewInit = BuildMemberInitializer(Member, TempInit.get(),
Sebastian Redla74948d2011-09-24 17:48:25 +00004596 Init->getSourceLocation());
Francois Pichetd583da02010-12-04 09:14:42 +00004597 } else if (Init->isIndirectMemberInitializer()) {
4598 IndirectFieldDecl *IndirectMember =
Douglas Gregor55e6b312011-03-04 19:46:35 +00004599 cast_or_null<IndirectFieldDecl>(FindInstantiatedDecl(
Francois Pichetd583da02010-12-04 09:14:42 +00004600 Init->getMemberLocation(),
4601 Init->getIndirectMember(), TemplateArgs));
4602
Douglas Gregor55e6b312011-03-04 19:46:35 +00004603 if (!IndirectMember) {
4604 AnyErrors = true;
4605 New->setInvalidDecl();
Sebastian Redla74948d2011-09-24 17:48:25 +00004606 continue;
Douglas Gregor55e6b312011-03-04 19:46:35 +00004607 }
Sebastian Redla74948d2011-09-24 17:48:25 +00004608
Nikola Smiljanic01a75982014-05-29 10:55:11 +00004609 NewInit = BuildMemberInitializer(IndirectMember, TempInit.get(),
Sebastian Redla74948d2011-09-24 17:48:25 +00004610 Init->getSourceLocation());
Anders Carlsson70553942009-08-29 05:16:22 +00004611 }
4612
Douglas Gregor7ae2d772010-01-31 09:12:51 +00004613 if (NewInit.isInvalid()) {
4614 AnyErrors = true;
Anders Carlsson70553942009-08-29 05:16:22 +00004615 New->setInvalidDecl();
Douglas Gregor7ae2d772010-01-31 09:12:51 +00004616 } else {
Richard Trieu9becef62011-09-09 03:18:59 +00004617 NewInits.push_back(NewInit.get());
Anders Carlsson70553942009-08-29 05:16:22 +00004618 }
4619 }
Mike Stump11289f42009-09-09 15:08:12 +00004620
Anders Carlsson70553942009-08-29 05:16:22 +00004621 // Assign all the initializers to the new constructor.
John McCall48871652010-08-21 09:40:31 +00004622 ActOnMemInitializers(New,
Anders Carlsson70553942009-08-29 05:16:22 +00004623 /*FIXME: ColonLoc */
4624 SourceLocation(),
David Blaikie3fc2f912013-01-17 05:26:25 +00004625 NewInits,
Douglas Gregor7ae2d772010-01-31 09:12:51 +00004626 AnyErrors);
Anders Carlsson70553942009-08-29 05:16:22 +00004627}
4628
John McCall59660882009-08-29 08:11:13 +00004629// TODO: this could be templated if the various decl types used the
4630// same method name.
4631static bool isInstantiationOf(ClassTemplateDecl *Pattern,
4632 ClassTemplateDecl *Instance) {
4633 Pattern = Pattern->getCanonicalDecl();
4634
4635 do {
4636 Instance = Instance->getCanonicalDecl();
4637 if (Pattern == Instance) return true;
4638 Instance = Instance->getInstantiatedFromMemberTemplate();
4639 } while (Instance);
4640
4641 return false;
4642}
4643
Douglas Gregor14d1bf42009-09-28 06:34:35 +00004644static bool isInstantiationOf(FunctionTemplateDecl *Pattern,
4645 FunctionTemplateDecl *Instance) {
4646 Pattern = Pattern->getCanonicalDecl();
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00004647
Douglas Gregor14d1bf42009-09-28 06:34:35 +00004648 do {
4649 Instance = Instance->getCanonicalDecl();
4650 if (Pattern == Instance) return true;
4651 Instance = Instance->getInstantiatedFromMemberTemplate();
4652 } while (Instance);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00004653
Douglas Gregor14d1bf42009-09-28 06:34:35 +00004654 return false;
4655}
4656
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00004657static bool
Douglas Gregor21610382009-10-29 00:04:11 +00004658isInstantiationOf(ClassTemplatePartialSpecializationDecl *Pattern,
4659 ClassTemplatePartialSpecializationDecl *Instance) {
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00004660 Pattern
Douglas Gregor21610382009-10-29 00:04:11 +00004661 = cast<ClassTemplatePartialSpecializationDecl>(Pattern->getCanonicalDecl());
4662 do {
4663 Instance = cast<ClassTemplatePartialSpecializationDecl>(
4664 Instance->getCanonicalDecl());
4665 if (Pattern == Instance)
4666 return true;
4667 Instance = Instance->getInstantiatedFromMember();
4668 } while (Instance);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00004669
Douglas Gregor21610382009-10-29 00:04:11 +00004670 return false;
4671}
4672
John McCall59660882009-08-29 08:11:13 +00004673static bool isInstantiationOf(CXXRecordDecl *Pattern,
4674 CXXRecordDecl *Instance) {
4675 Pattern = Pattern->getCanonicalDecl();
4676
4677 do {
4678 Instance = Instance->getCanonicalDecl();
4679 if (Pattern == Instance) return true;
4680 Instance = Instance->getInstantiatedFromMemberClass();
4681 } while (Instance);
4682
4683 return false;
4684}
4685
4686static bool isInstantiationOf(FunctionDecl *Pattern,
4687 FunctionDecl *Instance) {
4688 Pattern = Pattern->getCanonicalDecl();
4689
4690 do {
4691 Instance = Instance->getCanonicalDecl();
4692 if (Pattern == Instance) return true;
4693 Instance = Instance->getInstantiatedFromMemberFunction();
4694 } while (Instance);
4695
4696 return false;
4697}
4698
4699static bool isInstantiationOf(EnumDecl *Pattern,
4700 EnumDecl *Instance) {
4701 Pattern = Pattern->getCanonicalDecl();
4702
4703 do {
4704 Instance = Instance->getCanonicalDecl();
4705 if (Pattern == Instance) return true;
4706 Instance = Instance->getInstantiatedFromMemberEnum();
4707 } while (Instance);
4708
4709 return false;
4710}
4711
John McCallb96ec562009-12-04 22:46:56 +00004712static bool isInstantiationOf(UsingShadowDecl *Pattern,
4713 UsingShadowDecl *Instance,
4714 ASTContext &C) {
Richard Smith32952e12014-10-14 02:00:47 +00004715 return declaresSameEntity(C.getInstantiatedFromUsingShadowDecl(Instance),
4716 Pattern);
John McCallb96ec562009-12-04 22:46:56 +00004717}
4718
Richard Smith151c4562016-12-20 21:35:28 +00004719static bool isInstantiationOf(UsingDecl *Pattern, UsingDecl *Instance,
John McCallb96ec562009-12-04 22:46:56 +00004720 ASTContext &C) {
Richard Smith32952e12014-10-14 02:00:47 +00004721 return declaresSameEntity(C.getInstantiatedFromUsingDecl(Instance), Pattern);
John McCallb96ec562009-12-04 22:46:56 +00004722}
4723
Richard Smith151c4562016-12-20 21:35:28 +00004724template<typename T>
4725static bool isInstantiationOfUnresolvedUsingDecl(T *Pattern, Decl *Other,
4726 ASTContext &Ctx) {
4727 // An unresolved using declaration can instantiate to an unresolved using
4728 // declaration, or to a using declaration or a using declaration pack.
4729 //
4730 // Multiple declarations can claim to be instantiated from an unresolved
4731 // using declaration if it's a pack expansion. We want the UsingPackDecl
4732 // in that case, not the individual UsingDecls within the pack.
4733 bool OtherIsPackExpansion;
4734 NamedDecl *OtherFrom;
4735 if (auto *OtherUUD = dyn_cast<T>(Other)) {
4736 OtherIsPackExpansion = OtherUUD->isPackExpansion();
4737 OtherFrom = Ctx.getInstantiatedFromUsingDecl(OtherUUD);
4738 } else if (auto *OtherUPD = dyn_cast<UsingPackDecl>(Other)) {
4739 OtherIsPackExpansion = true;
4740 OtherFrom = OtherUPD->getInstantiatedFromUsingDecl();
4741 } else if (auto *OtherUD = dyn_cast<UsingDecl>(Other)) {
4742 OtherIsPackExpansion = false;
4743 OtherFrom = Ctx.getInstantiatedFromUsingDecl(OtherUD);
4744 } else {
4745 return false;
4746 }
4747 return Pattern->isPackExpansion() == OtherIsPackExpansion &&
4748 declaresSameEntity(OtherFrom, Pattern);
Anders Carlsson4bb87ce2009-08-29 19:37:28 +00004749}
4750
John McCall59660882009-08-29 08:11:13 +00004751static bool isInstantiationOfStaticDataMember(VarDecl *Pattern,
4752 VarDecl *Instance) {
4753 assert(Instance->isStaticDataMember());
4754
4755 Pattern = Pattern->getCanonicalDecl();
4756
4757 do {
4758 Instance = Instance->getCanonicalDecl();
4759 if (Pattern == Instance) return true;
4760 Instance = Instance->getInstantiatedFromStaticDataMember();
4761 } while (Instance);
4762
4763 return false;
4764}
4765
John McCallb96ec562009-12-04 22:46:56 +00004766// Other is the prospective instantiation
4767// D is the prospective pattern
Douglas Gregor51783312009-05-27 05:35:12 +00004768static bool isInstantiationOf(ASTContext &Ctx, NamedDecl *D, Decl *Other) {
Richard Smith151c4562016-12-20 21:35:28 +00004769 if (auto *UUD = dyn_cast<UnresolvedUsingTypenameDecl>(D))
4770 return isInstantiationOfUnresolvedUsingDecl(UUD, Other, Ctx);
John McCalle61f2ba2009-11-18 02:36:19 +00004771
Richard Smith151c4562016-12-20 21:35:28 +00004772 if (auto *UUD = dyn_cast<UnresolvedUsingValueDecl>(D))
4773 return isInstantiationOfUnresolvedUsingDecl(UUD, Other, Ctx);
Douglas Gregor51783312009-05-27 05:35:12 +00004774
Richard Smith151c4562016-12-20 21:35:28 +00004775 if (D->getKind() != Other->getKind())
Anders Carlsson4bb87ce2009-08-29 19:37:28 +00004776 return false;
Mike Stump11289f42009-09-09 15:08:12 +00004777
Richard Smithd8a9e372016-12-18 21:39:37 +00004778 if (auto *Record = dyn_cast<CXXRecordDecl>(Other))
John McCall59660882009-08-29 08:11:13 +00004779 return isInstantiationOf(cast<CXXRecordDecl>(D), Record);
Mike Stump11289f42009-09-09 15:08:12 +00004780
Richard Smithd8a9e372016-12-18 21:39:37 +00004781 if (auto *Function = dyn_cast<FunctionDecl>(Other))
John McCall59660882009-08-29 08:11:13 +00004782 return isInstantiationOf(cast<FunctionDecl>(D), Function);
Douglas Gregor51783312009-05-27 05:35:12 +00004783
Richard Smithd8a9e372016-12-18 21:39:37 +00004784 if (auto *Enum = dyn_cast<EnumDecl>(Other))
John McCall59660882009-08-29 08:11:13 +00004785 return isInstantiationOf(cast<EnumDecl>(D), Enum);
Douglas Gregor51783312009-05-27 05:35:12 +00004786
Richard Smithd8a9e372016-12-18 21:39:37 +00004787 if (auto *Var = dyn_cast<VarDecl>(Other))
John McCall59660882009-08-29 08:11:13 +00004788 if (Var->isStaticDataMember())
4789 return isInstantiationOfStaticDataMember(cast<VarDecl>(D), Var);
4790
Richard Smithd8a9e372016-12-18 21:39:37 +00004791 if (auto *Temp = dyn_cast<ClassTemplateDecl>(Other))
John McCall59660882009-08-29 08:11:13 +00004792 return isInstantiationOf(cast<ClassTemplateDecl>(D), Temp);
Douglas Gregorf3db0032009-08-28 22:03:51 +00004793
Richard Smithd8a9e372016-12-18 21:39:37 +00004794 if (auto *Temp = dyn_cast<FunctionTemplateDecl>(Other))
Douglas Gregor14d1bf42009-09-28 06:34:35 +00004795 return isInstantiationOf(cast<FunctionTemplateDecl>(D), Temp);
4796
Richard Smithd8a9e372016-12-18 21:39:37 +00004797 if (auto *PartialSpec =
4798 dyn_cast<ClassTemplatePartialSpecializationDecl>(Other))
Douglas Gregor21610382009-10-29 00:04:11 +00004799 return isInstantiationOf(cast<ClassTemplatePartialSpecializationDecl>(D),
4800 PartialSpec);
4801
Richard Smithd8a9e372016-12-18 21:39:37 +00004802 if (auto *Field = dyn_cast<FieldDecl>(Other)) {
Anders Carlsson5da84842009-09-01 04:26:58 +00004803 if (!Field->getDeclName()) {
4804 // This is an unnamed field.
Richard Smith32952e12014-10-14 02:00:47 +00004805 return declaresSameEntity(Ctx.getInstantiatedFromUnnamedFieldDecl(Field),
4806 cast<FieldDecl>(D));
Anders Carlsson5da84842009-09-01 04:26:58 +00004807 }
4808 }
Mike Stump11289f42009-09-09 15:08:12 +00004809
Richard Smithd8a9e372016-12-18 21:39:37 +00004810 if (auto *Using = dyn_cast<UsingDecl>(Other))
John McCallb96ec562009-12-04 22:46:56 +00004811 return isInstantiationOf(cast<UsingDecl>(D), Using, Ctx);
4812
Richard Smithd8a9e372016-12-18 21:39:37 +00004813 if (auto *Shadow = dyn_cast<UsingShadowDecl>(Other))
John McCallb96ec562009-12-04 22:46:56 +00004814 return isInstantiationOf(cast<UsingShadowDecl>(D), Shadow, Ctx);
4815
Richard Smithd8a9e372016-12-18 21:39:37 +00004816 return D->getDeclName() &&
4817 D->getDeclName() == cast<NamedDecl>(Other)->getDeclName();
Douglas Gregor51783312009-05-27 05:35:12 +00004818}
4819
4820template<typename ForwardIterator>
Mike Stump11289f42009-09-09 15:08:12 +00004821static NamedDecl *findInstantiationOf(ASTContext &Ctx,
Douglas Gregor51783312009-05-27 05:35:12 +00004822 NamedDecl *D,
4823 ForwardIterator first,
4824 ForwardIterator last) {
4825 for (; first != last; ++first)
4826 if (isInstantiationOf(Ctx, D, *first))
4827 return cast<NamedDecl>(*first);
4828
Craig Topperc3ec1492014-05-26 06:22:03 +00004829 return nullptr;
Douglas Gregor51783312009-05-27 05:35:12 +00004830}
4831
John McCallaa74a0c2009-08-28 07:59:38 +00004832/// \brief Finds the instantiation of the given declaration context
4833/// within the current instantiation.
4834///
4835/// \returns NULL if there was an error
Douglas Gregora04f2ca2010-03-01 15:56:25 +00004836DeclContext *Sema::FindInstantiatedContext(SourceLocation Loc, DeclContext* DC,
Douglas Gregor64621e62009-09-16 18:34:49 +00004837 const MultiLevelTemplateArgumentList &TemplateArgs) {
John McCallaa74a0c2009-08-28 07:59:38 +00004838 if (NamedDecl *D = dyn_cast<NamedDecl>(DC)) {
Richard Smith4f440e32017-06-08 01:08:50 +00004839 Decl* ID = FindInstantiatedDecl(Loc, D, TemplateArgs, true);
John McCallaa74a0c2009-08-28 07:59:38 +00004840 return cast_or_null<DeclContext>(ID);
4841 } else return DC;
4842}
4843
Douglas Gregorcd3a0972009-05-27 17:54:46 +00004844/// \brief Find the instantiation of the given declaration within the
4845/// current instantiation.
Douglas Gregor51783312009-05-27 05:35:12 +00004846///
4847/// This routine is intended to be used when \p D is a declaration
4848/// referenced from within a template, that needs to mapped into the
4849/// corresponding declaration within an instantiation. For example,
4850/// given:
4851///
4852/// \code
4853/// template<typename T>
4854/// struct X {
4855/// enum Kind {
4856/// KnownValue = sizeof(T)
4857/// };
4858///
4859/// bool getKind() const { return KnownValue; }
4860/// };
4861///
4862/// template struct X<int>;
4863/// \endcode
4864///
Serge Pavloved5fe902013-07-10 04:59:14 +00004865/// In the instantiation of <tt>X<int>::getKind()</tt>, we need to map the
4866/// \p EnumConstantDecl for \p KnownValue (which refers to
4867/// <tt>X<T>::<Kind>::KnownValue</tt>) to its instantiation
4868/// (<tt>X<int>::<Kind>::KnownValue</tt>). \p FindInstantiatedDecl performs
4869/// this mapping from within the instantiation of <tt>X<int></tt>.
Douglas Gregora04f2ca2010-03-01 15:56:25 +00004870NamedDecl *Sema::FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D,
Richard Smith4f440e32017-06-08 01:08:50 +00004871 const MultiLevelTemplateArgumentList &TemplateArgs,
4872 bool FindingInstantiatedContext) {
Douglas Gregor51783312009-05-27 05:35:12 +00004873 DeclContext *ParentDC = D->getDeclContext();
Faisal Vali2cba1332013-10-23 06:44:28 +00004874 // FIXME: Parmeters of pointer to functions (y below) that are themselves
4875 // parameters (p below) can have their ParentDC set to the translation-unit
4876 // - thus we can not consistently check if the ParentDC of such a parameter
4877 // is Dependent or/and a FunctionOrMethod.
4878 // For e.g. this code, during Template argument deduction tries to
4879 // find an instantiated decl for (T y) when the ParentDC for y is
4880 // the translation unit.
4881 // e.g. template <class T> void Foo(auto (*p)(T y) -> decltype(y())) {}
Aaron Ballman36a53502014-01-16 13:03:14 +00004882 // float baz(float(*)()) { return 0.0; }
Faisal Vali2cba1332013-10-23 06:44:28 +00004883 // Foo(baz);
4884 // The better fix here is perhaps to ensure that a ParmVarDecl, by the time
4885 // it gets here, always has a FunctionOrMethod as its ParentDC??
4886 // For now:
4887 // - as long as we have a ParmVarDecl whose parent is non-dependent and
4888 // whose type is not instantiation dependent, do nothing to the decl
4889 // - otherwise find its instantiated decl.
4890 if (isa<ParmVarDecl>(D) && !ParentDC->isDependentContext() &&
4891 !cast<ParmVarDecl>(D)->getType()->isInstantiationDependentType())
4892 return D;
Rafael Espindola09b00e32013-10-23 04:12:23 +00004893 if (isa<ParmVarDecl>(D) || isa<NonTypeTemplateParmDecl>(D) ||
Douglas Gregorb93971082010-02-05 19:54:12 +00004894 isa<TemplateTypeParmDecl>(D) || isa<TemplateTemplateParmDecl>(D) ||
Douglas Gregora86bc002012-02-16 21:36:18 +00004895 (ParentDC->isFunctionOrMethod() && ParentDC->isDependentContext()) ||
4896 (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda())) {
Douglas Gregorf98d9b62009-05-27 17:07:49 +00004897 // D is a local of some kind. Look into the map of local
4898 // declarations to their instantiations.
Alexey Samsonov2c0aac22014-09-03 18:45:45 +00004899 if (CurrentInstantiationScope) {
4900 if (auto Found = CurrentInstantiationScope->findInstantiationOf(D)) {
4901 if (Decl *FD = Found->dyn_cast<Decl *>())
4902 return cast<NamedDecl>(FD);
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00004903
Alexey Samsonov2c0aac22014-09-03 18:45:45 +00004904 int PackIdx = ArgumentPackSubstitutionIndex;
4905 assert(PackIdx != -1 &&
4906 "found declaration pack but not pack expanding");
4907 typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
4908 return cast<NamedDecl>((*Found->get<DeclArgumentPack *>())[PackIdx]);
4909 }
Chris Lattnercab02a62011-02-17 20:34:02 +00004910 }
4911
Serge Pavlov7cd8f602013-07-15 06:14:07 +00004912 // If we're performing a partial substitution during template argument
4913 // deduction, we may not have values for template parameters yet. They
4914 // just map to themselves.
4915 if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
4916 isa<TemplateTemplateParmDecl>(D))
4917 return D;
4918
Serge Pavlov074a5182013-08-10 12:00:21 +00004919 if (D->isInvalidDecl())
Craig Topperc3ec1492014-05-26 06:22:03 +00004920 return nullptr;
Serge Pavlov074a5182013-08-10 12:00:21 +00004921
Serge Pavlove7ad8312015-05-15 10:10:28 +00004922 // Normally this function only searches for already instantiated declaration
4923 // however we have to make an exclusion for local types used before
4924 // definition as in the code:
4925 //
4926 // template<typename T> void f1() {
4927 // void g1(struct x1);
4928 // struct x1 {};
4929 // }
4930 //
4931 // In this case instantiation of the type of 'g1' requires definition of
4932 // 'x1', which is defined later. Error recovery may produce an enum used
4933 // before definition. In these cases we need to instantiate relevant
4934 // declarations here.
4935 bool NeedInstantiate = false;
4936 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D))
4937 NeedInstantiate = RD->isLocalClass();
4938 else
4939 NeedInstantiate = isa<EnumDecl>(D);
4940 if (NeedInstantiate) {
Serge Pavlov4c511742015-05-04 16:44:39 +00004941 Decl *Inst = SubstDecl(D, CurContext, TemplateArgs);
4942 CurrentInstantiationScope->InstantiatedLocal(D, Inst);
4943 return cast<TypeDecl>(Inst);
4944 }
4945
Chris Lattnercab02a62011-02-17 20:34:02 +00004946 // If we didn't find the decl, then we must have a label decl that hasn't
4947 // been found yet. Lazily instantiate it and return it now.
4948 assert(isa<LabelDecl>(D));
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00004949
Chris Lattnercab02a62011-02-17 20:34:02 +00004950 Decl *Inst = SubstDecl(D, CurContext, TemplateArgs);
4951 assert(Inst && "Failed to instantiate label??");
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00004952
Chris Lattnercab02a62011-02-17 20:34:02 +00004953 CurrentInstantiationScope->InstantiatedLocal(D, Inst);
4954 return cast<LabelDecl>(Inst);
Douglas Gregorf98d9b62009-05-27 17:07:49 +00004955 }
Douglas Gregor51783312009-05-27 05:35:12 +00004956
Larisse Voufo39a1e502013-08-06 01:03:05 +00004957 // For variable template specializations, update those that are still
4958 // type-dependent.
4959 if (VarTemplateSpecializationDecl *VarSpec =
4960 dyn_cast<VarTemplateSpecializationDecl>(D)) {
4961 bool InstantiationDependent = false;
4962 const TemplateArgumentListInfo &VarTemplateArgs =
4963 VarSpec->getTemplateArgsInfo();
4964 if (TemplateSpecializationType::anyDependentTemplateArguments(
4965 VarTemplateArgs, InstantiationDependent))
4966 D = cast<NamedDecl>(
4967 SubstDecl(D, VarSpec->getDeclContext(), TemplateArgs));
4968 return D;
4969 }
4970
Douglas Gregor64621e62009-09-16 18:34:49 +00004971 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
4972 if (!Record->isDependentContext())
4973 return D;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00004974
Douglas Gregor4109afa2011-11-07 17:43:18 +00004975 // Determine whether this record is the "templated" declaration describing
4976 // a class template or class template partial specialization.
Douglas Gregor64621e62009-09-16 18:34:49 +00004977 ClassTemplateDecl *ClassTemplate = Record->getDescribedClassTemplate();
Douglas Gregor4109afa2011-11-07 17:43:18 +00004978 if (ClassTemplate)
4979 ClassTemplate = ClassTemplate->getCanonicalDecl();
4980 else if (ClassTemplatePartialSpecializationDecl *PartialSpec
4981 = dyn_cast<ClassTemplatePartialSpecializationDecl>(Record))
4982 ClassTemplate = PartialSpec->getSpecializedTemplate()->getCanonicalDecl();
Larisse Voufo39a1e502013-08-06 01:03:05 +00004983
Douglas Gregor4109afa2011-11-07 17:43:18 +00004984 // Walk the current context to find either the record or an instantiation of
4985 // it.
4986 DeclContext *DC = CurContext;
4987 while (!DC->isFileContext()) {
4988 // If we're performing substitution while we're inside the template
4989 // definition, we'll find our own context. We're done.
4990 if (DC->Equals(Record))
4991 return Record;
Larisse Voufo39a1e502013-08-06 01:03:05 +00004992
Douglas Gregor4109afa2011-11-07 17:43:18 +00004993 if (CXXRecordDecl *InstRecord = dyn_cast<CXXRecordDecl>(DC)) {
4994 // Check whether we're in the process of instantiating a class template
4995 // specialization of the template we're mapping.
4996 if (ClassTemplateSpecializationDecl *InstSpec
4997 = dyn_cast<ClassTemplateSpecializationDecl>(InstRecord)){
4998 ClassTemplateDecl *SpecTemplate = InstSpec->getSpecializedTemplate();
4999 if (ClassTemplate && isInstantiationOf(ClassTemplate, SpecTemplate))
5000 return InstRecord;
5001 }
Larisse Voufo39a1e502013-08-06 01:03:05 +00005002
Douglas Gregor4109afa2011-11-07 17:43:18 +00005003 // Check whether we're in the process of instantiating a member class.
5004 if (isInstantiationOf(Record, InstRecord))
5005 return InstRecord;
Douglas Gregor64621e62009-09-16 18:34:49 +00005006 }
Larisse Voufo39a1e502013-08-06 01:03:05 +00005007
Douglas Gregor4109afa2011-11-07 17:43:18 +00005008 // Move to the outer template scope.
5009 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(DC)) {
5010 if (FD->getFriendObjectKind() && FD->getDeclContext()->isFileContext()){
5011 DC = FD->getLexicalDeclContext();
5012 continue;
5013 }
Richard Smith32918772017-02-14 00:25:28 +00005014 // An implicit deduction guide acts as if it's within the class template
5015 // specialization described by its name and first N template params.
Richard Smithbc491202017-02-17 20:05:37 +00005016 auto *Guide = dyn_cast<CXXDeductionGuideDecl>(FD);
5017 if (Guide && Guide->isImplicit()) {
5018 TemplateDecl *TD = Guide->getDeducedTemplate();
Richard Smith0cd9c042017-02-21 08:42:39 +00005019 // Convert the arguments to an "as-written" list.
Richard Smith32918772017-02-14 00:25:28 +00005020 TemplateArgumentListInfo Args(Loc, Loc);
Richard Smith0cd9c042017-02-21 08:42:39 +00005021 for (TemplateArgument Arg : TemplateArgs.getInnermost().take_front(
5022 TD->getTemplateParameters()->size())) {
5023 ArrayRef<TemplateArgument> Unpacked(Arg);
5024 if (Arg.getKind() == TemplateArgument::Pack)
5025 Unpacked = Arg.pack_elements();
5026 for (TemplateArgument UnpackedArg : Unpacked)
5027 Args.addArgument(
5028 getTrivialTemplateArgumentLoc(UnpackedArg, QualType(), Loc));
5029 }
Richard Smith32918772017-02-14 00:25:28 +00005030 QualType T = CheckTemplateIdType(TemplateName(TD), Loc, Args);
5031 if (T.isNull())
5032 return nullptr;
Richard Smithe6d4b772017-06-07 02:42:27 +00005033 auto *SubstRecord = T->getAsCXXRecordDecl();
5034 assert(SubstRecord && "class template id not a class type?");
5035 // Check that this template-id names the primary template and not a
5036 // partial or explicit specialization. (In the latter cases, it's
5037 // meaningless to attempt to find an instantiation of D within the
5038 // specialization.)
5039 // FIXME: The standard doesn't say what should happen here.
Richard Smith4f440e32017-06-08 01:08:50 +00005040 if (FindingInstantiatedContext &&
5041 usesPartialOrExplicitSpecialization(
5042 Loc, cast<ClassTemplateSpecializationDecl>(SubstRecord))) {
Richard Smithe6d4b772017-06-07 02:42:27 +00005043 Diag(Loc, diag::err_specialization_not_primary_template)
5044 << T << (SubstRecord->getTemplateSpecializationKind() ==
5045 TSK_ExplicitSpecialization);
5046 return nullptr;
5047 }
5048 DC = SubstRecord;
Richard Smith32918772017-02-14 00:25:28 +00005049 continue;
5050 }
John McCall59660882009-08-29 08:11:13 +00005051 }
Larisse Voufo39a1e502013-08-06 01:03:05 +00005052
Douglas Gregor4109afa2011-11-07 17:43:18 +00005053 DC = DC->getParent();
John McCall59660882009-08-29 08:11:13 +00005054 }
Douglas Gregord225fa02010-02-05 22:40:03 +00005055
Douglas Gregor64621e62009-09-16 18:34:49 +00005056 // Fall through to deal with other dependent record types (e.g.,
5057 // anonymous unions in class templates).
5058 }
John McCall59660882009-08-29 08:11:13 +00005059
Douglas Gregor64621e62009-09-16 18:34:49 +00005060 if (!ParentDC->isDependentContext())
5061 return D;
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00005062
Douglas Gregora04f2ca2010-03-01 15:56:25 +00005063 ParentDC = FindInstantiatedContext(Loc, ParentDC, TemplateArgs);
Mike Stump11289f42009-09-09 15:08:12 +00005064 if (!ParentDC)
Craig Topperc3ec1492014-05-26 06:22:03 +00005065 return nullptr;
Mike Stump11289f42009-09-09 15:08:12 +00005066
Douglas Gregor51783312009-05-27 05:35:12 +00005067 if (ParentDC != D->getDeclContext()) {
5068 // We performed some kind of instantiation in the parent context,
5069 // so now we need to look into the instantiated parent context to
5070 // find the instantiation of the declaration D.
Douglas Gregora04f2ca2010-03-01 15:56:25 +00005071
John McCalle78aac42010-03-10 03:28:59 +00005072 // If our context used to be dependent, we may need to instantiate
5073 // it before performing lookup into that context.
Douglas Gregor528ad932011-03-06 20:12:45 +00005074 bool IsBeingInstantiated = false;
John McCalle78aac42010-03-10 03:28:59 +00005075 if (CXXRecordDecl *Spec = dyn_cast<CXXRecordDecl>(ParentDC)) {
Douglas Gregora04f2ca2010-03-01 15:56:25 +00005076 if (!Spec->isDependentContext()) {
5077 QualType T = Context.getTypeDeclType(Spec);
John McCalle78aac42010-03-10 03:28:59 +00005078 const RecordType *Tag = T->getAs<RecordType>();
5079 assert(Tag && "type of non-dependent record is not a RecordType");
Douglas Gregor528ad932011-03-06 20:12:45 +00005080 if (Tag->isBeingDefined())
5081 IsBeingInstantiated = true;
John McCalle78aac42010-03-10 03:28:59 +00005082 if (!Tag->isBeingDefined() &&
5083 RequireCompleteType(Loc, T, diag::err_incomplete_type))
Craig Topperc3ec1492014-05-26 06:22:03 +00005084 return nullptr;
Douglas Gregor25edf432010-11-05 23:22:45 +00005085
5086 ParentDC = Tag->getDecl();
Douglas Gregora04f2ca2010-03-01 15:56:25 +00005087 }
5088 }
5089
Craig Topperc3ec1492014-05-26 06:22:03 +00005090 NamedDecl *Result = nullptr;
Richard Smith151c4562016-12-20 21:35:28 +00005091 // FIXME: If the name is a dependent name, this lookup won't necessarily
5092 // find it. Does that ever matter?
Akira Hatanaka59e3b432017-01-31 19:53:32 +00005093 if (auto Name = D->getDeclName()) {
5094 DeclarationNameInfo NameInfo(Name, D->getLocation());
5095 Name = SubstDeclarationNameInfo(NameInfo, TemplateArgs).getName();
5096 if (!Name)
5097 return nullptr;
5098 DeclContext::lookup_result Found = ParentDC->lookup(Name);
David Blaikieff7d47a2012-12-19 00:45:41 +00005099 Result = findInstantiationOf(Context, D, Found.begin(), Found.end());
Douglas Gregor51783312009-05-27 05:35:12 +00005100 } else {
5101 // Since we don't have a name for the entity we're looking for,
5102 // our only option is to walk through all of the declarations to
5103 // find that name. This will occur in a few cases:
5104 //
5105 // - anonymous struct/union within a template
5106 // - unnamed class/struct/union/enum within a template
5107 //
5108 // FIXME: Find a better way to find these instantiations!
Mike Stump11289f42009-09-09 15:08:12 +00005109 Result = findInstantiationOf(Context, D,
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00005110 ParentDC->decls_begin(),
5111 ParentDC->decls_end());
Douglas Gregor51783312009-05-27 05:35:12 +00005112 }
Mike Stump11289f42009-09-09 15:08:12 +00005113
Douglas Gregor528ad932011-03-06 20:12:45 +00005114 if (!Result) {
5115 if (isa<UsingShadowDecl>(D)) {
5116 // UsingShadowDecls can instantiate to nothing because of using hiding.
5117 } else if (Diags.hasErrorOccurred()) {
5118 // We've already complained about something, so most likely this
5119 // declaration failed to instantiate. There's no point in complaining
5120 // further, since this is normal in invalid code.
5121 } else if (IsBeingInstantiated) {
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00005122 // The class in which this member exists is currently being
Douglas Gregor528ad932011-03-06 20:12:45 +00005123 // instantiated, and we haven't gotten around to instantiating this
5124 // member yet. This can happen when the code uses forward declarations
5125 // of member classes, and introduces ordering dependencies via
5126 // template instantiation.
5127 Diag(Loc, diag::err_member_not_yet_instantiated)
5128 << D->getDeclName()
5129 << Context.getTypeDeclType(cast<CXXRecordDecl>(ParentDC));
5130 Diag(D->getLocation(), diag::note_non_instantiated_member_here);
Richard Smith169f2192012-03-26 20:28:16 +00005131 } else if (EnumConstantDecl *ED = dyn_cast<EnumConstantDecl>(D)) {
5132 // This enumeration constant was found when the template was defined,
5133 // but can't be found in the instantiation. This can happen if an
5134 // unscoped enumeration member is explicitly specialized.
5135 EnumDecl *Enum = cast<EnumDecl>(ED->getLexicalDeclContext());
5136 EnumDecl *Spec = cast<EnumDecl>(FindInstantiatedDecl(Loc, Enum,
5137 TemplateArgs));
5138 assert(Spec->getTemplateSpecializationKind() ==
5139 TSK_ExplicitSpecialization);
5140 Diag(Loc, diag::err_enumerator_does_not_exist)
5141 << D->getDeclName()
5142 << Context.getTypeDeclType(cast<TypeDecl>(Spec->getDeclContext()));
5143 Diag(Spec->getLocation(), diag::note_enum_specialized_here)
5144 << Context.getTypeDeclType(Spec);
Douglas Gregor528ad932011-03-06 20:12:45 +00005145 } else {
5146 // We should have found something, but didn't.
5147 llvm_unreachable("Unable to find instantiation of declaration!");
5148 }
5149 }
NAKAMURA Takumi82a35112011-10-08 11:31:46 +00005150
Douglas Gregor51783312009-05-27 05:35:12 +00005151 D = Result;
5152 }
5153
Douglas Gregor51783312009-05-27 05:35:12 +00005154 return D;
5155}
Douglas Gregor77b50e12009-06-22 23:06:13 +00005156
Mike Stump11289f42009-09-09 15:08:12 +00005157/// \brief Performs template instantiation for all implicit template
Douglas Gregor77b50e12009-06-22 23:06:13 +00005158/// instantiations we have seen until this point.
Nick Lewycky67c4d0f2011-05-31 07:58:42 +00005159void Sema::PerformPendingInstantiations(bool LocalOnly) {
Douglas Gregor7f792cf2010-01-16 22:29:39 +00005160 while (!PendingLocalImplicitInstantiations.empty() ||
Chandler Carruth54080172010-08-25 08:44:16 +00005161 (!LocalOnly && !PendingInstantiations.empty())) {
Douglas Gregor7f792cf2010-01-16 22:29:39 +00005162 PendingImplicitInstantiation Inst;
5163
5164 if (PendingLocalImplicitInstantiations.empty()) {
Chandler Carruth54080172010-08-25 08:44:16 +00005165 Inst = PendingInstantiations.front();
5166 PendingInstantiations.pop_front();
Douglas Gregor7f792cf2010-01-16 22:29:39 +00005167 } else {
5168 Inst = PendingLocalImplicitInstantiations.front();
5169 PendingLocalImplicitInstantiations.pop_front();
5170 }
Mike Stump11289f42009-09-09 15:08:12 +00005171
Douglas Gregora6ef8f02009-07-24 20:34:43 +00005172 // Instantiate function definitions
5173 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Inst.first)) {
Chandler Carruthcfe41db2010-08-25 08:27:02 +00005174 bool DefinitionRequired = Function->getTemplateSpecializationKind() ==
5175 TSK_ExplicitInstantiationDefinition;
5176 InstantiateFunctionDefinition(/*FIXME:*/Inst.second, Function, true,
Serge Pavlov7dcc97e2016-04-19 06:19:52 +00005177 DefinitionRequired, true);
Sunil Srivastava15ed2922017-06-20 22:08:44 +00005178 if (Function->isDefined())
5179 Function->setInstantiationIsPending(false);
Douglas Gregora6ef8f02009-07-24 20:34:43 +00005180 continue;
5181 }
Mike Stump11289f42009-09-09 15:08:12 +00005182
Larisse Voufo39a1e502013-08-06 01:03:05 +00005183 // Instantiate variable definitions
Douglas Gregora6ef8f02009-07-24 20:34:43 +00005184 VarDecl *Var = cast<VarDecl>(Inst.first);
Larisse Voufo39a1e502013-08-06 01:03:05 +00005185
5186 assert((Var->isStaticDataMember() ||
5187 isa<VarTemplateSpecializationDecl>(Var)) &&
5188 "Not a static data member, nor a variable template"
5189 " specialization?");
Anders Carlsson62215c42009-09-01 05:12:24 +00005190
Chandler Carruth6b4756a2010-02-13 10:17:50 +00005191 // Don't try to instantiate declarations if the most recent redeclaration
5192 // is invalid.
Douglas Gregorec9fd132012-01-14 16:38:05 +00005193 if (Var->getMostRecentDecl()->isInvalidDecl())
Chandler Carruth6b4756a2010-02-13 10:17:50 +00005194 continue;
5195
5196 // Check if the most recent declaration has changed the specialization kind
5197 // and removed the need for implicit instantiation.
Douglas Gregorec9fd132012-01-14 16:38:05 +00005198 switch (Var->getMostRecentDecl()->getTemplateSpecializationKind()) {
Chandler Carruth6b4756a2010-02-13 10:17:50 +00005199 case TSK_Undeclared:
David Blaikie83d382b2011-09-23 05:06:16 +00005200 llvm_unreachable("Cannot instantitiate an undeclared specialization.");
Chandler Carruth6b4756a2010-02-13 10:17:50 +00005201 case TSK_ExplicitInstantiationDeclaration:
Chandler Carruth6b4756a2010-02-13 10:17:50 +00005202 case TSK_ExplicitSpecialization:
Chandler Carruthcfe41db2010-08-25 08:27:02 +00005203 continue; // No longer need to instantiate this type.
5204 case TSK_ExplicitInstantiationDefinition:
5205 // We only need an instantiation if the pending instantiation *is* the
5206 // explicit instantiation.
Adrian Prantlf3b3ccd2017-12-19 22:06:11 +00005207 if (Var != Var->getMostRecentDecl())
5208 continue;
5209 break;
Chandler Carruth6b4756a2010-02-13 10:17:50 +00005210 case TSK_ImplicitInstantiation:
5211 break;
5212 }
5213
Larisse Voufo39a1e502013-08-06 01:03:05 +00005214 PrettyDeclStackTraceEntry CrashInfo(*this, Var, SourceLocation(),
5215 "instantiating variable definition");
Chandler Carruthcfe41db2010-08-25 08:27:02 +00005216 bool DefinitionRequired = Var->getTemplateSpecializationKind() ==
5217 TSK_ExplicitInstantiationDefinition;
Larisse Voufo39a1e502013-08-06 01:03:05 +00005218
5219 // Instantiate static data member definitions or variable template
5220 // specializations.
5221 InstantiateVariableDefinition(/*FIXME:*/ Inst.second, Var, true,
Serge Pavlov7dcc97e2016-04-19 06:19:52 +00005222 DefinitionRequired, true);
Douglas Gregor77b50e12009-06-22 23:06:13 +00005223 }
5224}
John McCallc62bb642010-03-24 05:22:00 +00005225
5226void Sema::PerformDependentDiagnostics(const DeclContext *Pattern,
5227 const MultiLevelTemplateArgumentList &TemplateArgs) {
Aaron Ballmanb105e492014-03-07 14:09:15 +00005228 for (auto DD : Pattern->ddiags()) {
John McCallc62bb642010-03-24 05:22:00 +00005229 switch (DD->getKind()) {
5230 case DependentDiagnostic::Access:
5231 HandleDependentAccessCheck(*DD, TemplateArgs);
5232 break;
5233 }
5234 }
5235}