Bug Summary

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

Annotated Source Code

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