Bug Summary

File:clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
Warning:line 436, column 9
Value stored to 'E' during its initialization is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

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