Bug Summary

File:src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
Warning:line 5533, column 7
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name SemaTemplateInstantiateDecl.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangSema/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangSema/obj/../include/clang/Sema -I /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangSema/../include -I /usr/src/gnu/usr.bin/clang/libclangSema/obj -I /usr/src/gnu/usr.bin/clang/libclangSema/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangSema/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

1//===--- SemaTemplateInstantiateDecl.cpp - C++ Template Decl Instantiation ===/
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//===----------------------------------------------------------------------===/
7//
8// This file implements C++ template instantiation for declarations.
9//
10//===----------------------------------------------------------------------===/
11
12#include "TreeTransform.h"
13#include "clang/AST/ASTConsumer.h"
14#include "clang/AST/ASTContext.h"
15#include "clang/AST/ASTMutationListener.h"
16#include "clang/AST/DeclTemplate.h"
17#include "clang/AST/DeclVisitor.h"
18#include "clang/AST/DependentDiagnostic.h"
19#include "clang/AST/Expr.h"
20#include "clang/AST/ExprCXX.h"
21#include "clang/AST/PrettyDeclStackTrace.h"
22#include "clang/AST/TypeLoc.h"
23#include "clang/Basic/SourceManager.h"
24#include "clang/Basic/TargetInfo.h"
25#include "clang/Sema/Initialization.h"
26#include "clang/Sema/Lookup.h"
27#include "clang/Sema/ScopeInfo.h"
28#include "clang/Sema/SemaInternal.h"
29#include "clang/Sema/Template.h"
30#include "clang/Sema/TemplateInstCallback.h"
31#include "llvm/Support/TimeProfiler.h"
32
33using namespace clang;
34
35static bool isDeclWithinFunction(const Decl *D) {
36 const DeclContext *DC = D->getDeclContext();
37 if (DC->isFunctionOrMethod())
38 return true;
39
40 if (DC->isRecord())
41 return cast<CXXRecordDecl>(DC)->isLocalClass();
42
43 return false;
44}
45
46template<typename DeclT>
47static bool SubstQualifier(Sema &SemaRef, const DeclT *OldDecl, DeclT *NewDecl,
48 const MultiLevelTemplateArgumentList &TemplateArgs) {
49 if (!OldDecl->getQualifierLoc())
50 return false;
51
52 assert((NewDecl->getFriendObjectKind() ||((void)0)
53 !OldDecl->getLexicalDeclContext()->isDependentContext()) &&((void)0)
54 "non-friend with qualified name defined in dependent context")((void)0);
55 Sema::ContextRAII SavedContext(
56 SemaRef,
57 const_cast<DeclContext *>(NewDecl->getFriendObjectKind()
58 ? NewDecl->getLexicalDeclContext()
59 : OldDecl->getLexicalDeclContext()));
60
61 NestedNameSpecifierLoc NewQualifierLoc
62 = SemaRef.SubstNestedNameSpecifierLoc(OldDecl->getQualifierLoc(),
63 TemplateArgs);
64
65 if (!NewQualifierLoc)
66 return true;
67
68 NewDecl->setQualifierInfo(NewQualifierLoc);
69 return false;
70}
71
72bool TemplateDeclInstantiator::SubstQualifier(const DeclaratorDecl *OldDecl,
73 DeclaratorDecl *NewDecl) {
74 return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs);
75}
76
77bool TemplateDeclInstantiator::SubstQualifier(const TagDecl *OldDecl,
78 TagDecl *NewDecl) {
79 return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs);
80}
81
82// Include attribute instantiation code.
83#include "clang/Sema/AttrTemplateInstantiate.inc"
84
85static void instantiateDependentAlignedAttr(
86 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
87 const AlignedAttr *Aligned, Decl *New, bool IsPackExpansion) {
88 if (Aligned->isAlignmentExpr()) {
89 // The alignment expression is a constant expression.
90 EnterExpressionEvaluationContext Unevaluated(
91 S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
92 ExprResult Result = S.SubstExpr(Aligned->getAlignmentExpr(), TemplateArgs);
93 if (!Result.isInvalid())
94 S.AddAlignedAttr(New, *Aligned, Result.getAs<Expr>(), IsPackExpansion);
95 } else {
96 TypeSourceInfo *Result = S.SubstType(Aligned->getAlignmentType(),
97 TemplateArgs, Aligned->getLocation(),
98 DeclarationName());
99 if (Result)
100 S.AddAlignedAttr(New, *Aligned, Result, IsPackExpansion);
101 }
102}
103
104static void instantiateDependentAlignedAttr(
105 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
106 const AlignedAttr *Aligned, Decl *New) {
107 if (!Aligned->isPackExpansion()) {
108 instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, false);
109 return;
110 }
111
112 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
113 if (Aligned->isAlignmentExpr())
114 S.collectUnexpandedParameterPacks(Aligned->getAlignmentExpr(),
115 Unexpanded);
116 else
117 S.collectUnexpandedParameterPacks(Aligned->getAlignmentType()->getTypeLoc(),
118 Unexpanded);
119 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?")((void)0);
120
121 // Determine whether we can expand this attribute pack yet.
122 bool Expand = true, RetainExpansion = false;
123 Optional<unsigned> NumExpansions;
124 // FIXME: Use the actual location of the ellipsis.
125 SourceLocation EllipsisLoc = Aligned->getLocation();
126 if (S.CheckParameterPacksForExpansion(EllipsisLoc, Aligned->getRange(),
127 Unexpanded, TemplateArgs, Expand,
128 RetainExpansion, NumExpansions))
129 return;
130
131 if (!Expand) {
132 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, -1);
133 instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, true);
134 } else {
135 for (unsigned I = 0; I != *NumExpansions; ++I) {
136 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, I);
137 instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, false);
138 }
139 }
140}
141
142static void instantiateDependentAssumeAlignedAttr(
143 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
144 const AssumeAlignedAttr *Aligned, Decl *New) {
145 // The alignment expression is a constant expression.
146 EnterExpressionEvaluationContext Unevaluated(
147 S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
148
149 Expr *E, *OE = nullptr;
150 ExprResult Result = S.SubstExpr(Aligned->getAlignment(), TemplateArgs);
151 if (Result.isInvalid())
152 return;
153 E = Result.getAs<Expr>();
154
155 if (Aligned->getOffset()) {
156 Result = S.SubstExpr(Aligned->getOffset(), TemplateArgs);
157 if (Result.isInvalid())
158 return;
159 OE = Result.getAs<Expr>();
160 }
161
162 S.AddAssumeAlignedAttr(New, *Aligned, E, OE);
163}
164
165static void instantiateDependentAlignValueAttr(
166 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
167 const AlignValueAttr *Aligned, Decl *New) {
168 // The alignment expression is a constant expression.
169 EnterExpressionEvaluationContext Unevaluated(
170 S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
171 ExprResult Result = S.SubstExpr(Aligned->getAlignment(), TemplateArgs);
172 if (!Result.isInvalid())
173 S.AddAlignValueAttr(New, *Aligned, Result.getAs<Expr>());
174}
175
176static void instantiateDependentAllocAlignAttr(
177 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
178 const AllocAlignAttr *Align, Decl *New) {
179 Expr *Param = IntegerLiteral::Create(
180 S.getASTContext(),
181 llvm::APInt(64, Align->getParamIndex().getSourceIndex()),
182 S.getASTContext().UnsignedLongLongTy, Align->getLocation());
183 S.AddAllocAlignAttr(New, *Align, Param);
184}
185
186static void instantiateDependentAnnotationAttr(
187 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
188 const AnnotateAttr *Attr, Decl *New) {
189 EnterExpressionEvaluationContext Unevaluated(
190 S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
191 SmallVector<Expr *, 4> Args;
192 Args.reserve(Attr->args_size());
193 for (auto *E : Attr->args()) {
194 ExprResult Result = S.SubstExpr(E, TemplateArgs);
195 if (!Result.isUsable())
196 return;
197 Args.push_back(Result.get());
198 }
199 S.AddAnnotationAttr(New, *Attr, Attr->getAnnotation(), Args);
200}
201
202static Expr *instantiateDependentFunctionAttrCondition(
203 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
204 const Attr *A, Expr *OldCond, const Decl *Tmpl, FunctionDecl *New) {
205 Expr *Cond = nullptr;
206 {
207 Sema::ContextRAII SwitchContext(S, New);
208 EnterExpressionEvaluationContext Unevaluated(
209 S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
210 ExprResult Result = S.SubstExpr(OldCond, TemplateArgs);
211 if (Result.isInvalid())
212 return nullptr;
213 Cond = Result.getAs<Expr>();
214 }
215 if (!Cond->isTypeDependent()) {
216 ExprResult Converted = S.PerformContextuallyConvertToBool(Cond);
217 if (Converted.isInvalid())
218 return nullptr;
219 Cond = Converted.get();
220 }
221
222 SmallVector<PartialDiagnosticAt, 8> Diags;
223 if (OldCond->isValueDependent() && !Cond->isValueDependent() &&
224 !Expr::isPotentialConstantExprUnevaluated(Cond, New, Diags)) {
225 S.Diag(A->getLocation(), diag::err_attr_cond_never_constant_expr) << A;
226 for (const auto &P : Diags)
227 S.Diag(P.first, P.second);
228 return nullptr;
229 }
230 return Cond;
231}
232
233static void instantiateDependentEnableIfAttr(
234 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
235 const EnableIfAttr *EIA, const Decl *Tmpl, FunctionDecl *New) {
236 Expr *Cond = instantiateDependentFunctionAttrCondition(
237 S, TemplateArgs, EIA, EIA->getCond(), Tmpl, New);
238
239 if (Cond)
240 New->addAttr(new (S.getASTContext()) EnableIfAttr(S.getASTContext(), *EIA,
241 Cond, EIA->getMessage()));
242}
243
244static void instantiateDependentDiagnoseIfAttr(
245 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
246 const DiagnoseIfAttr *DIA, const Decl *Tmpl, FunctionDecl *New) {
247 Expr *Cond = instantiateDependentFunctionAttrCondition(
248 S, TemplateArgs, DIA, DIA->getCond(), Tmpl, New);
249
250 if (Cond)
251 New->addAttr(new (S.getASTContext()) DiagnoseIfAttr(
252 S.getASTContext(), *DIA, Cond, DIA->getMessage(),
253 DIA->getDiagnosticType(), DIA->getArgDependent(), New));
254}
255
256// Constructs and adds to New a new instance of CUDALaunchBoundsAttr using
257// template A as the base and arguments from TemplateArgs.
258static void instantiateDependentCUDALaunchBoundsAttr(
259 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
260 const CUDALaunchBoundsAttr &Attr, Decl *New) {
261 // The alignment expression is a constant expression.
262 EnterExpressionEvaluationContext Unevaluated(
263 S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
264
265 ExprResult Result = S.SubstExpr(Attr.getMaxThreads(), TemplateArgs);
266 if (Result.isInvalid())
267 return;
268 Expr *MaxThreads = Result.getAs<Expr>();
269
270 Expr *MinBlocks = nullptr;
271 if (Attr.getMinBlocks()) {
272 Result = S.SubstExpr(Attr.getMinBlocks(), TemplateArgs);
273 if (Result.isInvalid())
274 return;
275 MinBlocks = Result.getAs<Expr>();
276 }
277
278 S.AddLaunchBoundsAttr(New, Attr, MaxThreads, MinBlocks);
279}
280
281static void
282instantiateDependentModeAttr(Sema &S,
283 const MultiLevelTemplateArgumentList &TemplateArgs,
284 const ModeAttr &Attr, Decl *New) {
285 S.AddModeAttr(New, Attr, Attr.getMode(),
286 /*InInstantiation=*/true);
287}
288
289/// Instantiation of 'declare simd' attribute and its arguments.
290static void instantiateOMPDeclareSimdDeclAttr(
291 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
292 const OMPDeclareSimdDeclAttr &Attr, Decl *New) {
293 // Allow 'this' in clauses with varlists.
294 if (auto *FTD = dyn_cast<FunctionTemplateDecl>(New))
295 New = FTD->getTemplatedDecl();
296 auto *FD = cast<FunctionDecl>(New);
297 auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(FD->getDeclContext());
298 SmallVector<Expr *, 4> Uniforms, Aligneds, Alignments, Linears, Steps;
299 SmallVector<unsigned, 4> LinModifiers;
300
301 auto SubstExpr = [&](Expr *E) -> ExprResult {
302 if (auto *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts()))
303 if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
304 Sema::ContextRAII SavedContext(S, FD);
305 LocalInstantiationScope Local(S);
306 if (FD->getNumParams() > PVD->getFunctionScopeIndex())
307 Local.InstantiatedLocal(
308 PVD, FD->getParamDecl(PVD->getFunctionScopeIndex()));
309 return S.SubstExpr(E, TemplateArgs);
310 }
311 Sema::CXXThisScopeRAII ThisScope(S, ThisContext, Qualifiers(),
312 FD->isCXXInstanceMember());
313 return S.SubstExpr(E, TemplateArgs);
314 };
315
316 // Substitute a single OpenMP clause, which is a potentially-evaluated
317 // full-expression.
318 auto Subst = [&](Expr *E) -> ExprResult {
319 EnterExpressionEvaluationContext Evaluated(
320 S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
321 ExprResult Res = SubstExpr(E);
322 if (Res.isInvalid())
323 return Res;
324 return S.ActOnFinishFullExpr(Res.get(), false);
325 };
326
327 ExprResult Simdlen;
328 if (auto *E = Attr.getSimdlen())
329 Simdlen = Subst(E);
330
331 if (Attr.uniforms_size() > 0) {
332 for(auto *E : Attr.uniforms()) {
333 ExprResult Inst = Subst(E);
334 if (Inst.isInvalid())
335 continue;
336 Uniforms.push_back(Inst.get());
337 }
338 }
339
340 auto AI = Attr.alignments_begin();
341 for (auto *E : Attr.aligneds()) {
342 ExprResult Inst = Subst(E);
343 if (Inst.isInvalid())
344 continue;
345 Aligneds.push_back(Inst.get());
346 Inst = ExprEmpty();
347 if (*AI)
348 Inst = S.SubstExpr(*AI, TemplateArgs);
349 Alignments.push_back(Inst.get());
350 ++AI;
351 }
352
353 auto SI = Attr.steps_begin();
354 for (auto *E : Attr.linears()) {
355 ExprResult Inst = Subst(E);
356 if (Inst.isInvalid())
357 continue;
358 Linears.push_back(Inst.get());
359 Inst = ExprEmpty();
360 if (*SI)
361 Inst = S.SubstExpr(*SI, TemplateArgs);
362 Steps.push_back(Inst.get());
363 ++SI;
364 }
365 LinModifiers.append(Attr.modifiers_begin(), Attr.modifiers_end());
366 (void)S.ActOnOpenMPDeclareSimdDirective(
367 S.ConvertDeclToDeclGroup(New), Attr.getBranchState(), Simdlen.get(),
368 Uniforms, Aligneds, Alignments, Linears, LinModifiers, Steps,
369 Attr.getRange());
370}
371
372/// Instantiation of 'declare variant' attribute and its arguments.
373static void instantiateOMPDeclareVariantAttr(
374 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
375 const OMPDeclareVariantAttr &Attr, Decl *New) {
376 // Allow 'this' in clauses with varlists.
377 if (auto *FTD = dyn_cast<FunctionTemplateDecl>(New))
378 New = FTD->getTemplatedDecl();
379 auto *FD = cast<FunctionDecl>(New);
380 auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(FD->getDeclContext());
381
382 auto &&SubstExpr = [FD, ThisContext, &S, &TemplateArgs](Expr *E) {
383 if (auto *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts()))
384 if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
385 Sema::ContextRAII SavedContext(S, FD);
386 LocalInstantiationScope Local(S);
387 if (FD->getNumParams() > PVD->getFunctionScopeIndex())
388 Local.InstantiatedLocal(
389 PVD, FD->getParamDecl(PVD->getFunctionScopeIndex()));
390 return S.SubstExpr(E, TemplateArgs);
391 }
392 Sema::CXXThisScopeRAII ThisScope(S, ThisContext, Qualifiers(),
393 FD->isCXXInstanceMember());
394 return S.SubstExpr(E, TemplateArgs);
395 };
396
397 // Substitute a single OpenMP clause, which is a potentially-evaluated
398 // full-expression.
399 auto &&Subst = [&SubstExpr, &S](Expr *E) {
400 EnterExpressionEvaluationContext Evaluated(
401 S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
402 ExprResult Res = SubstExpr(E);
403 if (Res.isInvalid())
404 return Res;
405 return S.ActOnFinishFullExpr(Res.get(), false);
406 };
407
408 ExprResult VariantFuncRef;
409 if (Expr *E = Attr.getVariantFuncRef()) {
410 // Do not mark function as is used to prevent its emission if this is the
411 // only place where it is used.
412 EnterExpressionEvaluationContext Unevaluated(
413 S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
414 VariantFuncRef = Subst(E);
415 }
416
417 // Copy the template version of the OMPTraitInfo and run substitute on all
418 // score and condition expressiosn.
419 OMPTraitInfo &TI = S.getASTContext().getNewOMPTraitInfo();
420 TI = *Attr.getTraitInfos();
421
422 // Try to substitute template parameters in score and condition expressions.
423 auto SubstScoreOrConditionExpr = [&S, Subst](Expr *&E, bool) {
424 if (E) {
425 EnterExpressionEvaluationContext Unevaluated(
426 S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
427 ExprResult ER = Subst(E);
428 if (ER.isUsable())
429 E = ER.get();
430 else
431 return true;
432 }
433 return false;
434 };
435 if (TI.anyScoreOrCondition(SubstScoreOrConditionExpr))
436 return;
437
438 Expr *E = VariantFuncRef.get();
439 // Check function/variant ref for `omp declare variant` but not for `omp
440 // begin declare variant` (which use implicit attributes).
441 Optional<std::pair<FunctionDecl *, Expr *>> DeclVarData =
442 S.checkOpenMPDeclareVariantFunction(S.ConvertDeclToDeclGroup(New),
443 VariantFuncRef.get(), TI,
444 Attr.getRange());
445
446 if (!DeclVarData)
447 return;
448
449 E = DeclVarData.getValue().second;
450 FD = DeclVarData.getValue().first;
451
452 if (auto *VariantDRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts())) {
453 if (auto *VariantFD = dyn_cast<FunctionDecl>(VariantDRE->getDecl())) {
454 if (auto *VariantFTD = VariantFD->getDescribedFunctionTemplate()) {
455 if (!VariantFTD->isThisDeclarationADefinition())
456 return;
457 Sema::TentativeAnalysisScope Trap(S);
458 const TemplateArgumentList *TAL = TemplateArgumentList::CreateCopy(
459 S.Context, TemplateArgs.getInnermost());
460
461 auto *SubstFD = S.InstantiateFunctionDeclaration(VariantFTD, TAL,
462 New->getLocation());
463 if (!SubstFD)
464 return;
465 QualType NewType = S.Context.mergeFunctionTypes(
466 SubstFD->getType(), FD->getType(),
467 /* OfBlockPointer */ false,
468 /* Unqualified */ false, /* AllowCXX */ true);
469 if (NewType.isNull())
470 return;
471 S.InstantiateFunctionDefinition(
472 New->getLocation(), SubstFD, /* Recursive */ true,
473 /* DefinitionRequired */ false, /* AtEndOfTU */ false);
474 SubstFD->setInstantiationIsPending(!SubstFD->isDefined());
475 E = DeclRefExpr::Create(S.Context, NestedNameSpecifierLoc(),
476 SourceLocation(), SubstFD,
477 /* RefersToEnclosingVariableOrCapture */ false,
478 /* NameLoc */ SubstFD->getLocation(),
479 SubstFD->getType(), ExprValueKind::VK_PRValue);
480 }
481 }
482 }
483
484 S.ActOnOpenMPDeclareVariantDirective(FD, E, TI, Attr.getRange());
485}
486
487static void instantiateDependentAMDGPUFlatWorkGroupSizeAttr(
488 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
489 const AMDGPUFlatWorkGroupSizeAttr &Attr, Decl *New) {
490 // Both min and max expression are constant expressions.
491 EnterExpressionEvaluationContext Unevaluated(
492 S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
493
494 ExprResult Result = S.SubstExpr(Attr.getMin(), TemplateArgs);
495 if (Result.isInvalid())
496 return;
497 Expr *MinExpr = Result.getAs<Expr>();
498
499 Result = S.SubstExpr(Attr.getMax(), TemplateArgs);
500 if (Result.isInvalid())
501 return;
502 Expr *MaxExpr = Result.getAs<Expr>();
503
504 S.addAMDGPUFlatWorkGroupSizeAttr(New, Attr, MinExpr, MaxExpr);
505}
506
507static ExplicitSpecifier
508instantiateExplicitSpecifier(Sema &S,
509 const MultiLevelTemplateArgumentList &TemplateArgs,
510 ExplicitSpecifier ES, FunctionDecl *New) {
511 if (!ES.getExpr())
512 return ES;
513 Expr *OldCond = ES.getExpr();
514 Expr *Cond = nullptr;
515 {
516 EnterExpressionEvaluationContext Unevaluated(
517 S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
518 ExprResult SubstResult = S.SubstExpr(OldCond, TemplateArgs);
519 if (SubstResult.isInvalid()) {
520 return ExplicitSpecifier::Invalid();
521 }
522 Cond = SubstResult.get();
523 }
524 ExplicitSpecifier Result(Cond, ES.getKind());
525 if (!Cond->isTypeDependent())
526 S.tryResolveExplicitSpecifier(Result);
527 return Result;
528}
529
530static void instantiateDependentAMDGPUWavesPerEUAttr(
531 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
532 const AMDGPUWavesPerEUAttr &Attr, Decl *New) {
533 // Both min and max expression are constant expressions.
534 EnterExpressionEvaluationContext Unevaluated(
535 S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
536
537 ExprResult Result = S.SubstExpr(Attr.getMin(), TemplateArgs);
538 if (Result.isInvalid())
539 return;
540 Expr *MinExpr = Result.getAs<Expr>();
541
542 Expr *MaxExpr = nullptr;
543 if (auto Max = Attr.getMax()) {
544 Result = S.SubstExpr(Max, TemplateArgs);
545 if (Result.isInvalid())
546 return;
547 MaxExpr = Result.getAs<Expr>();
548 }
549
550 S.addAMDGPUWavesPerEUAttr(New, Attr, MinExpr, MaxExpr);
551}
552
553// This doesn't take any template parameters, but we have a custom action that
554// needs to happen when the kernel itself is instantiated. We need to run the
555// ItaniumMangler to mark the names required to name this kernel.
556static void instantiateDependentSYCLKernelAttr(
557 Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
558 const SYCLKernelAttr &Attr, Decl *New) {
559 // Functions cannot be partially specialized, so if we are being instantiated,
560 // we are obviously a complete specialization. Since this attribute is only
561 // valid on function template declarations, we know that this is a full
562 // instantiation of a kernel.
563 S.AddSYCLKernelLambda(cast<FunctionDecl>(New));
564
565 // Evaluate whether this would change any of the already evaluated
566 // __builtin_sycl_unique_stable_name values.
567 for (auto &Itr : S.Context.SYCLUniqueStableNameEvaluatedValues) {
568 const std::string &CurName = Itr.first->ComputeName(S.Context);
569 if (Itr.second != CurName) {
570 S.Diag(New->getLocation(),
571 diag::err_kernel_invalidates_sycl_unique_stable_name);
572 S.Diag(Itr.first->getLocation(),
573 diag::note_sycl_unique_stable_name_evaluated_here);
574 // Update this so future diagnostics work correctly.
575 Itr.second = CurName;
576 }
577 }
578
579 New->addAttr(Attr.clone(S.getASTContext()));
580}
581
582/// Determine whether the attribute A might be relevent to the declaration D.
583/// If not, we can skip instantiating it. The attribute may or may not have
584/// been instantiated yet.
585static bool isRelevantAttr(Sema &S, const Decl *D, const Attr *A) {
586 // 'preferred_name' is only relevant to the matching specialization of the
587 // template.
588 if (const auto *PNA = dyn_cast<PreferredNameAttr>(A)) {
589 QualType T = PNA->getTypedefType();
590 const auto *RD = cast<CXXRecordDecl>(D);
591 if (!T->isDependentType() && !RD->isDependentContext() &&
592 !declaresSameEntity(T->getAsCXXRecordDecl(), RD))
593 return false;
594 for (const auto *ExistingPNA : D->specific_attrs<PreferredNameAttr>())
595 if (S.Context.hasSameType(ExistingPNA->getTypedefType(),
596 PNA->getTypedefType()))
597 return false;
598 return true;
599 }
600
601 return true;
602}
603
604void Sema::InstantiateAttrsForDecl(
605 const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Tmpl,
606 Decl *New, LateInstantiatedAttrVec *LateAttrs,
607 LocalInstantiationScope *OuterMostScope) {
608 if (NamedDecl *ND = dyn_cast<NamedDecl>(New)) {
609 // FIXME: This function is called multiple times for the same template
610 // specialization. We should only instantiate attributes that were added
611 // since the previous instantiation.
612 for (const auto *TmplAttr : Tmpl->attrs()) {
613 if (!isRelevantAttr(*this, New, TmplAttr))
614 continue;
615
616 // FIXME: If any of the special case versions from InstantiateAttrs become
617 // applicable to template declaration, we'll need to add them here.
618 CXXThisScopeRAII ThisScope(
619 *this, dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext()),
620 Qualifiers(), ND->isCXXInstanceMember());
621
622 Attr *NewAttr = sema::instantiateTemplateAttributeForDecl(
623 TmplAttr, Context, *this, TemplateArgs);
624 if (NewAttr && isRelevantAttr(*this, New, NewAttr))
625 New->addAttr(NewAttr);
626 }
627 }
628}
629
630static Sema::RetainOwnershipKind
631attrToRetainOwnershipKind(const Attr *A) {
632 switch (A->getKind()) {
633 case clang::attr::CFConsumed:
634 return Sema::RetainOwnershipKind::CF;
635 case clang::attr::OSConsumed:
636 return Sema::RetainOwnershipKind::OS;
637 case clang::attr::NSConsumed:
638 return Sema::RetainOwnershipKind::NS;
639 default:
640 llvm_unreachable("Wrong argument supplied")__builtin_unreachable();
641 }
642}
643
644void Sema::InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs,
645 const Decl *Tmpl, Decl *New,
646 LateInstantiatedAttrVec *LateAttrs,
647 LocalInstantiationScope *OuterMostScope) {
648 for (const auto *TmplAttr : Tmpl->attrs()) {
649 if (!isRelevantAttr(*this, New, TmplAttr))
650 continue;
651
652 // FIXME: This should be generalized to more than just the AlignedAttr.
653 const AlignedAttr *Aligned = dyn_cast<AlignedAttr>(TmplAttr);
654 if (Aligned && Aligned->isAlignmentDependent()) {
655 instantiateDependentAlignedAttr(*this, TemplateArgs, Aligned, New);
656 continue;
657 }
658
659 if (const auto *AssumeAligned = dyn_cast<AssumeAlignedAttr>(TmplAttr)) {
660 instantiateDependentAssumeAlignedAttr(*this, TemplateArgs, AssumeAligned, New);
661 continue;
662 }
663
664 if (const auto *AlignValue = dyn_cast<AlignValueAttr>(TmplAttr)) {
665 instantiateDependentAlignValueAttr(*this, TemplateArgs, AlignValue, New);
666 continue;
667 }
668
669 if (const auto *AllocAlign = dyn_cast<AllocAlignAttr>(TmplAttr)) {
670 instantiateDependentAllocAlignAttr(*this, TemplateArgs, AllocAlign, New);
671 continue;
672 }
673
674 if (const auto *Annotate = dyn_cast<AnnotateAttr>(TmplAttr)) {
675 instantiateDependentAnnotationAttr(*this, TemplateArgs, Annotate, New);
676 continue;
677 }
678
679 if (const auto *EnableIf = dyn_cast<EnableIfAttr>(TmplAttr)) {
680 instantiateDependentEnableIfAttr(*this, TemplateArgs, EnableIf, Tmpl,
681 cast<FunctionDecl>(New));
682 continue;
683 }
684
685 if (const auto *DiagnoseIf = dyn_cast<DiagnoseIfAttr>(TmplAttr)) {
686 instantiateDependentDiagnoseIfAttr(*this, TemplateArgs, DiagnoseIf, Tmpl,
687 cast<FunctionDecl>(New));
688 continue;
689 }
690
691 if (const auto *CUDALaunchBounds =
692 dyn_cast<CUDALaunchBoundsAttr>(TmplAttr)) {
693 instantiateDependentCUDALaunchBoundsAttr(*this, TemplateArgs,
694 *CUDALaunchBounds, New);
695 continue;
696 }
697
698 if (const auto *Mode = dyn_cast<ModeAttr>(TmplAttr)) {
699 instantiateDependentModeAttr(*this, TemplateArgs, *Mode, New);
700 continue;
701 }
702
703 if (const auto *OMPAttr = dyn_cast<OMPDeclareSimdDeclAttr>(TmplAttr)) {
704 instantiateOMPDeclareSimdDeclAttr(*this, TemplateArgs, *OMPAttr, New);
705 continue;
706 }
707
708 if (const auto *OMPAttr = dyn_cast<OMPDeclareVariantAttr>(TmplAttr)) {
709 instantiateOMPDeclareVariantAttr(*this, TemplateArgs, *OMPAttr, New);
710 continue;
711 }
712
713 if (const auto *AMDGPUFlatWorkGroupSize =
714 dyn_cast<AMDGPUFlatWorkGroupSizeAttr>(TmplAttr)) {
715 instantiateDependentAMDGPUFlatWorkGroupSizeAttr(
716 *this, TemplateArgs, *AMDGPUFlatWorkGroupSize, New);
717 }
718
719 if (const auto *AMDGPUFlatWorkGroupSize =
720 dyn_cast<AMDGPUWavesPerEUAttr>(TmplAttr)) {
721 instantiateDependentAMDGPUWavesPerEUAttr(*this, TemplateArgs,
722 *AMDGPUFlatWorkGroupSize, New);
723 }
724
725 // Existing DLL attribute on the instantiation takes precedence.
726 if (TmplAttr->getKind() == attr::DLLExport ||
727 TmplAttr->getKind() == attr::DLLImport) {
728 if (New->hasAttr<DLLExportAttr>() || New->hasAttr<DLLImportAttr>()) {
729 continue;
730 }
731 }
732
733 if (const auto *ABIAttr = dyn_cast<ParameterABIAttr>(TmplAttr)) {
734 AddParameterABIAttr(New, *ABIAttr, ABIAttr->getABI());
735 continue;
736 }
737
738 if (isa<NSConsumedAttr>(TmplAttr) || isa<OSConsumedAttr>(TmplAttr) ||
739 isa<CFConsumedAttr>(TmplAttr)) {
740 AddXConsumedAttr(New, *TmplAttr, attrToRetainOwnershipKind(TmplAttr),
741 /*template instantiation=*/true);
742 continue;
743 }
744
745 if (auto *A = dyn_cast<PointerAttr>(TmplAttr)) {
746 if (!New->hasAttr<PointerAttr>())
747 New->addAttr(A->clone(Context));
748 continue;
749 }
750
751 if (auto *A = dyn_cast<OwnerAttr>(TmplAttr)) {
752 if (!New->hasAttr<OwnerAttr>())
753 New->addAttr(A->clone(Context));
754 continue;
755 }
756
757 if (auto *A = dyn_cast<SYCLKernelAttr>(TmplAttr)) {
758 instantiateDependentSYCLKernelAttr(*this, TemplateArgs, *A, New);
759 continue;
760 }
761
762 assert(!TmplAttr->isPackExpansion())((void)0);
763 if (TmplAttr->isLateParsed() && LateAttrs) {
764 // Late parsed attributes must be instantiated and attached after the
765 // enclosing class has been instantiated. See Sema::InstantiateClass.
766 LocalInstantiationScope *Saved = nullptr;
767 if (CurrentInstantiationScope)
768 Saved = CurrentInstantiationScope->cloneScopes(OuterMostScope);
769 LateAttrs->push_back(LateInstantiatedAttribute(TmplAttr, Saved, New));
770 } else {
771 // Allow 'this' within late-parsed attributes.
772 auto *ND = cast<NamedDecl>(New);
773 auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext());
774 CXXThisScopeRAII ThisScope(*this, ThisContext, Qualifiers(),
775 ND->isCXXInstanceMember());
776
777 Attr *NewAttr = sema::instantiateTemplateAttribute(TmplAttr, Context,
778 *this, TemplateArgs);
779 if (NewAttr && isRelevantAttr(*this, New, TmplAttr))
780 New->addAttr(NewAttr);
781 }
782 }
783}
784
785/// In the MS ABI, we need to instantiate default arguments of dllexported
786/// default constructors along with the constructor definition. This allows IR
787/// gen to emit a constructor closure which calls the default constructor with
788/// its default arguments.
789void Sema::InstantiateDefaultCtorDefaultArgs(CXXConstructorDecl *Ctor) {
790 assert(Context.getTargetInfo().getCXXABI().isMicrosoft() &&((void)0)
791 Ctor->isDefaultConstructor())((void)0);
792 unsigned NumParams = Ctor->getNumParams();
793 if (NumParams == 0)
794 return;
795 DLLExportAttr *Attr = Ctor->getAttr<DLLExportAttr>();
796 if (!Attr)
797 return;
798 for (unsigned I = 0; I != NumParams; ++I) {
799 (void)CheckCXXDefaultArgExpr(Attr->getLocation(), Ctor,
800 Ctor->getParamDecl(I));
801 DiscardCleanupsInEvaluationContext();
802 }
803}
804
805/// Get the previous declaration of a declaration for the purposes of template
806/// instantiation. If this finds a previous declaration, then the previous
807/// declaration of the instantiation of D should be an instantiation of the
808/// result of this function.
809template<typename DeclT>
810static DeclT *getPreviousDeclForInstantiation(DeclT *D) {
811 DeclT *Result = D->getPreviousDecl();
812
813 // If the declaration is within a class, and the previous declaration was
814 // merged from a different definition of that class, then we don't have a
815 // previous declaration for the purpose of template instantiation.
816 if (Result && isa<CXXRecordDecl>(D->getDeclContext()) &&
817 D->getLexicalDeclContext() != Result->getLexicalDeclContext())
818 return nullptr;
819
820 return Result;
821}
822
823Decl *
824TemplateDeclInstantiator::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
825 llvm_unreachable("Translation units cannot be instantiated")__builtin_unreachable();
826}
827
828Decl *
829TemplateDeclInstantiator::VisitPragmaCommentDecl(PragmaCommentDecl *D) {
830 llvm_unreachable("pragma comment cannot be instantiated")__builtin_unreachable();
831}
832
833Decl *TemplateDeclInstantiator::VisitPragmaDetectMismatchDecl(
834 PragmaDetectMismatchDecl *D) {
835 llvm_unreachable("pragma comment cannot be instantiated")__builtin_unreachable();
836}
837
838Decl *
839TemplateDeclInstantiator::VisitExternCContextDecl(ExternCContextDecl *D) {
840 llvm_unreachable("extern \"C\" context cannot be instantiated")__builtin_unreachable();
841}
842
843Decl *TemplateDeclInstantiator::VisitMSGuidDecl(MSGuidDecl *D) {
844 llvm_unreachable("GUID declaration cannot be instantiated")__builtin_unreachable();
845}
846
847Decl *TemplateDeclInstantiator::VisitTemplateParamObjectDecl(
848 TemplateParamObjectDecl *D) {
849 llvm_unreachable("template parameter objects cannot be instantiated")__builtin_unreachable();
850}
851
852Decl *
853TemplateDeclInstantiator::VisitLabelDecl(LabelDecl *D) {
854 LabelDecl *Inst = LabelDecl::Create(SemaRef.Context, Owner, D->getLocation(),
855 D->getIdentifier());
856 Owner->addDecl(Inst);
857 return Inst;
858}
859
860Decl *
861TemplateDeclInstantiator::VisitNamespaceDecl(NamespaceDecl *D) {
862 llvm_unreachable("Namespaces cannot be instantiated")__builtin_unreachable();
863}
864
865Decl *
866TemplateDeclInstantiator::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
867 NamespaceAliasDecl *Inst
868 = NamespaceAliasDecl::Create(SemaRef.Context, Owner,
869 D->getNamespaceLoc(),
870 D->getAliasLoc(),
871 D->getIdentifier(),
872 D->getQualifierLoc(),
873 D->getTargetNameLoc(),
874 D->getNamespace());
875 Owner->addDecl(Inst);
876 return Inst;
877}
878
879Decl *TemplateDeclInstantiator::InstantiateTypedefNameDecl(TypedefNameDecl *D,
880 bool IsTypeAlias) {
881 bool Invalid = false;
882 TypeSourceInfo *DI = D->getTypeSourceInfo();
883 if (DI->getType()->isInstantiationDependentType() ||
884 DI->getType()->isVariablyModifiedType()) {
885 DI = SemaRef.SubstType(DI, TemplateArgs,
886 D->getLocation(), D->getDeclName());
887 if (!DI) {
888 Invalid = true;
889 DI = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.Context.IntTy);
890 }
891 } else {
892 SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType());
893 }
894
895 // HACK: 2012-10-23 g++ has a bug where it gets the value kind of ?: wrong.
896 // libstdc++ relies upon this bug in its implementation of common_type. If we
897 // happen to be processing that implementation, fake up the g++ ?:
898 // semantics. See LWG issue 2141 for more information on the bug. The bugs
899 // are fixed in g++ and libstdc++ 4.9.0 (2014-04-22).
900 const DecltypeType *DT = DI->getType()->getAs<DecltypeType>();
901 CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
902 if (DT && RD && isa<ConditionalOperator>(DT->getUnderlyingExpr()) &&
903 DT->isReferenceType() &&
904 RD->getEnclosingNamespaceContext() == SemaRef.getStdNamespace() &&
905 RD->getIdentifier() && RD->getIdentifier()->isStr("common_type") &&
906 D->getIdentifier() && D->getIdentifier()->isStr("type") &&
907 SemaRef.getSourceManager().isInSystemHeader(D->getBeginLoc()))
908 // Fold it to the (non-reference) type which g++ would have produced.
909 DI = SemaRef.Context.getTrivialTypeSourceInfo(
910 DI->getType().getNonReferenceType());
911
912 // Create the new typedef
913 TypedefNameDecl *Typedef;
914 if (IsTypeAlias)
915 Typedef = TypeAliasDecl::Create(SemaRef.Context, Owner, D->getBeginLoc(),
916 D->getLocation(), D->getIdentifier(), DI);
917 else
918 Typedef = TypedefDecl::Create(SemaRef.Context, Owner, D->getBeginLoc(),
919 D->getLocation(), D->getIdentifier(), DI);
920 if (Invalid)
921 Typedef->setInvalidDecl();
922
923 // If the old typedef was the name for linkage purposes of an anonymous
924 // tag decl, re-establish that relationship for the new typedef.
925 if (const TagType *oldTagType = D->getUnderlyingType()->getAs<TagType>()) {
926 TagDecl *oldTag = oldTagType->getDecl();
927 if (oldTag->getTypedefNameForAnonDecl() == D && !Invalid) {
928 TagDecl *newTag = DI->getType()->castAs<TagType>()->getDecl();
929 assert(!newTag->hasNameForLinkage())((void)0);
930 newTag->setTypedefNameForAnonDecl(Typedef);
931 }
932 }
933
934 if (TypedefNameDecl *Prev = getPreviousDeclForInstantiation(D)) {
935 NamedDecl *InstPrev = SemaRef.FindInstantiatedDecl(D->getLocation(), Prev,
936 TemplateArgs);
937 if (!InstPrev)
938 return nullptr;
939
940 TypedefNameDecl *InstPrevTypedef = cast<TypedefNameDecl>(InstPrev);
941
942 // If the typedef types are not identical, reject them.
943 SemaRef.isIncompatibleTypedef(InstPrevTypedef, Typedef);
944
945 Typedef->setPreviousDecl(InstPrevTypedef);
946 }
947
948 SemaRef.InstantiateAttrs(TemplateArgs, D, Typedef);
949
950 if (D->getUnderlyingType()->getAs<DependentNameType>())
951 SemaRef.inferGslPointerAttribute(Typedef);
952
953 Typedef->setAccess(D->getAccess());
954
955 return Typedef;
956}
957
958Decl *TemplateDeclInstantiator::VisitTypedefDecl(TypedefDecl *D) {
959 Decl *Typedef = InstantiateTypedefNameDecl(D, /*IsTypeAlias=*/false);
960 if (Typedef)
961 Owner->addDecl(Typedef);
962 return Typedef;
963}
964
965Decl *TemplateDeclInstantiator::VisitTypeAliasDecl(TypeAliasDecl *D) {
966 Decl *Typedef = InstantiateTypedefNameDecl(D, /*IsTypeAlias=*/true);
967 if (Typedef)
968 Owner->addDecl(Typedef);
969 return Typedef;
970}
971
972Decl *
973TemplateDeclInstantiator::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
974 // Create a local instantiation scope for this type alias template, which
975 // will contain the instantiations of the template parameters.
976 LocalInstantiationScope Scope(SemaRef);
977
978 TemplateParameterList *TempParams = D->getTemplateParameters();
979 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
980 if (!InstParams)
981 return nullptr;
982
983 TypeAliasDecl *Pattern = D->getTemplatedDecl();
984
985 TypeAliasTemplateDecl *PrevAliasTemplate = nullptr;
986 if (getPreviousDeclForInstantiation<TypedefNameDecl>(Pattern)) {
987 DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
988 if (!Found.empty()) {
989 PrevAliasTemplate = dyn_cast<TypeAliasTemplateDecl>(Found.front());
990 }
991 }
992
993 TypeAliasDecl *AliasInst = cast_or_null<TypeAliasDecl>(
994 InstantiateTypedefNameDecl(Pattern, /*IsTypeAlias=*/true));
995 if (!AliasInst)
996 return nullptr;
997
998 TypeAliasTemplateDecl *Inst
999 = TypeAliasTemplateDecl::Create(SemaRef.Context, Owner, D->getLocation(),
1000 D->getDeclName(), InstParams, AliasInst);
1001 AliasInst->setDescribedAliasTemplate(Inst);
1002 if (PrevAliasTemplate)
1003 Inst->setPreviousDecl(PrevAliasTemplate);
1004
1005 Inst->setAccess(D->getAccess());
1006
1007 if (!PrevAliasTemplate)
1008 Inst->setInstantiatedFromMemberTemplate(D);
1009
1010 Owner->addDecl(Inst);
1011
1012 return Inst;
1013}
1014
1015Decl *TemplateDeclInstantiator::VisitBindingDecl(BindingDecl *D) {
1016 auto *NewBD = BindingDecl::Create(SemaRef.Context, Owner, D->getLocation(),
1017 D->getIdentifier());
1018 NewBD->setReferenced(D->isReferenced());
1019 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewBD);
1020 return NewBD;
1021}
1022
1023Decl *TemplateDeclInstantiator::VisitDecompositionDecl(DecompositionDecl *D) {
1024 // Transform the bindings first.
1025 SmallVector<BindingDecl*, 16> NewBindings;
1026 for (auto *OldBD : D->bindings())
1027 NewBindings.push_back(cast<BindingDecl>(VisitBindingDecl(OldBD)));
1028 ArrayRef<BindingDecl*> NewBindingArray = NewBindings;
1029
1030 auto *NewDD = cast_or_null<DecompositionDecl>(
1031 VisitVarDecl(D, /*InstantiatingVarTemplate=*/false, &NewBindingArray));
1032
1033 if (!NewDD || NewDD->isInvalidDecl())
1034 for (auto *NewBD : NewBindings)
1035 NewBD->setInvalidDecl();
1036
1037 return NewDD;
1038}
1039
1040Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D) {
1041 return VisitVarDecl(D, /*InstantiatingVarTemplate=*/false);
1042}
1043
1044Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D,
1045 bool InstantiatingVarTemplate,
1046 ArrayRef<BindingDecl*> *Bindings) {
1047
1048 // Do substitution on the type of the declaration
1049 TypeSourceInfo *DI = SemaRef.SubstType(
1050 D->getTypeSourceInfo(), TemplateArgs, D->getTypeSpecStartLoc(),
1051 D->getDeclName(), /*AllowDeducedTST*/true);
1052 if (!DI)
1053 return nullptr;
1054
1055 if (DI->getType()->isFunctionType()) {
1056 SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function)
1057 << D->isStaticDataMember() << DI->getType();
1058 return nullptr;
1059 }
1060
1061 DeclContext *DC = Owner;
1062 if (D->isLocalExternDecl())
1063 SemaRef.adjustContextForLocalExternDecl(DC);
1064
1065 // Build the instantiated declaration.
1066 VarDecl *Var;
1067 if (Bindings)
1068 Var = DecompositionDecl::Create(SemaRef.Context, DC, D->getInnerLocStart(),
1069 D->getLocation(), DI->getType(), DI,
1070 D->getStorageClass(), *Bindings);
1071 else
1072 Var = VarDecl::Create(SemaRef.Context, DC, D->getInnerLocStart(),
1073 D->getLocation(), D->getIdentifier(), DI->getType(),
1074 DI, D->getStorageClass());
1075
1076 // In ARC, infer 'retaining' for variables of retainable type.
1077 if (SemaRef.getLangOpts().ObjCAutoRefCount &&
1078 SemaRef.inferObjCARCLifetime(Var))
1079 Var->setInvalidDecl();
1080
1081 if (SemaRef.getLangOpts().OpenCL)
1082 SemaRef.deduceOpenCLAddressSpace(Var);
1083
1084 // Substitute the nested name specifier, if any.
1085 if (SubstQualifier(D, Var))
1086 return nullptr;
1087
1088 SemaRef.BuildVariableInstantiation(Var, D, TemplateArgs, LateAttrs, Owner,
1089 StartingScope, InstantiatingVarTemplate);
1090 if (D->isNRVOVariable() && !Var->isInvalidDecl()) {
1091 QualType RT;
1092 if (auto *F = dyn_cast<FunctionDecl>(DC))
1093 RT = F->getReturnType();
1094 else if (isa<BlockDecl>(DC))
1095 RT = cast<FunctionType>(SemaRef.getCurBlock()->FunctionType)
1096 ->getReturnType();
1097 else
1098 llvm_unreachable("Unknown context type")__builtin_unreachable();
1099
1100 // This is the last chance we have of checking copy elision eligibility
1101 // for functions in dependent contexts. The sema actions for building
1102 // the return statement during template instantiation will have no effect
1103 // regarding copy elision, since NRVO propagation runs on the scope exit
1104 // actions, and these are not run on instantiation.
1105 // This might run through some VarDecls which were returned from non-taken
1106 // 'if constexpr' branches, and these will end up being constructed on the
1107 // return slot even if they will never be returned, as a sort of accidental
1108 // 'optimization'. Notably, functions with 'auto' return types won't have it
1109 // deduced by this point. Coupled with the limitation described
1110 // previously, this makes it very hard to support copy elision for these.
1111 Sema::NamedReturnInfo Info = SemaRef.getNamedReturnInfo(Var);
1112 bool NRVO = SemaRef.getCopyElisionCandidate(Info, RT) != nullptr;
1113 Var->setNRVOVariable(NRVO);
1114 }
1115
1116 Var->setImplicit(D->isImplicit());
1117
1118 if (Var->isStaticLocal())
1119 SemaRef.CheckStaticLocalForDllExport(Var);
1120
1121 return Var;
1122}
1123
1124Decl *TemplateDeclInstantiator::VisitAccessSpecDecl(AccessSpecDecl *D) {
1125 AccessSpecDecl* AD
1126 = AccessSpecDecl::Create(SemaRef.Context, D->getAccess(), Owner,
1127 D->getAccessSpecifierLoc(), D->getColonLoc());
1128 Owner->addHiddenDecl(AD);
1129 return AD;
1130}
1131
1132Decl *TemplateDeclInstantiator::VisitFieldDecl(FieldDecl *D) {
1133 bool Invalid = false;
1134 TypeSourceInfo *DI = D->getTypeSourceInfo();
1135 if (DI->getType()->isInstantiationDependentType() ||
1136 DI->getType()->isVariablyModifiedType()) {
1137 DI = SemaRef.SubstType(DI, TemplateArgs,
1138 D->getLocation(), D->getDeclName());
1139 if (!DI) {
1140 DI = D->getTypeSourceInfo();
1141 Invalid = true;
1142 } else if (DI->getType()->isFunctionType()) {
1143 // C++ [temp.arg.type]p3:
1144 // If a declaration acquires a function type through a type
1145 // dependent on a template-parameter and this causes a
1146 // declaration that does not use the syntactic form of a
1147 // function declarator to have function type, the program is
1148 // ill-formed.
1149 SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function)
1150 << DI->getType();
1151 Invalid = true;
1152 }
1153 } else {
1154 SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType());
1155 }
1156
1157 Expr *BitWidth = D->getBitWidth();
1158 if (Invalid)
1159 BitWidth = nullptr;
1160 else if (BitWidth) {
1161 // The bit-width expression is a constant expression.
1162 EnterExpressionEvaluationContext Unevaluated(
1163 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
1164
1165 ExprResult InstantiatedBitWidth
1166 = SemaRef.SubstExpr(BitWidth, TemplateArgs);
1167 if (InstantiatedBitWidth.isInvalid()) {
1168 Invalid = true;
1169 BitWidth = nullptr;
1170 } else
1171 BitWidth = InstantiatedBitWidth.getAs<Expr>();
1172 }
1173
1174 FieldDecl *Field = SemaRef.CheckFieldDecl(D->getDeclName(),
1175 DI->getType(), DI,
1176 cast<RecordDecl>(Owner),
1177 D->getLocation(),
1178 D->isMutable(),
1179 BitWidth,
1180 D->getInClassInitStyle(),
1181 D->getInnerLocStart(),
1182 D->getAccess(),
1183 nullptr);
1184 if (!Field) {
1185 cast<Decl>(Owner)->setInvalidDecl();
1186 return nullptr;
1187 }
1188
1189 SemaRef.InstantiateAttrs(TemplateArgs, D, Field, LateAttrs, StartingScope);
1190
1191 if (Field->hasAttrs())
1192 SemaRef.CheckAlignasUnderalignment(Field);
1193
1194 if (Invalid)
1195 Field->setInvalidDecl();
1196
1197 if (!Field->getDeclName()) {
1198 // Keep track of where this decl came from.
1199 SemaRef.Context.setInstantiatedFromUnnamedFieldDecl(Field, D);
1200 }
1201 if (CXXRecordDecl *Parent= dyn_cast<CXXRecordDecl>(Field->getDeclContext())) {
1202 if (Parent->isAnonymousStructOrUnion() &&
1203 Parent->getRedeclContext()->isFunctionOrMethod())
1204 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Field);
1205 }
1206
1207 Field->setImplicit(D->isImplicit());
1208 Field->setAccess(D->getAccess());
1209 Owner->addDecl(Field);
1210
1211 return Field;
1212}
1213
1214Decl *TemplateDeclInstantiator::VisitMSPropertyDecl(MSPropertyDecl *D) {
1215 bool Invalid = false;
1216 TypeSourceInfo *DI = D->getTypeSourceInfo();
1217
1218 if (DI->getType()->isVariablyModifiedType()) {
1219 SemaRef.Diag(D->getLocation(), diag::err_property_is_variably_modified)
1220 << D;
1221 Invalid = true;
1222 } else if (DI->getType()->isInstantiationDependentType()) {
1223 DI = SemaRef.SubstType(DI, TemplateArgs,
1224 D->getLocation(), D->getDeclName());
1225 if (!DI) {
1226 DI = D->getTypeSourceInfo();
1227 Invalid = true;
1228 } else if (DI->getType()->isFunctionType()) {
1229 // C++ [temp.arg.type]p3:
1230 // If a declaration acquires a function type through a type
1231 // dependent on a template-parameter and this causes a
1232 // declaration that does not use the syntactic form of a
1233 // function declarator to have function type, the program is
1234 // ill-formed.
1235 SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function)
1236 << DI->getType();
1237 Invalid = true;
1238 }
1239 } else {
1240 SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType());
1241 }
1242
1243 MSPropertyDecl *Property = MSPropertyDecl::Create(
1244 SemaRef.Context, Owner, D->getLocation(), D->getDeclName(), DI->getType(),
1245 DI, D->getBeginLoc(), D->getGetterId(), D->getSetterId());
1246
1247 SemaRef.InstantiateAttrs(TemplateArgs, D, Property, LateAttrs,
1248 StartingScope);
1249
1250 if (Invalid)
1251 Property->setInvalidDecl();
1252
1253 Property->setAccess(D->getAccess());
1254 Owner->addDecl(Property);
1255
1256 return Property;
1257}
1258
1259Decl *TemplateDeclInstantiator::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
1260 NamedDecl **NamedChain =
1261 new (SemaRef.Context)NamedDecl*[D->getChainingSize()];
1262
1263 int i = 0;
1264 for (auto *PI : D->chain()) {
1265 NamedDecl *Next = SemaRef.FindInstantiatedDecl(D->getLocation(), PI,
1266 TemplateArgs);
1267 if (!Next)
1268 return nullptr;
1269
1270 NamedChain[i++] = Next;
1271 }
1272
1273 QualType T = cast<FieldDecl>(NamedChain[i-1])->getType();
1274 IndirectFieldDecl *IndirectField = IndirectFieldDecl::Create(
1275 SemaRef.Context, Owner, D->getLocation(), D->getIdentifier(), T,
1276 {NamedChain, D->getChainingSize()});
1277
1278 for (const auto *Attr : D->attrs())
1279 IndirectField->addAttr(Attr->clone(SemaRef.Context));
1280
1281 IndirectField->setImplicit(D->isImplicit());
1282 IndirectField->setAccess(D->getAccess());
1283 Owner->addDecl(IndirectField);
1284 return IndirectField;
1285}
1286
1287Decl *TemplateDeclInstantiator::VisitFriendDecl(FriendDecl *D) {
1288 // Handle friend type expressions by simply substituting template
1289 // parameters into the pattern type and checking the result.
1290 if (TypeSourceInfo *Ty = D->getFriendType()) {
1291 TypeSourceInfo *InstTy;
1292 // If this is an unsupported friend, don't bother substituting template
1293 // arguments into it. The actual type referred to won't be used by any
1294 // parts of Clang, and may not be valid for instantiating. Just use the
1295 // same info for the instantiated friend.
1296 if (D->isUnsupportedFriend()) {
1297 InstTy = Ty;
1298 } else {
1299 InstTy = SemaRef.SubstType(Ty, TemplateArgs,
1300 D->getLocation(), DeclarationName());
1301 }
1302 if (!InstTy)
1303 return nullptr;
1304
1305 FriendDecl *FD = SemaRef.CheckFriendTypeDecl(D->getBeginLoc(),
1306 D->getFriendLoc(), InstTy);
1307 if (!FD)
1308 return nullptr;
1309
1310 FD->setAccess(AS_public);
1311 FD->setUnsupportedFriend(D->isUnsupportedFriend());
1312 Owner->addDecl(FD);
1313 return FD;
1314 }
1315
1316 NamedDecl *ND = D->getFriendDecl();
1317 assert(ND && "friend decl must be a decl or a type!")((void)0);
1318
1319 // All of the Visit implementations for the various potential friend
1320 // declarations have to be carefully written to work for friend
1321 // objects, with the most important detail being that the target
1322 // decl should almost certainly not be placed in Owner.
1323 Decl *NewND = Visit(ND);
1324 if (!NewND) return nullptr;
1325
1326 FriendDecl *FD =
1327 FriendDecl::Create(SemaRef.Context, Owner, D->getLocation(),
1328 cast<NamedDecl>(NewND), D->getFriendLoc());
1329 FD->setAccess(AS_public);
1330 FD->setUnsupportedFriend(D->isUnsupportedFriend());
1331 Owner->addDecl(FD);
1332 return FD;
1333}
1334
1335Decl *TemplateDeclInstantiator::VisitStaticAssertDecl(StaticAssertDecl *D) {
1336 Expr *AssertExpr = D->getAssertExpr();
1337
1338 // The expression in a static assertion is a constant expression.
1339 EnterExpressionEvaluationContext Unevaluated(
1340 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
1341
1342 ExprResult InstantiatedAssertExpr
1343 = SemaRef.SubstExpr(AssertExpr, TemplateArgs);
1344 if (InstantiatedAssertExpr.isInvalid())
1345 return nullptr;
1346
1347 return SemaRef.BuildStaticAssertDeclaration(D->getLocation(),
1348 InstantiatedAssertExpr.get(),
1349 D->getMessage(),
1350 D->getRParenLoc(),
1351 D->isFailed());
1352}
1353
1354Decl *TemplateDeclInstantiator::VisitEnumDecl(EnumDecl *D) {
1355 EnumDecl *PrevDecl = nullptr;
1356 if (EnumDecl *PatternPrev = getPreviousDeclForInstantiation(D)) {
1357 NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(),
1358 PatternPrev,
1359 TemplateArgs);
1360 if (!Prev) return nullptr;
1361 PrevDecl = cast<EnumDecl>(Prev);
1362 }
1363
1364 EnumDecl *Enum =
1365 EnumDecl::Create(SemaRef.Context, Owner, D->getBeginLoc(),
1366 D->getLocation(), D->getIdentifier(), PrevDecl,
1367 D->isScoped(), D->isScopedUsingClassTag(), D->isFixed());
1368 if (D->isFixed()) {
1369 if (TypeSourceInfo *TI = D->getIntegerTypeSourceInfo()) {
1370 // If we have type source information for the underlying type, it means it
1371 // has been explicitly set by the user. Perform substitution on it before
1372 // moving on.
1373 SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
1374 TypeSourceInfo *NewTI = SemaRef.SubstType(TI, TemplateArgs, UnderlyingLoc,
1375 DeclarationName());
1376 if (!NewTI || SemaRef.CheckEnumUnderlyingType(NewTI))
1377 Enum->setIntegerType(SemaRef.Context.IntTy);
1378 else
1379 Enum->setIntegerTypeSourceInfo(NewTI);
1380 } else {
1381 assert(!D->getIntegerType()->isDependentType()((void)0)
1382 && "Dependent type without type source info")((void)0);
1383 Enum->setIntegerType(D->getIntegerType());
1384 }
1385 }
1386
1387 SemaRef.InstantiateAttrs(TemplateArgs, D, Enum);
1388
1389 Enum->setInstantiationOfMemberEnum(D, TSK_ImplicitInstantiation);
1390 Enum->setAccess(D->getAccess());
1391 // Forward the mangling number from the template to the instantiated decl.
1392 SemaRef.Context.setManglingNumber(Enum, SemaRef.Context.getManglingNumber(D));
1393 // See if the old tag was defined along with a declarator.
1394 // If it did, mark the new tag as being associated with that declarator.
1395 if (DeclaratorDecl *DD = SemaRef.Context.getDeclaratorForUnnamedTagDecl(D))
1396 SemaRef.Context.addDeclaratorForUnnamedTagDecl(Enum, DD);
1397 // See if the old tag was defined along with a typedef.
1398 // If it did, mark the new tag as being associated with that typedef.
1399 if (TypedefNameDecl *TND = SemaRef.Context.getTypedefNameForUnnamedTagDecl(D))
1400 SemaRef.Context.addTypedefNameForUnnamedTagDecl(Enum, TND);
1401 if (SubstQualifier(D, Enum)) return nullptr;
1402 Owner->addDecl(Enum);
1403
1404 EnumDecl *Def = D->getDefinition();
1405 if (Def && Def != D) {
1406 // If this is an out-of-line definition of an enum member template, check
1407 // that the underlying types match in the instantiation of both
1408 // declarations.
1409 if (TypeSourceInfo *TI = Def->getIntegerTypeSourceInfo()) {
1410 SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
1411 QualType DefnUnderlying =
1412 SemaRef.SubstType(TI->getType(), TemplateArgs,
1413 UnderlyingLoc, DeclarationName());
1414 SemaRef.CheckEnumRedeclaration(Def->getLocation(), Def->isScoped(),
1415 DefnUnderlying, /*IsFixed=*/true, Enum);
1416 }
1417 }
1418
1419 // C++11 [temp.inst]p1: The implicit instantiation of a class template
1420 // specialization causes the implicit instantiation of the declarations, but
1421 // not the definitions of scoped member enumerations.
1422 //
1423 // DR1484 clarifies that enumeration definitions inside of a template
1424 // declaration aren't considered entities that can be separately instantiated
1425 // from the rest of the entity they are declared inside of.
1426 if (isDeclWithinFunction(D) ? D == Def : Def && !Enum->isScoped()) {
1427 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Enum);
1428 InstantiateEnumDefinition(Enum, Def);
1429 }
1430
1431 return Enum;
1432}
1433
1434void TemplateDeclInstantiator::InstantiateEnumDefinition(
1435 EnumDecl *Enum, EnumDecl *Pattern) {
1436 Enum->startDefinition();
1437
1438 // Update the location to refer to the definition.
1439 Enum->setLocation(Pattern->getLocation());
1440
1441 SmallVector<Decl*, 4> Enumerators;
1442
1443 EnumConstantDecl *LastEnumConst = nullptr;
1444 for (auto *EC : Pattern->enumerators()) {
1445 // The specified value for the enumerator.
1446 ExprResult Value((Expr *)nullptr);
1447 if (Expr *UninstValue = EC->getInitExpr()) {
1448 // The enumerator's value expression is a constant expression.
1449 EnterExpressionEvaluationContext Unevaluated(
1450 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
1451
1452 Value = SemaRef.SubstExpr(UninstValue, TemplateArgs);
1453 }
1454
1455 // Drop the initial value and continue.
1456 bool isInvalid = false;
1457 if (Value.isInvalid()) {
1458 Value = nullptr;
1459 isInvalid = true;
1460 }
1461
1462 EnumConstantDecl *EnumConst
1463 = SemaRef.CheckEnumConstant(Enum, LastEnumConst,
1464 EC->getLocation(), EC->getIdentifier(),
1465 Value.get());
1466
1467 if (isInvalid) {
1468 if (EnumConst)
1469 EnumConst->setInvalidDecl();
1470 Enum->setInvalidDecl();
1471 }
1472
1473 if (EnumConst) {
1474 SemaRef.InstantiateAttrs(TemplateArgs, EC, EnumConst);
1475
1476 EnumConst->setAccess(Enum->getAccess());
1477 Enum->addDecl(EnumConst);
1478 Enumerators.push_back(EnumConst);
1479 LastEnumConst = EnumConst;
1480
1481 if (Pattern->getDeclContext()->isFunctionOrMethod() &&
1482 !Enum->isScoped()) {
1483 // If the enumeration is within a function or method, record the enum
1484 // constant as a local.
1485 SemaRef.CurrentInstantiationScope->InstantiatedLocal(EC, EnumConst);
1486 }
1487 }
1488 }
1489
1490 SemaRef.ActOnEnumBody(Enum->getLocation(), Enum->getBraceRange(), Enum,
1491 Enumerators, nullptr, ParsedAttributesView());
1492}
1493
1494Decl *TemplateDeclInstantiator::VisitEnumConstantDecl(EnumConstantDecl *D) {
1495 llvm_unreachable("EnumConstantDecls can only occur within EnumDecls.")__builtin_unreachable();
1496}
1497
1498Decl *
1499TemplateDeclInstantiator::VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D) {
1500 llvm_unreachable("BuiltinTemplateDecls cannot be instantiated.")__builtin_unreachable();
1501}
1502
1503Decl *TemplateDeclInstantiator::VisitClassTemplateDecl(ClassTemplateDecl *D) {
1504 bool isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
1505
1506 // Create a local instantiation scope for this class template, which
1507 // will contain the instantiations of the template parameters.
1508 LocalInstantiationScope Scope(SemaRef);
1509 TemplateParameterList *TempParams = D->getTemplateParameters();
1510 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
1511 if (!InstParams)
1512 return nullptr;
1513
1514 CXXRecordDecl *Pattern = D->getTemplatedDecl();
1515
1516 // Instantiate the qualifier. We have to do this first in case
1517 // we're a friend declaration, because if we are then we need to put
1518 // the new declaration in the appropriate context.
1519 NestedNameSpecifierLoc QualifierLoc = Pattern->getQualifierLoc();
1520 if (QualifierLoc) {
1521 QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
1522 TemplateArgs);
1523 if (!QualifierLoc)
1524 return nullptr;
1525 }
1526
1527 CXXRecordDecl *PrevDecl = nullptr;
1528 ClassTemplateDecl *PrevClassTemplate = nullptr;
1529
1530 if (!isFriend && getPreviousDeclForInstantiation(Pattern)) {
1531 DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
1532 if (!Found.empty()) {
1533 PrevClassTemplate = dyn_cast<ClassTemplateDecl>(Found.front());
1534 if (PrevClassTemplate)
1535 PrevDecl = PrevClassTemplate->getTemplatedDecl();
1536 }
1537 }
1538
1539 // If this isn't a friend, then it's a member template, in which
1540 // case we just want to build the instantiation in the
1541 // specialization. If it is a friend, we want to build it in
1542 // the appropriate context.
1543 DeclContext *DC = Owner;
1544 if (isFriend) {
1545 if (QualifierLoc) {
1546 CXXScopeSpec SS;
1547 SS.Adopt(QualifierLoc);
1548 DC = SemaRef.computeDeclContext(SS);
1549 if (!DC) return nullptr;
1550 } else {
1551 DC = SemaRef.FindInstantiatedContext(Pattern->getLocation(),
1552 Pattern->getDeclContext(),
1553 TemplateArgs);
1554 }
1555
1556 // Look for a previous declaration of the template in the owning
1557 // context.
1558 LookupResult R(SemaRef, Pattern->getDeclName(), Pattern->getLocation(),
1559 Sema::LookupOrdinaryName,
1560 SemaRef.forRedeclarationInCurContext());
1561 SemaRef.LookupQualifiedName(R, DC);
1562
1563 if (R.isSingleResult()) {
1564 PrevClassTemplate = R.getAsSingle<ClassTemplateDecl>();
1565 if (PrevClassTemplate)
1566 PrevDecl = PrevClassTemplate->getTemplatedDecl();
1567 }
1568
1569 if (!PrevClassTemplate && QualifierLoc) {
1570 SemaRef.Diag(Pattern->getLocation(), diag::err_not_tag_in_scope)
1571 << D->getTemplatedDecl()->getTagKind() << Pattern->getDeclName() << DC
1572 << QualifierLoc.getSourceRange();
1573 return nullptr;
1574 }
1575
1576 if (PrevClassTemplate) {
1577 TemplateParameterList *PrevParams
1578 = PrevClassTemplate->getMostRecentDecl()->getTemplateParameters();
1579
1580 // Make sure the parameter lists match.
1581 if (!SemaRef.TemplateParameterListsAreEqual(InstParams, PrevParams, true,
1582 Sema::TPL_TemplateMatch))
1583 return nullptr;
1584
1585 // Do some additional validation, then merge default arguments
1586 // from the existing declarations.
1587 if (SemaRef.CheckTemplateParameterList(InstParams, PrevParams,
1588 Sema::TPC_ClassTemplate))
1589 return nullptr;
1590 }
1591 }
1592
1593 CXXRecordDecl *RecordInst = CXXRecordDecl::Create(
1594 SemaRef.Context, Pattern->getTagKind(), DC, Pattern->getBeginLoc(),
1595 Pattern->getLocation(), Pattern->getIdentifier(), PrevDecl,
1596 /*DelayTypeCreation=*/true);
1597
1598 if (QualifierLoc)
1599 RecordInst->setQualifierInfo(QualifierLoc);
1600
1601 SemaRef.InstantiateAttrsForDecl(TemplateArgs, Pattern, RecordInst, LateAttrs,
1602 StartingScope);
1603
1604 ClassTemplateDecl *Inst
1605 = ClassTemplateDecl::Create(SemaRef.Context, DC, D->getLocation(),
1606 D->getIdentifier(), InstParams, RecordInst);
1607 assert(!(isFriend && Owner->isDependentContext()))((void)0);
1608 Inst->setPreviousDecl(PrevClassTemplate);
1609
1610 RecordInst->setDescribedClassTemplate(Inst);
1611
1612 if (isFriend) {
1613 if (PrevClassTemplate)
1614 Inst->setAccess(PrevClassTemplate->getAccess());
1615 else
1616 Inst->setAccess(D->getAccess());
1617
1618 Inst->setObjectOfFriendDecl();
1619 // TODO: do we want to track the instantiation progeny of this
1620 // friend target decl?
1621 } else {
1622 Inst->setAccess(D->getAccess());
1623 if (!PrevClassTemplate)
1624 Inst->setInstantiatedFromMemberTemplate(D);
1625 }
1626
1627 // Trigger creation of the type for the instantiation.
1628 SemaRef.Context.getInjectedClassNameType(RecordInst,
1629 Inst->getInjectedClassNameSpecialization());
1630
1631 // Finish handling of friends.
1632 if (isFriend) {
1633 DC->makeDeclVisibleInContext(Inst);
1634 Inst->setLexicalDeclContext(Owner);
1635 RecordInst->setLexicalDeclContext(Owner);
1636 return Inst;
1637 }
1638
1639 if (D->isOutOfLine()) {
1640 Inst->setLexicalDeclContext(D->getLexicalDeclContext());
1641 RecordInst->setLexicalDeclContext(D->getLexicalDeclContext());
1642 }
1643
1644 Owner->addDecl(Inst);
1645
1646 if (!PrevClassTemplate) {
1647 // Queue up any out-of-line partial specializations of this member
1648 // class template; the client will force their instantiation once
1649 // the enclosing class has been instantiated.
1650 SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs;
1651 D->getPartialSpecializations(PartialSpecs);
1652 for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
1653 if (PartialSpecs[I]->getFirstDecl()->isOutOfLine())
1654 OutOfLinePartialSpecs.push_back(std::make_pair(Inst, PartialSpecs[I]));
1655 }
1656
1657 return Inst;
1658}
1659
1660Decl *
1661TemplateDeclInstantiator::VisitClassTemplatePartialSpecializationDecl(
1662 ClassTemplatePartialSpecializationDecl *D) {
1663 ClassTemplateDecl *ClassTemplate = D->getSpecializedTemplate();
1664
1665 // Lookup the already-instantiated declaration in the instantiation
1666 // of the class template and return that.
1667 DeclContext::lookup_result Found
1668 = Owner->lookup(ClassTemplate->getDeclName());
1669 if (Found.empty())
1670 return nullptr;
1671
1672 ClassTemplateDecl *InstClassTemplate
1673 = dyn_cast<ClassTemplateDecl>(Found.front());
1674 if (!InstClassTemplate)
1675 return nullptr;
1676
1677 if (ClassTemplatePartialSpecializationDecl *Result
1678 = InstClassTemplate->findPartialSpecInstantiatedFromMember(D))
1679 return Result;
1680
1681 return InstantiateClassTemplatePartialSpecialization(InstClassTemplate, D);
1682}
1683
1684Decl *TemplateDeclInstantiator::VisitVarTemplateDecl(VarTemplateDecl *D) {
1685 assert(D->getTemplatedDecl()->isStaticDataMember() &&((void)0)
1686 "Only static data member templates are allowed.")((void)0);
1687
1688 // Create a local instantiation scope for this variable template, which
1689 // will contain the instantiations of the template parameters.
1690 LocalInstantiationScope Scope(SemaRef);
1691 TemplateParameterList *TempParams = D->getTemplateParameters();
1692 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
1693 if (!InstParams)
1694 return nullptr;
1695
1696 VarDecl *Pattern = D->getTemplatedDecl();
1697 VarTemplateDecl *PrevVarTemplate = nullptr;
1698
1699 if (getPreviousDeclForInstantiation(Pattern)) {
1700 DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
1701 if (!Found.empty())
1702 PrevVarTemplate = dyn_cast<VarTemplateDecl>(Found.front());
1703 }
1704
1705 VarDecl *VarInst =
1706 cast_or_null<VarDecl>(VisitVarDecl(Pattern,
1707 /*InstantiatingVarTemplate=*/true));
1708 if (!VarInst) return nullptr;
1709
1710 DeclContext *DC = Owner;
1711
1712 VarTemplateDecl *Inst = VarTemplateDecl::Create(
1713 SemaRef.Context, DC, D->getLocation(), D->getIdentifier(), InstParams,
1714 VarInst);
1715 VarInst->setDescribedVarTemplate(Inst);
1716 Inst->setPreviousDecl(PrevVarTemplate);
1717
1718 Inst->setAccess(D->getAccess());
1719 if (!PrevVarTemplate)
1720 Inst->setInstantiatedFromMemberTemplate(D);
1721
1722 if (D->isOutOfLine()) {
1723 Inst->setLexicalDeclContext(D->getLexicalDeclContext());
1724 VarInst->setLexicalDeclContext(D->getLexicalDeclContext());
1725 }
1726
1727 Owner->addDecl(Inst);
1728
1729 if (!PrevVarTemplate) {
1730 // Queue up any out-of-line partial specializations of this member
1731 // variable template; the client will force their instantiation once
1732 // the enclosing class has been instantiated.
1733 SmallVector<VarTemplatePartialSpecializationDecl *, 4> PartialSpecs;
1734 D->getPartialSpecializations(PartialSpecs);
1735 for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
1736 if (PartialSpecs[I]->getFirstDecl()->isOutOfLine())
1737 OutOfLineVarPartialSpecs.push_back(
1738 std::make_pair(Inst, PartialSpecs[I]));
1739 }
1740
1741 return Inst;
1742}
1743
1744Decl *TemplateDeclInstantiator::VisitVarTemplatePartialSpecializationDecl(
1745 VarTemplatePartialSpecializationDecl *D) {
1746 assert(D->isStaticDataMember() &&((void)0)
1747 "Only static data member templates are allowed.")((void)0);
1748
1749 VarTemplateDecl *VarTemplate = D->getSpecializedTemplate();
1750
1751 // Lookup the already-instantiated declaration and return that.
1752 DeclContext::lookup_result Found = Owner->lookup(VarTemplate->getDeclName());
1753 assert(!Found.empty() && "Instantiation found nothing?")((void)0);
1754
1755 VarTemplateDecl *InstVarTemplate = dyn_cast<VarTemplateDecl>(Found.front());
1756 assert(InstVarTemplate && "Instantiation did not find a variable template?")((void)0);
1757
1758 if (VarTemplatePartialSpecializationDecl *Result =
1759 InstVarTemplate->findPartialSpecInstantiatedFromMember(D))
1760 return Result;
1761
1762 return InstantiateVarTemplatePartialSpecialization(InstVarTemplate, D);
1763}
1764
1765Decl *
1766TemplateDeclInstantiator::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
1767 // Create a local instantiation scope for this function template, which
1768 // will contain the instantiations of the template parameters and then get
1769 // merged with the local instantiation scope for the function template
1770 // itself.
1771 LocalInstantiationScope Scope(SemaRef);
1772
1773 TemplateParameterList *TempParams = D->getTemplateParameters();
1774 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
1775 if (!InstParams)
1776 return nullptr;
1777
1778 FunctionDecl *Instantiated = nullptr;
1779 if (CXXMethodDecl *DMethod = dyn_cast<CXXMethodDecl>(D->getTemplatedDecl()))
1780 Instantiated = cast_or_null<FunctionDecl>(VisitCXXMethodDecl(DMethod,
1781 InstParams));
1782 else
1783 Instantiated = cast_or_null<FunctionDecl>(VisitFunctionDecl(
1784 D->getTemplatedDecl(),
1785 InstParams));
1786
1787 if (!Instantiated)
1788 return nullptr;
1789
1790 // Link the instantiated function template declaration to the function
1791 // template from which it was instantiated.
1792 FunctionTemplateDecl *InstTemplate
1793 = Instantiated->getDescribedFunctionTemplate();
1794 InstTemplate->setAccess(D->getAccess());
1795 assert(InstTemplate &&((void)0)
1796 "VisitFunctionDecl/CXXMethodDecl didn't create a template!")((void)0);
1797
1798 bool isFriend = (InstTemplate->getFriendObjectKind() != Decl::FOK_None);
1799
1800 // Link the instantiation back to the pattern *unless* this is a
1801 // non-definition friend declaration.
1802 if (!InstTemplate->getInstantiatedFromMemberTemplate() &&
1803 !(isFriend && !D->getTemplatedDecl()->isThisDeclarationADefinition()))
1804 InstTemplate->setInstantiatedFromMemberTemplate(D);
1805
1806 // Make declarations visible in the appropriate context.
1807 if (!isFriend) {
1808 Owner->addDecl(InstTemplate);
1809 } else if (InstTemplate->getDeclContext()->isRecord() &&
1810 !getPreviousDeclForInstantiation(D)) {
1811 SemaRef.CheckFriendAccess(InstTemplate);
1812 }
1813
1814 return InstTemplate;
1815}
1816
1817Decl *TemplateDeclInstantiator::VisitCXXRecordDecl(CXXRecordDecl *D) {
1818 CXXRecordDecl *PrevDecl = nullptr;
1819 if (D->isInjectedClassName())
1820 PrevDecl = cast<CXXRecordDecl>(Owner);
1821 else if (CXXRecordDecl *PatternPrev = getPreviousDeclForInstantiation(D)) {
1822 NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(),
1823 PatternPrev,
1824 TemplateArgs);
1825 if (!Prev) return nullptr;
1826 PrevDecl = cast<CXXRecordDecl>(Prev);
1827 }
1828
1829 CXXRecordDecl *Record = nullptr;
1830 if (D->isLambda())
1831 Record = CXXRecordDecl::CreateLambda(
1832 SemaRef.Context, Owner, D->getLambdaTypeInfo(), D->getLocation(),
1833 D->isDependentLambda(), D->isGenericLambda(),
1834 D->getLambdaCaptureDefault());
1835 else
1836 Record = CXXRecordDecl::Create(SemaRef.Context, D->getTagKind(), Owner,
1837 D->getBeginLoc(), D->getLocation(),
1838 D->getIdentifier(), PrevDecl);
1839
1840 // Substitute the nested name specifier, if any.
1841 if (SubstQualifier(D, Record))
1842 return nullptr;
1843
1844 SemaRef.InstantiateAttrsForDecl(TemplateArgs, D, Record, LateAttrs,
1845 StartingScope);
1846
1847 Record->setImplicit(D->isImplicit());
1848 // FIXME: Check against AS_none is an ugly hack to work around the issue that
1849 // the tag decls introduced by friend class declarations don't have an access
1850 // specifier. Remove once this area of the code gets sorted out.
1851 if (D->getAccess() != AS_none)
1852 Record->setAccess(D->getAccess());
1853 if (!D->isInjectedClassName())
1854 Record->setInstantiationOfMemberClass(D, TSK_ImplicitInstantiation);
1855
1856 // If the original function was part of a friend declaration,
1857 // inherit its namespace state.
1858 if (D->getFriendObjectKind())
1859 Record->setObjectOfFriendDecl();
1860
1861 // Make sure that anonymous structs and unions are recorded.
1862 if (D->isAnonymousStructOrUnion())
1863 Record->setAnonymousStructOrUnion(true);
1864
1865 if (D->isLocalClass())
1866 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Record);
1867
1868 // Forward the mangling number from the template to the instantiated decl.
1869 SemaRef.Context.setManglingNumber(Record,
1870 SemaRef.Context.getManglingNumber(D));
1871
1872 // See if the old tag was defined along with a declarator.
1873 // If it did, mark the new tag as being associated with that declarator.
1874 if (DeclaratorDecl *DD = SemaRef.Context.getDeclaratorForUnnamedTagDecl(D))
1875 SemaRef.Context.addDeclaratorForUnnamedTagDecl(Record, DD);
1876
1877 // See if the old tag was defined along with a typedef.
1878 // If it did, mark the new tag as being associated with that typedef.
1879 if (TypedefNameDecl *TND = SemaRef.Context.getTypedefNameForUnnamedTagDecl(D))
1880 SemaRef.Context.addTypedefNameForUnnamedTagDecl(Record, TND);
1881
1882 Owner->addDecl(Record);
1883
1884 // DR1484 clarifies that the members of a local class are instantiated as part
1885 // of the instantiation of their enclosing entity.
1886 if (D->isCompleteDefinition() && D->isLocalClass()) {
1887 Sema::LocalEagerInstantiationScope LocalInstantiations(SemaRef);
1888
1889 SemaRef.InstantiateClass(D->getLocation(), Record, D, TemplateArgs,
1890 TSK_ImplicitInstantiation,
1891 /*Complain=*/true);
1892
1893 // For nested local classes, we will instantiate the members when we
1894 // reach the end of the outermost (non-nested) local class.
1895 if (!D->isCXXClassMember())
1896 SemaRef.InstantiateClassMembers(D->getLocation(), Record, TemplateArgs,
1897 TSK_ImplicitInstantiation);
1898
1899 // This class may have local implicit instantiations that need to be
1900 // performed within this scope.
1901 LocalInstantiations.perform();
1902 }
1903
1904 SemaRef.DiagnoseUnusedNestedTypedefs(Record);
1905
1906 return Record;
1907}
1908
1909/// Adjust the given function type for an instantiation of the
1910/// given declaration, to cope with modifications to the function's type that
1911/// aren't reflected in the type-source information.
1912///
1913/// \param D The declaration we're instantiating.
1914/// \param TInfo The already-instantiated type.
1915static QualType adjustFunctionTypeForInstantiation(ASTContext &Context,
1916 FunctionDecl *D,
1917 TypeSourceInfo *TInfo) {
1918 const FunctionProtoType *OrigFunc
1919 = D->getType()->castAs<FunctionProtoType>();
1920 const FunctionProtoType *NewFunc
1921 = TInfo->getType()->castAs<FunctionProtoType>();
1922 if (OrigFunc->getExtInfo() == NewFunc->getExtInfo())
1923 return TInfo->getType();
1924
1925 FunctionProtoType::ExtProtoInfo NewEPI = NewFunc->getExtProtoInfo();
1926 NewEPI.ExtInfo = OrigFunc->getExtInfo();
1927 return Context.getFunctionType(NewFunc->getReturnType(),
1928 NewFunc->getParamTypes(), NewEPI);
1929}
1930
1931/// Normal class members are of more specific types and therefore
1932/// don't make it here. This function serves three purposes:
1933/// 1) instantiating function templates
1934/// 2) substituting friend declarations
1935/// 3) substituting deduction guide declarations for nested class templates
1936Decl *TemplateDeclInstantiator::VisitFunctionDecl(
1937 FunctionDecl *D, TemplateParameterList *TemplateParams,
1938 RewriteKind FunctionRewriteKind) {
1939 // Check whether there is already a function template specialization for
1940 // this declaration.
1941 FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate();
1942 if (FunctionTemplate && !TemplateParams) {
1943 ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
1944
1945 void *InsertPos = nullptr;
1946 FunctionDecl *SpecFunc
1947 = FunctionTemplate->findSpecialization(Innermost, InsertPos);
1948
1949 // If we already have a function template specialization, return it.
1950 if (SpecFunc)
1951 return SpecFunc;
1952 }
1953
1954 bool isFriend;
1955 if (FunctionTemplate)
1956 isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None);
1957 else
1958 isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
1959
1960 bool MergeWithParentScope = (TemplateParams != nullptr) ||
1961 Owner->isFunctionOrMethod() ||
1962 !(isa<Decl>(Owner) &&
1963 cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
1964 LocalInstantiationScope Scope(SemaRef, MergeWithParentScope);
1965
1966 ExplicitSpecifier InstantiatedExplicitSpecifier;
1967 if (auto *DGuide = dyn_cast<CXXDeductionGuideDecl>(D)) {
1968 InstantiatedExplicitSpecifier = instantiateExplicitSpecifier(
1969 SemaRef, TemplateArgs, DGuide->getExplicitSpecifier(), DGuide);
1970 if (InstantiatedExplicitSpecifier.isInvalid())
1971 return nullptr;
1972 }
1973
1974 SmallVector<ParmVarDecl *, 4> Params;
1975 TypeSourceInfo *TInfo = SubstFunctionType(D, Params);
1976 if (!TInfo)
1977 return nullptr;
1978 QualType T = adjustFunctionTypeForInstantiation(SemaRef.Context, D, TInfo);
1979
1980 if (TemplateParams && TemplateParams->size()) {
1981 auto *LastParam =
1982 dyn_cast<TemplateTypeParmDecl>(TemplateParams->asArray().back());
1983 if (LastParam && LastParam->isImplicit() &&
1984 LastParam->hasTypeConstraint()) {
1985 // In abbreviated templates, the type-constraints of invented template
1986 // type parameters are instantiated with the function type, invalidating
1987 // the TemplateParameterList which relied on the template type parameter
1988 // not having a type constraint. Recreate the TemplateParameterList with
1989 // the updated parameter list.
1990 TemplateParams = TemplateParameterList::Create(
1991 SemaRef.Context, TemplateParams->getTemplateLoc(),
1992 TemplateParams->getLAngleLoc(), TemplateParams->asArray(),
1993 TemplateParams->getRAngleLoc(), TemplateParams->getRequiresClause());
1994 }
1995 }
1996
1997 NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
1998 if (QualifierLoc) {
1999 QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
2000 TemplateArgs);
2001 if (!QualifierLoc)
2002 return nullptr;
2003 }
2004
2005 // FIXME: Concepts: Do not substitute into constraint expressions
2006 Expr *TrailingRequiresClause = D->getTrailingRequiresClause();
2007 if (TrailingRequiresClause) {
2008 EnterExpressionEvaluationContext ConstantEvaluated(
2009 SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
2010 ExprResult SubstRC = SemaRef.SubstExpr(TrailingRequiresClause,
2011 TemplateArgs);
2012 if (SubstRC.isInvalid())
2013 return nullptr;
2014 TrailingRequiresClause = SubstRC.get();
2015 if (!SemaRef.CheckConstraintExpression(TrailingRequiresClause))
2016 return nullptr;
2017 }
2018
2019 // If we're instantiating a local function declaration, put the result
2020 // in the enclosing namespace; otherwise we need to find the instantiated
2021 // context.
2022 DeclContext *DC;
2023 if (D->isLocalExternDecl()) {
2024 DC = Owner;
2025 SemaRef.adjustContextForLocalExternDecl(DC);
2026 } else if (isFriend && QualifierLoc) {
2027 CXXScopeSpec SS;
2028 SS.Adopt(QualifierLoc);
2029 DC = SemaRef.computeDeclContext(SS);
2030 if (!DC) return nullptr;
2031 } else {
2032 DC = SemaRef.FindInstantiatedContext(D->getLocation(), D->getDeclContext(),
2033 TemplateArgs);
2034 }
2035
2036 DeclarationNameInfo NameInfo
2037 = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
2038
2039 if (FunctionRewriteKind != RewriteKind::None)
2040 adjustForRewrite(FunctionRewriteKind, D, T, TInfo, NameInfo);
2041
2042 FunctionDecl *Function;
2043 if (auto *DGuide = dyn_cast<CXXDeductionGuideDecl>(D)) {
2044 Function = CXXDeductionGuideDecl::Create(
2045 SemaRef.Context, DC, D->getInnerLocStart(),
2046 InstantiatedExplicitSpecifier, NameInfo, T, TInfo,
2047 D->getSourceRange().getEnd());
2048 if (DGuide->isCopyDeductionCandidate())
2049 cast<CXXDeductionGuideDecl>(Function)->setIsCopyDeductionCandidate();
2050 Function->setAccess(D->getAccess());
2051 } else {
2052 Function = FunctionDecl::Create(
2053 SemaRef.Context, DC, D->getInnerLocStart(), NameInfo, T, TInfo,
2054 D->getCanonicalDecl()->getStorageClass(), D->isInlineSpecified(),
2055 D->hasWrittenPrototype(), D->getConstexprKind(),
2056 TrailingRequiresClause);
2057 Function->setRangeEnd(D->getSourceRange().getEnd());
2058 }
2059
2060 if (D->isInlined())
2061 Function->setImplicitlyInline();
2062
2063 if (QualifierLoc)
2064 Function->setQualifierInfo(QualifierLoc);
2065
2066 if (D->isLocalExternDecl())
2067 Function->setLocalExternDecl();
2068
2069 DeclContext *LexicalDC = Owner;
2070 if (!isFriend && D->isOutOfLine() && !D->isLocalExternDecl()) {
2071 assert(D->getDeclContext()->isFileContext())((void)0);
2072 LexicalDC = D->getDeclContext();
2073 }
2074
2075 Function->setLexicalDeclContext(LexicalDC);
2076
2077 // Attach the parameters
2078 for (unsigned P = 0; P < Params.size(); ++P)
2079 if (Params[P])
2080 Params[P]->setOwningFunction(Function);
2081 Function->setParams(Params);
2082
2083 if (TrailingRequiresClause)
2084 Function->setTrailingRequiresClause(TrailingRequiresClause);
2085
2086 if (TemplateParams) {
2087 // Our resulting instantiation is actually a function template, since we
2088 // are substituting only the outer template parameters. For example, given
2089 //
2090 // template<typename T>
2091 // struct X {
2092 // template<typename U> friend void f(T, U);
2093 // };
2094 //
2095 // X<int> x;
2096 //
2097 // We are instantiating the friend function template "f" within X<int>,
2098 // which means substituting int for T, but leaving "f" as a friend function
2099 // template.
2100 // Build the function template itself.
2101 FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, DC,
2102 Function->getLocation(),
2103 Function->getDeclName(),
2104 TemplateParams, Function);
2105 Function->setDescribedFunctionTemplate(FunctionTemplate);
2106
2107 FunctionTemplate->setLexicalDeclContext(LexicalDC);
2108
2109 if (isFriend && D->isThisDeclarationADefinition()) {
2110 FunctionTemplate->setInstantiatedFromMemberTemplate(
2111 D->getDescribedFunctionTemplate());
2112 }
2113 } else if (FunctionTemplate) {
2114 // Record this function template specialization.
2115 ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
2116 Function->setFunctionTemplateSpecialization(FunctionTemplate,
2117 TemplateArgumentList::CreateCopy(SemaRef.Context,
2118 Innermost),
2119 /*InsertPos=*/nullptr);
2120 } else if (isFriend && D->isThisDeclarationADefinition()) {
2121 // Do not connect the friend to the template unless it's actually a
2122 // definition. We don't want non-template functions to be marked as being
2123 // template instantiations.
2124 Function->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation);
2125 }
2126
2127 if (isFriend) {
2128 Function->setObjectOfFriendDecl();
2129 if (FunctionTemplateDecl *FT = Function->getDescribedFunctionTemplate())
2130 FT->setObjectOfFriendDecl();
2131 }
2132
2133 if (InitFunctionInstantiation(Function, D))
2134 Function->setInvalidDecl();
2135
2136 bool IsExplicitSpecialization = false;
2137
2138 LookupResult Previous(
2139 SemaRef, Function->getDeclName(), SourceLocation(),
2140 D->isLocalExternDecl() ? Sema::LookupRedeclarationWithLinkage
2141 : Sema::LookupOrdinaryName,
2142 D->isLocalExternDecl() ? Sema::ForExternalRedeclaration
2143 : SemaRef.forRedeclarationInCurContext());
2144
2145 if (DependentFunctionTemplateSpecializationInfo *Info
2146 = D->getDependentSpecializationInfo()) {
2147 assert(isFriend && "non-friend has dependent specialization info?")((void)0);
2148
2149 // Instantiate the explicit template arguments.
2150 TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(),
2151 Info->getRAngleLoc());
2152 if (SemaRef.Subst(Info->getTemplateArgs(), Info->getNumTemplateArgs(),
2153 ExplicitArgs, TemplateArgs))
2154 return nullptr;
2155
2156 // Map the candidate templates to their instantiations.
2157 for (unsigned I = 0, E = Info->getNumTemplates(); I != E; ++I) {
2158 Decl *Temp = SemaRef.FindInstantiatedDecl(D->getLocation(),
2159 Info->getTemplate(I),
2160 TemplateArgs);
2161 if (!Temp) return nullptr;
2162
2163 Previous.addDecl(cast<FunctionTemplateDecl>(Temp));
2164 }
2165
2166 if (SemaRef.CheckFunctionTemplateSpecialization(Function,
2167 &ExplicitArgs,
2168 Previous))
2169 Function->setInvalidDecl();
2170
2171 IsExplicitSpecialization = true;
2172 } else if (const ASTTemplateArgumentListInfo *Info =
2173 D->getTemplateSpecializationArgsAsWritten()) {
2174 // The name of this function was written as a template-id.
2175 SemaRef.LookupQualifiedName(Previous, DC);
2176
2177 // Instantiate the explicit template arguments.
2178 TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(),
2179 Info->getRAngleLoc());
2180 if (SemaRef.Subst(Info->getTemplateArgs(), Info->getNumTemplateArgs(),
2181 ExplicitArgs, TemplateArgs))
2182 return nullptr;
2183
2184 if (SemaRef.CheckFunctionTemplateSpecialization(Function,
2185 &ExplicitArgs,
2186 Previous))
2187 Function->setInvalidDecl();
2188
2189 IsExplicitSpecialization = true;
2190 } else if (TemplateParams || !FunctionTemplate) {
2191 // Look only into the namespace where the friend would be declared to
2192 // find a previous declaration. This is the innermost enclosing namespace,
2193 // as described in ActOnFriendFunctionDecl.
2194 SemaRef.LookupQualifiedName(Previous, DC->getRedeclContext());
2195
2196 // In C++, the previous declaration we find might be a tag type
2197 // (class or enum). In this case, the new declaration will hide the
2198 // tag type. Note that this does does not apply if we're declaring a
2199 // typedef (C++ [dcl.typedef]p4).
2200 if (Previous.isSingleTagDecl())
2201 Previous.clear();
2202
2203 // Filter out previous declarations that don't match the scope. The only
2204 // effect this has is to remove declarations found in inline namespaces
2205 // for friend declarations with unqualified names.
2206 SemaRef.FilterLookupForScope(Previous, DC, /*Scope*/ nullptr,
2207 /*ConsiderLinkage*/ true,
2208 QualifierLoc.hasQualifier());
2209 }
2210
2211 SemaRef.CheckFunctionDeclaration(/*Scope*/ nullptr, Function, Previous,
2212 IsExplicitSpecialization);
2213
2214 // Check the template parameter list against the previous declaration. The
2215 // goal here is to pick up default arguments added since the friend was
2216 // declared; we know the template parameter lists match, since otherwise
2217 // we would not have picked this template as the previous declaration.
2218 if (isFriend && TemplateParams && FunctionTemplate->getPreviousDecl()) {
2219 SemaRef.CheckTemplateParameterList(
2220 TemplateParams,
2221 FunctionTemplate->getPreviousDecl()->getTemplateParameters(),
2222 Function->isThisDeclarationADefinition()
2223 ? Sema::TPC_FriendFunctionTemplateDefinition
2224 : Sema::TPC_FriendFunctionTemplate);
2225 }
2226
2227 // If we're introducing a friend definition after the first use, trigger
2228 // instantiation.
2229 // FIXME: If this is a friend function template definition, we should check
2230 // to see if any specializations have been used.
2231 if (isFriend && D->isThisDeclarationADefinition() && Function->isUsed(false)) {
2232 if (MemberSpecializationInfo *MSInfo =
2233 Function->getMemberSpecializationInfo()) {
2234 if (MSInfo->getPointOfInstantiation().isInvalid()) {
2235 SourceLocation Loc = D->getLocation(); // FIXME
2236 MSInfo->setPointOfInstantiation(Loc);
2237 SemaRef.PendingLocalImplicitInstantiations.push_back(
2238 std::make_pair(Function, Loc));
2239 }
2240 }
2241 }
2242
2243 if (D->isExplicitlyDefaulted()) {
2244 if (SubstDefaultedFunction(Function, D))
2245 return nullptr;
2246 }
2247 if (D->isDeleted())
2248 SemaRef.SetDeclDeleted(Function, D->getLocation());
2249
2250 NamedDecl *PrincipalDecl =
2251 (TemplateParams ? cast<NamedDecl>(FunctionTemplate) : Function);
2252
2253 // If this declaration lives in a different context from its lexical context,
2254 // add it to the corresponding lookup table.
2255 if (isFriend ||
2256 (Function->isLocalExternDecl() && !Function->getPreviousDecl()))
2257 DC->makeDeclVisibleInContext(PrincipalDecl);
2258
2259 if (Function->isOverloadedOperator() && !DC->isRecord() &&
2260 PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
2261 PrincipalDecl->setNonMemberOperator();
2262
2263 return Function;
2264}
2265
2266Decl *TemplateDeclInstantiator::VisitCXXMethodDecl(
2267 CXXMethodDecl *D, TemplateParameterList *TemplateParams,
2268 Optional<const ASTTemplateArgumentListInfo *> ClassScopeSpecializationArgs,
2269 RewriteKind FunctionRewriteKind) {
2270 FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate();
2271 if (FunctionTemplate && !TemplateParams) {
2272 // We are creating a function template specialization from a function
2273 // template. Check whether there is already a function template
2274 // specialization for this particular set of template arguments.
2275 ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
2276
2277 void *InsertPos = nullptr;
2278 FunctionDecl *SpecFunc
2279 = FunctionTemplate->findSpecialization(Innermost, InsertPos);
2280
2281 // If we already have a function template specialization, return it.
2282 if (SpecFunc)
2283 return SpecFunc;
2284 }
2285
2286 bool isFriend;
2287 if (FunctionTemplate)
2288 isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None);
2289 else
2290 isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
2291
2292 bool MergeWithParentScope = (TemplateParams != nullptr) ||
2293 !(isa<Decl>(Owner) &&
2294 cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
2295 LocalInstantiationScope Scope(SemaRef, MergeWithParentScope);
2296
2297 // Instantiate enclosing template arguments for friends.
2298 SmallVector<TemplateParameterList *, 4> TempParamLists;
2299 unsigned NumTempParamLists = 0;
2300 if (isFriend && (NumTempParamLists = D->getNumTemplateParameterLists())) {
2301 TempParamLists.resize(NumTempParamLists);
2302 for (unsigned I = 0; I != NumTempParamLists; ++I) {
2303 TemplateParameterList *TempParams = D->getTemplateParameterList(I);
2304 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
2305 if (!InstParams)
2306 return nullptr;
2307 TempParamLists[I] = InstParams;
2308 }
2309 }
2310
2311 ExplicitSpecifier InstantiatedExplicitSpecifier =
2312 instantiateExplicitSpecifier(SemaRef, TemplateArgs,
2313 ExplicitSpecifier::getFromDecl(D), D);
2314 if (InstantiatedExplicitSpecifier.isInvalid())
2315 return nullptr;
2316
2317 // Implicit destructors/constructors created for local classes in
2318 // DeclareImplicit* (see SemaDeclCXX.cpp) might not have an associated TSI.
2319 // Unfortunately there isn't enough context in those functions to
2320 // conditionally populate the TSI without breaking non-template related use
2321 // cases. Populate TSIs prior to calling SubstFunctionType to make sure we get
2322 // a proper transformation.
2323 if (cast<CXXRecordDecl>(D->getParent())->isLambda() &&
2324 !D->getTypeSourceInfo() &&
2325 isa<CXXConstructorDecl, CXXDestructorDecl>(D)) {
2326 TypeSourceInfo *TSI =
2327 SemaRef.Context.getTrivialTypeSourceInfo(D->getType());
2328 D->setTypeSourceInfo(TSI);
2329 }
2330
2331 SmallVector<ParmVarDecl *, 4> Params;
2332 TypeSourceInfo *TInfo = SubstFunctionType(D, Params);
2333 if (!TInfo)
2334 return nullptr;
2335 QualType T = adjustFunctionTypeForInstantiation(SemaRef.Context, D, TInfo);
2336
2337 if (TemplateParams && TemplateParams->size()) {
2338 auto *LastParam =
2339 dyn_cast<TemplateTypeParmDecl>(TemplateParams->asArray().back());
2340 if (LastParam && LastParam->isImplicit() &&
2341 LastParam->hasTypeConstraint()) {
2342 // In abbreviated templates, the type-constraints of invented template
2343 // type parameters are instantiated with the function type, invalidating
2344 // the TemplateParameterList which relied on the template type parameter
2345 // not having a type constraint. Recreate the TemplateParameterList with
2346 // the updated parameter list.
2347 TemplateParams = TemplateParameterList::Create(
2348 SemaRef.Context, TemplateParams->getTemplateLoc(),
2349 TemplateParams->getLAngleLoc(), TemplateParams->asArray(),
2350 TemplateParams->getRAngleLoc(), TemplateParams->getRequiresClause());
2351 }
2352 }
2353
2354 NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
2355 if (QualifierLoc) {
2356 QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
2357 TemplateArgs);
2358 if (!QualifierLoc)
2359 return nullptr;
2360 }
2361
2362 // FIXME: Concepts: Do not substitute into constraint expressions
2363 Expr *TrailingRequiresClause = D->getTrailingRequiresClause();
2364 if (TrailingRequiresClause) {
2365 EnterExpressionEvaluationContext ConstantEvaluated(
2366 SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
2367 auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(Owner);
2368 Sema::CXXThisScopeRAII ThisScope(SemaRef, ThisContext,
2369 D->getMethodQualifiers(), ThisContext);
2370 ExprResult SubstRC = SemaRef.SubstExpr(TrailingRequiresClause,
2371 TemplateArgs);
2372 if (SubstRC.isInvalid())
2373 return nullptr;
2374 TrailingRequiresClause = SubstRC.get();
2375 if (!SemaRef.CheckConstraintExpression(TrailingRequiresClause))
2376 return nullptr;
2377 }
2378
2379 DeclContext *DC = Owner;
2380 if (isFriend) {
2381 if (QualifierLoc) {
2382 CXXScopeSpec SS;
2383 SS.Adopt(QualifierLoc);
2384 DC = SemaRef.computeDeclContext(SS);
2385
2386 if (DC && SemaRef.RequireCompleteDeclContext(SS, DC))
2387 return nullptr;
2388 } else {
2389 DC = SemaRef.FindInstantiatedContext(D->getLocation(),
2390 D->getDeclContext(),
2391 TemplateArgs);
2392 }
2393 if (!DC) return nullptr;
2394 }
2395
2396 DeclarationNameInfo NameInfo
2397 = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
2398
2399 if (FunctionRewriteKind != RewriteKind::None)
2400 adjustForRewrite(FunctionRewriteKind, D, T, TInfo, NameInfo);
2401
2402 // Build the instantiated method declaration.
2403 CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
2404 CXXMethodDecl *Method = nullptr;
2405
2406 SourceLocation StartLoc = D->getInnerLocStart();
2407 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
2408 Method = CXXConstructorDecl::Create(
2409 SemaRef.Context, Record, StartLoc, NameInfo, T, TInfo,
2410 InstantiatedExplicitSpecifier, Constructor->isInlineSpecified(), false,
2411 Constructor->getConstexprKind(), InheritedConstructor(),
2412 TrailingRequiresClause);
2413 Method->setRangeEnd(Constructor->getEndLoc());
2414 } else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(D)) {
2415 Method = CXXDestructorDecl::Create(
2416 SemaRef.Context, Record, StartLoc, NameInfo, T, TInfo,
2417 Destructor->isInlineSpecified(), false, Destructor->getConstexprKind(),
2418 TrailingRequiresClause);
2419 Method->setRangeEnd(Destructor->getEndLoc());
2420 Method->setDeclName(SemaRef.Context.DeclarationNames.getCXXDestructorName(
2421 SemaRef.Context.getCanonicalType(
2422 SemaRef.Context.getTypeDeclType(Record))));
2423 } else if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) {
2424 Method = CXXConversionDecl::Create(
2425 SemaRef.Context, Record, StartLoc, NameInfo, T, TInfo,
2426 Conversion->isInlineSpecified(), InstantiatedExplicitSpecifier,
2427 Conversion->getConstexprKind(), Conversion->getEndLoc(),
2428 TrailingRequiresClause);
2429 } else {
2430 StorageClass SC = D->isStatic() ? SC_Static : SC_None;
2431 Method = CXXMethodDecl::Create(SemaRef.Context, Record, StartLoc, NameInfo,
2432 T, TInfo, SC, D->isInlineSpecified(),
2433 D->getConstexprKind(), D->getEndLoc(),
2434 TrailingRequiresClause);
2435 }
2436
2437 if (D->isInlined())
2438 Method->setImplicitlyInline();
2439
2440 if (QualifierLoc)
2441 Method->setQualifierInfo(QualifierLoc);
2442
2443 if (TemplateParams) {
2444 // Our resulting instantiation is actually a function template, since we
2445 // are substituting only the outer template parameters. For example, given
2446 //
2447 // template<typename T>
2448 // struct X {
2449 // template<typename U> void f(T, U);
2450 // };
2451 //
2452 // X<int> x;
2453 //
2454 // We are instantiating the member template "f" within X<int>, which means
2455 // substituting int for T, but leaving "f" as a member function template.
2456 // Build the function template itself.
2457 FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, Record,
2458 Method->getLocation(),
2459 Method->getDeclName(),
2460 TemplateParams, Method);
2461 if (isFriend) {
2462 FunctionTemplate->setLexicalDeclContext(Owner);
2463 FunctionTemplate->setObjectOfFriendDecl();
2464 } else if (D->isOutOfLine())
2465 FunctionTemplate->setLexicalDeclContext(D->getLexicalDeclContext());
2466 Method->setDescribedFunctionTemplate(FunctionTemplate);
2467 } else if (FunctionTemplate) {
2468 // Record this function template specialization.
2469 ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
2470 Method->setFunctionTemplateSpecialization(FunctionTemplate,
2471 TemplateArgumentList::CreateCopy(SemaRef.Context,
2472 Innermost),
2473 /*InsertPos=*/nullptr);
2474 } else if (!isFriend) {
2475 // Record that this is an instantiation of a member function.
2476 Method->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation);
2477 }
2478
2479 // If we are instantiating a member function defined
2480 // out-of-line, the instantiation will have the same lexical
2481 // context (which will be a namespace scope) as the template.
2482 if (isFriend) {
2483 if (NumTempParamLists)
2484 Method->setTemplateParameterListsInfo(
2485 SemaRef.Context,
2486 llvm::makeArrayRef(TempParamLists.data(), NumTempParamLists));
2487
2488 Method->setLexicalDeclContext(Owner);
2489 Method->setObjectOfFriendDecl();
2490 } else if (D->isOutOfLine())
2491 Method->setLexicalDeclContext(D->getLexicalDeclContext());
2492
2493 // Attach the parameters
2494 for (unsigned P = 0; P < Params.size(); ++P)
2495 Params[P]->setOwningFunction(Method);
2496 Method->setParams(Params);
2497
2498 if (InitMethodInstantiation(Method, D))
2499 Method->setInvalidDecl();
2500
2501 LookupResult Previous(SemaRef, NameInfo, Sema::LookupOrdinaryName,
2502 Sema::ForExternalRedeclaration);
2503
2504 bool IsExplicitSpecialization = false;
2505
2506 // If the name of this function was written as a template-id, instantiate
2507 // the explicit template arguments.
2508 if (DependentFunctionTemplateSpecializationInfo *Info
2509 = D->getDependentSpecializationInfo()) {
2510 assert(isFriend && "non-friend has dependent specialization info?")((void)0);
2511
2512 // Instantiate the explicit template arguments.
2513 TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(),
2514 Info->getRAngleLoc());
2515 if (SemaRef.Subst(Info->getTemplateArgs(), Info->getNumTemplateArgs(),
2516 ExplicitArgs, TemplateArgs))
2517 return nullptr;
2518
2519 // Map the candidate templates to their instantiations.
2520 for (unsigned I = 0, E = Info->getNumTemplates(); I != E; ++I) {
2521 Decl *Temp = SemaRef.FindInstantiatedDecl(D->getLocation(),
2522 Info->getTemplate(I),
2523 TemplateArgs);
2524 if (!Temp) return nullptr;
2525
2526 Previous.addDecl(cast<FunctionTemplateDecl>(Temp));
2527 }
2528
2529 if (SemaRef.CheckFunctionTemplateSpecialization(Method,
2530 &ExplicitArgs,
2531 Previous))
2532 Method->setInvalidDecl();
2533
2534 IsExplicitSpecialization = true;
2535 } else if (const ASTTemplateArgumentListInfo *Info =
2536 ClassScopeSpecializationArgs.getValueOr(
2537 D->getTemplateSpecializationArgsAsWritten())) {
2538 SemaRef.LookupQualifiedName(Previous, DC);
2539
2540 TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(),
2541 Info->getRAngleLoc());
2542 if (SemaRef.Subst(Info->getTemplateArgs(), Info->getNumTemplateArgs(),
2543 ExplicitArgs, TemplateArgs))
2544 return nullptr;
2545
2546 if (SemaRef.CheckFunctionTemplateSpecialization(Method,
2547 &ExplicitArgs,
2548 Previous))
2549 Method->setInvalidDecl();
2550
2551 IsExplicitSpecialization = true;
2552 } else if (ClassScopeSpecializationArgs) {
2553 // Class-scope explicit specialization written without explicit template
2554 // arguments.
2555 SemaRef.LookupQualifiedName(Previous, DC);
2556 if (SemaRef.CheckFunctionTemplateSpecialization(Method, nullptr, Previous))
2557 Method->setInvalidDecl();
2558
2559 IsExplicitSpecialization = true;
2560 } else if (!FunctionTemplate || TemplateParams || isFriend) {
2561 SemaRef.LookupQualifiedName(Previous, Record);
2562
2563 // In C++, the previous declaration we find might be a tag type
2564 // (class or enum). In this case, the new declaration will hide the
2565 // tag type. Note that this does does not apply if we're declaring a
2566 // typedef (C++ [dcl.typedef]p4).
2567 if (Previous.isSingleTagDecl())
2568 Previous.clear();
2569 }
2570
2571 SemaRef.CheckFunctionDeclaration(nullptr, Method, Previous,
2572 IsExplicitSpecialization);
2573
2574 if (D->isPure())
2575 SemaRef.CheckPureMethod(Method, SourceRange());
2576
2577 // Propagate access. For a non-friend declaration, the access is
2578 // whatever we're propagating from. For a friend, it should be the
2579 // previous declaration we just found.
2580 if (isFriend && Method->getPreviousDecl())
2581 Method->setAccess(Method->getPreviousDecl()->getAccess());
2582 else
2583 Method->setAccess(D->getAccess());
2584 if (FunctionTemplate)
2585 FunctionTemplate->setAccess(Method->getAccess());
2586
2587 SemaRef.CheckOverrideControl(Method);
2588
2589 // If a function is defined as defaulted or deleted, mark it as such now.
2590 if (D->isExplicitlyDefaulted()) {
2591 if (SubstDefaultedFunction(Method, D))
2592 return nullptr;
2593 }
2594 if (D->isDeletedAsWritten())
2595 SemaRef.SetDeclDeleted(Method, Method->getLocation());
2596
2597 // If this is an explicit specialization, mark the implicitly-instantiated
2598 // template specialization as being an explicit specialization too.
2599 // FIXME: Is this necessary?
2600 if (IsExplicitSpecialization && !isFriend)
2601 SemaRef.CompleteMemberSpecialization(Method, Previous);
2602
2603 // If there's a function template, let our caller handle it.
2604 if (FunctionTemplate) {
2605 // do nothing
2606
2607 // Don't hide a (potentially) valid declaration with an invalid one.
2608 } else if (Method->isInvalidDecl() && !Previous.empty()) {
2609 // do nothing
2610
2611 // Otherwise, check access to friends and make them visible.
2612 } else if (isFriend) {
2613 // We only need to re-check access for methods which we didn't
2614 // manage to match during parsing.
2615 if (!D->getPreviousDecl())
2616 SemaRef.CheckFriendAccess(Method);
2617
2618 Record->makeDeclVisibleInContext(Method);
2619
2620 // Otherwise, add the declaration. We don't need to do this for
2621 // class-scope specializations because we'll have matched them with
2622 // the appropriate template.
2623 } else {
2624 Owner->addDecl(Method);
2625 }
2626
2627 // PR17480: Honor the used attribute to instantiate member function
2628 // definitions
2629 if (Method->hasAttr<UsedAttr>()) {
2630 if (const auto *A = dyn_cast<CXXRecordDecl>(Owner)) {
2631 SourceLocation Loc;
2632 if (const MemberSpecializationInfo *MSInfo =
2633 A->getMemberSpecializationInfo())
2634 Loc = MSInfo->getPointOfInstantiation();
2635 else if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(A))
2636 Loc = Spec->getPointOfInstantiation();
2637 SemaRef.MarkFunctionReferenced(Loc, Method);
2638 }
2639 }
2640
2641 return Method;
2642}
2643
2644Decl *TemplateDeclInstantiator::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
2645 return VisitCXXMethodDecl(D);
2646}
2647
2648Decl *TemplateDeclInstantiator::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
2649 return VisitCXXMethodDecl(D);
2650}
2651
2652Decl *TemplateDeclInstantiator::VisitCXXConversionDecl(CXXConversionDecl *D) {
2653 return VisitCXXMethodDecl(D);
2654}
2655
2656Decl *TemplateDeclInstantiator::VisitParmVarDecl(ParmVarDecl *D) {
2657 return SemaRef.SubstParmVarDecl(D, TemplateArgs, /*indexAdjustment*/ 0, None,
2658 /*ExpectParameterPack=*/ false);
2659}
2660
2661Decl *TemplateDeclInstantiator::VisitTemplateTypeParmDecl(
2662 TemplateTypeParmDecl *D) {
2663 assert(D->getTypeForDecl()->isTemplateTypeParmType())((void)0);
2664
2665 Optional<unsigned> NumExpanded;
2666
2667 if (const TypeConstraint *TC = D->getTypeConstraint()) {
2668 if (D->isPackExpansion() && !D->isExpandedParameterPack()) {
2669 assert(TC->getTemplateArgsAsWritten() &&((void)0)
2670 "type parameter can only be an expansion when explicit arguments "((void)0)
2671 "are specified")((void)0);
2672 // The template type parameter pack's type is a pack expansion of types.
2673 // Determine whether we need to expand this parameter pack into separate
2674 // types.
2675 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
2676 for (auto &ArgLoc : TC->getTemplateArgsAsWritten()->arguments())
2677 SemaRef.collectUnexpandedParameterPacks(ArgLoc, Unexpanded);
2678
2679 // Determine whether the set of unexpanded parameter packs can and should
2680 // be expanded.
2681 bool Expand = true;
2682 bool RetainExpansion = false;
2683 if (SemaRef.CheckParameterPacksForExpansion(
2684 cast<CXXFoldExpr>(TC->getImmediatelyDeclaredConstraint())
2685 ->getEllipsisLoc(),
2686 SourceRange(TC->getConceptNameLoc(),
2687 TC->hasExplicitTemplateArgs() ?
2688 TC->getTemplateArgsAsWritten()->getRAngleLoc() :
2689 TC->getConceptNameInfo().getEndLoc()),
2690 Unexpanded, TemplateArgs, Expand, RetainExpansion, NumExpanded))
2691 return nullptr;
2692 }
2693 }
2694
2695 TemplateTypeParmDecl *Inst = TemplateTypeParmDecl::Create(
2696 SemaRef.Context, Owner, D->getBeginLoc(), D->getLocation(),
2697 D->getDepth() - TemplateArgs.getNumSubstitutedLevels(), D->getIndex(),
2698 D->getIdentifier(), D->wasDeclaredWithTypename(), D->isParameterPack(),
2699 D->hasTypeConstraint(), NumExpanded);
2700
2701 Inst->setAccess(AS_public);
2702 Inst->setImplicit(D->isImplicit());
2703 if (auto *TC = D->getTypeConstraint()) {
2704 if (!D->isImplicit()) {
2705 // Invented template parameter type constraints will be instantiated with
2706 // the corresponding auto-typed parameter as it might reference other
2707 // parameters.
2708
2709 // TODO: Concepts: do not instantiate the constraint (delayed constraint
2710 // substitution)
2711 const ASTTemplateArgumentListInfo *TemplArgInfo
2712 = TC->getTemplateArgsAsWritten();
2713 TemplateArgumentListInfo InstArgs;
2714
2715 if (TemplArgInfo) {
2716 InstArgs.setLAngleLoc(TemplArgInfo->LAngleLoc);
2717 InstArgs.setRAngleLoc(TemplArgInfo->RAngleLoc);
2718 if (SemaRef.Subst(TemplArgInfo->getTemplateArgs(),
2719 TemplArgInfo->NumTemplateArgs,
2720 InstArgs, TemplateArgs))
2721 return nullptr;
2722 }
2723 if (SemaRef.AttachTypeConstraint(
2724 TC->getNestedNameSpecifierLoc(), TC->getConceptNameInfo(),
2725 TC->getNamedConcept(), &InstArgs, Inst,
2726 D->isParameterPack()
2727 ? cast<CXXFoldExpr>(TC->getImmediatelyDeclaredConstraint())
2728 ->getEllipsisLoc()
2729 : SourceLocation()))
2730 return nullptr;
2731 }
2732 }
2733 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
2734 TypeSourceInfo *InstantiatedDefaultArg =
2735 SemaRef.SubstType(D->getDefaultArgumentInfo(), TemplateArgs,
2736 D->getDefaultArgumentLoc(), D->getDeclName());
2737 if (InstantiatedDefaultArg)
2738 Inst->setDefaultArgument(InstantiatedDefaultArg);
2739 }
2740
2741 // Introduce this template parameter's instantiation into the instantiation
2742 // scope.
2743 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Inst);
2744
2745 return Inst;
2746}
2747
2748Decl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl(
2749 NonTypeTemplateParmDecl *D) {
2750 // Substitute into the type of the non-type template parameter.
2751 TypeLoc TL = D->getTypeSourceInfo()->getTypeLoc();
2752 SmallVector<TypeSourceInfo *, 4> ExpandedParameterPackTypesAsWritten;
2753 SmallVector<QualType, 4> ExpandedParameterPackTypes;
2754 bool IsExpandedParameterPack = false;
2755 TypeSourceInfo *DI;
2756 QualType T;
2757 bool Invalid = false;
2758
2759 if (D->isExpandedParameterPack()) {
2760 // The non-type template parameter pack is an already-expanded pack
2761 // expansion of types. Substitute into each of the expanded types.
2762 ExpandedParameterPackTypes.reserve(D->getNumExpansionTypes());
2763 ExpandedParameterPackTypesAsWritten.reserve(D->getNumExpansionTypes());
2764 for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
2765 TypeSourceInfo *NewDI =
2766 SemaRef.SubstType(D->getExpansionTypeSourceInfo(I), TemplateArgs,
2767 D->getLocation(), D->getDeclName());
2768 if (!NewDI)
2769 return nullptr;
2770
2771 QualType NewT =
2772 SemaRef.CheckNonTypeTemplateParameterType(NewDI, D->getLocation());
2773 if (NewT.isNull())
2774 return nullptr;
2775
2776 ExpandedParameterPackTypesAsWritten.push_back(NewDI);
2777 ExpandedParameterPackTypes.push_back(NewT);
2778 }
2779
2780 IsExpandedParameterPack = true;
2781 DI = D->getTypeSourceInfo();
2782 T = DI->getType();
2783 } else if (D->isPackExpansion()) {
2784 // The non-type template parameter pack's type is a pack expansion of types.
2785 // Determine whether we need to expand this parameter pack into separate
2786 // types.
2787 PackExpansionTypeLoc Expansion = TL.castAs<PackExpansionTypeLoc>();
2788 TypeLoc Pattern = Expansion.getPatternLoc();
2789 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
2790 SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded);
2791
2792 // Determine whether the set of unexpanded parameter packs can and should
2793 // be expanded.
2794 bool Expand = true;
2795 bool RetainExpansion = false;
2796 Optional<unsigned> OrigNumExpansions
2797 = Expansion.getTypePtr()->getNumExpansions();
2798 Optional<unsigned> NumExpansions = OrigNumExpansions;
2799 if (SemaRef.CheckParameterPacksForExpansion(Expansion.getEllipsisLoc(),
2800 Pattern.getSourceRange(),
2801 Unexpanded,
2802 TemplateArgs,
2803 Expand, RetainExpansion,
2804 NumExpansions))
2805 return nullptr;
2806
2807 if (Expand) {
2808 for (unsigned I = 0; I != *NumExpansions; ++I) {
2809 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
2810 TypeSourceInfo *NewDI = SemaRef.SubstType(Pattern, TemplateArgs,
2811 D->getLocation(),
2812 D->getDeclName());
2813 if (!NewDI)
2814 return nullptr;
2815
2816 QualType NewT =
2817 SemaRef.CheckNonTypeTemplateParameterType(NewDI, D->getLocation());
2818 if (NewT.isNull())
2819 return nullptr;
2820
2821 ExpandedParameterPackTypesAsWritten.push_back(NewDI);
2822 ExpandedParameterPackTypes.push_back(NewT);
2823 }
2824
2825 // Note that we have an expanded parameter pack. The "type" of this
2826 // expanded parameter pack is the original expansion type, but callers
2827 // will end up using the expanded parameter pack types for type-checking.
2828 IsExpandedParameterPack = true;
2829 DI = D->getTypeSourceInfo();
2830 T = DI->getType();
2831 } else {
2832 // We cannot fully expand the pack expansion now, so substitute into the
2833 // pattern and create a new pack expansion type.
2834 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
2835 TypeSourceInfo *NewPattern = SemaRef.SubstType(Pattern, TemplateArgs,
2836 D->getLocation(),
2837 D->getDeclName());
2838 if (!NewPattern)
2839 return nullptr;
2840
2841 SemaRef.CheckNonTypeTemplateParameterType(NewPattern, D->getLocation());
2842 DI = SemaRef.CheckPackExpansion(NewPattern, Expansion.getEllipsisLoc(),
2843 NumExpansions);
2844 if (!DI)
2845 return nullptr;
2846
2847 T = DI->getType();
2848 }
2849 } else {
2850 // Simple case: substitution into a parameter that is not a parameter pack.
2851 DI = SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs,
2852 D->getLocation(), D->getDeclName());
2853 if (!DI)
2854 return nullptr;
2855
2856 // Check that this type is acceptable for a non-type template parameter.
2857 T = SemaRef.CheckNonTypeTemplateParameterType(DI, D->getLocation());
2858 if (T.isNull()) {
2859 T = SemaRef.Context.IntTy;
2860 Invalid = true;
2861 }
2862 }
2863
2864 NonTypeTemplateParmDecl *Param;
2865 if (IsExpandedParameterPack)
2866 Param = NonTypeTemplateParmDecl::Create(
2867 SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
2868 D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
2869 D->getPosition(), D->getIdentifier(), T, DI, ExpandedParameterPackTypes,
2870 ExpandedParameterPackTypesAsWritten);
2871 else
2872 Param = NonTypeTemplateParmDecl::Create(
2873 SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
2874 D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
2875 D->getPosition(), D->getIdentifier(), T, D->isParameterPack(), DI);
2876
2877 if (AutoTypeLoc AutoLoc = DI->getTypeLoc().getContainedAutoTypeLoc())
2878 if (AutoLoc.isConstrained())
2879 if (SemaRef.AttachTypeConstraint(
2880 AutoLoc, Param,
2881 IsExpandedParameterPack
2882 ? DI->getTypeLoc().getAs<PackExpansionTypeLoc>()
2883 .getEllipsisLoc()
2884 : SourceLocation()))
2885 Invalid = true;
2886
2887 Param->setAccess(AS_public);
2888 Param->setImplicit(D->isImplicit());
2889 if (Invalid)
2890 Param->setInvalidDecl();
2891
2892 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
2893 EnterExpressionEvaluationContext ConstantEvaluated(
2894 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
2895 ExprResult Value = SemaRef.SubstExpr(D->getDefaultArgument(), TemplateArgs);
2896 if (!Value.isInvalid())
2897 Param->setDefaultArgument(Value.get());
2898 }
2899
2900 // Introduce this template parameter's instantiation into the instantiation
2901 // scope.
2902 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);
2903 return Param;
2904}
2905
2906static void collectUnexpandedParameterPacks(
2907 Sema &S,
2908 TemplateParameterList *Params,
2909 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
2910 for (const auto &P : *Params) {
2911 if (P->isTemplateParameterPack())
2912 continue;
2913 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P))
2914 S.collectUnexpandedParameterPacks(NTTP->getTypeSourceInfo()->getTypeLoc(),
2915 Unexpanded);
2916 if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
2917 collectUnexpandedParameterPacks(S, TTP->getTemplateParameters(),
2918 Unexpanded);
2919 }
2920}
2921
2922Decl *
2923TemplateDeclInstantiator::VisitTemplateTemplateParmDecl(
2924 TemplateTemplateParmDecl *D) {
2925 // Instantiate the template parameter list of the template template parameter.
2926 TemplateParameterList *TempParams = D->getTemplateParameters();
2927 TemplateParameterList *InstParams;
2928 SmallVector<TemplateParameterList*, 8> ExpandedParams;
2929
2930 bool IsExpandedParameterPack = false;
2931
2932 if (D->isExpandedParameterPack()) {
2933 // The template template parameter pack is an already-expanded pack
2934 // expansion of template parameters. Substitute into each of the expanded
2935 // parameters.
2936 ExpandedParams.reserve(D->getNumExpansionTemplateParameters());
2937 for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
2938 I != N; ++I) {
2939 LocalInstantiationScope Scope(SemaRef);
2940 TemplateParameterList *Expansion =
2941 SubstTemplateParams(D->getExpansionTemplateParameters(I));
2942 if (!Expansion)
2943 return nullptr;
2944 ExpandedParams.push_back(Expansion);
2945 }
2946
2947 IsExpandedParameterPack = true;
2948 InstParams = TempParams;
2949 } else if (D->isPackExpansion()) {
2950 // The template template parameter pack expands to a pack of template
2951 // template parameters. Determine whether we need to expand this parameter
2952 // pack into separate parameters.
2953 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
2954 collectUnexpandedParameterPacks(SemaRef, D->getTemplateParameters(),
2955 Unexpanded);
2956
2957 // Determine whether the set of unexpanded parameter packs can and should
2958 // be expanded.
2959 bool Expand = true;
2960 bool RetainExpansion = false;
2961 Optional<unsigned> NumExpansions;
2962 if (SemaRef.CheckParameterPacksForExpansion(D->getLocation(),
2963 TempParams->getSourceRange(),
2964 Unexpanded,
2965 TemplateArgs,
2966 Expand, RetainExpansion,
2967 NumExpansions))
2968 return nullptr;
2969
2970 if (Expand) {
2971 for (unsigned I = 0; I != *NumExpansions; ++I) {
2972 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
2973 LocalInstantiationScope Scope(SemaRef);
2974 TemplateParameterList *Expansion = SubstTemplateParams(TempParams);
2975 if (!Expansion)
2976 return nullptr;
2977 ExpandedParams.push_back(Expansion);
2978 }
2979
2980 // Note that we have an expanded parameter pack. The "type" of this
2981 // expanded parameter pack is the original expansion type, but callers
2982 // will end up using the expanded parameter pack types for type-checking.
2983 IsExpandedParameterPack = true;
2984 InstParams = TempParams;
2985 } else {
2986 // We cannot fully expand the pack expansion now, so just substitute
2987 // into the pattern.
2988 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
2989
2990 LocalInstantiationScope Scope(SemaRef);
2991 InstParams = SubstTemplateParams(TempParams);
2992 if (!InstParams)
2993 return nullptr;
2994 }
2995 } else {
2996 // Perform the actual substitution of template parameters within a new,
2997 // local instantiation scope.
2998 LocalInstantiationScope Scope(SemaRef);
2999 InstParams = SubstTemplateParams(TempParams);
3000 if (!InstParams)
3001 return nullptr;
3002 }
3003
3004 // Build the template template parameter.
3005 TemplateTemplateParmDecl *Param;
3006 if (IsExpandedParameterPack)
3007 Param = TemplateTemplateParmDecl::Create(
3008 SemaRef.Context, Owner, D->getLocation(),
3009 D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
3010 D->getPosition(), D->getIdentifier(), InstParams, ExpandedParams);
3011 else
3012 Param = TemplateTemplateParmDecl::Create(
3013 SemaRef.Context, Owner, D->getLocation(),
3014 D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
3015 D->getPosition(), D->isParameterPack(), D->getIdentifier(), InstParams);
3016 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
3017 NestedNameSpecifierLoc QualifierLoc =
3018 D->getDefaultArgument().getTemplateQualifierLoc();
3019 QualifierLoc =
3020 SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, TemplateArgs);
3021 TemplateName TName = SemaRef.SubstTemplateName(
3022 QualifierLoc, D->getDefaultArgument().getArgument().getAsTemplate(),
3023 D->getDefaultArgument().getTemplateNameLoc(), TemplateArgs);
3024 if (!TName.isNull())
3025 Param->setDefaultArgument(
3026 SemaRef.Context,
3027 TemplateArgumentLoc(SemaRef.Context, TemplateArgument(TName),
3028 D->getDefaultArgument().getTemplateQualifierLoc(),
3029 D->getDefaultArgument().getTemplateNameLoc()));
3030 }
3031 Param->setAccess(AS_public);
3032 Param->setImplicit(D->isImplicit());
3033
3034 // Introduce this template parameter's instantiation into the instantiation
3035 // scope.
3036 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);
3037
3038 return Param;
3039}
3040
3041Decl *TemplateDeclInstantiator::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
3042 // Using directives are never dependent (and never contain any types or
3043 // expressions), so they require no explicit instantiation work.
3044
3045 UsingDirectiveDecl *Inst
3046 = UsingDirectiveDecl::Create(SemaRef.Context, Owner, D->getLocation(),
3047 D->getNamespaceKeyLocation(),
3048 D->getQualifierLoc(),
3049 D->getIdentLocation(),
3050 D->getNominatedNamespace(),
3051 D->getCommonAncestor());
3052
3053 // Add the using directive to its declaration context
3054 // only if this is not a function or method.
3055 if (!Owner->isFunctionOrMethod())
3056 Owner->addDecl(Inst);
3057
3058 return Inst;
3059}
3060
3061Decl *TemplateDeclInstantiator::VisitBaseUsingDecls(BaseUsingDecl *D,
3062 BaseUsingDecl *Inst,
3063 LookupResult *Lookup) {
3064
3065 bool isFunctionScope = Owner->isFunctionOrMethod();
3066
3067 for (auto *Shadow : D->shadows()) {
3068 // FIXME: UsingShadowDecl doesn't preserve its immediate target, so
3069 // reconstruct it in the case where it matters. Hm, can we extract it from
3070 // the DeclSpec when parsing and save it in the UsingDecl itself?
3071 NamedDecl *OldTarget = Shadow->getTargetDecl();
3072 if (auto *CUSD = dyn_cast<ConstructorUsingShadowDecl>(Shadow))
3073 if (auto *BaseShadow = CUSD->getNominatedBaseClassShadowDecl())
3074 OldTarget = BaseShadow;
3075
3076 NamedDecl *InstTarget = nullptr;
3077 if (auto *EmptyD =
3078 dyn_cast<UnresolvedUsingIfExistsDecl>(Shadow->getTargetDecl())) {
3079 InstTarget = UnresolvedUsingIfExistsDecl::Create(
3080 SemaRef.Context, Owner, EmptyD->getLocation(), EmptyD->getDeclName());
3081 } else {
3082 InstTarget = cast_or_null<NamedDecl>(SemaRef.FindInstantiatedDecl(
3083 Shadow->getLocation(), OldTarget, TemplateArgs));
3084 }
3085 if (!InstTarget)
3086 return nullptr;
3087
3088 UsingShadowDecl *PrevDecl = nullptr;
3089 if (Lookup &&
3090 SemaRef.CheckUsingShadowDecl(Inst, InstTarget, *Lookup, PrevDecl))
3091 continue;
3092
3093 if (UsingShadowDecl *OldPrev = getPreviousDeclForInstantiation(Shadow))
3094 PrevDecl = cast_or_null<UsingShadowDecl>(SemaRef.FindInstantiatedDecl(
3095 Shadow->getLocation(), OldPrev, TemplateArgs));
3096
3097 UsingShadowDecl *InstShadow = SemaRef.BuildUsingShadowDecl(
3098 /*Scope*/ nullptr, Inst, InstTarget, PrevDecl);
3099 SemaRef.Context.setInstantiatedFromUsingShadowDecl(InstShadow, Shadow);
3100
3101 if (isFunctionScope)
3102 SemaRef.CurrentInstantiationScope->InstantiatedLocal(Shadow, InstShadow);
3103 }
3104
3105 return Inst;
3106}
3107
3108Decl *TemplateDeclInstantiator::VisitUsingDecl(UsingDecl *D) {
3109
3110 // The nested name specifier may be dependent, for example
3111 // template <typename T> struct t {
3112 // struct s1 { T f1(); };
3113 // struct s2 : s1 { using s1::f1; };
3114 // };
3115 // template struct t<int>;
3116 // Here, in using s1::f1, s1 refers to t<T>::s1;
3117 // we need to substitute for t<int>::s1.
3118 NestedNameSpecifierLoc QualifierLoc
3119 = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(),
3120 TemplateArgs);
3121 if (!QualifierLoc)
3122 return nullptr;
3123
3124 // For an inheriting constructor declaration, the name of the using
3125 // declaration is the name of a constructor in this class, not in the
3126 // base class.
3127 DeclarationNameInfo NameInfo = D->getNameInfo();
3128 if (NameInfo.getName().getNameKind() == DeclarationName::CXXConstructorName)
3129 if (auto *RD = dyn_cast<CXXRecordDecl>(SemaRef.CurContext))
3130 NameInfo.setName(SemaRef.Context.DeclarationNames.getCXXConstructorName(
3131 SemaRef.Context.getCanonicalType(SemaRef.Context.getRecordType(RD))));
3132
3133 // We only need to do redeclaration lookups if we're in a class scope (in
3134 // fact, it's not really even possible in non-class scopes).
3135 bool CheckRedeclaration = Owner->isRecord();
3136 LookupResult Prev(SemaRef, NameInfo, Sema::LookupUsingDeclName,
3137 Sema::ForVisibleRedeclaration);
3138
3139 UsingDecl *NewUD = UsingDecl::Create(SemaRef.Context, Owner,
3140 D->getUsingLoc(),
3141 QualifierLoc,
3142 NameInfo,
3143 D->hasTypename());
3144
3145 CXXScopeSpec SS;
3146 SS.Adopt(QualifierLoc);
3147 if (CheckRedeclaration) {
3148 Prev.setHideTags(false);
3149 SemaRef.LookupQualifiedName(Prev, Owner);
3150
3151 // Check for invalid redeclarations.
3152 if (SemaRef.CheckUsingDeclRedeclaration(D->getUsingLoc(),
3153 D->hasTypename(), SS,
3154 D->getLocation(), Prev))
3155 NewUD->setInvalidDecl();
3156 }
3157
3158 if (!NewUD->isInvalidDecl() &&
3159 SemaRef.CheckUsingDeclQualifier(D->getUsingLoc(), D->hasTypename(), SS,
3160 NameInfo, D->getLocation(), nullptr, D))
3161 NewUD->setInvalidDecl();
3162
3163 SemaRef.Context.setInstantiatedFromUsingDecl(NewUD, D);
3164 NewUD->setAccess(D->getAccess());
3165 Owner->addDecl(NewUD);
3166
3167 // Don't process the shadow decls for an invalid decl.
3168 if (NewUD->isInvalidDecl())
3169 return NewUD;
3170
3171 // If the using scope was dependent, or we had dependent bases, we need to
3172 // recheck the inheritance
3173 if (NameInfo.getName().getNameKind() == DeclarationName::CXXConstructorName)
3174 SemaRef.CheckInheritingConstructorUsingDecl(NewUD);
3175
3176 return VisitBaseUsingDecls(D, NewUD, CheckRedeclaration ? &Prev : nullptr);
3177}
3178
3179Decl *TemplateDeclInstantiator::VisitUsingEnumDecl(UsingEnumDecl *D) {
3180 // Cannot be a dependent type, but still could be an instantiation
3181 EnumDecl *EnumD = cast_or_null<EnumDecl>(SemaRef.FindInstantiatedDecl(
3182 D->getLocation(), D->getEnumDecl(), TemplateArgs));
3183
3184 if (SemaRef.RequireCompleteEnumDecl(EnumD, EnumD->getLocation()))
3185 return nullptr;
3186
3187 UsingEnumDecl *NewUD =
3188 UsingEnumDecl::Create(SemaRef.Context, Owner, D->getUsingLoc(),
3189 D->getEnumLoc(), D->getLocation(), EnumD);
3190
3191 SemaRef.Context.setInstantiatedFromUsingEnumDecl(NewUD, D);
3192 NewUD->setAccess(D->getAccess());
3193 Owner->addDecl(NewUD);
3194
3195 // Don't process the shadow decls for an invalid decl.
3196 if (NewUD->isInvalidDecl())
3197 return NewUD;
3198
3199 // We don't have to recheck for duplication of the UsingEnumDecl itself, as it
3200 // cannot be dependent, and will therefore have been checked during template
3201 // definition.
3202
3203 return VisitBaseUsingDecls(D, NewUD, nullptr);
3204}
3205
3206Decl *TemplateDeclInstantiator::VisitUsingShadowDecl(UsingShadowDecl *D) {
3207 // Ignore these; we handle them in bulk when processing the UsingDecl.
3208 return nullptr;
3209}
3210
3211Decl *TemplateDeclInstantiator::VisitConstructorUsingShadowDecl(
3212 ConstructorUsingShadowDecl *D) {
3213 // Ignore these; we handle them in bulk when processing the UsingDecl.
3214 return nullptr;
3215}
3216
3217template <typename T>
3218Decl *TemplateDeclInstantiator::instantiateUnresolvedUsingDecl(
3219 T *D, bool InstantiatingPackElement) {
3220 // If this is a pack expansion, expand it now.
3221 if (D->isPackExpansion() && !InstantiatingPackElement) {
3222 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
3223 SemaRef.collectUnexpandedParameterPacks(D->getQualifierLoc(), Unexpanded);
3224 SemaRef.collectUnexpandedParameterPacks(D->getNameInfo(), Unexpanded);
3225
3226 // Determine whether the set of unexpanded parameter packs can and should
3227 // be expanded.
3228 bool Expand = true;
3229 bool RetainExpansion = false;
3230 Optional<unsigned> NumExpansions;
3231 if (SemaRef.CheckParameterPacksForExpansion(
3232 D->getEllipsisLoc(), D->getSourceRange(), Unexpanded, TemplateArgs,
3233 Expand, RetainExpansion, NumExpansions))
3234 return nullptr;
3235
3236 // This declaration cannot appear within a function template signature,
3237 // so we can't have a partial argument list for a parameter pack.
3238 assert(!RetainExpansion &&((void)0)
3239 "should never need to retain an expansion for UsingPackDecl")((void)0);
3240
3241 if (!Expand) {
3242 // We cannot fully expand the pack expansion now, so substitute into the
3243 // pattern and create a new pack expansion.
3244 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
3245 return instantiateUnresolvedUsingDecl(D, true);
3246 }
3247
3248 // Within a function, we don't have any normal way to check for conflicts
3249 // between shadow declarations from different using declarations in the
3250 // same pack expansion, but this is always ill-formed because all expansions
3251 // must produce (conflicting) enumerators.
3252 //
3253 // Sadly we can't just reject this in the template definition because it
3254 // could be valid if the pack is empty or has exactly one expansion.
3255 if (D->getDeclContext()->isFunctionOrMethod() && *NumExpansions > 1) {
3256 SemaRef.Diag(D->getEllipsisLoc(),
3257 diag::err_using_decl_redeclaration_expansion);
3258 return nullptr;
3259 }
3260
3261 // Instantiate the slices of this pack and build a UsingPackDecl.
3262 SmallVector<NamedDecl*, 8> Expansions;
3263 for (unsigned I = 0; I != *NumExpansions; ++I) {
3264 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
3265 Decl *Slice = instantiateUnresolvedUsingDecl(D, true);
3266 if (!Slice)
3267 return nullptr;
3268 // Note that we can still get unresolved using declarations here, if we
3269 // had arguments for all packs but the pattern also contained other
3270 // template arguments (this only happens during partial substitution, eg
3271 // into the body of a generic lambda in a function template).
3272 Expansions.push_back(cast<NamedDecl>(Slice));
3273 }
3274
3275 auto *NewD = SemaRef.BuildUsingPackDecl(D, Expansions);
3276 if (isDeclWithinFunction(D))
3277 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewD);
3278 return NewD;
3279 }
3280
3281 UnresolvedUsingTypenameDecl *TD = dyn_cast<UnresolvedUsingTypenameDecl>(D);
3282 SourceLocation TypenameLoc = TD ? TD->getTypenameLoc() : SourceLocation();
3283
3284 NestedNameSpecifierLoc QualifierLoc
3285 = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(),
3286 TemplateArgs);
3287 if (!QualifierLoc)
3288 return nullptr;
3289
3290 CXXScopeSpec SS;
3291 SS.Adopt(QualifierLoc);
3292
3293 DeclarationNameInfo NameInfo
3294 = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
3295
3296 // Produce a pack expansion only if we're not instantiating a particular
3297 // slice of a pack expansion.
3298 bool InstantiatingSlice = D->getEllipsisLoc().isValid() &&
3299 SemaRef.ArgumentPackSubstitutionIndex != -1;
3300 SourceLocation EllipsisLoc =
3301 InstantiatingSlice ? SourceLocation() : D->getEllipsisLoc();
3302
3303 bool IsUsingIfExists = D->template hasAttr<UsingIfExistsAttr>();
3304 NamedDecl *UD = SemaRef.BuildUsingDeclaration(
3305 /*Scope*/ nullptr, D->getAccess(), D->getUsingLoc(),
3306 /*HasTypename*/ TD, TypenameLoc, SS, NameInfo, EllipsisLoc,
3307 ParsedAttributesView(),
3308 /*IsInstantiation*/ true, IsUsingIfExists);
3309 if (UD) {
3310 SemaRef.InstantiateAttrs(TemplateArgs, D, UD);
3311 SemaRef.Context.setInstantiatedFromUsingDecl(UD, D);
3312 }
3313
3314 return UD;
3315}
3316
3317Decl *TemplateDeclInstantiator::VisitUnresolvedUsingTypenameDecl(
3318 UnresolvedUsingTypenameDecl *D) {
3319 return instantiateUnresolvedUsingDecl(D);
3320}
3321
3322Decl *TemplateDeclInstantiator::VisitUnresolvedUsingValueDecl(
3323 UnresolvedUsingValueDecl *D) {
3324 return instantiateUnresolvedUsingDecl(D);
3325}
3326
3327Decl *TemplateDeclInstantiator::VisitUnresolvedUsingIfExistsDecl(
3328 UnresolvedUsingIfExistsDecl *D) {
3329 llvm_unreachable("referring to unresolved decl out of UsingShadowDecl")__builtin_unreachable();
3330}
3331
3332Decl *TemplateDeclInstantiator::VisitUsingPackDecl(UsingPackDecl *D) {
3333 SmallVector<NamedDecl*, 8> Expansions;
3334 for (auto *UD : D->expansions()) {
3335 if (NamedDecl *NewUD =
3336 SemaRef.FindInstantiatedDecl(D->getLocation(), UD, TemplateArgs))
3337 Expansions.push_back(NewUD);
3338 else
3339 return nullptr;
3340 }
3341
3342 auto *NewD = SemaRef.BuildUsingPackDecl(D, Expansions);
3343 if (isDeclWithinFunction(D))
3344 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewD);
3345 return NewD;
3346}
3347
3348Decl *TemplateDeclInstantiator::VisitClassScopeFunctionSpecializationDecl(
3349 ClassScopeFunctionSpecializationDecl *Decl) {
3350 CXXMethodDecl *OldFD = Decl->getSpecialization();
3351 return cast_or_null<CXXMethodDecl>(
3352 VisitCXXMethodDecl(OldFD, nullptr, Decl->getTemplateArgsAsWritten()));
3353}
3354
3355Decl *TemplateDeclInstantiator::VisitOMPThreadPrivateDecl(
3356 OMPThreadPrivateDecl *D) {
3357 SmallVector<Expr *, 5> Vars;
3358 for (auto *I : D->varlists()) {
3359 Expr *Var = SemaRef.SubstExpr(I, TemplateArgs).get();
3360 assert(isa<DeclRefExpr>(Var) && "threadprivate arg is not a DeclRefExpr")((void)0);
3361 Vars.push_back(Var);
3362 }
3363
3364 OMPThreadPrivateDecl *TD =
3365 SemaRef.CheckOMPThreadPrivateDecl(D->getLocation(), Vars);
3366
3367 TD->setAccess(AS_public);
3368 Owner->addDecl(TD);
3369
3370 return TD;
3371}
3372
3373Decl *TemplateDeclInstantiator::VisitOMPAllocateDecl(OMPAllocateDecl *D) {
3374 SmallVector<Expr *, 5> Vars;
3375 for (auto *I : D->varlists()) {
3376 Expr *Var = SemaRef.SubstExpr(I, TemplateArgs).get();
3377 assert(isa<DeclRefExpr>(Var) && "allocate arg is not a DeclRefExpr")((void)0);
3378 Vars.push_back(Var);
3379 }
3380 SmallVector<OMPClause *, 4> Clauses;
3381 // Copy map clauses from the original mapper.
3382 for (OMPClause *C : D->clauselists()) {
3383 auto *AC = cast<OMPAllocatorClause>(C);
3384 ExprResult NewE = SemaRef.SubstExpr(AC->getAllocator(), TemplateArgs);
3385 if (!NewE.isUsable())
3386 continue;
3387 OMPClause *IC = SemaRef.ActOnOpenMPAllocatorClause(
3388 NewE.get(), AC->getBeginLoc(), AC->getLParenLoc(), AC->getEndLoc());
3389 Clauses.push_back(IC);
3390 }
3391
3392 Sema::DeclGroupPtrTy Res = SemaRef.ActOnOpenMPAllocateDirective(
3393 D->getLocation(), Vars, Clauses, Owner);
3394 if (Res.get().isNull())
3395 return nullptr;
3396 return Res.get().getSingleDecl();
3397}
3398
3399Decl *TemplateDeclInstantiator::VisitOMPRequiresDecl(OMPRequiresDecl *D) {
3400 llvm_unreachable(__builtin_unreachable()
3401 "Requires directive cannot be instantiated within a dependent context")__builtin_unreachable();
3402}
3403
3404Decl *TemplateDeclInstantiator::VisitOMPDeclareReductionDecl(
3405 OMPDeclareReductionDecl *D) {
3406 // Instantiate type and check if it is allowed.
3407 const bool RequiresInstantiation =
3408 D->getType()->isDependentType() ||
3409 D->getType()->isInstantiationDependentType() ||
3410 D->getType()->containsUnexpandedParameterPack();
3411 QualType SubstReductionType;
3412 if (RequiresInstantiation) {
3413 SubstReductionType = SemaRef.ActOnOpenMPDeclareReductionType(
3414 D->getLocation(),
3415 ParsedType::make(SemaRef.SubstType(
3416 D->getType(), TemplateArgs, D->getLocation(), DeclarationName())));
3417 } else {
3418 SubstReductionType = D->getType();
3419 }
3420 if (SubstReductionType.isNull())
3421 return nullptr;
3422 Expr *Combiner = D->getCombiner();
3423 Expr *Init = D->getInitializer();
3424 bool IsCorrect = true;
3425 // Create instantiated copy.
3426 std::pair<QualType, SourceLocation> ReductionTypes[] = {
3427 std::make_pair(SubstReductionType, D->getLocation())};
3428 auto *PrevDeclInScope = D->getPrevDeclInScope();
3429 if (PrevDeclInScope && !PrevDeclInScope->isInvalidDecl()) {
3430 PrevDeclInScope = cast<OMPDeclareReductionDecl>(
3431 SemaRef.CurrentInstantiationScope->findInstantiationOf(PrevDeclInScope)
3432 ->get<Decl *>());
3433 }
3434 auto DRD = SemaRef.ActOnOpenMPDeclareReductionDirectiveStart(
3435 /*S=*/nullptr, Owner, D->getDeclName(), ReductionTypes, D->getAccess(),
3436 PrevDeclInScope);
3437 auto *NewDRD = cast<OMPDeclareReductionDecl>(DRD.get().getSingleDecl());
3438 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewDRD);
3439 Expr *SubstCombiner = nullptr;
3440 Expr *SubstInitializer = nullptr;
3441 // Combiners instantiation sequence.
3442 if (Combiner) {
3443 SemaRef.ActOnOpenMPDeclareReductionCombinerStart(
3444 /*S=*/nullptr, NewDRD);
3445 SemaRef.CurrentInstantiationScope->InstantiatedLocal(
3446 cast<DeclRefExpr>(D->getCombinerIn())->getDecl(),
3447 cast<DeclRefExpr>(NewDRD->getCombinerIn())->getDecl());
3448 SemaRef.CurrentInstantiationScope->InstantiatedLocal(
3449 cast<DeclRefExpr>(D->getCombinerOut())->getDecl(),
3450 cast<DeclRefExpr>(NewDRD->getCombinerOut())->getDecl());
3451 auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(Owner);
3452 Sema::CXXThisScopeRAII ThisScope(SemaRef, ThisContext, Qualifiers(),
3453 ThisContext);
3454 SubstCombiner = SemaRef.SubstExpr(Combiner, TemplateArgs).get();
3455 SemaRef.ActOnOpenMPDeclareReductionCombinerEnd(NewDRD, SubstCombiner);
3456 }
3457 // Initializers instantiation sequence.
3458 if (Init) {
3459 VarDecl *OmpPrivParm = SemaRef.ActOnOpenMPDeclareReductionInitializerStart(
3460 /*S=*/nullptr, NewDRD);
3461 SemaRef.CurrentInstantiationScope->InstantiatedLocal(
3462 cast<DeclRefExpr>(D->getInitOrig())->getDecl(),
3463 cast<DeclRefExpr>(NewDRD->getInitOrig())->getDecl());
3464 SemaRef.CurrentInstantiationScope->InstantiatedLocal(
3465 cast<DeclRefExpr>(D->getInitPriv())->getDecl(),
3466 cast<DeclRefExpr>(NewDRD->getInitPriv())->getDecl());
3467 if (D->getInitializerKind() == OMPDeclareReductionDecl::CallInit) {
3468 SubstInitializer = SemaRef.SubstExpr(Init, TemplateArgs).get();
3469 } else {
3470 auto *OldPrivParm =
3471 cast<VarDecl>(cast<DeclRefExpr>(D->getInitPriv())->getDecl());
3472 IsCorrect = IsCorrect && OldPrivParm->hasInit();
3473 if (IsCorrect)
3474 SemaRef.InstantiateVariableInitializer(OmpPrivParm, OldPrivParm,
3475 TemplateArgs);
3476 }
3477 SemaRef.ActOnOpenMPDeclareReductionInitializerEnd(NewDRD, SubstInitializer,
3478 OmpPrivParm);
3479 }
3480 IsCorrect = IsCorrect && SubstCombiner &&
3481 (!Init ||
3482 (D->getInitializerKind() == OMPDeclareReductionDecl::CallInit &&
3483 SubstInitializer) ||
3484 (D->getInitializerKind() != OMPDeclareReductionDecl::CallInit &&
3485 !SubstInitializer));
3486
3487 (void)SemaRef.ActOnOpenMPDeclareReductionDirectiveEnd(
3488 /*S=*/nullptr, DRD, IsCorrect && !D->isInvalidDecl());
3489
3490 return NewDRD;
3491}
3492
3493Decl *
3494TemplateDeclInstantiator::VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D) {
3495 // Instantiate type and check if it is allowed.
3496 const bool RequiresInstantiation =
3497 D->getType()->isDependentType() ||
3498 D->getType()->isInstantiationDependentType() ||
3499 D->getType()->containsUnexpandedParameterPack();
3500 QualType SubstMapperTy;
3501 DeclarationName VN = D->getVarName();
3502 if (RequiresInstantiation) {
3503 SubstMapperTy = SemaRef.ActOnOpenMPDeclareMapperType(
3504 D->getLocation(),
3505 ParsedType::make(SemaRef.SubstType(D->getType(), TemplateArgs,
3506 D->getLocation(), VN)));
3507 } else {
3508 SubstMapperTy = D->getType();
3509 }
3510 if (SubstMapperTy.isNull())
3511 return nullptr;
3512 // Create an instantiated copy of mapper.
3513 auto *PrevDeclInScope = D->getPrevDeclInScope();
3514 if (PrevDeclInScope && !PrevDeclInScope->isInvalidDecl()) {
3515 PrevDeclInScope = cast<OMPDeclareMapperDecl>(
3516 SemaRef.CurrentInstantiationScope->findInstantiationOf(PrevDeclInScope)
3517 ->get<Decl *>());
3518 }
3519 bool IsCorrect = true;
3520 SmallVector<OMPClause *, 6> Clauses;
3521 // Instantiate the mapper variable.
3522 DeclarationNameInfo DirName;
3523 SemaRef.StartOpenMPDSABlock(llvm::omp::OMPD_declare_mapper, DirName,
3524 /*S=*/nullptr,
3525 (*D->clauselist_begin())->getBeginLoc());
3526 ExprResult MapperVarRef = SemaRef.ActOnOpenMPDeclareMapperDirectiveVarDecl(
3527 /*S=*/nullptr, SubstMapperTy, D->getLocation(), VN);
3528 SemaRef.CurrentInstantiationScope->InstantiatedLocal(
3529 cast<DeclRefExpr>(D->getMapperVarRef())->getDecl(),
3530 cast<DeclRefExpr>(MapperVarRef.get())->getDecl());
3531 auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(Owner);
3532 Sema::CXXThisScopeRAII ThisScope(SemaRef, ThisContext, Qualifiers(),
3533 ThisContext);
3534 // Instantiate map clauses.
3535 for (OMPClause *C : D->clauselists()) {
3536 auto *OldC = cast<OMPMapClause>(C);
3537 SmallVector<Expr *, 4> NewVars;
3538 for (Expr *OE : OldC->varlists()) {
3539 Expr *NE = SemaRef.SubstExpr(OE, TemplateArgs).get();
3540 if (!NE) {
3541 IsCorrect = false;
3542 break;
3543 }
3544 NewVars.push_back(NE);
3545 }
3546 if (!IsCorrect)
3547 break;
3548 NestedNameSpecifierLoc NewQualifierLoc =
3549 SemaRef.SubstNestedNameSpecifierLoc(OldC->getMapperQualifierLoc(),
3550 TemplateArgs);
3551 CXXScopeSpec SS;
3552 SS.Adopt(NewQualifierLoc);
3553 DeclarationNameInfo NewNameInfo =
3554 SemaRef.SubstDeclarationNameInfo(OldC->getMapperIdInfo(), TemplateArgs);
3555 OMPVarListLocTy Locs(OldC->getBeginLoc(), OldC->getLParenLoc(),
3556 OldC->getEndLoc());
3557 OMPClause *NewC = SemaRef.ActOnOpenMPMapClause(
3558 OldC->getMapTypeModifiers(), OldC->getMapTypeModifiersLoc(), SS,
3559 NewNameInfo, OldC->getMapType(), OldC->isImplicitMapType(),
3560 OldC->getMapLoc(), OldC->getColonLoc(), NewVars, Locs);
3561 Clauses.push_back(NewC);
3562 }
3563 SemaRef.EndOpenMPDSABlock(nullptr);
3564 if (!IsCorrect)
3565 return nullptr;
3566 Sema::DeclGroupPtrTy DG = SemaRef.ActOnOpenMPDeclareMapperDirective(
3567 /*S=*/nullptr, Owner, D->getDeclName(), SubstMapperTy, D->getLocation(),
3568 VN, D->getAccess(), MapperVarRef.get(), Clauses, PrevDeclInScope);
3569 Decl *NewDMD = DG.get().getSingleDecl();
3570 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewDMD);
3571 return NewDMD;
3572}
3573
3574Decl *TemplateDeclInstantiator::VisitOMPCapturedExprDecl(
3575 OMPCapturedExprDecl * /*D*/) {
3576 llvm_unreachable("Should not be met in templates")__builtin_unreachable();
3577}
3578
3579Decl *TemplateDeclInstantiator::VisitFunctionDecl(FunctionDecl *D) {
3580 return VisitFunctionDecl(D, nullptr);
3581}
3582
3583Decl *
3584TemplateDeclInstantiator::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {
3585 Decl *Inst = VisitFunctionDecl(D, nullptr);
3586 if (Inst && !D->getDescribedFunctionTemplate())
3587 Owner->addDecl(Inst);
3588 return Inst;
3589}
3590
3591Decl *TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D) {
3592 return VisitCXXMethodDecl(D, nullptr);
3593}
3594
3595Decl *TemplateDeclInstantiator::VisitRecordDecl(RecordDecl *D) {
3596 llvm_unreachable("There are only CXXRecordDecls in C++")__builtin_unreachable();
3597}
3598
3599Decl *
3600TemplateDeclInstantiator::VisitClassTemplateSpecializationDecl(
3601 ClassTemplateSpecializationDecl *D) {
3602 // As a MS extension, we permit class-scope explicit specialization
3603 // of member class templates.
3604 ClassTemplateDecl *ClassTemplate = D->getSpecializedTemplate();
3605 assert(ClassTemplate->getDeclContext()->isRecord() &&((void)0)
3606 D->getTemplateSpecializationKind() == TSK_ExplicitSpecialization &&((void)0)
3607 "can only instantiate an explicit specialization "((void)0)
3608 "for a member class template")((void)0);
3609
3610 // Lookup the already-instantiated declaration in the instantiation
3611 // of the class template.
3612 ClassTemplateDecl *InstClassTemplate =
3613 cast_or_null<ClassTemplateDecl>(SemaRef.FindInstantiatedDecl(
3614 D->getLocation(), ClassTemplate, TemplateArgs));
3615 if (!InstClassTemplate)
3616 return nullptr;
3617
3618 // Substitute into the template arguments of the class template explicit
3619 // specialization.
3620 TemplateSpecializationTypeLoc Loc = D->getTypeAsWritten()->getTypeLoc().
3621 castAs<TemplateSpecializationTypeLoc>();
3622 TemplateArgumentListInfo InstTemplateArgs(Loc.getLAngleLoc(),
3623 Loc.getRAngleLoc());
3624 SmallVector<TemplateArgumentLoc, 4> ArgLocs;
3625 for (unsigned I = 0; I != Loc.getNumArgs(); ++I)
3626 ArgLocs.push_back(Loc.getArgLoc(I));
3627 if (SemaRef.Subst(ArgLocs.data(), ArgLocs.size(),
3628 InstTemplateArgs, TemplateArgs))
3629 return nullptr;
3630
3631 // Check that the template argument list is well-formed for this
3632 // class template.
3633 SmallVector<TemplateArgument, 4> Converted;
3634 if (SemaRef.CheckTemplateArgumentList(InstClassTemplate,
3635 D->getLocation(),
3636 InstTemplateArgs,
3637 false,
3638 Converted,
3639 /*UpdateArgsWithConversion=*/true))
3640 return nullptr;
3641
3642 // Figure out where to insert this class template explicit specialization
3643 // in the member template's set of class template explicit specializations.
3644 void *InsertPos = nullptr;
3645 ClassTemplateSpecializationDecl *PrevDecl =
3646 InstClassTemplate->findSpecialization(Converted, InsertPos);
3647
3648 // Check whether we've already seen a conflicting instantiation of this
3649 // declaration (for instance, if there was a prior implicit instantiation).
3650 bool Ignored;
3651 if (PrevDecl &&
3652 SemaRef.CheckSpecializationInstantiationRedecl(D->getLocation(),
3653 D->getSpecializationKind(),
3654 PrevDecl,
3655 PrevDecl->getSpecializationKind(),
3656 PrevDecl->getPointOfInstantiation(),
3657 Ignored))
3658 return nullptr;
3659
3660 // If PrevDecl was a definition and D is also a definition, diagnose.
3661 // This happens in cases like:
3662 //
3663 // template<typename T, typename U>
3664 // struct Outer {
3665 // template<typename X> struct Inner;
3666 // template<> struct Inner<T> {};
3667 // template<> struct Inner<U> {};
3668 // };
3669 //
3670 // Outer<int, int> outer; // error: the explicit specializations of Inner
3671 // // have the same signature.
3672 if (PrevDecl && PrevDecl->getDefinition() &&
3673 D->isThisDeclarationADefinition()) {
3674 SemaRef.Diag(D->getLocation(), diag::err_redefinition) << PrevDecl;
3675 SemaRef.Diag(PrevDecl->getDefinition()->getLocation(),
3676 diag::note_previous_definition);
3677 return nullptr;
3678 }
3679
3680 // Create the class template partial specialization declaration.
3681 ClassTemplateSpecializationDecl *InstD =
3682 ClassTemplateSpecializationDecl::Create(
3683 SemaRef.Context, D->getTagKind(), Owner, D->getBeginLoc(),
3684 D->getLocation(), InstClassTemplate, Converted, PrevDecl);
3685
3686 // Add this partial specialization to the set of class template partial
3687 // specializations.
3688 if (!PrevDecl)
3689 InstClassTemplate->AddSpecialization(InstD, InsertPos);
3690
3691 // Substitute the nested name specifier, if any.
3692 if (SubstQualifier(D, InstD))
3693 return nullptr;
3694
3695 // Build the canonical type that describes the converted template
3696 // arguments of the class template explicit specialization.
3697 QualType CanonType = SemaRef.Context.getTemplateSpecializationType(
3698 TemplateName(InstClassTemplate), Converted,
3699 SemaRef.Context.getRecordType(InstD));
3700
3701 // Build the fully-sugared type for this class template
3702 // specialization as the user wrote in the specialization
3703 // itself. This means that we'll pretty-print the type retrieved
3704 // from the specialization's declaration the way that the user
3705 // actually wrote the specialization, rather than formatting the
3706 // name based on the "canonical" representation used to store the
3707 // template arguments in the specialization.
3708 TypeSourceInfo *WrittenTy = SemaRef.Context.getTemplateSpecializationTypeInfo(
3709 TemplateName(InstClassTemplate), D->getLocation(), InstTemplateArgs,
3710 CanonType);
3711
3712 InstD->setAccess(D->getAccess());
3713 InstD->setInstantiationOfMemberClass(D, TSK_ImplicitInstantiation);
3714 InstD->setSpecializationKind(D->getSpecializationKind());
3715 InstD->setTypeAsWritten(WrittenTy);
3716 InstD->setExternLoc(D->getExternLoc());
3717 InstD->setTemplateKeywordLoc(D->getTemplateKeywordLoc());
3718
3719 Owner->addDecl(InstD);
3720
3721 // Instantiate the members of the class-scope explicit specialization eagerly.
3722 // We don't have support for lazy instantiation of an explicit specialization
3723 // yet, and MSVC eagerly instantiates in this case.
3724 // FIXME: This is wrong in standard C++.
3725 if (D->isThisDeclarationADefinition() &&
3726 SemaRef.InstantiateClass(D->getLocation(), InstD, D, TemplateArgs,
3727 TSK_ImplicitInstantiation,
3728 /*Complain=*/true))
3729 return nullptr;
3730
3731 return InstD;
3732}
3733
3734Decl *TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl(
3735 VarTemplateSpecializationDecl *D) {
3736
3737 TemplateArgumentListInfo VarTemplateArgsInfo;
3738 VarTemplateDecl *VarTemplate = D->getSpecializedTemplate();
3739 assert(VarTemplate &&((void)0)
3740 "A template specialization without specialized template?")((void)0);
3741
3742 VarTemplateDecl *InstVarTemplate =
3743 cast_or_null<VarTemplateDecl>(SemaRef.FindInstantiatedDecl(
3744 D->getLocation(), VarTemplate, TemplateArgs));
3745 if (!InstVarTemplate)
3746 return nullptr;
3747
3748 // Substitute the current template arguments.
3749 const TemplateArgumentListInfo &TemplateArgsInfo = D->getTemplateArgsInfo();
3750 VarTemplateArgsInfo.setLAngleLoc(TemplateArgsInfo.getLAngleLoc());
3751 VarTemplateArgsInfo.setRAngleLoc(TemplateArgsInfo.getRAngleLoc());
3752
3753 if (SemaRef.Subst(TemplateArgsInfo.getArgumentArray(),
3754 TemplateArgsInfo.size(), VarTemplateArgsInfo, TemplateArgs))
3755 return nullptr;
3756
3757 // Check that the template argument list is well-formed for this template.
3758 SmallVector<TemplateArgument, 4> Converted;
3759 if (SemaRef.CheckTemplateArgumentList(InstVarTemplate, D->getLocation(),
3760 VarTemplateArgsInfo, false, Converted,
3761 /*UpdateArgsWithConversion=*/true))
3762 return nullptr;
3763
3764 // Check whether we've already seen a declaration of this specialization.
3765 void *InsertPos = nullptr;
3766 VarTemplateSpecializationDecl *PrevDecl =
3767 InstVarTemplate->findSpecialization(Converted, InsertPos);
3768
3769 // Check whether we've already seen a conflicting instantiation of this
3770 // declaration (for instance, if there was a prior implicit instantiation).
3771 bool Ignored;
3772 if (PrevDecl && SemaRef.CheckSpecializationInstantiationRedecl(
3773 D->getLocation(), D->getSpecializationKind(), PrevDecl,
3774 PrevDecl->getSpecializationKind(),
3775 PrevDecl->getPointOfInstantiation(), Ignored))
3776 return nullptr;
3777
3778 return VisitVarTemplateSpecializationDecl(
3779 InstVarTemplate, D, VarTemplateArgsInfo, Converted, PrevDecl);
3780}
3781
3782Decl *TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl(
3783 VarTemplateDecl *VarTemplate, VarDecl *D,
3784 const TemplateArgumentListInfo &TemplateArgsInfo,
3785 ArrayRef<TemplateArgument> Converted,
3786 VarTemplateSpecializationDecl *PrevDecl) {
3787
3788 // Do substitution on the type of the declaration
3789 TypeSourceInfo *DI =
3790 SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs,
3791 D->getTypeSpecStartLoc(), D->getDeclName());
3792 if (!DI)
3793 return nullptr;
3794
3795 if (DI->getType()->isFunctionType()) {
3796 SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function)
3797 << D->isStaticDataMember() << DI->getType();
3798 return nullptr;
3799 }
3800
3801 // Build the instantiated declaration
3802 VarTemplateSpecializationDecl *Var = VarTemplateSpecializationDecl::Create(
3803 SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
3804 VarTemplate, DI->getType(), DI, D->getStorageClass(), Converted);
3805 Var->setTemplateArgsInfo(TemplateArgsInfo);
3806 if (!PrevDecl) {
3807 void *InsertPos = nullptr;
3808 VarTemplate->findSpecialization(Converted, InsertPos);
3809 VarTemplate->AddSpecialization(Var, InsertPos);
3810 }
3811
3812 if (SemaRef.getLangOpts().OpenCL)
3813 SemaRef.deduceOpenCLAddressSpace(Var);
3814
3815 // Substitute the nested name specifier, if any.
3816 if (SubstQualifier(D, Var))
3817 return nullptr;
3818
3819 SemaRef.BuildVariableInstantiation(Var, D, TemplateArgs, LateAttrs, Owner,
3820 StartingScope, false, PrevDecl);
3821
3822 return Var;
3823}
3824
3825Decl *TemplateDeclInstantiator::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) {
3826 llvm_unreachable("@defs is not supported in Objective-C++")__builtin_unreachable();
3827}
3828
3829Decl *TemplateDeclInstantiator::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
3830 // FIXME: We need to be able to instantiate FriendTemplateDecls.
3831 unsigned DiagID = SemaRef.getDiagnostics().getCustomDiagID(
3832 DiagnosticsEngine::Error,
3833 "cannot instantiate %0 yet");
3834 SemaRef.Diag(D->getLocation(), DiagID)
3835 << D->getDeclKindName();
3836
3837 return nullptr;
3838}
3839
3840Decl *TemplateDeclInstantiator::VisitConceptDecl(ConceptDecl *D) {
3841 llvm_unreachable("Concept definitions cannot reside inside a template")__builtin_unreachable();
3842}
3843
3844Decl *
3845TemplateDeclInstantiator::VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D) {
3846 return RequiresExprBodyDecl::Create(SemaRef.Context, D->getDeclContext(),
3847 D->getBeginLoc());
3848}
3849
3850Decl *TemplateDeclInstantiator::VisitDecl(Decl *D) {
3851 llvm_unreachable("Unexpected decl")__builtin_unreachable();
3852}
3853
3854Decl *Sema::SubstDecl(Decl *D, DeclContext *Owner,
3855 const MultiLevelTemplateArgumentList &TemplateArgs) {
3856 TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs);
3857 if (D->isInvalidDecl())
3858 return nullptr;
3859
3860 Decl *SubstD;
3861 runWithSufficientStackSpace(D->getLocation(), [&] {
3862 SubstD = Instantiator.Visit(D);
3863 });
3864 return SubstD;
3865}
3866
3867void TemplateDeclInstantiator::adjustForRewrite(RewriteKind RK,
3868 FunctionDecl *Orig, QualType &T,
3869 TypeSourceInfo *&TInfo,
3870 DeclarationNameInfo &NameInfo) {
3871 assert(RK == RewriteKind::RewriteSpaceshipAsEqualEqual)((void)0);
3872
3873 // C++2a [class.compare.default]p3:
3874 // the return type is replaced with bool
3875 auto *FPT = T->castAs<FunctionProtoType>();
3876 T = SemaRef.Context.getFunctionType(
3877 SemaRef.Context.BoolTy, FPT->getParamTypes(), FPT->getExtProtoInfo());
3878
3879 // Update the return type in the source info too. The most straightforward
3880 // way is to create new TypeSourceInfo for the new type. Use the location of
3881 // the '= default' as the location of the new type.
3882 //
3883 // FIXME: Set the correct return type when we initially transform the type,
3884 // rather than delaying it to now.
3885 TypeSourceInfo *NewTInfo =
3886 SemaRef.Context.getTrivialTypeSourceInfo(T, Orig->getEndLoc());
3887 auto OldLoc = TInfo->getTypeLoc().getAsAdjusted<FunctionProtoTypeLoc>();
3888 assert(OldLoc && "type of function is not a function type?")((void)0);
3889 auto NewLoc = NewTInfo->getTypeLoc().castAs<FunctionProtoTypeLoc>();
3890 for (unsigned I = 0, N = OldLoc.getNumParams(); I != N; ++I)
3891 NewLoc.setParam(I, OldLoc.getParam(I));
3892 TInfo = NewTInfo;
3893
3894 // and the declarator-id is replaced with operator==
3895 NameInfo.setName(
3896 SemaRef.Context.DeclarationNames.getCXXOperatorName(OO_EqualEqual));
3897}
3898
3899FunctionDecl *Sema::SubstSpaceshipAsEqualEqual(CXXRecordDecl *RD,
3900 FunctionDecl *Spaceship) {
3901 if (Spaceship->isInvalidDecl())
3902 return nullptr;
3903
3904 // C++2a [class.compare.default]p3:
3905 // an == operator function is declared implicitly [...] with the same
3906 // access and function-definition and in the same class scope as the
3907 // three-way comparison operator function
3908 MultiLevelTemplateArgumentList NoTemplateArgs;
3909 NoTemplateArgs.setKind(TemplateSubstitutionKind::Rewrite);
3910 NoTemplateArgs.addOuterRetainedLevels(RD->getTemplateDepth());
3911 TemplateDeclInstantiator Instantiator(*this, RD, NoTemplateArgs);
3912 Decl *R;
3913 if (auto *MD = dyn_cast<CXXMethodDecl>(Spaceship)) {
3914 R = Instantiator.VisitCXXMethodDecl(
3915 MD, nullptr, None,
3916 TemplateDeclInstantiator::RewriteKind::RewriteSpaceshipAsEqualEqual);
3917 } else {
3918 assert(Spaceship->getFriendObjectKind() &&((void)0)
3919 "defaulted spaceship is neither a member nor a friend")((void)0);
3920
3921 R = Instantiator.VisitFunctionDecl(
3922 Spaceship, nullptr,
3923 TemplateDeclInstantiator::RewriteKind::RewriteSpaceshipAsEqualEqual);
3924 if (!R)
3925 return nullptr;
3926
3927 FriendDecl *FD =
3928 FriendDecl::Create(Context, RD, Spaceship->getLocation(),
3929 cast<NamedDecl>(R), Spaceship->getBeginLoc());
3930 FD->setAccess(AS_public);
3931 RD->addDecl(FD);
3932 }
3933 return cast_or_null<FunctionDecl>(R);
3934}
3935
3936/// Instantiates a nested template parameter list in the current
3937/// instantiation context.
3938///
3939/// \param L The parameter list to instantiate
3940///
3941/// \returns NULL if there was an error
3942TemplateParameterList *
3943TemplateDeclInstantiator::SubstTemplateParams(TemplateParameterList *L) {
3944 // Get errors for all the parameters before bailing out.
3945 bool Invalid = false;
3946
3947 unsigned N = L->size();
3948 typedef SmallVector<NamedDecl *, 8> ParamVector;
3949 ParamVector Params;
3950 Params.reserve(N);
3951 for (auto &P : *L) {
3952 NamedDecl *D = cast_or_null<NamedDecl>(Visit(P));
3953 Params.push_back(D);
3954 Invalid = Invalid || !D || D->isInvalidDecl();
3955 }
3956
3957 // Clean up if we had an error.
3958 if (Invalid)
3959 return nullptr;
3960
3961 // FIXME: Concepts: Substitution into requires clause should only happen when
3962 // checking satisfaction.
3963 Expr *InstRequiresClause = nullptr;
3964 if (Expr *E = L->getRequiresClause()) {
3965 EnterExpressionEvaluationContext ConstantEvaluated(
3966 SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
3967 ExprResult Res = SemaRef.SubstExpr(E, TemplateArgs);
3968 if (Res.isInvalid() || !Res.isUsable()) {
3969 return nullptr;
3970 }
3971 InstRequiresClause = Res.get();
3972 }
3973
3974 TemplateParameterList *InstL
3975 = TemplateParameterList::Create(SemaRef.Context, L->getTemplateLoc(),
3976 L->getLAngleLoc(), Params,
3977 L->getRAngleLoc(), InstRequiresClause);
3978 return InstL;
3979}
3980
3981TemplateParameterList *
3982Sema::SubstTemplateParams(TemplateParameterList *Params, DeclContext *Owner,
3983 const MultiLevelTemplateArgumentList &TemplateArgs) {
3984 TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs);
3985 return Instantiator.SubstTemplateParams(Params);
3986}
3987
3988/// Instantiate the declaration of a class template partial
3989/// specialization.
3990///
3991/// \param ClassTemplate the (instantiated) class template that is partially
3992// specialized by the instantiation of \p PartialSpec.
3993///
3994/// \param PartialSpec the (uninstantiated) class template partial
3995/// specialization that we are instantiating.
3996///
3997/// \returns The instantiated partial specialization, if successful; otherwise,
3998/// NULL to indicate an error.
3999ClassTemplatePartialSpecializationDecl *
4000TemplateDeclInstantiator::InstantiateClassTemplatePartialSpecialization(
4001 ClassTemplateDecl *ClassTemplate,
4002 ClassTemplatePartialSpecializationDecl *PartialSpec) {
4003 // Create a local instantiation scope for this class template partial
4004 // specialization, which will contain the instantiations of the template
4005 // parameters.
4006 LocalInstantiationScope Scope(SemaRef);
4007
4008 // Substitute into the template parameters of the class template partial
4009 // specialization.
4010 TemplateParameterList *TempParams = PartialSpec->getTemplateParameters();
4011 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
4012 if (!InstParams)
4013 return nullptr;
4014
4015 // Substitute into the template arguments of the class template partial
4016 // specialization.
4017 const ASTTemplateArgumentListInfo *TemplArgInfo
4018 = PartialSpec->getTemplateArgsAsWritten();
4019 TemplateArgumentListInfo InstTemplateArgs(TemplArgInfo->LAngleLoc,
4020 TemplArgInfo->RAngleLoc);
4021 if (SemaRef.Subst(TemplArgInfo->getTemplateArgs(),
4022 TemplArgInfo->NumTemplateArgs,
4023 InstTemplateArgs, TemplateArgs))
4024 return nullptr;
4025
4026 // Check that the template argument list is well-formed for this
4027 // class template.
4028 SmallVector<TemplateArgument, 4> Converted;
4029 if (SemaRef.CheckTemplateArgumentList(ClassTemplate,
4030 PartialSpec->getLocation(),
4031 InstTemplateArgs,
4032 false,
4033 Converted))
4034 return nullptr;
4035
4036 // Check these arguments are valid for a template partial specialization.
4037 if (SemaRef.CheckTemplatePartialSpecializationArgs(
4038 PartialSpec->getLocation(), ClassTemplate, InstTemplateArgs.size(),
4039 Converted))
4040 return nullptr;
4041
4042 // Figure out where to insert this class template partial specialization
4043 // in the member template's set of class template partial specializations.
4044 void *InsertPos = nullptr;
4045 ClassTemplateSpecializationDecl *PrevDecl
4046 = ClassTemplate->findPartialSpecialization(Converted, InstParams,
4047 InsertPos);
4048
4049 // Build the canonical type that describes the converted template
4050 // arguments of the class template partial specialization.
4051 QualType CanonType
4052 = SemaRef.Context.getTemplateSpecializationType(TemplateName(ClassTemplate),
4053 Converted);
4054
4055 // Build the fully-sugared type for this class template
4056 // specialization as the user wrote in the specialization
4057 // itself. This means that we'll pretty-print the type retrieved
4058 // from the specialization's declaration the way that the user
4059 // actually wrote the specialization, rather than formatting the
4060 // name based on the "canonical" representation used to store the
4061 // template arguments in the specialization.
4062 TypeSourceInfo *WrittenTy
4063 = SemaRef.Context.getTemplateSpecializationTypeInfo(
4064 TemplateName(ClassTemplate),
4065 PartialSpec->getLocation(),
4066 InstTemplateArgs,
4067 CanonType);
4068
4069 if (PrevDecl) {
4070 // We've already seen a partial specialization with the same template
4071 // parameters and template arguments. This can happen, for example, when
4072 // substituting the outer template arguments ends up causing two
4073 // class template partial specializations of a member class template
4074 // to have identical forms, e.g.,
4075 //
4076 // template<typename T, typename U>
4077 // struct Outer {
4078 // template<typename X, typename Y> struct Inner;
4079 // template<typename Y> struct Inner<T, Y>;
4080 // template<typename Y> struct Inner<U, Y>;
4081 // };
4082 //
4083 // Outer<int, int> outer; // error: the partial specializations of Inner
4084 // // have the same signature.
4085 SemaRef.Diag(PartialSpec->getLocation(), diag::err_partial_spec_redeclared)
4086 << WrittenTy->getType();
4087 SemaRef.Diag(PrevDecl->getLocation(), diag::note_prev_partial_spec_here)
4088 << SemaRef.Context.getTypeDeclType(PrevDecl);
4089 return nullptr;
4090 }
4091
4092
4093 // Create the class template partial specialization declaration.
4094 ClassTemplatePartialSpecializationDecl *InstPartialSpec =
4095 ClassTemplatePartialSpecializationDecl::Create(
4096 SemaRef.Context, PartialSpec->getTagKind(), Owner,
4097 PartialSpec->getBeginLoc(), PartialSpec->getLocation(), InstParams,
4098 ClassTemplate, Converted, InstTemplateArgs, CanonType, nullptr);
4099 // Substitute the nested name specifier, if any.
4100 if (SubstQualifier(PartialSpec, InstPartialSpec))
4101 return nullptr;
4102
4103 InstPartialSpec->setInstantiatedFromMember(PartialSpec);
4104 InstPartialSpec->setTypeAsWritten(WrittenTy);
4105
4106 // Check the completed partial specialization.
4107 SemaRef.CheckTemplatePartialSpecialization(InstPartialSpec);
4108
4109 // Add this partial specialization to the set of class template partial
4110 // specializations.
4111 ClassTemplate->AddPartialSpecialization(InstPartialSpec,
4112 /*InsertPos=*/nullptr);
4113 return InstPartialSpec;
4114}
4115
4116/// Instantiate the declaration of a variable template partial
4117/// specialization.
4118///
4119/// \param VarTemplate the (instantiated) variable template that is partially
4120/// specialized by the instantiation of \p PartialSpec.
4121///
4122/// \param PartialSpec the (uninstantiated) variable template partial
4123/// specialization that we are instantiating.
4124///
4125/// \returns The instantiated partial specialization, if successful; otherwise,
4126/// NULL to indicate an error.
4127VarTemplatePartialSpecializationDecl *
4128TemplateDeclInstantiator::InstantiateVarTemplatePartialSpecialization(
4129 VarTemplateDecl *VarTemplate,
4130 VarTemplatePartialSpecializationDecl *PartialSpec) {
4131 // Create a local instantiation scope for this variable template partial
4132 // specialization, which will contain the instantiations of the template
4133 // parameters.
4134 LocalInstantiationScope Scope(SemaRef);
4135
4136 // Substitute into the template parameters of the variable template partial
4137 // specialization.
4138 TemplateParameterList *TempParams = PartialSpec->getTemplateParameters();
4139 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
4140 if (!InstParams)
4141 return nullptr;
4142
4143 // Substitute into the template arguments of the variable template partial
4144 // specialization.
4145 const ASTTemplateArgumentListInfo *TemplArgInfo
4146 = PartialSpec->getTemplateArgsAsWritten();
4147 TemplateArgumentListInfo InstTemplateArgs(TemplArgInfo->LAngleLoc,
4148 TemplArgInfo->RAngleLoc);
4149 if (SemaRef.Subst(TemplArgInfo->getTemplateArgs(),
4150 TemplArgInfo->NumTemplateArgs,
4151 InstTemplateArgs, TemplateArgs))
4152 return nullptr;
4153
4154 // Check that the template argument list is well-formed for this
4155 // class template.
4156 SmallVector<TemplateArgument, 4> Converted;
4157 if (SemaRef.CheckTemplateArgumentList(VarTemplate, PartialSpec->getLocation(),
4158 InstTemplateArgs, false, Converted))
4159 return nullptr;
4160
4161 // Check these arguments are valid for a template partial specialization.
4162 if (SemaRef.CheckTemplatePartialSpecializationArgs(
4163 PartialSpec->getLocation(), VarTemplate, InstTemplateArgs.size(),
4164 Converted))
4165 return nullptr;
4166
4167 // Figure out where to insert this variable template partial specialization
4168 // in the member template's set of variable template partial specializations.
4169 void *InsertPos = nullptr;
4170 VarTemplateSpecializationDecl *PrevDecl =
4171 VarTemplate->findPartialSpecialization(Converted, InstParams, InsertPos);
4172
4173 // Build the canonical type that describes the converted template
4174 // arguments of the variable template partial specialization.
4175 QualType CanonType = SemaRef.Context.getTemplateSpecializationType(
4176 TemplateName(VarTemplate), Converted);
4177
4178 // Build the fully-sugared type for this variable template
4179 // specialization as the user wrote in the specialization
4180 // itself. This means that we'll pretty-print the type retrieved
4181 // from the specialization's declaration the way that the user
4182 // actually wrote the specialization, rather than formatting the
4183 // name based on the "canonical" representation used to store the
4184 // template arguments in the specialization.
4185 TypeSourceInfo *WrittenTy = SemaRef.Context.getTemplateSpecializationTypeInfo(
4186 TemplateName(VarTemplate), PartialSpec->getLocation(), InstTemplateArgs,
4187 CanonType);
4188
4189 if (PrevDecl) {
4190 // We've already seen a partial specialization with the same template
4191 // parameters and template arguments. This can happen, for example, when
4192 // substituting the outer template arguments ends up causing two
4193 // variable template partial specializations of a member variable template
4194 // to have identical forms, e.g.,
4195 //
4196 // template<typename T, typename U>
4197 // struct Outer {
4198 // template<typename X, typename Y> pair<X,Y> p;
4199 // template<typename Y> pair<T, Y> p;
4200 // template<typename Y> pair<U, Y> p;
4201 // };
4202 //
4203 // Outer<int, int> outer; // error: the partial specializations of Inner
4204 // // have the same signature.
4205 SemaRef.Diag(PartialSpec->getLocation(),
4206 diag::err_var_partial_spec_redeclared)
4207 << WrittenTy->getType();
4208 SemaRef.Diag(PrevDecl->getLocation(),
4209 diag::note_var_prev_partial_spec_here);
4210 return nullptr;
4211 }
4212
4213 // Do substitution on the type of the declaration
4214 TypeSourceInfo *DI = SemaRef.SubstType(
4215 PartialSpec->getTypeSourceInfo(), TemplateArgs,
4216 PartialSpec->getTypeSpecStartLoc(), PartialSpec->getDeclName());
4217 if (!DI)
4218 return nullptr;
4219
4220 if (DI->getType()->isFunctionType()) {
4221 SemaRef.Diag(PartialSpec->getLocation(),
4222 diag::err_variable_instantiates_to_function)
4223 << PartialSpec->isStaticDataMember() << DI->getType();
4224 return nullptr;
4225 }
4226
4227 // Create the variable template partial specialization declaration.
4228 VarTemplatePartialSpecializationDecl *InstPartialSpec =
4229 VarTemplatePartialSpecializationDecl::Create(
4230 SemaRef.Context, Owner, PartialSpec->getInnerLocStart(),
4231 PartialSpec->getLocation(), InstParams, VarTemplate, DI->getType(),
4232 DI, PartialSpec->getStorageClass(), Converted, InstTemplateArgs);
4233
4234 // Substitute the nested name specifier, if any.
4235 if (SubstQualifier(PartialSpec, InstPartialSpec))
4236 return nullptr;
4237
4238 InstPartialSpec->setInstantiatedFromMember(PartialSpec);
4239 InstPartialSpec->setTypeAsWritten(WrittenTy);
4240
4241 // Check the completed partial specialization.
4242 SemaRef.CheckTemplatePartialSpecialization(InstPartialSpec);
4243
4244 // Add this partial specialization to the set of variable template partial
4245 // specializations. The instantiation of the initializer is not necessary.
4246 VarTemplate->AddPartialSpecialization(InstPartialSpec, /*InsertPos=*/nullptr);
4247
4248 SemaRef.BuildVariableInstantiation(InstPartialSpec, PartialSpec, TemplateArgs,
4249 LateAttrs, Owner, StartingScope);
4250
4251 return InstPartialSpec;
4252}
4253
4254TypeSourceInfo*
4255TemplateDeclInstantiator::SubstFunctionType(FunctionDecl *D,
4256 SmallVectorImpl<ParmVarDecl *> &Params) {
4257 TypeSourceInfo *OldTInfo = D->getTypeSourceInfo();
4258 assert(OldTInfo && "substituting function without type source info")((void)0);
4259 assert(Params.empty() && "parameter vector is non-empty at start")((void)0);
4260
4261 CXXRecordDecl *ThisContext = nullptr;
4262 Qualifiers ThisTypeQuals;
4263 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
4264 ThisContext = cast<CXXRecordDecl>(Owner);
4265 ThisTypeQuals = Method->getMethodQualifiers();
4266 }
4267
4268 TypeSourceInfo *NewTInfo
4269 = SemaRef.SubstFunctionDeclType(OldTInfo, TemplateArgs,
4270 D->getTypeSpecStartLoc(),
4271 D->getDeclName(),
4272 ThisContext, ThisTypeQuals);
4273 if (!NewTInfo)
4274 return nullptr;
4275
4276 TypeLoc OldTL = OldTInfo->getTypeLoc().IgnoreParens();
4277 if (FunctionProtoTypeLoc OldProtoLoc = OldTL.getAs<FunctionProtoTypeLoc>()) {
4278 if (NewTInfo != OldTInfo) {
4279 // Get parameters from the new type info.
4280 TypeLoc NewTL = NewTInfo->getTypeLoc().IgnoreParens();
4281 FunctionProtoTypeLoc NewProtoLoc = NewTL.castAs<FunctionProtoTypeLoc>();
4282 unsigned NewIdx = 0;
4283 for (unsigned OldIdx = 0, NumOldParams = OldProtoLoc.getNumParams();
4284 OldIdx != NumOldParams; ++OldIdx) {
4285 ParmVarDecl *OldParam = OldProtoLoc.getParam(OldIdx);
4286 if (!OldParam)
4287 return nullptr;
4288
4289 LocalInstantiationScope *Scope = SemaRef.CurrentInstantiationScope;
4290
4291 Optional<unsigned> NumArgumentsInExpansion;
4292 if (OldParam->isParameterPack())
4293 NumArgumentsInExpansion =
4294 SemaRef.getNumArgumentsInExpansion(OldParam->getType(),
4295 TemplateArgs);
4296 if (!NumArgumentsInExpansion) {
4297 // Simple case: normal parameter, or a parameter pack that's
4298 // instantiated to a (still-dependent) parameter pack.
4299 ParmVarDecl *NewParam = NewProtoLoc.getParam(NewIdx++);
4300 Params.push_back(NewParam);
4301 Scope->InstantiatedLocal(OldParam, NewParam);
4302 } else {
4303 // Parameter pack expansion: make the instantiation an argument pack.
4304 Scope->MakeInstantiatedLocalArgPack(OldParam);
4305 for (unsigned I = 0; I != *NumArgumentsInExpansion; ++I) {
4306 ParmVarDecl *NewParam = NewProtoLoc.getParam(NewIdx++);
4307 Params.push_back(NewParam);
4308 Scope->InstantiatedLocalPackArg(OldParam, NewParam);
4309 }
4310 }
4311 }
4312 } else {
4313 // The function type itself was not dependent and therefore no
4314 // substitution occurred. However, we still need to instantiate
4315 // the function parameters themselves.
4316 const FunctionProtoType *OldProto =
4317 cast<FunctionProtoType>(OldProtoLoc.getType());
4318 for (unsigned i = 0, i_end = OldProtoLoc.getNumParams(); i != i_end;
4319 ++i) {
4320 ParmVarDecl *OldParam = OldProtoLoc.getParam(i);
4321 if (!OldParam) {
4322 Params.push_back(SemaRef.BuildParmVarDeclForTypedef(
4323 D, D->getLocation(), OldProto->getParamType(i)));
4324 continue;
4325 }
4326
4327 ParmVarDecl *Parm =
4328 cast_or_null<ParmVarDecl>(VisitParmVarDecl(OldParam));
4329 if (!Parm)
4330 return nullptr;
4331 Params.push_back(Parm);
4332 }
4333 }
4334 } else {
4335 // If the type of this function, after ignoring parentheses, is not
4336 // *directly* a function type, then we're instantiating a function that
4337 // was declared via a typedef or with attributes, e.g.,
4338 //
4339 // typedef int functype(int, int);
4340 // functype func;
4341 // int __cdecl meth(int, int);
4342 //
4343 // In this case, we'll just go instantiate the ParmVarDecls that we
4344 // synthesized in the method declaration.
4345 SmallVector<QualType, 4> ParamTypes;
4346 Sema::ExtParameterInfoBuilder ExtParamInfos;
4347 if (SemaRef.SubstParmTypes(D->getLocation(), D->parameters(), nullptr,
4348 TemplateArgs, ParamTypes, &Params,
4349 ExtParamInfos))
4350 return nullptr;
4351 }
4352
4353 return NewTInfo;
4354}
4355
4356/// Introduce the instantiated function parameters into the local
4357/// instantiation scope, and set the parameter names to those used
4358/// in the template.
4359static bool addInstantiatedParametersToScope(Sema &S, FunctionDecl *Function,
4360 const FunctionDecl *PatternDecl,
4361 LocalInstantiationScope &Scope,
4362 const MultiLevelTemplateArgumentList &TemplateArgs) {
4363 unsigned FParamIdx = 0;
4364 for (unsigned I = 0, N = PatternDecl->getNumParams(); I != N; ++I) {
4365 const ParmVarDecl *PatternParam = PatternDecl->getParamDecl(I);
4366 if (!PatternParam->isParameterPack()) {
4367 // Simple case: not a parameter pack.
4368 assert(FParamIdx < Function->getNumParams())((void)0);
4369 ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx);
4370 FunctionParam->setDeclName(PatternParam->getDeclName());
4371 // If the parameter's type is not dependent, update it to match the type
4372 // in the pattern. They can differ in top-level cv-qualifiers, and we want
4373 // the pattern's type here. If the type is dependent, they can't differ,
4374 // per core issue 1668. Substitute into the type from the pattern, in case
4375 // it's instantiation-dependent.
4376 // FIXME: Updating the type to work around this is at best fragile.
4377 if (!PatternDecl->getType()->isDependentType()) {
4378 QualType T = S.SubstType(PatternParam->getType(), TemplateArgs,
4379 FunctionParam->getLocation(),
4380 FunctionParam->getDeclName());
4381 if (T.isNull())
4382 return true;
4383 FunctionParam->setType(T);
4384 }
4385
4386 Scope.InstantiatedLocal(PatternParam, FunctionParam);
4387 ++FParamIdx;
4388 continue;
4389 }
4390
4391 // Expand the parameter pack.
4392 Scope.MakeInstantiatedLocalArgPack(PatternParam);
4393 Optional<unsigned> NumArgumentsInExpansion
4394 = S.getNumArgumentsInExpansion(PatternParam->getType(), TemplateArgs);
4395 if (NumArgumentsInExpansion) {
4396 QualType PatternType =
4397 PatternParam->getType()->castAs<PackExpansionType>()->getPattern();
4398 for (unsigned Arg = 0; Arg < *NumArgumentsInExpansion; ++Arg) {
4399 ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx);
4400 FunctionParam->setDeclName(PatternParam->getDeclName());
4401 if (!PatternDecl->getType()->isDependentType()) {
4402 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, Arg);
4403 QualType T = S.SubstType(PatternType, TemplateArgs,
4404 FunctionParam->getLocation(),
4405 FunctionParam->getDeclName());
4406 if (T.isNull())
4407 return true;
4408 FunctionParam->setType(T);
4409 }
4410
4411 Scope.InstantiatedLocalPackArg(PatternParam, FunctionParam);
4412 ++FParamIdx;
4413 }
4414 }
4415 }
4416
4417 return false;
4418}
4419
4420bool Sema::InstantiateDefaultArgument(SourceLocation CallLoc, FunctionDecl *FD,
4421 ParmVarDecl *Param) {
4422 assert(Param->hasUninstantiatedDefaultArg())((void)0);
4423 Expr *UninstExpr = Param->getUninstantiatedDefaultArg();
4424
4425 EnterExpressionEvaluationContext EvalContext(
4426 *this, ExpressionEvaluationContext::PotentiallyEvaluated, Param);
4427
4428 // Instantiate the expression.
4429 //
4430 // FIXME: Pass in a correct Pattern argument, otherwise
4431 // getTemplateInstantiationArgs uses the lexical context of FD, e.g.
4432 //
4433 // template<typename T>
4434 // struct A {
4435 // static int FooImpl();
4436 //
4437 // template<typename Tp>
4438 // // bug: default argument A<T>::FooImpl() is evaluated with 2-level
4439 // // template argument list [[T], [Tp]], should be [[Tp]].
4440 // friend A<Tp> Foo(int a);
4441 // };
4442 //
4443 // template<typename T>
4444 // A<T> Foo(int a = A<T>::FooImpl());
4445 MultiLevelTemplateArgumentList TemplateArgs
4446 = getTemplateInstantiationArgs(FD, nullptr, /*RelativeToPrimary=*/true);
4447
4448 InstantiatingTemplate Inst(*this, CallLoc, Param,
4449 TemplateArgs.getInnermost());
4450 if (Inst.isInvalid())
4451 return true;
4452 if (Inst.isAlreadyInstantiating()) {
4453 Diag(Param->getBeginLoc(), diag::err_recursive_default_argument) << FD;
4454 Param->setInvalidDecl();
4455 return true;
4456 }
4457
4458 ExprResult Result;
4459 {
4460 // C++ [dcl.fct.default]p5:
4461 // The names in the [default argument] expression are bound, and
4462 // the semantic constraints are checked, at the point where the
4463 // default argument expression appears.
4464 ContextRAII SavedContext(*this, FD);
4465 LocalInstantiationScope Local(*this);
4466
4467 FunctionDecl *Pattern = FD->getTemplateInstantiationPattern(
4468 /*ForDefinition*/ false);
4469 if (addInstantiatedParametersToScope(*this, FD, Pattern, Local,
4470 TemplateArgs))
4471 return true;
4472
4473 runWithSufficientStackSpace(CallLoc, [&] {
4474 Result = SubstInitializer(UninstExpr, TemplateArgs,
4475 /*DirectInit*/false);
4476 });
4477 }
4478 if (Result.isInvalid())
4479 return true;
4480
4481 // Check the expression as an initializer for the parameter.
4482 InitializedEntity Entity
4483 = InitializedEntity::InitializeParameter(Context, Param);
4484 InitializationKind Kind = InitializationKind::CreateCopy(
4485 Param->getLocation(),
4486 /*FIXME:EqualLoc*/ UninstExpr->getBeginLoc());
4487 Expr *ResultE = Result.getAs<Expr>();
4488
4489 InitializationSequence InitSeq(*this, Entity, Kind, ResultE);
4490 Result = InitSeq.Perform(*this, Entity, Kind, ResultE);
4491 if (Result.isInvalid())
4492 return true;
4493
4494 Result =
4495 ActOnFinishFullExpr(Result.getAs<Expr>(), Param->getOuterLocStart(),
4496 /*DiscardedValue*/ false);
4497 if (Result.isInvalid())
4498 return true;
4499
4500 // Remember the instantiated default argument.
4501 Param->setDefaultArg(Result.getAs<Expr>());
4502 if (ASTMutationListener *L = getASTMutationListener())
4503 L->DefaultArgumentInstantiated(Param);
4504
4505 return false;
4506}
4507
4508void Sema::InstantiateExceptionSpec(SourceLocation PointOfInstantiation,
4509 FunctionDecl *Decl) {
4510 const FunctionProtoType *Proto = Decl->getType()->castAs<FunctionProtoType>();
4511 if (Proto->getExceptionSpecType() != EST_Uninstantiated)
4512 return;
4513
4514 InstantiatingTemplate Inst(*this, PointOfInstantiation, Decl,
4515 InstantiatingTemplate::ExceptionSpecification());
4516 if (Inst.isInvalid()) {
4517 // We hit the instantiation depth limit. Clear the exception specification
4518 // so that our callers don't have to cope with EST_Uninstantiated.
4519 UpdateExceptionSpec(Decl, EST_None);
4520 return;
4521 }
4522 if (Inst.isAlreadyInstantiating()) {
4523 // This exception specification indirectly depends on itself. Reject.
4524 // FIXME: Corresponding rule in the standard?
4525 Diag(PointOfInstantiation, diag::err_exception_spec_cycle) << Decl;
4526 UpdateExceptionSpec(Decl, EST_None);
4527 return;
4528 }
4529
4530 // Enter the scope of this instantiation. We don't use
4531 // PushDeclContext because we don't have a scope.
4532 Sema::ContextRAII savedContext(*this, Decl);
4533 LocalInstantiationScope Scope(*this);
4534
4535 MultiLevelTemplateArgumentList TemplateArgs =
4536 getTemplateInstantiationArgs(Decl, nullptr, /*RelativeToPrimary*/true);
4537
4538 // FIXME: We can't use getTemplateInstantiationPattern(false) in general
4539 // here, because for a non-defining friend declaration in a class template,
4540 // we don't store enough information to map back to the friend declaration in
4541 // the template.
4542 FunctionDecl *Template = Proto->getExceptionSpecTemplate();
4543 if (addInstantiatedParametersToScope(*this, Decl, Template, Scope,
4544 TemplateArgs)) {
4545 UpdateExceptionSpec(Decl, EST_None);
4546 return;
4547 }
4548
4549 SubstExceptionSpec(Decl, Template->getType()->castAs<FunctionProtoType>(),
4550 TemplateArgs);
4551}
4552
4553bool Sema::CheckInstantiatedFunctionTemplateConstraints(
4554 SourceLocation PointOfInstantiation, FunctionDecl *Decl,
4555 ArrayRef<TemplateArgument> TemplateArgs,
4556 ConstraintSatisfaction &Satisfaction) {
4557 // In most cases we're not going to have constraints, so check for that first.
4558 FunctionTemplateDecl *Template = Decl->getPrimaryTemplate();
4559 // Note - code synthesis context for the constraints check is created
4560 // inside CheckConstraintsSatisfaction.
4561 SmallVector<const Expr *, 3> TemplateAC;
4562 Template->getAssociatedConstraints(TemplateAC);
4563 if (TemplateAC.empty()) {
4564 Satisfaction.IsSatisfied = true;
4565 return false;
4566 }
4567
4568 // Enter the scope of this instantiation. We don't use
4569 // PushDeclContext because we don't have a scope.
4570 Sema::ContextRAII savedContext(*this, Decl);
4571 LocalInstantiationScope Scope(*this);
4572
4573 // If this is not an explicit specialization - we need to get the instantiated
4574 // version of the template arguments and add them to scope for the
4575 // substitution.
4576 if (Decl->isTemplateInstantiation()) {
4577 InstantiatingTemplate Inst(*this, Decl->getPointOfInstantiation(),
4578 InstantiatingTemplate::ConstraintsCheck{}, Decl->getPrimaryTemplate(),
4579 TemplateArgs, SourceRange());
4580 if (Inst.isInvalid())
4581 return true;
4582 MultiLevelTemplateArgumentList MLTAL(
4583 *Decl->getTemplateSpecializationArgs());
4584 if (addInstantiatedParametersToScope(
4585 *this, Decl, Decl->getPrimaryTemplate()->getTemplatedDecl(),
4586 Scope, MLTAL))
4587 return true;
4588 }
4589 Qualifiers ThisQuals;
4590 CXXRecordDecl *Record = nullptr;
4591 if (auto *Method = dyn_cast<CXXMethodDecl>(Decl)) {
4592 ThisQuals = Method->getMethodQualifiers();
4593 Record = Method->getParent();
4594 }
4595 CXXThisScopeRAII ThisScope(*this, Record, ThisQuals, Record != nullptr);
4596 return CheckConstraintSatisfaction(Template, TemplateAC, TemplateArgs,
4597 PointOfInstantiation, Satisfaction);
4598}
4599
4600/// Initializes the common fields of an instantiation function
4601/// declaration (New) from the corresponding fields of its template (Tmpl).
4602///
4603/// \returns true if there was an error
4604bool
4605TemplateDeclInstantiator::InitFunctionInstantiation(FunctionDecl *New,
4606 FunctionDecl *Tmpl) {
4607 New->setImplicit(Tmpl->isImplicit());
4608
4609 // Forward the mangling number from the template to the instantiated decl.
4610 SemaRef.Context.setManglingNumber(New,
4611 SemaRef.Context.getManglingNumber(Tmpl));
4612
4613 // If we are performing substituting explicitly-specified template arguments
4614 // or deduced template arguments into a function template and we reach this
4615 // point, we are now past the point where SFINAE applies and have committed
4616 // to keeping the new function template specialization. We therefore
4617 // convert the active template instantiation for the function template
4618 // into a template instantiation for this specific function template
4619 // specialization, which is not a SFINAE context, so that we diagnose any
4620 // further errors in the declaration itself.
4621 //
4622 // FIXME: This is a hack.
4623 typedef Sema::CodeSynthesisContext ActiveInstType;
4624 ActiveInstType &ActiveInst = SemaRef.CodeSynthesisContexts.back();
4625 if (ActiveInst.Kind == ActiveInstType::ExplicitTemplateArgumentSubstitution ||
4626 ActiveInst.Kind == ActiveInstType::DeducedTemplateArgumentSubstitution) {
4627 if (FunctionTemplateDecl *FunTmpl
4628 = dyn_cast<FunctionTemplateDecl>(ActiveInst.Entity)) {
4629 assert(FunTmpl->getTemplatedDecl() == Tmpl &&((void)0)
4630 "Deduction from the wrong function template?")((void)0);
4631 (void) FunTmpl;
4632 SemaRef.InstantiatingSpecializations.erase(
4633 {ActiveInst.Entity->getCanonicalDecl(), ActiveInst.Kind});
4634 atTemplateEnd(SemaRef.TemplateInstCallbacks, SemaRef, ActiveInst);
4635 ActiveInst.Kind = ActiveInstType::TemplateInstantiation;
4636 ActiveInst.Entity = New;
4637 atTemplateBegin(SemaRef.TemplateInstCallbacks, SemaRef, ActiveInst);
4638 }
4639 }
4640
4641 const FunctionProtoType *Proto = Tmpl->getType()->getAs<FunctionProtoType>();
4642 assert(Proto && "Function template without prototype?")((void)0);
4643
4644 if (Proto->hasExceptionSpec() || Proto->getNoReturnAttr()) {
4645 FunctionProtoType::ExtProtoInfo EPI = Proto->getExtProtoInfo();
4646
4647 // DR1330: In C++11, defer instantiation of a non-trivial
4648 // exception specification.
4649 // DR1484: Local classes and their members are instantiated along with the
4650 // containing function.
4651 if (SemaRef.getLangOpts().CPlusPlus11 &&
4652 EPI.ExceptionSpec.Type != EST_None &&
4653 EPI.ExceptionSpec.Type != EST_DynamicNone &&
4654 EPI.ExceptionSpec.Type != EST_BasicNoexcept &&
4655 !Tmpl->isInLocalScopeForInstantiation()) {
4656 FunctionDecl *ExceptionSpecTemplate = Tmpl;
4657 if (EPI.ExceptionSpec.Type == EST_Uninstantiated)
4658 ExceptionSpecTemplate = EPI.ExceptionSpec.SourceTemplate;
4659 ExceptionSpecificationType NewEST = EST_Uninstantiated;
4660 if (EPI.ExceptionSpec.Type == EST_Unevaluated)
4661 NewEST = EST_Unevaluated;
4662
4663 // Mark the function has having an uninstantiated exception specification.
4664 const FunctionProtoType *NewProto
4665 = New->getType()->getAs<FunctionProtoType>();
4666 assert(NewProto && "Template instantiation without function prototype?")((void)0);
4667 EPI = NewProto->getExtProtoInfo();
4668 EPI.ExceptionSpec.Type = NewEST;
4669 EPI.ExceptionSpec.SourceDecl = New;
4670 EPI.ExceptionSpec.SourceTemplate = ExceptionSpecTemplate;
4671 New->setType(SemaRef.Context.getFunctionType(
4672 NewProto->getReturnType(), NewProto->getParamTypes(), EPI));
4673 } else {
4674 Sema::ContextRAII SwitchContext(SemaRef, New);
4675 SemaRef.SubstExceptionSpec(New, Proto, TemplateArgs);
4676 }
4677 }
4678
4679 // Get the definition. Leaves the variable unchanged if undefined.
4680 const FunctionDecl *Definition = Tmpl;
4681 Tmpl->isDefined(Definition);
4682
4683 SemaRef.InstantiateAttrs(TemplateArgs, Definition, New,
4684 LateAttrs, StartingScope);
4685
4686 return false;
4687}
4688
4689/// Initializes common fields of an instantiated method
4690/// declaration (New) from the corresponding fields of its template
4691/// (Tmpl).
4692///
4693/// \returns true if there was an error
4694bool
4695TemplateDeclInstantiator::InitMethodInstantiation(CXXMethodDecl *New,
4696 CXXMethodDecl *Tmpl) {
4697 if (InitFunctionInstantiation(New, Tmpl))
4698 return true;
4699
4700 if (isa<CXXDestructorDecl>(New) && SemaRef.getLangOpts().CPlusPlus11)
4701 SemaRef.AdjustDestructorExceptionSpec(cast<CXXDestructorDecl>(New));
4702
4703 New->setAccess(Tmpl->getAccess());
4704 if (Tmpl->isVirtualAsWritten())
4705 New->setVirtualAsWritten(true);
4706
4707 // FIXME: New needs a pointer to Tmpl
4708 return false;
4709}
4710
4711bool TemplateDeclInstantiator::SubstDefaultedFunction(FunctionDecl *New,
4712 FunctionDecl *Tmpl) {
4713 // Transfer across any unqualified lookups.
4714 if (auto *DFI = Tmpl->getDefaultedFunctionInfo()) {
4715 SmallVector<DeclAccessPair, 32> Lookups;
4716 Lookups.reserve(DFI->getUnqualifiedLookups().size());
4717 bool AnyChanged = false;
4718 for (DeclAccessPair DA : DFI->getUnqualifiedLookups()) {
4719 NamedDecl *D = SemaRef.FindInstantiatedDecl(New->getLocation(),
4720 DA.getDecl(), TemplateArgs);
4721 if (!D)
4722 return true;
4723 AnyChanged |= (D != DA.getDecl());
4724 Lookups.push_back(DeclAccessPair::make(D, DA.getAccess()));
4725 }
4726
4727 // It's unlikely that substitution will change any declarations. Don't
4728 // store an unnecessary copy in that case.
4729 New->setDefaultedFunctionInfo(
4730 AnyChanged ? FunctionDecl::DefaultedFunctionInfo::Create(
4731 SemaRef.Context, Lookups)
4732 : DFI);
4733 }
4734
4735 SemaRef.SetDeclDefaulted(New, Tmpl->getLocation());
4736 return false;
4737}
4738
4739/// Instantiate (or find existing instantiation of) a function template with a
4740/// given set of template arguments.
4741///
4742/// Usually this should not be used, and template argument deduction should be
4743/// used in its place.
4744FunctionDecl *
4745Sema::InstantiateFunctionDeclaration(FunctionTemplateDecl *FTD,
4746 const TemplateArgumentList *Args,
4747 SourceLocation Loc) {
4748 FunctionDecl *FD = FTD->getTemplatedDecl();
4749
4750 sema::TemplateDeductionInfo Info(Loc);
4751 InstantiatingTemplate Inst(
4752 *this, Loc, FTD, Args->asArray(),
4753 CodeSynthesisContext::ExplicitTemplateArgumentSubstitution, Info);
4754 if (Inst.isInvalid())
4755 return nullptr;
4756
4757 ContextRAII SavedContext(*this, FD);
4758 MultiLevelTemplateArgumentList MArgs(*Args);
4759
4760 return cast_or_null<FunctionDecl>(SubstDecl(FD, FD->getParent(), MArgs));
4761}
4762
4763/// Instantiate the definition of the given function from its
4764/// template.
4765///
4766/// \param PointOfInstantiation the point at which the instantiation was
4767/// required. Note that this is not precisely a "point of instantiation"
4768/// for the function, but it's close.
4769///
4770/// \param Function the already-instantiated declaration of a
4771/// function template specialization or member function of a class template
4772/// specialization.
4773///
4774/// \param Recursive if true, recursively instantiates any functions that
4775/// are required by this instantiation.
4776///
4777/// \param DefinitionRequired if true, then we are performing an explicit
4778/// instantiation where the body of the function is required. Complain if
4779/// there is no such body.
4780void Sema::InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
4781 FunctionDecl *Function,
4782 bool Recursive,
4783 bool DefinitionRequired,
4784 bool AtEndOfTU) {
4785 if (Function->isInvalidDecl() || isa<CXXDeductionGuideDecl>(Function))
2
Assuming the condition is false
3
Assuming 'Function' is not a 'CXXDeductionGuideDecl'
4
Taking false branch
4786 return;
4787
4788 // Never instantiate an explicit specialization except if it is a class scope
4789 // explicit specialization.
4790 TemplateSpecializationKind TSK =
4791 Function->getTemplateSpecializationKindForInstantiation();
4792 if (TSK == TSK_ExplicitSpecialization)
5
Assuming 'TSK' is not equal to TSK_ExplicitSpecialization
6
Taking false branch
4793 return;
4794
4795 // Don't instantiate a definition if we already have one.
4796 const FunctionDecl *ExistingDefn = nullptr;
4797 if (Function->isDefined(ExistingDefn,
7
Assuming the condition is false
8
Taking false branch
4798 /*CheckForPendingFriendDefinition=*/true)) {
4799 if (ExistingDefn->isThisDeclarationADefinition())
4800 return;
4801
4802 // If we're asked to instantiate a function whose body comes from an
4803 // instantiated friend declaration, attach the instantiated body to the
4804 // corresponding declaration of the function.
4805 assert(ExistingDefn->isThisDeclarationInstantiatedFromAFriendDefinition())((void)0);
4806 Function = const_cast<FunctionDecl*>(ExistingDefn);
4807 }
4808
4809 // Find the function body that we'll be substituting.
4810 const FunctionDecl *PatternDecl = Function->getTemplateInstantiationPattern();
4811 assert(PatternDecl && "instantiating a non-template")((void)0);
4812
4813 const FunctionDecl *PatternDef = PatternDecl->getDefinition();
4814 Stmt *Pattern = nullptr;
4815 if (PatternDef
8.1
'PatternDef' is null
8.1
'PatternDef' is null
) {
9
Taking false branch
4816 Pattern = PatternDef->getBody(PatternDef);
4817 PatternDecl = PatternDef;
4818 if (PatternDef->willHaveBody())
4819 PatternDef = nullptr;
4820 }
4821
4822 // FIXME: We need to track the instantiation stack in order to know which
4823 // definitions should be visible within this instantiation.
4824 if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Function,
10
Assuming the condition is false
11
Taking false branch
4825 Function->getInstantiatedFromMemberFunction(),
4826 PatternDecl, PatternDef, TSK,
4827 /*Complain*/DefinitionRequired)) {
4828 if (DefinitionRequired)
4829 Function->setInvalidDecl();
4830 else if (TSK == TSK_ExplicitInstantiationDefinition) {
4831 // Try again at the end of the translation unit (at which point a
4832 // definition will be required).
4833 assert(!Recursive)((void)0);
4834 Function->setInstantiationIsPending(true);
4835 PendingInstantiations.push_back(
4836 std::make_pair(Function, PointOfInstantiation));
4837 } else if (TSK == TSK_ImplicitInstantiation) {
4838 if (AtEndOfTU && !getDiagnostics().hasErrorOccurred() &&
4839 !getSourceManager().isInSystemHeader(PatternDecl->getBeginLoc())) {
4840 Diag(PointOfInstantiation, diag::warn_func_template_missing)
4841 << Function;
4842 Diag(PatternDecl->getLocation(), diag::note_forward_template_decl);
4843 if (getLangOpts().CPlusPlus11)
4844 Diag(PointOfInstantiation, diag::note_inst_declaration_hint)
4845 << Function;
4846 }
4847 }
4848
4849 return;
4850 }
4851
4852 // Postpone late parsed template instantiations.
4853 if (PatternDecl->isLateTemplateParsed() &&
12
Assuming the condition is false
4854 !LateTemplateParser) {
4855 Function->setInstantiationIsPending(true);
4856 LateParsedInstantiations.push_back(
4857 std::make_pair(Function, PointOfInstantiation));
4858 return;
4859 }
4860
4861 llvm::TimeTraceScope TimeScope("InstantiateFunction", [&]() {
4862 std::string Name;
4863 llvm::raw_string_ostream OS(Name);
4864 Function->getNameForDiagnostic(OS, getPrintingPolicy(),
4865 /*Qualified=*/true);
4866 return Name;
4867 });
4868
4869 // If we're performing recursive template instantiation, create our own
4870 // queue of pending implicit instantiations that we will instantiate later,
4871 // while we're still within our own instantiation context.
4872 // This has to happen before LateTemplateParser below is called, so that
4873 // it marks vtables used in late parsed templates as used.
4874 GlobalEagerInstantiationScope GlobalInstantiations(*this,
4875 /*Enabled=*/Recursive);
4876 LocalEagerInstantiationScope LocalInstantiations(*this);
4877
4878 // Call the LateTemplateParser callback if there is a need to late parse
4879 // a templated function definition.
4880 if (!Pattern
12.1
'Pattern' is null
12.1
'Pattern' is null
&& PatternDecl->isLateTemplateParsed() &&
4881 LateTemplateParser) {
4882 // FIXME: Optimize to allow individual templates to be deserialized.
4883 if (PatternDecl->isFromASTFile())
4884 ExternalSource->ReadLateParsedTemplates(LateParsedTemplateMap);
4885
4886 auto LPTIter = LateParsedTemplateMap.find(PatternDecl);
4887 assert(LPTIter != LateParsedTemplateMap.end() &&((void)0)
4888 "missing LateParsedTemplate")((void)0);
4889 LateTemplateParser(OpaqueParser, *LPTIter->second);
4890 Pattern = PatternDecl->getBody(PatternDecl);
4891 }
4892
4893 // Note, we should never try to instantiate a deleted function template.
4894 assert((Pattern || PatternDecl->isDefaulted() ||((void)0)
4895 PatternDecl->hasSkippedBody()) &&((void)0)
4896 "unexpected kind of function template definition")((void)0);
4897
4898 // C++1y [temp.explicit]p10:
4899 // Except for inline functions, declarations with types deduced from their
4900 // initializer or return value, and class template specializations, other
4901 // explicit instantiation declarations have the effect of suppressing the
4902 // implicit instantiation of the entity to which they refer.
4903 if (TSK == TSK_ExplicitInstantiationDeclaration &&
13
Assuming 'TSK' is not equal to TSK_ExplicitInstantiationDeclaration
14
Taking false branch
4904 !PatternDecl->isInlined() &&
4905 !PatternDecl->getReturnType()->getContainedAutoType())
4906 return;
4907
4908 if (PatternDecl->isInlined()) {
15
Assuming the condition is false
16
Taking false branch
4909 // Function, and all later redeclarations of it (from imported modules,
4910 // for instance), are now implicitly inline.
4911 for (auto *D = Function->getMostRecentDecl(); /**/;
4912 D = D->getPreviousDecl()) {
4913 D->setImplicitlyInline();
4914 if (D == Function)
4915 break;
4916 }
4917 }
4918
4919 InstantiatingTemplate Inst(*this, PointOfInstantiation, Function);
4920 if (Inst.isInvalid() || Inst.isAlreadyInstantiating())
17
Assuming the condition is false
18
Assuming the condition is false
19
Taking false branch
4921 return;
4922 PrettyDeclStackTraceEntry CrashInfo(Context, Function, SourceLocation(),
4923 "instantiating function definition");
4924
4925 // The instantiation is visible here, even if it was first declared in an
4926 // unimported module.
4927 Function->setVisibleDespiteOwningModule();
4928
4929 // Copy the inner loc start from the pattern.
4930 Function->setInnerLocStart(PatternDecl->getInnerLocStart());
4931
4932 EnterExpressionEvaluationContext EvalContext(
4933 *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
4934
4935 // Introduce a new scope where local variable instantiations will be
4936 // recorded, unless we're actually a member function within a local
4937 // class, in which case we need to merge our results with the parent
4938 // scope (of the enclosing function). The exception is instantiating
4939 // a function template specialization, since the template to be
4940 // instantiated already has references to locals properly substituted.
4941 bool MergeWithParentScope = false;
4942 if (CXXRecordDecl *Rec
20.1
'Rec' is null
20.1
'Rec' is null
= dyn_cast<CXXRecordDecl>(Function->getDeclContext()))
20
Assuming the object is not a 'CXXRecordDecl'
21
Taking false branch
4943 MergeWithParentScope =
4944 Rec->isLocalClass() && !Function->isFunctionTemplateSpecialization();
4945
4946 LocalInstantiationScope Scope(*this, MergeWithParentScope);
4947 auto RebuildTypeSourceInfoForDefaultSpecialMembers = [&]() {
4948 // Special members might get their TypeSourceInfo set up w.r.t the
4949 // PatternDecl context, in which case parameters could still be pointing
4950 // back to the original class, make sure arguments are bound to the
4951 // instantiated record instead.
4952 assert(PatternDecl->isDefaulted() &&((void)0)
4953 "Special member needs to be defaulted")((void)0);
4954 auto PatternSM = getDefaultedFunctionKind(PatternDecl).asSpecialMember();
4955 if (!(PatternSM == Sema::CXXCopyConstructor ||
4956 PatternSM == Sema::CXXCopyAssignment ||
4957 PatternSM == Sema::CXXMoveConstructor ||
4958 PatternSM == Sema::CXXMoveAssignment))
4959 return;
4960
4961 auto *NewRec = dyn_cast<CXXRecordDecl>(Function->getDeclContext());
4962 const auto *PatternRec =
4963 dyn_cast<CXXRecordDecl>(PatternDecl->getDeclContext());
4964 if (!NewRec || !PatternRec)
4965 return;
4966 if (!PatternRec->isLambda())
4967 return;
4968
4969 struct SpecialMemberTypeInfoRebuilder
4970 : TreeTransform<SpecialMemberTypeInfoRebuilder> {
4971 using Base = TreeTransform<SpecialMemberTypeInfoRebuilder>;
4972 const CXXRecordDecl *OldDecl;
4973 CXXRecordDecl *NewDecl;
4974
4975 SpecialMemberTypeInfoRebuilder(Sema &SemaRef, const CXXRecordDecl *O,
4976 CXXRecordDecl *N)
4977 : TreeTransform(SemaRef), OldDecl(O), NewDecl(N) {}
4978
4979 bool TransformExceptionSpec(SourceLocation Loc,
4980 FunctionProtoType::ExceptionSpecInfo &ESI,
4981 SmallVectorImpl<QualType> &Exceptions,
4982 bool &Changed) {
4983 return false;
4984 }
4985
4986 QualType TransformRecordType(TypeLocBuilder &TLB, RecordTypeLoc TL) {
4987 const RecordType *T = TL.getTypePtr();
4988 RecordDecl *Record = cast_or_null<RecordDecl>(
4989 getDerived().TransformDecl(TL.getNameLoc(), T->getDecl()));
4990 if (Record != OldDecl)
4991 return Base::TransformRecordType(TLB, TL);
4992
4993 QualType Result = getDerived().RebuildRecordType(NewDecl);
4994 if (Result.isNull())
4995 return QualType();
4996
4997 RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result);
4998 NewTL.setNameLoc(TL.getNameLoc());
4999 return Result;
5000 }
5001 } IR{*this, PatternRec, NewRec};
5002
5003 TypeSourceInfo *NewSI = IR.TransformType(Function->getTypeSourceInfo());
5004 Function->setType(NewSI->getType());
5005 Function->setTypeSourceInfo(NewSI);
5006
5007 ParmVarDecl *Parm = Function->getParamDecl(0);
5008 TypeSourceInfo *NewParmSI = IR.TransformType(Parm->getTypeSourceInfo());
5009 Parm->setType(NewParmSI->getType());
5010 Parm->setTypeSourceInfo(NewParmSI);
5011 };
5012
5013 if (PatternDecl->isDefaulted()) {
22
Assuming the condition is false
23
Taking false branch
5014 RebuildTypeSourceInfoForDefaultSpecialMembers();
5015 SetDeclDefaulted(Function, PatternDecl->getLocation());
5016 } else {
5017 MultiLevelTemplateArgumentList TemplateArgs =
5018 getTemplateInstantiationArgs(Function, nullptr, false, PatternDecl);
5019
5020 // Substitute into the qualifier; we can get a substitution failure here
5021 // through evil use of alias templates.
5022 // FIXME: Is CurContext correct for this? Should we go to the (instantiation
5023 // of the) lexical context of the pattern?
5024 SubstQualifier(*this, PatternDecl, Function, TemplateArgs);
5025
5026 ActOnStartOfFunctionDef(nullptr, Function);
5027
5028 // Enter the scope of this instantiation. We don't use
5029 // PushDeclContext because we don't have a scope.
5030 Sema::ContextRAII savedContext(*this, Function);
5031
5032 if (addInstantiatedParametersToScope(*this, Function, PatternDecl, Scope,
24
Assuming the condition is false
25
Taking false branch
5033 TemplateArgs))
5034 return;
5035
5036 StmtResult Body;
5037 if (PatternDecl->hasSkippedBody()) {
26
Assuming the condition is false
27
Taking false branch
5038 ActOnSkippedFunctionBody(Function);
5039 Body = nullptr;
5040 } else {
5041 if (CXXConstructorDecl *Ctor
28.1
'Ctor' is null
28.1
'Ctor' is null
= dyn_cast<CXXConstructorDecl>(Function)) {
28
Assuming 'Function' is not a 'CXXConstructorDecl'
29
Taking false branch
5042 // If this is a constructor, instantiate the member initializers.
5043 InstantiateMemInitializers(Ctor, cast<CXXConstructorDecl>(PatternDecl),
5044 TemplateArgs);
5045
5046 // If this is an MS ABI dllexport default constructor, instantiate any
5047 // default arguments.
5048 if (Context.getTargetInfo().getCXXABI().isMicrosoft() &&
5049 Ctor->isDefaultConstructor()) {
5050 InstantiateDefaultCtorDefaultArgs(Ctor);
5051 }
5052 }
5053
5054 // Instantiate the function body.
5055 Body = SubstStmt(Pattern, TemplateArgs);
5056
5057 if (Body.isInvalid())
30
Assuming the condition is false
31
Taking false branch
5058 Function->setInvalidDecl();
5059 }
5060 // FIXME: finishing the function body while in an expression evaluation
5061 // context seems wrong. Investigate more.
5062 ActOnFinishFunctionBody(Function, Body.get(), /*IsInstantiation=*/true);
5063
5064 PerformDependentDiagnostics(PatternDecl, TemplateArgs);
5065
5066 if (auto *Listener = getASTMutationListener())
32
Assuming 'Listener' is null
33
Taking false branch
5067 Listener->FunctionDefinitionInstantiated(Function);
5068
5069 savedContext.pop();
5070 }
5071
5072 DeclGroupRef DG(Function);
5073 Consumer.HandleTopLevelDecl(DG);
5074
5075 // This class may have local implicit instantiations that need to be
5076 // instantiation within this scope.
5077 LocalInstantiations.perform();
5078 Scope.Exit();
5079 GlobalInstantiations.perform();
34
Calling 'GlobalEagerInstantiationScope::perform'
5080}
5081
5082VarTemplateSpecializationDecl *Sema::BuildVarTemplateInstantiation(
5083 VarTemplateDecl *VarTemplate, VarDecl *FromVar,
5084 const TemplateArgumentList &TemplateArgList,
5085 const TemplateArgumentListInfo &TemplateArgsInfo,
5086 SmallVectorImpl<TemplateArgument> &Converted,
5087 SourceLocation PointOfInstantiation,
5088 LateInstantiatedAttrVec *LateAttrs,
5089 LocalInstantiationScope *StartingScope) {
5090 if (FromVar->isInvalidDecl())
5091 return nullptr;
5092
5093 InstantiatingTemplate Inst(*this, PointOfInstantiation, FromVar);
5094 if (Inst.isInvalid())
5095 return nullptr;
5096
5097 MultiLevelTemplateArgumentList TemplateArgLists;
5098 TemplateArgLists.addOuterTemplateArguments(&TemplateArgList);
5099
5100 // Instantiate the first declaration of the variable template: for a partial
5101 // specialization of a static data member template, the first declaration may
5102 // or may not be the declaration in the class; if it's in the class, we want
5103 // to instantiate a member in the class (a declaration), and if it's outside,
5104 // we want to instantiate a definition.
5105 //
5106 // If we're instantiating an explicitly-specialized member template or member
5107 // partial specialization, don't do this. The member specialization completely
5108 // replaces the original declaration in this case.
5109 bool IsMemberSpec = false;
5110 if (VarTemplatePartialSpecializationDecl *PartialSpec =
5111 dyn_cast<VarTemplatePartialSpecializationDecl>(FromVar))
5112 IsMemberSpec = PartialSpec->isMemberSpecialization();
5113 else if (VarTemplateDecl *FromTemplate = FromVar->getDescribedVarTemplate())
5114 IsMemberSpec = FromTemplate->isMemberSpecialization();
5115 if (!IsMemberSpec)
5116 FromVar = FromVar->getFirstDecl();
5117
5118 MultiLevelTemplateArgumentList MultiLevelList(TemplateArgList);
5119 TemplateDeclInstantiator Instantiator(*this, FromVar->getDeclContext(),
5120 MultiLevelList);
5121
5122 // TODO: Set LateAttrs and StartingScope ...
5123
5124 return cast_or_null<VarTemplateSpecializationDecl>(
5125 Instantiator.VisitVarTemplateSpecializationDecl(
5126 VarTemplate, FromVar, TemplateArgsInfo, Converted));
5127}
5128
5129/// Instantiates a variable template specialization by completing it
5130/// with appropriate type information and initializer.
5131VarTemplateSpecializationDecl *Sema::CompleteVarTemplateSpecializationDecl(
5132 VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl,
5133 const MultiLevelTemplateArgumentList &TemplateArgs) {
5134 assert(PatternDecl->isThisDeclarationADefinition() &&((void)0)
5135 "don't have a definition to instantiate from")((void)0);
5136
5137 // Do substitution on the type of the declaration
5138 TypeSourceInfo *DI =
5139 SubstType(PatternDecl->getTypeSourceInfo(), TemplateArgs,
5140 PatternDecl->getTypeSpecStartLoc(), PatternDecl->getDeclName());
5141 if (!DI)
5142 return nullptr;
5143
5144 // Update the type of this variable template specialization.
5145 VarSpec->setType(DI->getType());
5146
5147 // Convert the declaration into a definition now.
5148 VarSpec->setCompleteDefinition();
5149
5150 // Instantiate the initializer.
5151 InstantiateVariableInitializer(VarSpec, PatternDecl, TemplateArgs);
5152
5153 if (getLangOpts().OpenCL)
5154 deduceOpenCLAddressSpace(VarSpec);
5155
5156 return VarSpec;
5157}
5158
5159/// BuildVariableInstantiation - Used after a new variable has been created.
5160/// Sets basic variable data and decides whether to postpone the
5161/// variable instantiation.
5162void Sema::BuildVariableInstantiation(
5163 VarDecl *NewVar, VarDecl *OldVar,
5164 const MultiLevelTemplateArgumentList &TemplateArgs,
5165 LateInstantiatedAttrVec *LateAttrs, DeclContext *Owner,
5166 LocalInstantiationScope *StartingScope,
5167 bool InstantiatingVarTemplate,
5168 VarTemplateSpecializationDecl *PrevDeclForVarTemplateSpecialization) {
5169 // Instantiating a partial specialization to produce a partial
5170 // specialization.
5171 bool InstantiatingVarTemplatePartialSpec =
5172 isa<VarTemplatePartialSpecializationDecl>(OldVar) &&
5173 isa<VarTemplatePartialSpecializationDecl>(NewVar);
5174 // Instantiating from a variable template (or partial specialization) to
5175 // produce a variable template specialization.
5176 bool InstantiatingSpecFromTemplate =
5177 isa<VarTemplateSpecializationDecl>(NewVar) &&
5178 (OldVar->getDescribedVarTemplate() ||
5179 isa<VarTemplatePartialSpecializationDecl>(OldVar));
5180
5181 // If we are instantiating a local extern declaration, the
5182 // instantiation belongs lexically to the containing function.
5183 // If we are instantiating a static data member defined
5184 // out-of-line, the instantiation will have the same lexical
5185 // context (which will be a namespace scope) as the template.
5186 if (OldVar->isLocalExternDecl()) {
5187 NewVar->setLocalExternDecl();
5188 NewVar->setLexicalDeclContext(Owner);
5189 } else if (OldVar->isOutOfLine())
5190 NewVar->setLexicalDeclContext(OldVar->getLexicalDeclContext());
5191 NewVar->setTSCSpec(OldVar->getTSCSpec());
5192 NewVar->setInitStyle(OldVar->getInitStyle());
5193 NewVar->setCXXForRangeDecl(OldVar->isCXXForRangeDecl());
5194 NewVar->setObjCForDecl(OldVar->isObjCForDecl());
5195 NewVar->setConstexpr(OldVar->isConstexpr());
5196 NewVar->setInitCapture(OldVar->isInitCapture());
5197 NewVar->setPreviousDeclInSameBlockScope(
5198 OldVar->isPreviousDeclInSameBlockScope());
5199 NewVar->setAccess(OldVar->getAccess());
5200
5201 if (!OldVar->isStaticDataMember()) {
5202 if (OldVar->isUsed(false))
5203 NewVar->setIsUsed();
5204 NewVar->setReferenced(OldVar->isReferenced());
5205 }
5206
5207 InstantiateAttrs(TemplateArgs, OldVar, NewVar, LateAttrs, StartingScope);
5208
5209 LookupResult Previous(
5210 *this, NewVar->getDeclName(), NewVar->getLocation(),
5211 NewVar->isLocalExternDecl() ? Sema::LookupRedeclarationWithLinkage
5212 : Sema::LookupOrdinaryName,
5213 NewVar->isLocalExternDecl() ? Sema::ForExternalRedeclaration
5214 : forRedeclarationInCurContext());
5215
5216 if (NewVar->isLocalExternDecl() && OldVar->getPreviousDecl() &&
5217 (!OldVar->getPreviousDecl()->getDeclContext()->isDependentContext() ||
5218 OldVar->getPreviousDecl()->getDeclContext()==OldVar->getDeclContext())) {
5219 // We have a previous declaration. Use that one, so we merge with the
5220 // right type.
5221 if (NamedDecl *NewPrev = FindInstantiatedDecl(
5222 NewVar->getLocation(), OldVar->getPreviousDecl(), TemplateArgs))
5223 Previous.addDecl(NewPrev);
5224 } else if (!isa<VarTemplateSpecializationDecl>(NewVar) &&
5225 OldVar->hasLinkage()) {
5226 LookupQualifiedName(Previous, NewVar->getDeclContext(), false);
5227 } else if (PrevDeclForVarTemplateSpecialization) {
5228 Previous.addDecl(PrevDeclForVarTemplateSpecialization);
5229 }
5230 CheckVariableDeclaration(NewVar, Previous);
5231
5232 if (!InstantiatingVarTemplate) {
5233 NewVar->getLexicalDeclContext()->addHiddenDecl(NewVar);
5234 if (!NewVar->isLocalExternDecl() || !NewVar->getPreviousDecl())
5235 NewVar->getDeclContext()->makeDeclVisibleInContext(NewVar);
5236 }
5237
5238 if (!OldVar->isOutOfLine()) {
5239 if (NewVar->getDeclContext()->isFunctionOrMethod())
5240 CurrentInstantiationScope->InstantiatedLocal(OldVar, NewVar);
5241 }
5242
5243 // Link instantiations of static data members back to the template from
5244 // which they were instantiated.
5245 //
5246 // Don't do this when instantiating a template (we link the template itself
5247 // back in that case) nor when instantiating a static data member template
5248 // (that's not a member specialization).
5249 if (NewVar->isStaticDataMember() && !InstantiatingVarTemplate &&
5250 !InstantiatingSpecFromTemplate)
5251 NewVar->setInstantiationOfStaticDataMember(OldVar,
5252 TSK_ImplicitInstantiation);
5253
5254 // If the pattern is an (in-class) explicit specialization, then the result
5255 // is also an explicit specialization.
5256 if (VarTemplateSpecializationDecl *OldVTSD =
5257 dyn_cast<VarTemplateSpecializationDecl>(OldVar)) {
5258 if (OldVTSD->getSpecializationKind() == TSK_ExplicitSpecialization &&
5259 !isa<VarTemplatePartialSpecializationDecl>(OldVTSD))
5260 cast<VarTemplateSpecializationDecl>(NewVar)->setSpecializationKind(
5261 TSK_ExplicitSpecialization);
5262 }
5263
5264 // Forward the mangling number from the template to the instantiated decl.
5265 Context.setManglingNumber(NewVar, Context.getManglingNumber(OldVar));
5266 Context.setStaticLocalNumber(NewVar, Context.getStaticLocalNumber(OldVar));
5267
5268 // Figure out whether to eagerly instantiate the initializer.
5269 if (InstantiatingVarTemplate || InstantiatingVarTemplatePartialSpec) {
5270 // We're producing a template. Don't instantiate the initializer yet.
5271 } else if (NewVar->getType()->isUndeducedType()) {
5272 // We need the type to complete the declaration of the variable.
5273 InstantiateVariableInitializer(NewVar, OldVar, TemplateArgs);
5274 } else if (InstantiatingSpecFromTemplate ||
5275 (OldVar->isInline() && OldVar->isThisDeclarationADefinition() &&
5276 !NewVar->isThisDeclarationADefinition())) {
5277 // Delay instantiation of the initializer for variable template
5278 // specializations or inline static data members until a definition of the
5279 // variable is needed.
5280 } else {
5281 InstantiateVariableInitializer(NewVar, OldVar, TemplateArgs);
5282 }
5283
5284 // Diagnose unused local variables with dependent types, where the diagnostic
5285 // will have been deferred.
5286 if (!NewVar->isInvalidDecl() &&
5287 NewVar->getDeclContext()->isFunctionOrMethod() &&
5288 OldVar->getType()->isDependentType())
5289 DiagnoseUnusedDecl(NewVar);
5290}
5291
5292/// Instantiate the initializer of a variable.
5293void Sema::InstantiateVariableInitializer(
5294 VarDecl *Var, VarDecl *OldVar,
5295 const MultiLevelTemplateArgumentList &TemplateArgs) {
5296 if (ASTMutationListener *L = getASTContext().getASTMutationListener())
5297 L->VariableDefinitionInstantiated(Var);
5298
5299 // We propagate the 'inline' flag with the initializer, because it
5300 // would otherwise imply that the variable is a definition for a
5301 // non-static data member.
5302 if (OldVar->isInlineSpecified())
5303 Var->setInlineSpecified();
5304 else if (OldVar->isInline())
5305 Var->setImplicitlyInline();
5306
5307 if (OldVar->getInit()) {
5308 EnterExpressionEvaluationContext Evaluated(
5309 *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated, Var);
5310
5311 // Instantiate the initializer.
5312 ExprResult Init;
5313
5314 {
5315 ContextRAII SwitchContext(*this, Var->getDeclContext());
5316 Init = SubstInitializer(OldVar->getInit(), TemplateArgs,
5317 OldVar->getInitStyle() == VarDecl::CallInit);
5318 }
5319
5320 if (!Init.isInvalid()) {
5321 Expr *InitExpr = Init.get();
5322
5323 if (Var->hasAttr<DLLImportAttr>() &&
5324 (!InitExpr ||
5325 !InitExpr->isConstantInitializer(getASTContext(), false))) {
5326 // Do not dynamically initialize dllimport variables.
5327 } else if (InitExpr) {
5328 bool DirectInit = OldVar->isDirectInit();
5329 AddInitializerToDecl(Var, InitExpr, DirectInit);
5330 } else
5331 ActOnUninitializedDecl(Var);
5332 } else {
5333 // FIXME: Not too happy about invalidating the declaration
5334 // because of a bogus initializer.
5335 Var->setInvalidDecl();
5336 }
5337 } else {
5338 // `inline` variables are a definition and declaration all in one; we won't
5339 // pick up an initializer from anywhere else.
5340 if (Var->isStaticDataMember() && !Var->isInline()) {
5341 if (!Var->isOutOfLine())
5342 return;
5343
5344 // If the declaration inside the class had an initializer, don't add
5345 // another one to the out-of-line definition.
5346 if (OldVar->getFirstDecl()->hasInit())
5347 return;
5348 }
5349
5350 // We'll add an initializer to a for-range declaration later.
5351 if (Var->isCXXForRangeDecl() || Var->isObjCForDecl())
5352 return;
5353
5354 ActOnUninitializedDecl(Var);
5355 }
5356
5357 if (getLangOpts().CUDA)
5358 checkAllowedCUDAInitializer(Var);
5359}
5360
5361/// Instantiate the definition of the given variable from its
5362/// template.
5363///
5364/// \param PointOfInstantiation the point at which the instantiation was
5365/// required. Note that this is not precisely a "point of instantiation"
5366/// for the variable, but it's close.
5367///
5368/// \param Var the already-instantiated declaration of a templated variable.
5369///
5370/// \param Recursive if true, recursively instantiates any functions that
5371/// are required by this instantiation.
5372///
5373/// \param DefinitionRequired if true, then we are performing an explicit
5374/// instantiation where a definition of the variable is required. Complain
5375/// if there is no such definition.
5376void Sema::InstantiateVariableDefinition(SourceLocation PointOfInstantiation,
5377 VarDecl *Var, bool Recursive,
5378 bool DefinitionRequired, bool AtEndOfTU) {
5379 if (Var->isInvalidDecl())
52
Assuming the condition is false
53
Taking false branch
5380 return;
5381
5382 // Never instantiate an explicitly-specialized entity.
5383 TemplateSpecializationKind TSK =
5384 Var->getTemplateSpecializationKindForInstantiation();
5385 if (TSK == TSK_ExplicitSpecialization)
54
Assuming 'TSK' is not equal to TSK_ExplicitSpecialization
55
Taking false branch
5386 return;
5387
5388 // Find the pattern and the arguments to substitute into it.
5389 VarDecl *PatternDecl = Var->getTemplateInstantiationPattern();
5390 assert(PatternDecl && "no pattern for templated variable")((void)0);
5391 MultiLevelTemplateArgumentList TemplateArgs =
5392 getTemplateInstantiationArgs(Var);
5393
5394 VarTemplateSpecializationDecl *VarSpec =
5395 dyn_cast<VarTemplateSpecializationDecl>(Var);
56
Assuming 'Var' is not a 'VarTemplateSpecializationDecl'
5396 if (VarSpec
56.1
'VarSpec' is null
56.1
'VarSpec' is null
) {
57
Taking false branch
5397 // If this is a static data member template, there might be an
5398 // uninstantiated initializer on the declaration. If so, instantiate
5399 // it now.
5400 //
5401 // FIXME: This largely duplicates what we would do below. The difference
5402 // is that along this path we may instantiate an initializer from an
5403 // in-class declaration of the template and instantiate the definition
5404 // from a separate out-of-class definition.
5405 if (PatternDecl->isStaticDataMember() &&
5406 (PatternDecl = PatternDecl->getFirstDecl())->hasInit() &&
5407 !Var->hasInit()) {
5408 // FIXME: Factor out the duplicated instantiation context setup/tear down
5409 // code here.
5410 InstantiatingTemplate Inst(*this, PointOfInstantiation, Var);
5411 if (Inst.isInvalid() || Inst.isAlreadyInstantiating())
5412 return;
5413 PrettyDeclStackTraceEntry CrashInfo(Context, Var, SourceLocation(),
5414 "instantiating variable initializer");
5415
5416 // The instantiation is visible here, even if it was first declared in an
5417 // unimported module.
5418 Var->setVisibleDespiteOwningModule();
5419
5420 // If we're performing recursive template instantiation, create our own
5421 // queue of pending implicit instantiations that we will instantiate
5422 // later, while we're still within our own instantiation context.
5423 GlobalEagerInstantiationScope GlobalInstantiations(*this,
5424 /*Enabled=*/Recursive);
5425 LocalInstantiationScope Local(*this);
5426 LocalEagerInstantiationScope LocalInstantiations(*this);
5427
5428 // Enter the scope of this instantiation. We don't use
5429 // PushDeclContext because we don't have a scope.
5430 ContextRAII PreviousContext(*this, Var->getDeclContext());
5431 InstantiateVariableInitializer(Var, PatternDecl, TemplateArgs);
5432 PreviousContext.pop();
5433
5434 // This variable may have local implicit instantiations that need to be
5435 // instantiated within this scope.
5436 LocalInstantiations.perform();
5437 Local.Exit();
5438 GlobalInstantiations.perform();
5439 }
5440 } else {
5441 assert(Var->isStaticDataMember() && PatternDecl->isStaticDataMember() &&((void)0)
5442 "not a static data member?")((void)0);
5443 }
5444
5445 VarDecl *Def = PatternDecl->getDefinition(getASTContext());
58
'Def' initialized here
5446
5447 // If we don't have a definition of the variable template, we won't perform
5448 // any instantiation. Rather, we rely on the user to instantiate this
5449 // definition (or provide a specialization for it) in another translation
5450 // unit.
5451 if (!Def && !DefinitionRequired
60.1
'DefinitionRequired' is false
60.1
'DefinitionRequired' is false
) {
59
Assuming 'Def' is null
60
Assuming pointer value is null
61
Taking true branch
5452 if (TSK == TSK_ExplicitInstantiationDefinition) {
62
Assuming 'TSK' is not equal to TSK_ExplicitInstantiationDefinition
63
Taking false branch
5453 PendingInstantiations.push_back(
5454 std::make_pair(Var, PointOfInstantiation));
5455 } else if (TSK == TSK_ImplicitInstantiation) {
64
Assuming 'TSK' is not equal to TSK_ImplicitInstantiation
65
Taking false branch
5456 // Warn about missing definition at the end of translation unit.
5457 if (AtEndOfTU && !getDiagnostics().hasErrorOccurred() &&
5458 !getSourceManager().isInSystemHeader(PatternDecl->getBeginLoc())) {
5459 Diag(PointOfInstantiation, diag::warn_var_template_missing)
5460 << Var;
5461 Diag(PatternDecl->getLocation(), diag::note_forward_template_decl);
5462 if (getLangOpts().CPlusPlus11)
5463 Diag(PointOfInstantiation, diag::note_inst_declaration_hint) << Var;
5464 }
5465 return;
5466 }
5467 }
5468
5469 // FIXME: We need to track the instantiation stack in order to know which
5470 // definitions should be visible within this instantiation.
5471 // FIXME: Produce diagnostics when Var->getInstantiatedFromStaticDataMember().
5472 if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Var,
66
Assuming the condition is false
67
Taking false branch
5473 /*InstantiatedFromMember*/false,
5474 PatternDecl, Def, TSK,
5475 /*Complain*/DefinitionRequired))
5476 return;
5477
5478 // C++11 [temp.explicit]p10:
5479 // Except for inline functions, const variables of literal types, variables
5480 // of reference types, [...] explicit instantiation declarations
5481 // have the effect of suppressing the implicit instantiation of the entity
5482 // to which they refer.
5483 //
5484 // FIXME: That's not exactly the same as "might be usable in constant
5485 // expressions", which only allows constexpr variables and const integral
5486 // types, not arbitrary const literal types.
5487 if (TSK == TSK_ExplicitInstantiationDeclaration &&
68
Assuming 'TSK' is not equal to TSK_ExplicitInstantiationDeclaration
5488 !Var->mightBeUsableInConstantExpressions(getASTContext()))
5489 return;
5490
5491 // Make sure to pass the instantiated variable to the consumer at the end.
5492 struct PassToConsumerRAII {
5493 ASTConsumer &Consumer;
5494 VarDecl *Var;
5495
5496 PassToConsumerRAII(ASTConsumer &Consumer, VarDecl *Var)
5497 : Consumer(Consumer), Var(Var) { }
5498
5499 ~PassToConsumerRAII() {
5500 Consumer.HandleCXXStaticMemberVarInstantiation(Var);
5501 }
5502 } PassToConsumerRAII(Consumer, Var);
5503
5504 // If we already have a definition, we're done.
5505 if (VarDecl *Def = Var->getDefinition()) {
69
Assuming 'Def' is null
70
Taking false branch
5506 // We may be explicitly instantiating something we've already implicitly
5507 // instantiated.
5508 Def->setTemplateSpecializationKind(Var->getTemplateSpecializationKind(),
5509 PointOfInstantiation);
5510 return;
5511 }
5512
5513 InstantiatingTemplate Inst(*this, PointOfInstantiation, Var);
5514 if (Inst.isInvalid() || Inst.isAlreadyInstantiating())
71
Assuming the condition is false
72
Assuming the condition is false
73
Taking false branch
5515 return;
5516 PrettyDeclStackTraceEntry CrashInfo(Context, Var, SourceLocation(),
5517 "instantiating variable definition");
5518
5519 // If we're performing recursive template instantiation, create our own
5520 // queue of pending implicit instantiations that we will instantiate later,
5521 // while we're still within our own instantiation context.
5522 GlobalEagerInstantiationScope GlobalInstantiations(*this,
5523 /*Enabled=*/Recursive);
5524
5525 // Enter the scope of this instantiation. We don't use
5526 // PushDeclContext because we don't have a scope.
5527 ContextRAII PreviousContext(*this, Var->getDeclContext());
5528 LocalInstantiationScope Local(*this);
5529
5530 LocalEagerInstantiationScope LocalInstantiations(*this);
5531
5532 VarDecl *OldVar = Var;
5533 if (Def->isStaticDataMember() && !Def->isOutOfLine()) {
74
Called C++ object pointer is null
5534 // We're instantiating an inline static data member whose definition was
5535 // provided inside the class.
5536 InstantiateVariableInitializer(Var, Def, TemplateArgs);
5537 } else if (!VarSpec) {
5538 Var = cast_or_null<VarDecl>(SubstDecl(Def, Var->getDeclContext(),
5539 TemplateArgs));
5540 } else if (Var->isStaticDataMember() &&
5541 Var->getLexicalDeclContext()->isRecord()) {
5542 // We need to instantiate the definition of a static data member template,
5543 // and all we have is the in-class declaration of it. Instantiate a separate
5544 // declaration of the definition.
5545 TemplateDeclInstantiator Instantiator(*this, Var->getDeclContext(),
5546 TemplateArgs);
5547 Var = cast_or_null<VarDecl>(Instantiator.VisitVarTemplateSpecializationDecl(
5548 VarSpec->getSpecializedTemplate(), Def, VarSpec->getTemplateArgsInfo(),
5549 VarSpec->getTemplateArgs().asArray(), VarSpec));
5550 if (Var) {
5551 llvm::PointerUnion<VarTemplateDecl *,
5552 VarTemplatePartialSpecializationDecl *> PatternPtr =
5553 VarSpec->getSpecializedTemplateOrPartial();
5554 if (VarTemplatePartialSpecializationDecl *Partial =
5555 PatternPtr.dyn_cast<VarTemplatePartialSpecializationDecl *>())
5556 cast<VarTemplateSpecializationDecl>(Var)->setInstantiationOf(
5557 Partial, &VarSpec->getTemplateInstantiationArgs());
5558
5559 // Attach the initializer.
5560 InstantiateVariableInitializer(Var, Def, TemplateArgs);
5561 }
5562 } else
5563 // Complete the existing variable's definition with an appropriately
5564 // substituted type and initializer.
5565 Var = CompleteVarTemplateSpecializationDecl(VarSpec, Def, TemplateArgs);
5566
5567 PreviousContext.pop();
5568
5569 if (Var) {
5570 PassToConsumerRAII.Var = Var;
5571 Var->setTemplateSpecializationKind(OldVar->getTemplateSpecializationKind(),
5572 OldVar->getPointOfInstantiation());
5573 }
5574
5575 // This variable may have local implicit instantiations that need to be
5576 // instantiated within this scope.
5577 LocalInstantiations.perform();
5578 Local.Exit();
5579 GlobalInstantiations.perform();
5580}
5581
5582void
5583Sema::InstantiateMemInitializers(CXXConstructorDecl *New,
5584 const CXXConstructorDecl *Tmpl,
5585 const MultiLevelTemplateArgumentList &TemplateArgs) {
5586
5587 SmallVector<CXXCtorInitializer*, 4> NewInits;
5588 bool AnyErrors = Tmpl->isInvalidDecl();
5589
5590 // Instantiate all the initializers.
5591 for (const auto *Init : Tmpl->inits()) {
5592 // Only instantiate written initializers, let Sema re-construct implicit
5593 // ones.
5594 if (!Init->isWritten())
5595 continue;
5596
5597 SourceLocation EllipsisLoc;
5598
5599 if (Init->isPackExpansion()) {
5600 // This is a pack expansion. We should expand it now.
5601 TypeLoc BaseTL = Init->getTypeSourceInfo()->getTypeLoc();
5602 SmallVector<UnexpandedParameterPack, 4> Unexpanded;
5603 collectUnexpandedParameterPacks(BaseTL, Unexpanded);
5604 collectUnexpandedParameterPacks(Init->getInit(), Unexpanded);
5605 bool ShouldExpand = false;
5606 bool RetainExpansion = false;
5607 Optional<unsigned> NumExpansions;
5608 if (CheckParameterPacksForExpansion(Init->getEllipsisLoc(),
5609 BaseTL.getSourceRange(),
5610 Unexpanded,
5611 TemplateArgs, ShouldExpand,
5612 RetainExpansion,
5613 NumExpansions)) {
5614 AnyErrors = true;
5615 New->setInvalidDecl();
5616 continue;
5617 }
5618 assert(ShouldExpand && "Partial instantiation of base initializer?")((void)0);
5619
5620 // Loop over all of the arguments in the argument pack(s),
5621 for (unsigned I = 0; I != *NumExpansions; ++I) {
5622 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, I);
5623
5624 // Instantiate the initializer.
5625 ExprResult TempInit = SubstInitializer(Init->getInit(), TemplateArgs,
5626 /*CXXDirectInit=*/true);
5627 if (TempInit.isInvalid()) {
5628 AnyErrors = true;
5629 break;
5630 }
5631
5632 // Instantiate the base type.
5633 TypeSourceInfo *BaseTInfo = SubstType(Init->getTypeSourceInfo(),
5634 TemplateArgs,
5635 Init->getSourceLocation(),
5636 New->getDeclName());
5637 if (!BaseTInfo) {
5638 AnyErrors = true;
5639 break;
5640 }
5641
5642 // Build the initializer.
5643 MemInitResult NewInit = BuildBaseInitializer(BaseTInfo->getType(),
5644 BaseTInfo, TempInit.get(),
5645 New->getParent(),
5646 SourceLocation());
5647 if (NewInit.isInvalid()) {
5648 AnyErrors = true;
5649 break;
5650 }
5651
5652 NewInits.push_back(NewInit.get());
5653 }
5654
5655 continue;
5656 }
5657
5658 // Instantiate the initializer.
5659 ExprResult TempInit = SubstInitializer(Init->getInit(), TemplateArgs,
5660 /*CXXDirectInit=*/true);
5661 if (TempInit.isInvalid()) {
5662 AnyErrors = true;
5663 continue;
5664 }
5665
5666 MemInitResult NewInit;
5667 if (Init->isDelegatingInitializer() || Init->isBaseInitializer()) {
5668 TypeSourceInfo *TInfo = SubstType(Init->getTypeSourceInfo(),
5669 TemplateArgs,
5670 Init->getSourceLocation(),
5671 New->getDeclName());
5672 if (!TInfo) {
5673 AnyErrors = true;
5674 New->setInvalidDecl();
5675 continue;
5676 }
5677
5678 if (Init->isBaseInitializer())
5679 NewInit = BuildBaseInitializer(TInfo->getType(), TInfo, TempInit.get(),
5680 New->getParent(), EllipsisLoc);
5681 else
5682 NewInit = BuildDelegatingInitializer(TInfo, TempInit.get(),
5683 cast<CXXRecordDecl>(CurContext->getParent()));
5684 } else if (Init->isMemberInitializer()) {
5685 FieldDecl *Member = cast_or_null<FieldDecl>(FindInstantiatedDecl(
5686 Init->getMemberLocation(),
5687 Init->getMember(),
5688 TemplateArgs));
5689 if (!Member) {
5690 AnyErrors = true;
5691 New->setInvalidDecl();
5692 continue;
5693 }
5694
5695 NewInit = BuildMemberInitializer(Member, TempInit.get(),
5696 Init->getSourceLocation());
5697 } else if (Init->isIndirectMemberInitializer()) {
5698 IndirectFieldDecl *IndirectMember =
5699 cast_or_null<IndirectFieldDecl>(FindInstantiatedDecl(
5700 Init->getMemberLocation(),
5701 Init->getIndirectMember(), TemplateArgs));
5702
5703 if (!IndirectMember) {
5704 AnyErrors = true;
5705 New->setInvalidDecl();
5706 continue;
5707 }
5708
5709 NewInit = BuildMemberInitializer(IndirectMember, TempInit.get(),
5710 Init->getSourceLocation());
5711 }
5712
5713 if (NewInit.isInvalid()) {
5714 AnyErrors = true;
5715 New->setInvalidDecl();
5716 } else {
5717 NewInits.push_back(NewInit.get());
5718 }
5719 }
5720
5721 // Assign all the initializers to the new constructor.
5722 ActOnMemInitializers(New,
5723 /*FIXME: ColonLoc */
5724 SourceLocation(),
5725 NewInits,
5726 AnyErrors);
5727}
5728
5729// TODO: this could be templated if the various decl types used the
5730// same method name.
5731static bool isInstantiationOf(ClassTemplateDecl *Pattern,
5732 ClassTemplateDecl *Instance) {
5733 Pattern = Pattern->getCanonicalDecl();
5734
5735 do {
5736 Instance = Instance->getCanonicalDecl();
5737 if (Pattern == Instance) return true;
5738 Instance = Instance->getInstantiatedFromMemberTemplate();
5739 } while (Instance);
5740
5741 return false;
5742}
5743
5744static bool isInstantiationOf(FunctionTemplateDecl *Pattern,
5745 FunctionTemplateDecl *Instance) {
5746 Pattern = Pattern->getCanonicalDecl();
5747
5748 do {
5749 Instance = Instance->getCanonicalDecl();
5750 if (Pattern == Instance) return true;
5751 Instance = Instance->getInstantiatedFromMemberTemplate();
5752 } while (Instance);
5753
5754 return false;
5755}
5756
5757static bool
5758isInstantiationOf(ClassTemplatePartialSpecializationDecl *Pattern,
5759 ClassTemplatePartialSpecializationDecl *Instance) {
5760 Pattern
5761 = cast<ClassTemplatePartialSpecializationDecl>(Pattern->getCanonicalDecl());
5762 do {
5763 Instance = cast<ClassTemplatePartialSpecializationDecl>(
5764 Instance->getCanonicalDecl());
5765 if (Pattern == Instance)
5766 return true;
5767 Instance = Instance->getInstantiatedFromMember();
5768 } while (Instance);
5769
5770 return false;
5771}
5772
5773static bool isInstantiationOf(CXXRecordDecl *Pattern,
5774 CXXRecordDecl *Instance) {
5775 Pattern = Pattern->getCanonicalDecl();
5776
5777 do {
5778 Instance = Instance->getCanonicalDecl();
5779 if (Pattern == Instance) return true;
5780 Instance = Instance->getInstantiatedFromMemberClass();
5781 } while (Instance);
5782
5783 return false;
5784}
5785
5786static bool isInstantiationOf(FunctionDecl *Pattern,
5787 FunctionDecl *Instance) {
5788 Pattern = Pattern->getCanonicalDecl();
5789
5790 do {
5791 Instance = Instance->getCanonicalDecl();
5792 if (Pattern == Instance) return true;
5793 Instance = Instance->getInstantiatedFromMemberFunction();
5794 } while (Instance);
5795
5796 return false;
5797}
5798
5799static bool isInstantiationOf(EnumDecl *Pattern,
5800 EnumDecl *Instance) {
5801 Pattern = Pattern->getCanonicalDecl();
5802
5803 do {
5804 Instance = Instance->getCanonicalDecl();
5805 if (Pattern == Instance) return true;
5806 Instance = Instance->getInstantiatedFromMemberEnum();
5807 } while (Instance);
5808
5809 return false;
5810}
5811
5812static bool isInstantiationOf(UsingShadowDecl *Pattern,
5813 UsingShadowDecl *Instance,
5814 ASTContext &C) {
5815 return declaresSameEntity(C.getInstantiatedFromUsingShadowDecl(Instance),
5816 Pattern);
5817}
5818
5819static bool isInstantiationOf(UsingDecl *Pattern, UsingDecl *Instance,
5820 ASTContext &C) {
5821 return declaresSameEntity(C.getInstantiatedFromUsingDecl(Instance), Pattern);
5822}
5823
5824template<typename T>
5825static bool isInstantiationOfUnresolvedUsingDecl(T *Pattern, Decl *Other,
5826 ASTContext &Ctx) {
5827 // An unresolved using declaration can instantiate to an unresolved using
5828 // declaration, or to a using declaration or a using declaration pack.
5829 //
5830 // Multiple declarations can claim to be instantiated from an unresolved
5831 // using declaration if it's a pack expansion. We want the UsingPackDecl
5832 // in that case, not the individual UsingDecls within the pack.
5833 bool OtherIsPackExpansion;
5834 NamedDecl *OtherFrom;
5835 if (auto *OtherUUD = dyn_cast<T>(Other)) {
5836 OtherIsPackExpansion = OtherUUD->isPackExpansion();
5837 OtherFrom = Ctx.getInstantiatedFromUsingDecl(OtherUUD);
5838 } else if (auto *OtherUPD = dyn_cast<UsingPackDecl>(Other)) {
5839 OtherIsPackExpansion = true;
5840 OtherFrom = OtherUPD->getInstantiatedFromUsingDecl();
5841 } else if (auto *OtherUD = dyn_cast<UsingDecl>(Other)) {
5842 OtherIsPackExpansion = false;
5843 OtherFrom = Ctx.getInstantiatedFromUsingDecl(OtherUD);
5844 } else {
5845 return false;
5846 }
5847 return Pattern->isPackExpansion() == OtherIsPackExpansion &&
5848 declaresSameEntity(OtherFrom, Pattern);
5849}
5850
5851static bool isInstantiationOfStaticDataMember(VarDecl *Pattern,
5852 VarDecl *Instance) {
5853 assert(Instance->isStaticDataMember())((void)0);
5854
5855 Pattern = Pattern->getCanonicalDecl();
5856
5857 do {
5858 Instance = Instance->getCanonicalDecl();
5859 if (Pattern == Instance) return true;
5860 Instance = Instance->getInstantiatedFromStaticDataMember();
5861 } while (Instance);
5862
5863 return false;
5864}
5865
5866// Other is the prospective instantiation
5867// D is the prospective pattern
5868static bool isInstantiationOf(ASTContext &Ctx, NamedDecl *D, Decl *Other) {
5869 if (auto *UUD = dyn_cast<UnresolvedUsingTypenameDecl>(D))
5870 return isInstantiationOfUnresolvedUsingDecl(UUD, Other, Ctx);
5871
5872 if (auto *UUD = dyn_cast<UnresolvedUsingValueDecl>(D))
5873 return isInstantiationOfUnresolvedUsingDecl(UUD, Other, Ctx);
5874
5875 if (D->getKind() != Other->getKind())
5876 return false;
5877
5878 if (auto *Record = dyn_cast<CXXRecordDecl>(Other))
5879 return isInstantiationOf(cast<CXXRecordDecl>(D), Record);
5880
5881 if (auto *Function = dyn_cast<FunctionDecl>(Other))
5882 return isInstantiationOf(cast<FunctionDecl>(D), Function);
5883
5884 if (auto *Enum = dyn_cast<EnumDecl>(Other))
5885 return isInstantiationOf(cast<EnumDecl>(D), Enum);
5886
5887 if (auto *Var = dyn_cast<VarDecl>(Other))
5888 if (Var->isStaticDataMember())
5889 return isInstantiationOfStaticDataMember(cast<VarDecl>(D), Var);
5890
5891 if (auto *Temp = dyn_cast<ClassTemplateDecl>(Other))
5892 return isInstantiationOf(cast<ClassTemplateDecl>(D), Temp);
5893
5894 if (auto *Temp = dyn_cast<FunctionTemplateDecl>(Other))
5895 return isInstantiationOf(cast<FunctionTemplateDecl>(D), Temp);
5896
5897 if (auto *PartialSpec =
5898 dyn_cast<ClassTemplatePartialSpecializationDecl>(Other))
5899 return isInstantiationOf(cast<ClassTemplatePartialSpecializationDecl>(D),
5900 PartialSpec);
5901
5902 if (auto *Field = dyn_cast<FieldDecl>(Other)) {
5903 if (!Field->getDeclName()) {
5904 // This is an unnamed field.
5905 return declaresSameEntity(Ctx.getInstantiatedFromUnnamedFieldDecl(Field),
5906 cast<FieldDecl>(D));
5907 }
5908 }
5909
5910 if (auto *Using = dyn_cast<UsingDecl>(Other))
5911 return isInstantiationOf(cast<UsingDecl>(D), Using, Ctx);
5912
5913 if (auto *Shadow = dyn_cast<UsingShadowDecl>(Other))
5914 return isInstantiationOf(cast<UsingShadowDecl>(D), Shadow, Ctx);
5915
5916 return D->getDeclName() &&
5917 D->getDeclName() == cast<NamedDecl>(Other)->getDeclName();
5918}
5919
5920template<typename ForwardIterator>
5921static NamedDecl *findInstantiationOf(ASTContext &Ctx,
5922 NamedDecl *D,
5923 ForwardIterator first,
5924 ForwardIterator last) {
5925 for (; first != last; ++first)
5926 if (isInstantiationOf(Ctx, D, *first))
5927 return cast<NamedDecl>(*first);
5928
5929 return nullptr;
5930}
5931
5932/// Finds the instantiation of the given declaration context
5933/// within the current instantiation.
5934///
5935/// \returns NULL if there was an error
5936DeclContext *Sema::FindInstantiatedContext(SourceLocation Loc, DeclContext* DC,
5937 const MultiLevelTemplateArgumentList &TemplateArgs) {
5938 if (NamedDecl *D = dyn_cast<NamedDecl>(DC)) {
5939 Decl* ID = FindInstantiatedDecl(Loc, D, TemplateArgs, true);
5940 return cast_or_null<DeclContext>(ID);
5941 } else return DC;
5942}
5943
5944/// Determine whether the given context is dependent on template parameters at
5945/// level \p Level or below.
5946///
5947/// Sometimes we only substitute an inner set of template arguments and leave
5948/// the outer templates alone. In such cases, contexts dependent only on the
5949/// outer levels are not effectively dependent.
5950static bool isDependentContextAtLevel(DeclContext *DC, unsigned Level) {
5951 if (!DC->isDependentContext())
5952 return false;
5953 if (!Level)
5954 return true;
5955 return cast<Decl>(DC)->getTemplateDepth() > Level;
5956}
5957
5958/// Find the instantiation of the given declaration within the
5959/// current instantiation.
5960///
5961/// This routine is intended to be used when \p D is a declaration
5962/// referenced from within a template, that needs to mapped into the
5963/// corresponding declaration within an instantiation. For example,
5964/// given:
5965///
5966/// \code
5967/// template<typename T>
5968/// struct X {
5969/// enum Kind {
5970/// KnownValue = sizeof(T)
5971/// };
5972///
5973/// bool getKind() const { return KnownValue; }
5974/// };
5975///
5976/// template struct X<int>;
5977/// \endcode
5978///
5979/// In the instantiation of X<int>::getKind(), we need to map the \p
5980/// EnumConstantDecl for \p KnownValue (which refers to
5981/// X<T>::<Kind>::KnownValue) to its instantiation (X<int>::<Kind>::KnownValue).
5982/// \p FindInstantiatedDecl performs this mapping from within the instantiation
5983/// of X<int>.
5984NamedDecl *Sema::FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D,
5985 const MultiLevelTemplateArgumentList &TemplateArgs,
5986 bool FindingInstantiatedContext) {
5987 DeclContext *ParentDC = D->getDeclContext();
5988 // Determine whether our parent context depends on any of the tempalte
5989 // arguments we're currently substituting.
5990 bool ParentDependsOnArgs = isDependentContextAtLevel(
5991 ParentDC, TemplateArgs.getNumRetainedOuterLevels());
5992 // FIXME: Parmeters of pointer to functions (y below) that are themselves
5993 // parameters (p below) can have their ParentDC set to the translation-unit
5994 // - thus we can not consistently check if the ParentDC of such a parameter
5995 // is Dependent or/and a FunctionOrMethod.
5996 // For e.g. this code, during Template argument deduction tries to
5997 // find an instantiated decl for (T y) when the ParentDC for y is
5998 // the translation unit.
5999 // e.g. template <class T> void Foo(auto (*p)(T y) -> decltype(y())) {}
6000 // float baz(float(*)()) { return 0.0; }
6001 // Foo(baz);
6002 // The better fix here is perhaps to ensure that a ParmVarDecl, by the time
6003 // it gets here, always has a FunctionOrMethod as its ParentDC??
6004 // For now:
6005 // - as long as we have a ParmVarDecl whose parent is non-dependent and
6006 // whose type is not instantiation dependent, do nothing to the decl
6007 // - otherwise find its instantiated decl.
6008 if (isa<ParmVarDecl>(D) && !ParentDependsOnArgs &&
6009 !cast<ParmVarDecl>(D)->getType()->isInstantiationDependentType())
6010 return D;
6011 if (isa<ParmVarDecl>(D) || isa<NonTypeTemplateParmDecl>(D) ||
6012 isa<TemplateTypeParmDecl>(D) || isa<TemplateTemplateParmDecl>(D) ||
6013 (ParentDependsOnArgs && (ParentDC->isFunctionOrMethod() ||
6014 isa<OMPDeclareReductionDecl>(ParentDC) ||
6015 isa<OMPDeclareMapperDecl>(ParentDC))) ||
6016 (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda())) {
6017 // D is a local of some kind. Look into the map of local
6018 // declarations to their instantiations.
6019 if (CurrentInstantiationScope) {
6020 if (auto Found = CurrentInstantiationScope->findInstantiationOf(D)) {
6021 if (Decl *FD = Found->dyn_cast<Decl *>())
6022 return cast<NamedDecl>(FD);
6023
6024 int PackIdx = ArgumentPackSubstitutionIndex;
6025 assert(PackIdx != -1 &&((void)0)
6026 "found declaration pack but not pack expanding")((void)0);
6027 typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
6028 return cast<NamedDecl>((*Found->get<DeclArgumentPack *>())[PackIdx]);
6029 }
6030 }
6031
6032 // If we're performing a partial substitution during template argument
6033 // deduction, we may not have values for template parameters yet. They
6034 // just map to themselves.
6035 if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
6036 isa<TemplateTemplateParmDecl>(D))
6037 return D;
6038
6039 if (D->isInvalidDecl())
6040 return nullptr;
6041
6042 // Normally this function only searches for already instantiated declaration
6043 // however we have to make an exclusion for local types used before
6044 // definition as in the code:
6045 //
6046 // template<typename T> void f1() {
6047 // void g1(struct x1);
6048 // struct x1 {};
6049 // }
6050 //
6051 // In this