Bug Summary

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