Bug Summary

File:tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
Warning:line 4478, column 7
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -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-config-compatibility-mode=true -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 -mrelocation-model pic -pic-level 2 -mthread-model posix -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-8/lib/clang/8.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-8~svn349319/build-llvm/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-8~svn349319/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-8~svn349319/tools/clang/include -I /build/llvm-toolchain-snapshot-8~svn349319/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-8~svn349319/build-llvm/include -I /build/llvm-toolchain-snapshot-8~svn349319/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/8.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-8/lib/clang/8.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-8~svn349319/build-llvm/tools/clang/lib/Sema -fdebug-prefix-map=/build/llvm-toolchain-snapshot-8~svn349319=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-12-17-043027-19008-1 -x c++ /build/llvm-toolchain-snapshot-8~svn349319/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp -faddrsig

/build/llvm-toolchain-snapshot-8~svn349319/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

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

/build/llvm-toolchain-snapshot-8~svn349319/tools/clang/include/clang/Sema/Sema.h

1//===--- Sema.h - Semantic Analysis & AST Building --------------*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file defines the Sema class, which performs semantic analysis and
11// builds ASTs.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_CLANG_SEMA_SEMA_H
16#define LLVM_CLANG_SEMA_SEMA_H
17
18#include "clang/AST/Attr.h"
19#include "clang/AST/Availability.h"
20#include "clang/AST/ComparisonCategories.h"
21#include "clang/AST/DeclTemplate.h"
22#include "clang/AST/DeclarationName.h"
23#include "clang/AST/Expr.h"
24#include "clang/AST/ExprCXX.h"
25#include "clang/AST/ExprObjC.h"
26#include "clang/AST/ExternalASTSource.h"
27#include "clang/AST/LocInfoType.h"
28#include "clang/AST/MangleNumberingContext.h"
29#include "clang/AST/NSAPI.h"
30#include "clang/AST/PrettyPrinter.h"
31#include "clang/AST/StmtCXX.h"
32#include "clang/AST/TypeLoc.h"
33#include "clang/AST/TypeOrdering.h"
34#include "clang/Basic/ExpressionTraits.h"
35#include "clang/Basic/Module.h"
36#include "clang/Basic/OpenMPKinds.h"
37#include "clang/Basic/PragmaKinds.h"
38#include "clang/Basic/Specifiers.h"
39#include "clang/Basic/TemplateKinds.h"
40#include "clang/Basic/TypeTraits.h"
41#include "clang/Sema/AnalysisBasedWarnings.h"
42#include "clang/Sema/CleanupInfo.h"
43#include "clang/Sema/DeclSpec.h"
44#include "clang/Sema/ExternalSemaSource.h"
45#include "clang/Sema/IdentifierResolver.h"
46#include "clang/Sema/ObjCMethodList.h"
47#include "clang/Sema/Ownership.h"
48#include "clang/Sema/Scope.h"
49#include "clang/Sema/TypoCorrection.h"
50#include "clang/Sema/Weak.h"
51#include "llvm/ADT/ArrayRef.h"
52#include "llvm/ADT/Optional.h"
53#include "llvm/ADT/SetVector.h"
54#include "llvm/ADT/SmallBitVector.h"
55#include "llvm/ADT/SmallPtrSet.h"
56#include "llvm/ADT/SmallVector.h"
57#include "llvm/ADT/TinyPtrVector.h"
58#include <deque>
59#include <memory>
60#include <string>
61#include <vector>
62
63namespace llvm {
64 class APSInt;
65 template <typename ValueT> struct DenseMapInfo;
66 template <typename ValueT, typename ValueInfoT> class DenseSet;
67 class SmallBitVector;
68 struct InlineAsmIdentifierInfo;
69}
70
71namespace clang {
72 class ADLResult;
73 class ASTConsumer;
74 class ASTContext;
75 class ASTMutationListener;
76 class ASTReader;
77 class ASTWriter;
78 class ArrayType;
79 class ParsedAttr;
80 class BindingDecl;
81 class BlockDecl;
82 class CapturedDecl;
83 class CXXBasePath;
84 class CXXBasePaths;
85 class CXXBindTemporaryExpr;
86 typedef SmallVector<CXXBaseSpecifier*, 4> CXXCastPath;
87 class CXXConstructorDecl;
88 class CXXConversionDecl;
89 class CXXDeleteExpr;
90 class CXXDestructorDecl;
91 class CXXFieldCollector;
92 class CXXMemberCallExpr;
93 class CXXMethodDecl;
94 class CXXScopeSpec;
95 class CXXTemporary;
96 class CXXTryStmt;
97 class CallExpr;
98 class ClassTemplateDecl;
99 class ClassTemplatePartialSpecializationDecl;
100 class ClassTemplateSpecializationDecl;
101 class VarTemplatePartialSpecializationDecl;
102 class CodeCompleteConsumer;
103 class CodeCompletionAllocator;
104 class CodeCompletionTUInfo;
105 class CodeCompletionResult;
106 class CoroutineBodyStmt;
107 class Decl;
108 class DeclAccessPair;
109 class DeclContext;
110 class DeclRefExpr;
111 class DeclaratorDecl;
112 class DeducedTemplateArgument;
113 class DependentDiagnostic;
114 class DesignatedInitExpr;
115 class Designation;
116 class EnableIfAttr;
117 class EnumConstantDecl;
118 class Expr;
119 class ExtVectorType;
120 class FormatAttr;
121 class FriendDecl;
122 class FunctionDecl;
123 class FunctionProtoType;
124 class FunctionTemplateDecl;
125 class ImplicitConversionSequence;
126 typedef MutableArrayRef<ImplicitConversionSequence> ConversionSequenceList;
127 class InitListExpr;
128 class InitializationKind;
129 class InitializationSequence;
130 class InitializedEntity;
131 class IntegerLiteral;
132 class LabelStmt;
133 class LambdaExpr;
134 class LangOptions;
135 class LocalInstantiationScope;
136 class LookupResult;
137 class MacroInfo;
138 typedef ArrayRef<std::pair<IdentifierInfo *, SourceLocation>> ModuleIdPath;
139 class ModuleLoader;
140 class MultiLevelTemplateArgumentList;
141 class NamedDecl;
142 class ObjCCategoryDecl;
143 class ObjCCategoryImplDecl;
144 class ObjCCompatibleAliasDecl;
145 class ObjCContainerDecl;
146 class ObjCImplDecl;
147 class ObjCImplementationDecl;
148 class ObjCInterfaceDecl;
149 class ObjCIvarDecl;
150 template <class T> class ObjCList;
151 class ObjCMessageExpr;
152 class ObjCMethodDecl;
153 class ObjCPropertyDecl;
154 class ObjCProtocolDecl;
155 class OMPThreadPrivateDecl;
156 class OMPRequiresDecl;
157 class OMPDeclareReductionDecl;
158 class OMPDeclareSimdDecl;
159 class OMPClause;
160 struct OverloadCandidate;
161 class OverloadCandidateSet;
162 class OverloadExpr;
163 class ParenListExpr;
164 class ParmVarDecl;
165 class Preprocessor;
166 class PseudoDestructorTypeStorage;
167 class PseudoObjectExpr;
168 class QualType;
169 class StandardConversionSequence;
170 class Stmt;
171 class StringLiteral;
172 class SwitchStmt;
173 class TemplateArgument;
174 class TemplateArgumentList;
175 class TemplateArgumentLoc;
176 class TemplateDecl;
177 class TemplateInstantiationCallback;
178 class TemplateParameterList;
179 class TemplatePartialOrderingContext;
180 class TemplateTemplateParmDecl;
181 class Token;
182 class TypeAliasDecl;
183 class TypedefDecl;
184 class TypedefNameDecl;
185 class TypeLoc;
186 class TypoCorrectionConsumer;
187 class UnqualifiedId;
188 class UnresolvedLookupExpr;
189 class UnresolvedMemberExpr;
190 class UnresolvedSetImpl;
191 class UnresolvedSetIterator;
192 class UsingDecl;
193 class UsingShadowDecl;
194 class ValueDecl;
195 class VarDecl;
196 class VarTemplateSpecializationDecl;
197 class VisibilityAttr;
198 class VisibleDeclConsumer;
199 class IndirectFieldDecl;
200 struct DeductionFailureInfo;
201 class TemplateSpecCandidateSet;
202
203namespace sema {
204 class AccessedEntity;
205 class BlockScopeInfo;
206 class Capture;
207 class CapturedRegionScopeInfo;
208 class CapturingScopeInfo;
209 class CompoundScopeInfo;
210 class DelayedDiagnostic;
211 class DelayedDiagnosticPool;
212 class FunctionScopeInfo;
213 class LambdaScopeInfo;
214 class PossiblyUnreachableDiag;
215 class SemaPPCallbacks;
216 class TemplateDeductionInfo;
217}
218
219namespace threadSafety {
220 class BeforeSet;
221 void threadSafetyCleanup(BeforeSet* Cache);
222}
223
224// FIXME: No way to easily map from TemplateTypeParmTypes to
225// TemplateTypeParmDecls, so we have this horrible PointerUnion.
226typedef std::pair<llvm::PointerUnion<const TemplateTypeParmType*, NamedDecl*>,
227 SourceLocation> UnexpandedParameterPack;
228
229/// Describes whether we've seen any nullability information for the given
230/// file.
231struct FileNullability {
232 /// The first pointer declarator (of any pointer kind) in the file that does
233 /// not have a corresponding nullability annotation.
234 SourceLocation PointerLoc;
235
236 /// The end location for the first pointer declarator in the file. Used for
237 /// placing fix-its.
238 SourceLocation PointerEndLoc;
239
240 /// Which kind of pointer declarator we saw.
241 uint8_t PointerKind;
242
243 /// Whether we saw any type nullability annotations in the given file.
244 bool SawTypeNullability = false;
245};
246
247/// A mapping from file IDs to a record of whether we've seen nullability
248/// information in that file.
249class FileNullabilityMap {
250 /// A mapping from file IDs to the nullability information for each file ID.
251 llvm::DenseMap<FileID, FileNullability> Map;
252
253 /// A single-element cache based on the file ID.
254 struct {
255 FileID File;
256 FileNullability Nullability;
257 } Cache;
258
259public:
260 FileNullability &operator[](FileID file) {
261 // Check the single-element cache.
262 if (file == Cache.File)
263 return Cache.Nullability;
264
265 // It's not in the single-element cache; flush the cache if we have one.
266 if (!Cache.File.isInvalid()) {
267 Map[Cache.File] = Cache.Nullability;
268 }
269
270 // Pull this entry into the cache.
271 Cache.File = file;
272 Cache.Nullability = Map[file];
273 return Cache.Nullability;
274 }
275};
276
277/// Sema - This implements semantic analysis and AST building for C.
278class Sema {
279 Sema(const Sema &) = delete;
280 void operator=(const Sema &) = delete;
281
282 ///Source of additional semantic information.
283 ExternalSemaSource *ExternalSource;
284
285 ///Whether Sema has generated a multiplexer and has to delete it.
286 bool isMultiplexExternalSource;
287
288 static bool mightHaveNonExternalLinkage(const DeclaratorDecl *FD);
289
290 bool isVisibleSlow(const NamedDecl *D);
291
292 /// Determine whether two declarations should be linked together, given that
293 /// the old declaration might not be visible and the new declaration might
294 /// not have external linkage.
295 bool shouldLinkPossiblyHiddenDecl(const NamedDecl *Old,
296 const NamedDecl *New) {
297 if (isVisible(Old))
298 return true;
299 // See comment in below overload for why it's safe to compute the linkage
300 // of the new declaration here.
301 if (New->isExternallyDeclarable()) {
302 assert(Old->isExternallyDeclarable() &&((Old->isExternallyDeclarable() && "should not have found a non-externally-declarable previous decl"
) ? static_cast<void> (0) : __assert_fail ("Old->isExternallyDeclarable() && \"should not have found a non-externally-declarable previous decl\""
, "/build/llvm-toolchain-snapshot-8~svn349319/tools/clang/include/clang/Sema/Sema.h"
, 303, __PRETTY_FUNCTION__))
303 "should not have found a non-externally-declarable previous decl")((Old->isExternallyDeclarable() && "should not have found a non-externally-declarable previous decl"
) ? static_cast<void> (0) : __assert_fail ("Old->isExternallyDeclarable() && \"should not have found a non-externally-declarable previous decl\""
, "/build/llvm-toolchain-snapshot-8~svn349319/tools/clang/include/clang/Sema/Sema.h"
, 303, __PRETTY_FUNCTION__))
;
304 return true;
305 }
306 return false;
307 }
308 bool shouldLinkPossiblyHiddenDecl(LookupResult &Old, const NamedDecl *New);
309
310public:
311 typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy;
312 typedef OpaquePtr<TemplateName> TemplateTy;
313 typedef OpaquePtr<QualType> TypeTy;
314
315 OpenCLOptions OpenCLFeatures;
316 FPOptions FPFeatures;
317
318 const LangOptions &LangOpts;
319 Preprocessor &PP;
320 ASTContext &Context;
321 ASTConsumer &Consumer;
322 DiagnosticsEngine &Diags;
323 SourceManager &SourceMgr;
324
325 /// Flag indicating whether or not to collect detailed statistics.
326 bool CollectStats;
327
328 /// Code-completion consumer.
329 CodeCompleteConsumer *CodeCompleter;
330
331 /// CurContext - This is the current declaration context of parsing.
332 DeclContext *CurContext;
333
334 /// Generally null except when we temporarily switch decl contexts,
335 /// like in \see ActOnObjCTemporaryExitContainerContext.
336 DeclContext *OriginalLexicalContext;
337
338 /// VAListTagName - The declaration name corresponding to __va_list_tag.
339 /// This is used as part of a hack to omit that class from ADL results.
340 DeclarationName VAListTagName;
341
342 bool MSStructPragmaOn; // True when \#pragma ms_struct on
343
344 /// Controls member pointer representation format under the MS ABI.
345 LangOptions::PragmaMSPointersToMembersKind
346 MSPointerToMemberRepresentationMethod;
347
348 /// Stack of active SEH __finally scopes. Can be empty.
349 SmallVector<Scope*, 2> CurrentSEHFinally;
350
351 /// Source location for newly created implicit MSInheritanceAttrs
352 SourceLocation ImplicitMSInheritanceAttrLoc;
353
354 /// pragma clang section kind
355 enum PragmaClangSectionKind {
356 PCSK_Invalid = 0,
357 PCSK_BSS = 1,
358 PCSK_Data = 2,
359 PCSK_Rodata = 3,
360 PCSK_Text = 4
361 };
362
363 enum PragmaClangSectionAction {
364 PCSA_Set = 0,
365 PCSA_Clear = 1
366 };
367
368 struct PragmaClangSection {
369 std::string SectionName;
370 bool Valid = false;
371 SourceLocation PragmaLocation;
372
373 void Act(SourceLocation PragmaLocation,
374 PragmaClangSectionAction Action,
375 StringLiteral* Name);
376 };
377
378 PragmaClangSection PragmaClangBSSSection;
379 PragmaClangSection PragmaClangDataSection;
380 PragmaClangSection PragmaClangRodataSection;
381 PragmaClangSection PragmaClangTextSection;
382
383 enum PragmaMsStackAction {
384 PSK_Reset = 0x0, // #pragma ()
385 PSK_Set = 0x1, // #pragma (value)
386 PSK_Push = 0x2, // #pragma (push[, id])
387 PSK_Pop = 0x4, // #pragma (pop[, id])
388 PSK_Show = 0x8, // #pragma (show) -- only for "pack"!
389 PSK_Push_Set = PSK_Push | PSK_Set, // #pragma (push[, id], value)
390 PSK_Pop_Set = PSK_Pop | PSK_Set, // #pragma (pop[, id], value)
391 };
392
393 template<typename ValueType>
394 struct PragmaStack {
395 struct Slot {
396 llvm::StringRef StackSlotLabel;
397 ValueType Value;
398 SourceLocation PragmaLocation;
399 SourceLocation PragmaPushLocation;
400 Slot(llvm::StringRef StackSlotLabel, ValueType Value,
401 SourceLocation PragmaLocation, SourceLocation PragmaPushLocation)
402 : StackSlotLabel(StackSlotLabel), Value(Value),
403 PragmaLocation(PragmaLocation),
404 PragmaPushLocation(PragmaPushLocation) {}
405 };
406 void Act(SourceLocation PragmaLocation,
407 PragmaMsStackAction Action,
408 llvm::StringRef StackSlotLabel,
409 ValueType Value);
410
411 // MSVC seems to add artificial slots to #pragma stacks on entering a C++
412 // method body to restore the stacks on exit, so it works like this:
413 //
414 // struct S {
415 // #pragma <name>(push, InternalPragmaSlot, <current_pragma_value>)
416 // void Method {}
417 // #pragma <name>(pop, InternalPragmaSlot)
418 // };
419 //
420 // It works even with #pragma vtordisp, although MSVC doesn't support
421 // #pragma vtordisp(push [, id], n)
422 // syntax.
423 //
424 // Push / pop a named sentinel slot.
425 void SentinelAction(PragmaMsStackAction Action, StringRef Label) {
426 assert((Action == PSK_Push || Action == PSK_Pop) &&(((Action == PSK_Push || Action == PSK_Pop) && "Can only push / pop #pragma stack sentinels!"
) ? static_cast<void> (0) : __assert_fail ("(Action == PSK_Push || Action == PSK_Pop) && \"Can only push / pop #pragma stack sentinels!\""
, "/build/llvm-toolchain-snapshot-8~svn349319/tools/clang/include/clang/Sema/Sema.h"
, 427, __PRETTY_FUNCTION__))
427 "Can only push / pop #pragma stack sentinels!")(((Action == PSK_Push || Action == PSK_Pop) && "Can only push / pop #pragma stack sentinels!"
) ? static_cast<void> (0) : __assert_fail ("(Action == PSK_Push || Action == PSK_Pop) && \"Can only push / pop #pragma stack sentinels!\""
, "/build/llvm-toolchain-snapshot-8~svn349319/tools/clang/include/clang/Sema/Sema.h"
, 427, __PRETTY_FUNCTION__))
;
428 Act(CurrentPragmaLocation, Action, Label, CurrentValue);
429 }
430
431 // Constructors.
432 explicit PragmaStack(const ValueType &Default)
433 : DefaultValue(Default), CurrentValue(Default) {}
434
435 bool hasValue() const { return CurrentValue != DefaultValue; }
436
437 SmallVector<Slot, 2> Stack;
438 ValueType DefaultValue; // Value used for PSK_Reset action.
439 ValueType CurrentValue;
440 SourceLocation CurrentPragmaLocation;
441 };
442 // FIXME: We should serialize / deserialize these if they occur in a PCH (but
443 // we shouldn't do so if they're in a module).
444
445 /// Whether to insert vtordisps prior to virtual bases in the Microsoft
446 /// C++ ABI. Possible values are 0, 1, and 2, which mean:
447 ///
448 /// 0: Suppress all vtordisps
449 /// 1: Insert vtordisps in the presence of vbase overrides and non-trivial
450 /// structors
451 /// 2: Always insert vtordisps to support RTTI on partially constructed
452 /// objects
453 PragmaStack<MSVtorDispAttr::Mode> VtorDispStack;
454 // #pragma pack.
455 // Sentinel to represent when the stack is set to mac68k alignment.
456 static const unsigned kMac68kAlignmentSentinel = ~0U;
457 PragmaStack<unsigned> PackStack;
458 // The current #pragma pack values and locations at each #include.
459 struct PackIncludeState {
460 unsigned CurrentValue;
461 SourceLocation CurrentPragmaLocation;
462 bool HasNonDefaultValue, ShouldWarnOnInclude;
463 };
464 SmallVector<PackIncludeState, 8> PackIncludeStack;
465 // Segment #pragmas.
466 PragmaStack<StringLiteral *> DataSegStack;
467 PragmaStack<StringLiteral *> BSSSegStack;
468 PragmaStack<StringLiteral *> ConstSegStack;
469 PragmaStack<StringLiteral *> CodeSegStack;
470
471 // RAII object to push / pop sentinel slots for all MS #pragma stacks.
472 // Actions should be performed only if we enter / exit a C++ method body.
473 class PragmaStackSentinelRAII {
474 public:
475 PragmaStackSentinelRAII(Sema &S, StringRef SlotLabel, bool ShouldAct);
476 ~PragmaStackSentinelRAII();
477
478 private:
479 Sema &S;
480 StringRef SlotLabel;
481 bool ShouldAct;
482 };
483
484 /// A mapping that describes the nullability we've seen in each header file.
485 FileNullabilityMap NullabilityMap;
486
487 /// Last section used with #pragma init_seg.
488 StringLiteral *CurInitSeg;
489 SourceLocation CurInitSegLoc;
490
491 /// VisContext - Manages the stack for \#pragma GCC visibility.
492 void *VisContext; // Really a "PragmaVisStack*"
493
494 /// This an attribute introduced by \#pragma clang attribute.
495 struct PragmaAttributeEntry {
496 SourceLocation Loc;
497 ParsedAttr *Attribute;
498 SmallVector<attr::SubjectMatchRule, 4> MatchRules;
499 bool IsUsed;
500 };
501
502 /// A push'd group of PragmaAttributeEntries.
503 struct PragmaAttributeGroup {
504 /// The location of the push attribute.
505 SourceLocation Loc;
506 SmallVector<PragmaAttributeEntry, 2> Entries;
507 };
508
509 SmallVector<PragmaAttributeGroup, 2> PragmaAttributeStack;
510
511 /// The declaration that is currently receiving an attribute from the
512 /// #pragma attribute stack.
513 const Decl *PragmaAttributeCurrentTargetDecl;
514
515 /// This represents the last location of a "#pragma clang optimize off"
516 /// directive if such a directive has not been closed by an "on" yet. If
517 /// optimizations are currently "on", this is set to an invalid location.
518 SourceLocation OptimizeOffPragmaLocation;
519
520 /// Flag indicating if Sema is building a recovery call expression.
521 ///
522 /// This flag is used to avoid building recovery call expressions
523 /// if Sema is already doing so, which would cause infinite recursions.
524 bool IsBuildingRecoveryCallExpr;
525
526 /// Used to control the generation of ExprWithCleanups.
527 CleanupInfo Cleanup;
528
529 /// ExprCleanupObjects - This is the stack of objects requiring
530 /// cleanup that are created by the current full expression. The
531 /// element type here is ExprWithCleanups::Object.
532 SmallVector<BlockDecl*, 8> ExprCleanupObjects;
533
534 /// Store a list of either DeclRefExprs or MemberExprs
535 /// that contain a reference to a variable (constant) that may or may not
536 /// be odr-used in this Expr, and we won't know until all lvalue-to-rvalue
537 /// and discarded value conversions have been applied to all subexpressions
538 /// of the enclosing full expression. This is cleared at the end of each
539 /// full expression.
540 llvm::SmallPtrSet<Expr*, 2> MaybeODRUseExprs;
541
542 std::unique_ptr<sema::FunctionScopeInfo> PreallocatedFunctionScope;
543
544 /// Stack containing information about each of the nested
545 /// function, block, and method scopes that are currently active.
546 SmallVector<sema::FunctionScopeInfo *, 4> FunctionScopes;
547
548 typedef LazyVector<TypedefNameDecl *, ExternalSemaSource,
549 &ExternalSemaSource::ReadExtVectorDecls, 2, 2>
550 ExtVectorDeclsType;
551
552 /// ExtVectorDecls - This is a list all the extended vector types. This allows
553 /// us to associate a raw vector type with one of the ext_vector type names.
554 /// This is only necessary for issuing pretty diagnostics.
555 ExtVectorDeclsType ExtVectorDecls;
556
557 /// FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
558 std::unique_ptr<CXXFieldCollector> FieldCollector;
559
560 typedef llvm::SmallSetVector<NamedDecl *, 16> NamedDeclSetType;
561
562 /// Set containing all declared private fields that are not used.