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/Sema/Lookup.h"
14 #include "clang/Sema/PrettyDeclStackTrace.h"
15 #include "clang/Sema/Template.h"
16 #include "clang/AST/ASTConsumer.h"
17 #include "clang/AST/ASTContext.h"
18 #include "clang/AST/DeclTemplate.h"
19 #include "clang/AST/DeclVisitor.h"
20 #include "clang/AST/DependentDiagnostic.h"
21 #include "clang/AST/Expr.h"
22 #include "clang/AST/ExprCXX.h"
23 #include "clang/AST/TypeLoc.h"
24 #include "clang/Lex/Preprocessor.h"
25
26 using namespace clang;
27
SubstQualifier(const DeclaratorDecl * OldDecl,DeclaratorDecl * NewDecl)28 bool TemplateDeclInstantiator::SubstQualifier(const DeclaratorDecl *OldDecl,
29 DeclaratorDecl *NewDecl) {
30 if (!OldDecl->getQualifierLoc())
31 return false;
32
33 NestedNameSpecifierLoc NewQualifierLoc
34 = SemaRef.SubstNestedNameSpecifierLoc(OldDecl->getQualifierLoc(),
35 TemplateArgs);
36
37 if (!NewQualifierLoc)
38 return true;
39
40 NewDecl->setQualifierInfo(NewQualifierLoc);
41 return false;
42 }
43
SubstQualifier(const TagDecl * OldDecl,TagDecl * NewDecl)44 bool TemplateDeclInstantiator::SubstQualifier(const TagDecl *OldDecl,
45 TagDecl *NewDecl) {
46 if (!OldDecl->getQualifierLoc())
47 return false;
48
49 NestedNameSpecifierLoc NewQualifierLoc
50 = SemaRef.SubstNestedNameSpecifierLoc(OldDecl->getQualifierLoc(),
51 TemplateArgs);
52
53 if (!NewQualifierLoc)
54 return true;
55
56 NewDecl->setQualifierInfo(NewQualifierLoc);
57 return false;
58 }
59
60 // Include attribute instantiation code.
61 #include "clang/Sema/AttrTemplateInstantiate.inc"
62
InstantiateAttrs(const MultiLevelTemplateArgumentList & TemplateArgs,const Decl * Tmpl,Decl * New,LateInstantiatedAttrVec * LateAttrs,LocalInstantiationScope * OuterMostScope)63 void Sema::InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs,
64 const Decl *Tmpl, Decl *New,
65 LateInstantiatedAttrVec *LateAttrs,
66 LocalInstantiationScope *OuterMostScope) {
67 for (AttrVec::const_iterator i = Tmpl->attr_begin(), e = Tmpl->attr_end();
68 i != e; ++i) {
69 const Attr *TmplAttr = *i;
70
71 // FIXME: This should be generalized to more than just the AlignedAttr.
72 if (const AlignedAttr *Aligned = dyn_cast<AlignedAttr>(TmplAttr)) {
73 if (Aligned->isAlignmentDependent()) {
74 if (Aligned->isAlignmentExpr()) {
75 // The alignment expression is a constant expression.
76 EnterExpressionEvaluationContext Unevaluated(*this,
77 Sema::ConstantEvaluated);
78
79 ExprResult Result = SubstExpr(Aligned->getAlignmentExpr(),
80 TemplateArgs);
81 if (!Result.isInvalid())
82 AddAlignedAttr(Aligned->getLocation(), New, Result.takeAs<Expr>());
83 } else {
84 TypeSourceInfo *Result = SubstType(Aligned->getAlignmentType(),
85 TemplateArgs,
86 Aligned->getLocation(),
87 DeclarationName());
88 if (Result)
89 AddAlignedAttr(Aligned->getLocation(), New, Result);
90 }
91 continue;
92 }
93 }
94
95 if (TmplAttr->isLateParsed() && LateAttrs) {
96 // Late parsed attributes must be instantiated and attached after the
97 // enclosing class has been instantiated. See Sema::InstantiateClass.
98 LocalInstantiationScope *Saved = 0;
99 if (CurrentInstantiationScope)
100 Saved = CurrentInstantiationScope->cloneScopes(OuterMostScope);
101 LateAttrs->push_back(LateInstantiatedAttribute(TmplAttr, Saved, New));
102 } else {
103 Attr *NewAttr = sema::instantiateTemplateAttribute(TmplAttr, Context,
104 *this, TemplateArgs);
105 New->addAttr(NewAttr);
106 }
107 }
108 }
109
110 Decl *
VisitTranslationUnitDecl(TranslationUnitDecl * D)111 TemplateDeclInstantiator::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
112 llvm_unreachable("Translation units cannot be instantiated");
113 }
114
115 Decl *
VisitLabelDecl(LabelDecl * D)116 TemplateDeclInstantiator::VisitLabelDecl(LabelDecl *D) {
117 LabelDecl *Inst = LabelDecl::Create(SemaRef.Context, Owner, D->getLocation(),
118 D->getIdentifier());
119 Owner->addDecl(Inst);
120 return Inst;
121 }
122
123 Decl *
VisitNamespaceDecl(NamespaceDecl * D)124 TemplateDeclInstantiator::VisitNamespaceDecl(NamespaceDecl *D) {
125 llvm_unreachable("Namespaces cannot be instantiated");
126 }
127
128 Decl *
VisitNamespaceAliasDecl(NamespaceAliasDecl * D)129 TemplateDeclInstantiator::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
130 NamespaceAliasDecl *Inst
131 = NamespaceAliasDecl::Create(SemaRef.Context, Owner,
132 D->getNamespaceLoc(),
133 D->getAliasLoc(),
134 D->getIdentifier(),
135 D->getQualifierLoc(),
136 D->getTargetNameLoc(),
137 D->getNamespace());
138 Owner->addDecl(Inst);
139 return Inst;
140 }
141
InstantiateTypedefNameDecl(TypedefNameDecl * D,bool IsTypeAlias)142 Decl *TemplateDeclInstantiator::InstantiateTypedefNameDecl(TypedefNameDecl *D,
143 bool IsTypeAlias) {
144 bool Invalid = false;
145 TypeSourceInfo *DI = D->getTypeSourceInfo();
146 if (DI->getType()->isInstantiationDependentType() ||
147 DI->getType()->isVariablyModifiedType()) {
148 DI = SemaRef.SubstType(DI, TemplateArgs,
149 D->getLocation(), D->getDeclName());
150 if (!DI) {
151 Invalid = true;
152 DI = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.Context.IntTy);
153 }
154 } else {
155 SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType());
156 }
157
158 // Create the new typedef
159 TypedefNameDecl *Typedef;
160 if (IsTypeAlias)
161 Typedef = TypeAliasDecl::Create(SemaRef.Context, Owner, D->getLocStart(),
162 D->getLocation(), D->getIdentifier(), DI);
163 else
164 Typedef = TypedefDecl::Create(SemaRef.Context, Owner, D->getLocStart(),
165 D->getLocation(), D->getIdentifier(), DI);
166 if (Invalid)
167 Typedef->setInvalidDecl();
168
169 // If the old typedef was the name for linkage purposes of an anonymous
170 // tag decl, re-establish that relationship for the new typedef.
171 if (const TagType *oldTagType = D->getUnderlyingType()->getAs<TagType>()) {
172 TagDecl *oldTag = oldTagType->getDecl();
173 if (oldTag->getTypedefNameForAnonDecl() == D) {
174 TagDecl *newTag = DI->getType()->castAs<TagType>()->getDecl();
175 assert(!newTag->getIdentifier() && !newTag->getTypedefNameForAnonDecl());
176 newTag->setTypedefNameForAnonDecl(Typedef);
177 }
178 }
179
180 if (TypedefNameDecl *Prev = D->getPreviousDecl()) {
181 NamedDecl *InstPrev = SemaRef.FindInstantiatedDecl(D->getLocation(), Prev,
182 TemplateArgs);
183 if (!InstPrev)
184 return 0;
185
186 TypedefNameDecl *InstPrevTypedef = cast<TypedefNameDecl>(InstPrev);
187
188 // If the typedef types are not identical, reject them.
189 SemaRef.isIncompatibleTypedef(InstPrevTypedef, Typedef);
190
191 Typedef->setPreviousDeclaration(InstPrevTypedef);
192 }
193
194 SemaRef.InstantiateAttrs(TemplateArgs, D, Typedef);
195
196 Typedef->setAccess(D->getAccess());
197
198 return Typedef;
199 }
200
VisitTypedefDecl(TypedefDecl * D)201 Decl *TemplateDeclInstantiator::VisitTypedefDecl(TypedefDecl *D) {
202 Decl *Typedef = InstantiateTypedefNameDecl(D, /*IsTypeAlias=*/false);
203 Owner->addDecl(Typedef);
204 return Typedef;
205 }
206
VisitTypeAliasDecl(TypeAliasDecl * D)207 Decl *TemplateDeclInstantiator::VisitTypeAliasDecl(TypeAliasDecl *D) {
208 Decl *Typedef = InstantiateTypedefNameDecl(D, /*IsTypeAlias=*/true);
209 Owner->addDecl(Typedef);
210 return Typedef;
211 }
212
213 Decl *
VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl * D)214 TemplateDeclInstantiator::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
215 // Create a local instantiation scope for this type alias template, which
216 // will contain the instantiations of the template parameters.
217 LocalInstantiationScope Scope(SemaRef);
218
219 TemplateParameterList *TempParams = D->getTemplateParameters();
220 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
221 if (!InstParams)
222 return 0;
223
224 TypeAliasDecl *Pattern = D->getTemplatedDecl();
225
226 TypeAliasTemplateDecl *PrevAliasTemplate = 0;
227 if (Pattern->getPreviousDecl()) {
228 DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
229 if (Found.first != Found.second) {
230 PrevAliasTemplate = dyn_cast<TypeAliasTemplateDecl>(*Found.first);
231 }
232 }
233
234 TypeAliasDecl *AliasInst = cast_or_null<TypeAliasDecl>(
235 InstantiateTypedefNameDecl(Pattern, /*IsTypeAlias=*/true));
236 if (!AliasInst)
237 return 0;
238
239 TypeAliasTemplateDecl *Inst
240 = TypeAliasTemplateDecl::Create(SemaRef.Context, Owner, D->getLocation(),
241 D->getDeclName(), InstParams, AliasInst);
242 if (PrevAliasTemplate)
243 Inst->setPreviousDeclaration(PrevAliasTemplate);
244
245 Inst->setAccess(D->getAccess());
246
247 if (!PrevAliasTemplate)
248 Inst->setInstantiatedFromMemberTemplate(D);
249
250 Owner->addDecl(Inst);
251
252 return Inst;
253 }
254
VisitVarDecl(VarDecl * D)255 Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D) {
256 // If this is the variable for an anonymous struct or union,
257 // instantiate the anonymous struct/union type first.
258 if (const RecordType *RecordTy = D->getType()->getAs<RecordType>())
259 if (RecordTy->getDecl()->isAnonymousStructOrUnion())
260 if (!VisitCXXRecordDecl(cast<CXXRecordDecl>(RecordTy->getDecl())))
261 return 0;
262
263 // Do substitution on the type of the declaration
264 TypeSourceInfo *DI = SemaRef.SubstType(D->getTypeSourceInfo(),
265 TemplateArgs,
266 D->getTypeSpecStartLoc(),
267 D->getDeclName());
268 if (!DI)
269 return 0;
270
271 if (DI->getType()->isFunctionType()) {
272 SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function)
273 << D->isStaticDataMember() << DI->getType();
274 return 0;
275 }
276
277 // Build the instantiated declaration
278 VarDecl *Var = VarDecl::Create(SemaRef.Context, Owner,
279 D->getInnerLocStart(),
280 D->getLocation(), D->getIdentifier(),
281 DI->getType(), DI,
282 D->getStorageClass(),
283 D->getStorageClassAsWritten());
284 Var->setThreadSpecified(D->isThreadSpecified());
285 Var->setInitStyle(D->getInitStyle());
286 Var->setCXXForRangeDecl(D->isCXXForRangeDecl());
287 Var->setConstexpr(D->isConstexpr());
288
289 // Substitute the nested name specifier, if any.
290 if (SubstQualifier(D, Var))
291 return 0;
292
293 // If we are instantiating a static data member defined
294 // out-of-line, the instantiation will have the same lexical
295 // context (which will be a namespace scope) as the template.
296 if (D->isOutOfLine())
297 Var->setLexicalDeclContext(D->getLexicalDeclContext());
298
299 Var->setAccess(D->getAccess());
300
301 if (!D->isStaticDataMember()) {
302 Var->setUsed(D->isUsed(false));
303 Var->setReferenced(D->isReferenced());
304 }
305
306 // FIXME: In theory, we could have a previous declaration for variables that
307 // are not static data members.
308 // FIXME: having to fake up a LookupResult is dumb.
309 LookupResult Previous(SemaRef, Var->getDeclName(), Var->getLocation(),
310 Sema::LookupOrdinaryName, Sema::ForRedeclaration);
311 if (D->isStaticDataMember())
312 SemaRef.LookupQualifiedName(Previous, Owner, false);
313
314 // In ARC, infer 'retaining' for variables of retainable type.
315 if (SemaRef.getLangOpts().ObjCAutoRefCount &&
316 SemaRef.inferObjCARCLifetime(Var))
317 Var->setInvalidDecl();
318
319 SemaRef.CheckVariableDeclaration(Var, Previous);
320
321 if (D->isOutOfLine()) {
322 D->getLexicalDeclContext()->addDecl(Var);
323 Owner->makeDeclVisibleInContext(Var);
324 } else {
325 Owner->addDecl(Var);
326 if (Owner->isFunctionOrMethod())
327 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Var);
328 }
329 SemaRef.InstantiateAttrs(TemplateArgs, D, Var, LateAttrs, StartingScope);
330
331 // Link instantiations of static data members back to the template from
332 // which they were instantiated.
333 if (Var->isStaticDataMember())
334 SemaRef.Context.setInstantiatedFromStaticDataMember(Var, D,
335 TSK_ImplicitInstantiation);
336
337 if (Var->getAnyInitializer()) {
338 // We already have an initializer in the class.
339 } else if (D->getInit()) {
340 if (Var->isStaticDataMember() && !D->isOutOfLine())
341 SemaRef.PushExpressionEvaluationContext(Sema::ConstantEvaluated);
342 else
343 SemaRef.PushExpressionEvaluationContext(Sema::PotentiallyEvaluated);
344
345 // Instantiate the initializer.
346 ExprResult Init = SemaRef.SubstInitializer(D->getInit(), TemplateArgs,
347 D->getInitStyle() == VarDecl::CallInit);
348 if (!Init.isInvalid()) {
349 bool TypeMayContainAuto = true;
350 if (Init.get()) {
351 bool DirectInit = D->isDirectInit();
352 SemaRef.AddInitializerToDecl(Var, Init.take(), DirectInit,
353 TypeMayContainAuto);
354 } else
355 SemaRef.ActOnUninitializedDecl(Var, TypeMayContainAuto);
356 } else {
357 // FIXME: Not too happy about invalidating the declaration
358 // because of a bogus initializer.
359 Var->setInvalidDecl();
360 }
361
362 SemaRef.PopExpressionEvaluationContext();
363 } else if ((!Var->isStaticDataMember() || Var->isOutOfLine()) &&
364 !Var->isCXXForRangeDecl())
365 SemaRef.ActOnUninitializedDecl(Var, false);
366
367 // Diagnose unused local variables with dependent types, where the diagnostic
368 // will have been deferred.
369 if (!Var->isInvalidDecl() && Owner->isFunctionOrMethod() && !Var->isUsed() &&
370 D->getType()->isDependentType())
371 SemaRef.DiagnoseUnusedDecl(Var);
372
373 return Var;
374 }
375
VisitAccessSpecDecl(AccessSpecDecl * D)376 Decl *TemplateDeclInstantiator::VisitAccessSpecDecl(AccessSpecDecl *D) {
377 AccessSpecDecl* AD
378 = AccessSpecDecl::Create(SemaRef.Context, D->getAccess(), Owner,
379 D->getAccessSpecifierLoc(), D->getColonLoc());
380 Owner->addHiddenDecl(AD);
381 return AD;
382 }
383
VisitFieldDecl(FieldDecl * D)384 Decl *TemplateDeclInstantiator::VisitFieldDecl(FieldDecl *D) {
385 bool Invalid = false;
386 TypeSourceInfo *DI = D->getTypeSourceInfo();
387 if (DI->getType()->isInstantiationDependentType() ||
388 DI->getType()->isVariablyModifiedType()) {
389 DI = SemaRef.SubstType(DI, TemplateArgs,
390 D->getLocation(), D->getDeclName());
391 if (!DI) {
392 DI = D->getTypeSourceInfo();
393 Invalid = true;
394 } else if (DI->getType()->isFunctionType()) {
395 // C++ [temp.arg.type]p3:
396 // If a declaration acquires a function type through a type
397 // dependent on a template-parameter and this causes a
398 // declaration that does not use the syntactic form of a
399 // function declarator to have function type, the program is
400 // ill-formed.
401 SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function)
402 << DI->getType();
403 Invalid = true;
404 }
405 } else {
406 SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType());
407 }
408
409 Expr *BitWidth = D->getBitWidth();
410 if (Invalid)
411 BitWidth = 0;
412 else if (BitWidth) {
413 // The bit-width expression is a constant expression.
414 EnterExpressionEvaluationContext Unevaluated(SemaRef,
415 Sema::ConstantEvaluated);
416
417 ExprResult InstantiatedBitWidth
418 = SemaRef.SubstExpr(BitWidth, TemplateArgs);
419 if (InstantiatedBitWidth.isInvalid()) {
420 Invalid = true;
421 BitWidth = 0;
422 } else
423 BitWidth = InstantiatedBitWidth.takeAs<Expr>();
424 }
425
426 FieldDecl *Field = SemaRef.CheckFieldDecl(D->getDeclName(),
427 DI->getType(), DI,
428 cast<RecordDecl>(Owner),
429 D->getLocation(),
430 D->isMutable(),
431 BitWidth,
432 D->hasInClassInitializer(),
433 D->getTypeSpecStartLoc(),
434 D->getAccess(),
435 0);
436 if (!Field) {
437 cast<Decl>(Owner)->setInvalidDecl();
438 return 0;
439 }
440
441 SemaRef.InstantiateAttrs(TemplateArgs, D, Field, LateAttrs, StartingScope);
442
443 if (Invalid)
444 Field->setInvalidDecl();
445
446 if (!Field->getDeclName()) {
447 // Keep track of where this decl came from.
448 SemaRef.Context.setInstantiatedFromUnnamedFieldDecl(Field, D);
449 }
450 if (CXXRecordDecl *Parent= dyn_cast<CXXRecordDecl>(Field->getDeclContext())) {
451 if (Parent->isAnonymousStructOrUnion() &&
452 Parent->getRedeclContext()->isFunctionOrMethod())
453 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Field);
454 }
455
456 Field->setImplicit(D->isImplicit());
457 Field->setAccess(D->getAccess());
458 Owner->addDecl(Field);
459
460 return Field;
461 }
462
VisitIndirectFieldDecl(IndirectFieldDecl * D)463 Decl *TemplateDeclInstantiator::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
464 NamedDecl **NamedChain =
465 new (SemaRef.Context)NamedDecl*[D->getChainingSize()];
466
467 int i = 0;
468 for (IndirectFieldDecl::chain_iterator PI =
469 D->chain_begin(), PE = D->chain_end();
470 PI != PE; ++PI) {
471 NamedDecl *Next = SemaRef.FindInstantiatedDecl(D->getLocation(), *PI,
472 TemplateArgs);
473 if (!Next)
474 return 0;
475
476 NamedChain[i++] = Next;
477 }
478
479 QualType T = cast<FieldDecl>(NamedChain[i-1])->getType();
480 IndirectFieldDecl* IndirectField
481 = IndirectFieldDecl::Create(SemaRef.Context, Owner, D->getLocation(),
482 D->getIdentifier(), T,
483 NamedChain, D->getChainingSize());
484
485
486 IndirectField->setImplicit(D->isImplicit());
487 IndirectField->setAccess(D->getAccess());
488 Owner->addDecl(IndirectField);
489 return IndirectField;
490 }
491
VisitFriendDecl(FriendDecl * D)492 Decl *TemplateDeclInstantiator::VisitFriendDecl(FriendDecl *D) {
493 // Handle friend type expressions by simply substituting template
494 // parameters into the pattern type and checking the result.
495 if (TypeSourceInfo *Ty = D->getFriendType()) {
496 TypeSourceInfo *InstTy;
497 // If this is an unsupported friend, don't bother substituting template
498 // arguments into it. The actual type referred to won't be used by any
499 // parts of Clang, and may not be valid for instantiating. Just use the
500 // same info for the instantiated friend.
501 if (D->isUnsupportedFriend()) {
502 InstTy = Ty;
503 } else {
504 InstTy = SemaRef.SubstType(Ty, TemplateArgs,
505 D->getLocation(), DeclarationName());
506 }
507 if (!InstTy)
508 return 0;
509
510 FriendDecl *FD = SemaRef.CheckFriendTypeDecl(D->getLocation(),
511 D->getFriendLoc(), InstTy);
512 if (!FD)
513 return 0;
514
515 FD->setAccess(AS_public);
516 FD->setUnsupportedFriend(D->isUnsupportedFriend());
517 Owner->addDecl(FD);
518 return FD;
519 }
520
521 NamedDecl *ND = D->getFriendDecl();
522 assert(ND && "friend decl must be a decl or a type!");
523
524 // All of the Visit implementations for the various potential friend
525 // declarations have to be carefully written to work for friend
526 // objects, with the most important detail being that the target
527 // decl should almost certainly not be placed in Owner.
528 Decl *NewND = Visit(ND);
529 if (!NewND) return 0;
530
531 FriendDecl *FD =
532 FriendDecl::Create(SemaRef.Context, Owner, D->getLocation(),
533 cast<NamedDecl>(NewND), D->getFriendLoc());
534 FD->setAccess(AS_public);
535 FD->setUnsupportedFriend(D->isUnsupportedFriend());
536 Owner->addDecl(FD);
537 return FD;
538 }
539
VisitStaticAssertDecl(StaticAssertDecl * D)540 Decl *TemplateDeclInstantiator::VisitStaticAssertDecl(StaticAssertDecl *D) {
541 Expr *AssertExpr = D->getAssertExpr();
542
543 // The expression in a static assertion is a constant expression.
544 EnterExpressionEvaluationContext Unevaluated(SemaRef,
545 Sema::ConstantEvaluated);
546
547 ExprResult InstantiatedAssertExpr
548 = SemaRef.SubstExpr(AssertExpr, TemplateArgs);
549 if (InstantiatedAssertExpr.isInvalid())
550 return 0;
551
552 ExprResult Message(D->getMessage());
553 D->getMessage();
554 return SemaRef.ActOnStaticAssertDeclaration(D->getLocation(),
555 InstantiatedAssertExpr.get(),
556 Message.get(),
557 D->getRParenLoc());
558 }
559
VisitEnumDecl(EnumDecl * D)560 Decl *TemplateDeclInstantiator::VisitEnumDecl(EnumDecl *D) {
561 EnumDecl *PrevDecl = 0;
562 if (D->getPreviousDecl()) {
563 NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(),
564 D->getPreviousDecl(),
565 TemplateArgs);
566 if (!Prev) return 0;
567 PrevDecl = cast<EnumDecl>(Prev);
568 }
569
570 EnumDecl *Enum = EnumDecl::Create(SemaRef.Context, Owner, D->getLocStart(),
571 D->getLocation(), D->getIdentifier(),
572 PrevDecl, D->isScoped(),
573 D->isScopedUsingClassTag(), D->isFixed());
574 if (D->isFixed()) {
575 if (TypeSourceInfo *TI = D->getIntegerTypeSourceInfo()) {
576 // If we have type source information for the underlying type, it means it
577 // has been explicitly set by the user. Perform substitution on it before
578 // moving on.
579 SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
580 TypeSourceInfo *NewTI = SemaRef.SubstType(TI, TemplateArgs, UnderlyingLoc,
581 DeclarationName());
582 if (!NewTI || SemaRef.CheckEnumUnderlyingType(NewTI))
583 Enum->setIntegerType(SemaRef.Context.IntTy);
584 else
585 Enum->setIntegerTypeSourceInfo(NewTI);
586 } else {
587 assert(!D->getIntegerType()->isDependentType()
588 && "Dependent type without type source info");
589 Enum->setIntegerType(D->getIntegerType());
590 }
591 }
592
593 SemaRef.InstantiateAttrs(TemplateArgs, D, Enum);
594
595 Enum->setInstantiationOfMemberEnum(D, TSK_ImplicitInstantiation);
596 Enum->setAccess(D->getAccess());
597 if (SubstQualifier(D, Enum)) return 0;
598 Owner->addDecl(Enum);
599
600 EnumDecl *Def = D->getDefinition();
601 if (Def && Def != D) {
602 // If this is an out-of-line definition of an enum member template, check
603 // that the underlying types match in the instantiation of both
604 // declarations.
605 if (TypeSourceInfo *TI = Def->getIntegerTypeSourceInfo()) {
606 SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
607 QualType DefnUnderlying =
608 SemaRef.SubstType(TI->getType(), TemplateArgs,
609 UnderlyingLoc, DeclarationName());
610 SemaRef.CheckEnumRedeclaration(Def->getLocation(), Def->isScoped(),
611 DefnUnderlying, Enum);
612 }
613 }
614
615 if (D->getDeclContext()->isFunctionOrMethod())
616 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Enum);
617
618 // C++11 [temp.inst]p1: The implicit instantiation of a class template
619 // specialization causes the implicit instantiation of the declarations, but
620 // not the definitions of scoped member enumerations.
621 // FIXME: There appears to be no wording for what happens for an enum defined
622 // within a block scope, but we treat that much like a member template. Only
623 // instantiate the definition when visiting the definition in that case, since
624 // we will visit all redeclarations.
625 if (!Enum->isScoped() && Def &&
626 (!D->getDeclContext()->isFunctionOrMethod() || D->isCompleteDefinition()))
627 InstantiateEnumDefinition(Enum, Def);
628
629 return Enum;
630 }
631
InstantiateEnumDefinition(EnumDecl * Enum,EnumDecl * Pattern)632 void TemplateDeclInstantiator::InstantiateEnumDefinition(
633 EnumDecl *Enum, EnumDecl *Pattern) {
634 Enum->startDefinition();
635
636 // Update the location to refer to the definition.
637 Enum->setLocation(Pattern->getLocation());
638
639 SmallVector<Decl*, 4> Enumerators;
640
641 EnumConstantDecl *LastEnumConst = 0;
642 for (EnumDecl::enumerator_iterator EC = Pattern->enumerator_begin(),
643 ECEnd = Pattern->enumerator_end();
644 EC != ECEnd; ++EC) {
645 // The specified value for the enumerator.
646 ExprResult Value = SemaRef.Owned((Expr *)0);
647 if (Expr *UninstValue = EC->getInitExpr()) {
648 // The enumerator's value expression is a constant expression.
649 EnterExpressionEvaluationContext Unevaluated(SemaRef,
650 Sema::ConstantEvaluated);
651
652 Value = SemaRef.SubstExpr(UninstValue, TemplateArgs);
653 }
654
655 // Drop the initial value and continue.
656 bool isInvalid = false;
657 if (Value.isInvalid()) {
658 Value = SemaRef.Owned((Expr *)0);
659 isInvalid = true;
660 }
661
662 EnumConstantDecl *EnumConst
663 = SemaRef.CheckEnumConstant(Enum, LastEnumConst,
664 EC->getLocation(), EC->getIdentifier(),
665 Value.get());
666
667 if (isInvalid) {
668 if (EnumConst)
669 EnumConst->setInvalidDecl();
670 Enum->setInvalidDecl();
671 }
672
673 if (EnumConst) {
674 SemaRef.InstantiateAttrs(TemplateArgs, *EC, EnumConst);
675
676 EnumConst->setAccess(Enum->getAccess());
677 Enum->addDecl(EnumConst);
678 Enumerators.push_back(EnumConst);
679 LastEnumConst = EnumConst;
680
681 if (Pattern->getDeclContext()->isFunctionOrMethod() &&
682 !Enum->isScoped()) {
683 // If the enumeration is within a function or method, record the enum
684 // constant as a local.
685 SemaRef.CurrentInstantiationScope->InstantiatedLocal(*EC, EnumConst);
686 }
687 }
688 }
689
690 // FIXME: Fixup LBraceLoc
691 SemaRef.ActOnEnumBody(Enum->getLocation(), SourceLocation(),
692 Enum->getRBraceLoc(), Enum,
693 Enumerators.data(), Enumerators.size(),
694 0, 0);
695 }
696
VisitEnumConstantDecl(EnumConstantDecl * D)697 Decl *TemplateDeclInstantiator::VisitEnumConstantDecl(EnumConstantDecl *D) {
698 llvm_unreachable("EnumConstantDecls can only occur within EnumDecls.");
699 }
700
VisitClassTemplateDecl(ClassTemplateDecl * D)701 Decl *TemplateDeclInstantiator::VisitClassTemplateDecl(ClassTemplateDecl *D) {
702 bool isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
703
704 // Create a local instantiation scope for this class template, which
705 // will contain the instantiations of the template parameters.
706 LocalInstantiationScope Scope(SemaRef);
707 TemplateParameterList *TempParams = D->getTemplateParameters();
708 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
709 if (!InstParams)
710 return NULL;
711
712 CXXRecordDecl *Pattern = D->getTemplatedDecl();
713
714 // Instantiate the qualifier. We have to do this first in case
715 // we're a friend declaration, because if we are then we need to put
716 // the new declaration in the appropriate context.
717 NestedNameSpecifierLoc QualifierLoc = Pattern->getQualifierLoc();
718 if (QualifierLoc) {
719 QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
720 TemplateArgs);
721 if (!QualifierLoc)
722 return 0;
723 }
724
725 CXXRecordDecl *PrevDecl = 0;
726 ClassTemplateDecl *PrevClassTemplate = 0;
727
728 if (!isFriend && Pattern->getPreviousDecl()) {
729 DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
730 if (Found.first != Found.second) {
731 PrevClassTemplate = dyn_cast<ClassTemplateDecl>(*Found.first);
732 if (PrevClassTemplate)
733 PrevDecl = PrevClassTemplate->getTemplatedDecl();
734 }
735 }
736
737 // If this isn't a friend, then it's a member template, in which
738 // case we just want to build the instantiation in the
739 // specialization. If it is a friend, we want to build it in
740 // the appropriate context.
741 DeclContext *DC = Owner;
742 if (isFriend) {
743 if (QualifierLoc) {
744 CXXScopeSpec SS;
745 SS.Adopt(QualifierLoc);
746 DC = SemaRef.computeDeclContext(SS);
747 if (!DC) return 0;
748 } else {
749 DC = SemaRef.FindInstantiatedContext(Pattern->getLocation(),
750 Pattern->getDeclContext(),
751 TemplateArgs);
752 }
753
754 // Look for a previous declaration of the template in the owning
755 // context.
756 LookupResult R(SemaRef, Pattern->getDeclName(), Pattern->getLocation(),
757 Sema::LookupOrdinaryName, Sema::ForRedeclaration);
758 SemaRef.LookupQualifiedName(R, DC);
759
760 if (R.isSingleResult()) {
761 PrevClassTemplate = R.getAsSingle<ClassTemplateDecl>();
762 if (PrevClassTemplate)
763 PrevDecl = PrevClassTemplate->getTemplatedDecl();
764 }
765
766 if (!PrevClassTemplate && QualifierLoc) {
767 SemaRef.Diag(Pattern->getLocation(), diag::err_not_tag_in_scope)
768 << D->getTemplatedDecl()->getTagKind() << Pattern->getDeclName() << DC
769 << QualifierLoc.getSourceRange();
770 return 0;
771 }
772
773 bool AdoptedPreviousTemplateParams = false;
774 if (PrevClassTemplate) {
775 bool Complain = true;
776
777 // HACK: libstdc++ 4.2.1 contains an ill-formed friend class
778 // template for struct std::tr1::__detail::_Map_base, where the
779 // template parameters of the friend declaration don't match the
780 // template parameters of the original declaration. In this one
781 // case, we don't complain about the ill-formed friend
782 // declaration.
783 if (isFriend && Pattern->getIdentifier() &&
784 Pattern->getIdentifier()->isStr("_Map_base") &&
785 DC->isNamespace() &&
786 cast<NamespaceDecl>(DC)->getIdentifier() &&
787 cast<NamespaceDecl>(DC)->getIdentifier()->isStr("__detail")) {
788 DeclContext *DCParent = DC->getParent();
789 if (DCParent->isNamespace() &&
790 cast<NamespaceDecl>(DCParent)->getIdentifier() &&
791 cast<NamespaceDecl>(DCParent)->getIdentifier()->isStr("tr1")) {
792 DeclContext *DCParent2 = DCParent->getParent();
793 if (DCParent2->isNamespace() &&
794 cast<NamespaceDecl>(DCParent2)->getIdentifier() &&
795 cast<NamespaceDecl>(DCParent2)->getIdentifier()->isStr("std") &&
796 DCParent2->getParent()->isTranslationUnit())
797 Complain = false;
798 }
799 }
800
801 TemplateParameterList *PrevParams
802 = PrevClassTemplate->getTemplateParameters();
803
804 // Make sure the parameter lists match.
805 if (!SemaRef.TemplateParameterListsAreEqual(InstParams, PrevParams,
806 Complain,
807 Sema::TPL_TemplateMatch)) {
808 if (Complain)
809 return 0;
810
811 AdoptedPreviousTemplateParams = true;
812 InstParams = PrevParams;
813 }
814
815 // Do some additional validation, then merge default arguments
816 // from the existing declarations.
817 if (!AdoptedPreviousTemplateParams &&
818 SemaRef.CheckTemplateParameterList(InstParams, PrevParams,
819 Sema::TPC_ClassTemplate))
820 return 0;
821 }
822 }
823
824 CXXRecordDecl *RecordInst
825 = CXXRecordDecl::Create(SemaRef.Context, Pattern->getTagKind(), DC,
826 Pattern->getLocStart(), Pattern->getLocation(),
827 Pattern->getIdentifier(), PrevDecl,
828 /*DelayTypeCreation=*/true);
829
830 if (QualifierLoc)
831 RecordInst->setQualifierInfo(QualifierLoc);
832
833 ClassTemplateDecl *Inst
834 = ClassTemplateDecl::Create(SemaRef.Context, DC, D->getLocation(),
835 D->getIdentifier(), InstParams, RecordInst,
836 PrevClassTemplate);
837 RecordInst->setDescribedClassTemplate(Inst);
838
839 if (isFriend) {
840 if (PrevClassTemplate)
841 Inst->setAccess(PrevClassTemplate->getAccess());
842 else
843 Inst->setAccess(D->getAccess());
844
845 Inst->setObjectOfFriendDecl(PrevClassTemplate != 0);
846 // TODO: do we want to track the instantiation progeny of this
847 // friend target decl?
848 } else {
849 Inst->setAccess(D->getAccess());
850 if (!PrevClassTemplate)
851 Inst->setInstantiatedFromMemberTemplate(D);
852 }
853
854 // Trigger creation of the type for the instantiation.
855 SemaRef.Context.getInjectedClassNameType(RecordInst,
856 Inst->getInjectedClassNameSpecialization());
857
858 // Finish handling of friends.
859 if (isFriend) {
860 DC->makeDeclVisibleInContext(Inst);
861 Inst->setLexicalDeclContext(Owner);
862 RecordInst->setLexicalDeclContext(Owner);
863 return Inst;
864 }
865
866 if (D->isOutOfLine()) {
867 Inst->setLexicalDeclContext(D->getLexicalDeclContext());
868 RecordInst->setLexicalDeclContext(D->getLexicalDeclContext());
869 }
870
871 Owner->addDecl(Inst);
872
873 if (!PrevClassTemplate) {
874 // Queue up any out-of-line partial specializations of this member
875 // class template; the client will force their instantiation once
876 // the enclosing class has been instantiated.
877 SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs;
878 D->getPartialSpecializations(PartialSpecs);
879 for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
880 if (PartialSpecs[I]->isOutOfLine())
881 OutOfLinePartialSpecs.push_back(std::make_pair(Inst, PartialSpecs[I]));
882 }
883
884 return Inst;
885 }
886
887 Decl *
VisitClassTemplatePartialSpecializationDecl(ClassTemplatePartialSpecializationDecl * D)888 TemplateDeclInstantiator::VisitClassTemplatePartialSpecializationDecl(
889 ClassTemplatePartialSpecializationDecl *D) {
890 ClassTemplateDecl *ClassTemplate = D->getSpecializedTemplate();
891
892 // Lookup the already-instantiated declaration in the instantiation
893 // of the class template and return that.
894 DeclContext::lookup_result Found
895 = Owner->lookup(ClassTemplate->getDeclName());
896 if (Found.first == Found.second)
897 return 0;
898
899 ClassTemplateDecl *InstClassTemplate
900 = dyn_cast<ClassTemplateDecl>(*Found.first);
901 if (!InstClassTemplate)
902 return 0;
903
904 if (ClassTemplatePartialSpecializationDecl *Result
905 = InstClassTemplate->findPartialSpecInstantiatedFromMember(D))
906 return Result;
907
908 return InstantiateClassTemplatePartialSpecialization(InstClassTemplate, D);
909 }
910
911 Decl *
VisitFunctionTemplateDecl(FunctionTemplateDecl * D)912 TemplateDeclInstantiator::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
913 // Create a local instantiation scope for this function template, which
914 // will contain the instantiations of the template parameters and then get
915 // merged with the local instantiation scope for the function template
916 // itself.
917 LocalInstantiationScope Scope(SemaRef);
918
919 TemplateParameterList *TempParams = D->getTemplateParameters();
920 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
921 if (!InstParams)
922 return NULL;
923
924 FunctionDecl *Instantiated = 0;
925 if (CXXMethodDecl *DMethod = dyn_cast<CXXMethodDecl>(D->getTemplatedDecl()))
926 Instantiated = cast_or_null<FunctionDecl>(VisitCXXMethodDecl(DMethod,
927 InstParams));
928 else
929 Instantiated = cast_or_null<FunctionDecl>(VisitFunctionDecl(
930 D->getTemplatedDecl(),
931 InstParams));
932
933 if (!Instantiated)
934 return 0;
935
936 Instantiated->setAccess(D->getAccess());
937
938 // Link the instantiated function template declaration to the function
939 // template from which it was instantiated.
940 FunctionTemplateDecl *InstTemplate
941 = Instantiated->getDescribedFunctionTemplate();
942 InstTemplate->setAccess(D->getAccess());
943 assert(InstTemplate &&
944 "VisitFunctionDecl/CXXMethodDecl didn't create a template!");
945
946 bool isFriend = (InstTemplate->getFriendObjectKind() != Decl::FOK_None);
947
948 // Link the instantiation back to the pattern *unless* this is a
949 // non-definition friend declaration.
950 if (!InstTemplate->getInstantiatedFromMemberTemplate() &&
951 !(isFriend && !D->getTemplatedDecl()->isThisDeclarationADefinition()))
952 InstTemplate->setInstantiatedFromMemberTemplate(D);
953
954 // Make declarations visible in the appropriate context.
955 if (!isFriend)
956 Owner->addDecl(InstTemplate);
957
958 return InstTemplate;
959 }
960
VisitCXXRecordDecl(CXXRecordDecl * D)961 Decl *TemplateDeclInstantiator::VisitCXXRecordDecl(CXXRecordDecl *D) {
962 CXXRecordDecl *PrevDecl = 0;
963 if (D->isInjectedClassName())
964 PrevDecl = cast<CXXRecordDecl>(Owner);
965 else if (D->getPreviousDecl()) {
966 NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(),
967 D->getPreviousDecl(),
968 TemplateArgs);
969 if (!Prev) return 0;
970 PrevDecl = cast<CXXRecordDecl>(Prev);
971 }
972
973 CXXRecordDecl *Record
974 = CXXRecordDecl::Create(SemaRef.Context, D->getTagKind(), Owner,
975 D->getLocStart(), D->getLocation(),
976 D->getIdentifier(), PrevDecl);
977
978 // Substitute the nested name specifier, if any.
979 if (SubstQualifier(D, Record))
980 return 0;
981
982 Record->setImplicit(D->isImplicit());
983 // FIXME: Check against AS_none is an ugly hack to work around the issue that
984 // the tag decls introduced by friend class declarations don't have an access
985 // specifier. Remove once this area of the code gets sorted out.
986 if (D->getAccess() != AS_none)
987 Record->setAccess(D->getAccess());
988 if (!D->isInjectedClassName())
989 Record->setInstantiationOfMemberClass(D, TSK_ImplicitInstantiation);
990
991 // If the original function was part of a friend declaration,
992 // inherit its namespace state.
993 if (Decl::FriendObjectKind FOK = D->getFriendObjectKind())
994 Record->setObjectOfFriendDecl(FOK == Decl::FOK_Declared);
995
996 // Make sure that anonymous structs and unions are recorded.
997 if (D->isAnonymousStructOrUnion()) {
998 Record->setAnonymousStructOrUnion(true);
999 if (Record->getDeclContext()->getRedeclContext()->isFunctionOrMethod())
1000 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Record);
1001 }
1002
1003 Owner->addDecl(Record);
1004 return Record;
1005 }
1006
1007 /// Normal class members are of more specific types and therefore
1008 /// don't make it here. This function serves two purposes:
1009 /// 1) instantiating function templates
1010 /// 2) substituting friend declarations
1011 /// FIXME: preserve function definitions in case #2
VisitFunctionDecl(FunctionDecl * D,TemplateParameterList * TemplateParams)1012 Decl *TemplateDeclInstantiator::VisitFunctionDecl(FunctionDecl *D,
1013 TemplateParameterList *TemplateParams) {
1014 // Check whether there is already a function template specialization for
1015 // this declaration.
1016 FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate();
1017 if (FunctionTemplate && !TemplateParams) {
1018 std::pair<const TemplateArgument *, unsigned> Innermost
1019 = TemplateArgs.getInnermost();
1020
1021 void *InsertPos = 0;
1022 FunctionDecl *SpecFunc
1023 = FunctionTemplate->findSpecialization(Innermost.first, Innermost.second,
1024 InsertPos);
1025
1026 // If we already have a function template specialization, return it.
1027 if (SpecFunc)
1028 return SpecFunc;
1029 }
1030
1031 bool isFriend;
1032 if (FunctionTemplate)
1033 isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None);
1034 else
1035 isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
1036
1037 bool MergeWithParentScope = (TemplateParams != 0) ||
1038 Owner->isFunctionOrMethod() ||
1039 !(isa<Decl>(Owner) &&
1040 cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
1041 LocalInstantiationScope Scope(SemaRef, MergeWithParentScope);
1042
1043 SmallVector<ParmVarDecl *, 4> Params;
1044 TypeSourceInfo *TInfo = SubstFunctionType(D, Params);
1045 if (!TInfo)
1046 return 0;
1047 QualType T = TInfo->getType();
1048
1049 NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
1050 if (QualifierLoc) {
1051 QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
1052 TemplateArgs);
1053 if (!QualifierLoc)
1054 return 0;
1055 }
1056
1057 // If we're instantiating a local function declaration, put the result
1058 // in the owner; otherwise we need to find the instantiated context.
1059 DeclContext *DC;
1060 if (D->getDeclContext()->isFunctionOrMethod())
1061 DC = Owner;
1062 else if (isFriend && QualifierLoc) {
1063 CXXScopeSpec SS;
1064 SS.Adopt(QualifierLoc);
1065 DC = SemaRef.computeDeclContext(SS);
1066 if (!DC) return 0;
1067 } else {
1068 DC = SemaRef.FindInstantiatedContext(D->getLocation(), D->getDeclContext(),
1069 TemplateArgs);
1070 }
1071
1072 FunctionDecl *Function =
1073 FunctionDecl::Create(SemaRef.Context, DC, D->getInnerLocStart(),
1074 D->getLocation(), D->getDeclName(), T, TInfo,
1075 D->getStorageClass(), D->getStorageClassAsWritten(),
1076 D->isInlineSpecified(), D->hasWrittenPrototype(),
1077 D->isConstexpr());
1078
1079 if (QualifierLoc)
1080 Function->setQualifierInfo(QualifierLoc);
1081
1082 DeclContext *LexicalDC = Owner;
1083 if (!isFriend && D->isOutOfLine()) {
1084 assert(D->getDeclContext()->isFileContext());
1085 LexicalDC = D->getDeclContext();
1086 }
1087
1088 Function->setLexicalDeclContext(LexicalDC);
1089
1090 // Attach the parameters
1091 if (isa<FunctionProtoType>(Function->getType().IgnoreParens())) {
1092 // Adopt the already-instantiated parameters into our own context.
1093 for (unsigned P = 0; P < Params.size(); ++P)
1094 if (Params[P])
1095 Params[P]->setOwningFunction(Function);
1096 } else {
1097 // Since we were instantiated via a typedef of a function type, create
1098 // new parameters.
1099 const FunctionProtoType *Proto
1100 = Function->getType()->getAs<FunctionProtoType>();
1101 assert(Proto && "No function prototype in template instantiation?");
1102 for (FunctionProtoType::arg_type_iterator AI = Proto->arg_type_begin(),
1103 AE = Proto->arg_type_end(); AI != AE; ++AI) {
1104 ParmVarDecl *Param
1105 = SemaRef.BuildParmVarDeclForTypedef(Function, Function->getLocation(),
1106 *AI);
1107 Param->setScopeInfo(0, Params.size());
1108 Params.push_back(Param);
1109 }
1110 }
1111 Function->setParams(Params);
1112
1113 SourceLocation InstantiateAtPOI;
1114 if (TemplateParams) {
1115 // Our resulting instantiation is actually a function template, since we
1116 // are substituting only the outer template parameters. For example, given
1117 //
1118 // template<typename T>
1119 // struct X {
1120 // template<typename U> friend void f(T, U);
1121 // };
1122 //
1123 // X<int> x;
1124 //
1125 // We are instantiating the friend function template "f" within X<int>,
1126 // which means substituting int for T, but leaving "f" as a friend function
1127 // template.
1128 // Build the function template itself.
1129 FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, DC,
1130 Function->getLocation(),
1131 Function->getDeclName(),
1132 TemplateParams, Function);
1133 Function->setDescribedFunctionTemplate(FunctionTemplate);
1134
1135 FunctionTemplate->setLexicalDeclContext(LexicalDC);
1136
1137 if (isFriend && D->isThisDeclarationADefinition()) {
1138 // TODO: should we remember this connection regardless of whether
1139 // the friend declaration provided a body?
1140 FunctionTemplate->setInstantiatedFromMemberTemplate(
1141 D->getDescribedFunctionTemplate());
1142 }
1143 } else if (FunctionTemplate) {
1144 // Record this function template specialization.
1145 std::pair<const TemplateArgument *, unsigned> Innermost
1146 = TemplateArgs.getInnermost();
1147 Function->setFunctionTemplateSpecialization(FunctionTemplate,
1148 TemplateArgumentList::CreateCopy(SemaRef.Context,
1149 Innermost.first,
1150 Innermost.second),
1151 /*InsertPos=*/0);
1152 } else if (isFriend) {
1153 // Note, we need this connection even if the friend doesn't have a body.
1154 // Its body may exist but not have been attached yet due to deferred
1155 // parsing.
1156 // FIXME: It might be cleaner to set this when attaching the body to the
1157 // friend function declaration, however that would require finding all the
1158 // instantiations and modifying them.
1159 Function->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation);
1160 }
1161
1162 if (InitFunctionInstantiation(Function, D))
1163 Function->setInvalidDecl();
1164
1165 bool isExplicitSpecialization = false;
1166
1167 LookupResult Previous(SemaRef, Function->getDeclName(), SourceLocation(),
1168 Sema::LookupOrdinaryName, Sema::ForRedeclaration);
1169
1170 if (DependentFunctionTemplateSpecializationInfo *Info
1171 = D->getDependentSpecializationInfo()) {
1172 assert(isFriend && "non-friend has dependent specialization info?");
1173
1174 // This needs to be set now for future sanity.
1175 Function->setObjectOfFriendDecl(/*HasPrevious*/ true);
1176
1177 // Instantiate the explicit template arguments.
1178 TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(),
1179 Info->getRAngleLoc());
1180 if (SemaRef.Subst(Info->getTemplateArgs(), Info->getNumTemplateArgs(),
1181 ExplicitArgs, TemplateArgs))
1182 return 0;
1183
1184 // Map the candidate templates to their instantiations.
1185 for (unsigned I = 0, E = Info->getNumTemplates(); I != E; ++I) {
1186 Decl *Temp = SemaRef.FindInstantiatedDecl(D->getLocation(),
1187 Info->getTemplate(I),
1188 TemplateArgs);
1189 if (!Temp) return 0;
1190
1191 Previous.addDecl(cast<FunctionTemplateDecl>(Temp));
1192 }
1193
1194 if (SemaRef.CheckFunctionTemplateSpecialization(Function,
1195 &ExplicitArgs,
1196 Previous))
1197 Function->setInvalidDecl();
1198
1199 isExplicitSpecialization = true;
1200
1201 } else if (TemplateParams || !FunctionTemplate) {
1202 // Look only into the namespace where the friend would be declared to
1203 // find a previous declaration. This is the innermost enclosing namespace,
1204 // as described in ActOnFriendFunctionDecl.
1205 SemaRef.LookupQualifiedName(Previous, DC);
1206
1207 // In C++, the previous declaration we find might be a tag type
1208 // (class or enum). In this case, the new declaration will hide the
1209 // tag type. Note that this does does not apply if we're declaring a
1210 // typedef (C++ [dcl.typedef]p4).
1211 if (Previous.isSingleTagDecl())
1212 Previous.clear();
1213 }
1214
1215 SemaRef.CheckFunctionDeclaration(/*Scope*/ 0, Function, Previous,
1216 isExplicitSpecialization);
1217
1218 NamedDecl *PrincipalDecl = (TemplateParams
1219 ? cast<NamedDecl>(FunctionTemplate)
1220 : Function);
1221
1222 // If the original function was part of a friend declaration,
1223 // inherit its namespace state and add it to the owner.
1224 if (isFriend) {
1225 NamedDecl *PrevDecl;
1226 if (TemplateParams)
1227 PrevDecl = FunctionTemplate->getPreviousDecl();
1228 else
1229 PrevDecl = Function->getPreviousDecl();
1230
1231 PrincipalDecl->setObjectOfFriendDecl(PrevDecl != 0);
1232 DC->makeDeclVisibleInContext(PrincipalDecl);
1233
1234 bool queuedInstantiation = false;
1235
1236 // C++98 [temp.friend]p5: When a function is defined in a friend function
1237 // declaration in a class template, the function is defined at each
1238 // instantiation of the class template. The function is defined even if it
1239 // is never used.
1240 // C++11 [temp.friend]p4: When a function is defined in a friend function
1241 // declaration in a class template, the function is instantiated when the
1242 // function is odr-used.
1243 //
1244 // If -Wc++98-compat is enabled, we go through the motions of checking for a
1245 // redefinition, but don't instantiate the function.
1246 if ((!SemaRef.getLangOpts().CPlusPlus0x ||
1247 SemaRef.Diags.getDiagnosticLevel(
1248 diag::warn_cxx98_compat_friend_redefinition,
1249 Function->getLocation())
1250 != DiagnosticsEngine::Ignored) &&
1251 D->isThisDeclarationADefinition()) {
1252 // Check for a function body.
1253 const FunctionDecl *Definition = 0;
1254 if (Function->isDefined(Definition) &&
1255 Definition->getTemplateSpecializationKind() == TSK_Undeclared) {
1256 SemaRef.Diag(Function->getLocation(),
1257 SemaRef.getLangOpts().CPlusPlus0x ?
1258 diag::warn_cxx98_compat_friend_redefinition :
1259 diag::err_redefinition) << Function->getDeclName();
1260 SemaRef.Diag(Definition->getLocation(), diag::note_previous_definition);
1261 if (!SemaRef.getLangOpts().CPlusPlus0x)
1262 Function->setInvalidDecl();
1263 }
1264 // Check for redefinitions due to other instantiations of this or
1265 // a similar friend function.
1266 else for (FunctionDecl::redecl_iterator R = Function->redecls_begin(),
1267 REnd = Function->redecls_end();
1268 R != REnd; ++R) {
1269 if (*R == Function)
1270 continue;
1271 switch (R->getFriendObjectKind()) {
1272 case Decl::FOK_None:
1273 if (!SemaRef.getLangOpts().CPlusPlus0x &&
1274 !queuedInstantiation && R->isUsed(false)) {
1275 if (MemberSpecializationInfo *MSInfo
1276 = Function->getMemberSpecializationInfo()) {
1277 if (MSInfo->getPointOfInstantiation().isInvalid()) {
1278 SourceLocation Loc = R->getLocation(); // FIXME
1279 MSInfo->setPointOfInstantiation(Loc);
1280 SemaRef.PendingLocalImplicitInstantiations.push_back(
1281 std::make_pair(Function, Loc));
1282 queuedInstantiation = true;
1283 }
1284 }
1285 }
1286 break;
1287 default:
1288 if (const FunctionDecl *RPattern
1289 = R->getTemplateInstantiationPattern())
1290 if (RPattern->isDefined(RPattern)) {
1291 SemaRef.Diag(Function->getLocation(),
1292 SemaRef.getLangOpts().CPlusPlus0x ?
1293 diag::warn_cxx98_compat_friend_redefinition :
1294 diag::err_redefinition)
1295 << Function->getDeclName();
1296 SemaRef.Diag(R->getLocation(), diag::note_previous_definition);
1297 if (!SemaRef.getLangOpts().CPlusPlus0x)
1298 Function->setInvalidDecl();
1299 break;
1300 }
1301 }
1302 }
1303 }
1304 }
1305
1306 if (Function->isOverloadedOperator() && !DC->isRecord() &&
1307 PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
1308 PrincipalDecl->setNonMemberOperator();
1309
1310 assert(!D->isDefaulted() && "only methods should be defaulted");
1311 return Function;
1312 }
1313
1314 Decl *
VisitCXXMethodDecl(CXXMethodDecl * D,TemplateParameterList * TemplateParams,bool IsClassScopeSpecialization)1315 TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D,
1316 TemplateParameterList *TemplateParams,
1317 bool IsClassScopeSpecialization) {
1318 FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate();
1319 if (FunctionTemplate && !TemplateParams) {
1320 // We are creating a function template specialization from a function
1321 // template. Check whether there is already a function template
1322 // specialization for this particular set of template arguments.
1323 std::pair<const TemplateArgument *, unsigned> Innermost
1324 = TemplateArgs.getInnermost();
1325
1326 void *InsertPos = 0;
1327 FunctionDecl *SpecFunc
1328 = FunctionTemplate->findSpecialization(Innermost.first, Innermost.second,
1329 InsertPos);
1330
1331 // If we already have a function template specialization, return it.
1332 if (SpecFunc)
1333 return SpecFunc;
1334 }
1335
1336 bool isFriend;
1337 if (FunctionTemplate)
1338 isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None);
1339 else
1340 isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
1341
1342 bool MergeWithParentScope = (TemplateParams != 0) ||
1343 !(isa<Decl>(Owner) &&
1344 cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
1345 LocalInstantiationScope Scope(SemaRef, MergeWithParentScope);
1346
1347 // Instantiate enclosing template arguments for friends.
1348 SmallVector<TemplateParameterList *, 4> TempParamLists;
1349 unsigned NumTempParamLists = 0;
1350 if (isFriend && (NumTempParamLists = D->getNumTemplateParameterLists())) {
1351 TempParamLists.set_size(NumTempParamLists);
1352 for (unsigned I = 0; I != NumTempParamLists; ++I) {
1353 TemplateParameterList *TempParams = D->getTemplateParameterList(I);
1354 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
1355 if (!InstParams)
1356 return NULL;
1357 TempParamLists[I] = InstParams;
1358 }
1359 }
1360
1361 SmallVector<ParmVarDecl *, 4> Params;
1362 TypeSourceInfo *TInfo = SubstFunctionType(D, Params);
1363 if (!TInfo)
1364 return 0;
1365 QualType T = TInfo->getType();
1366
1367 // \brief If the type of this function, after ignoring parentheses,
1368 // is not *directly* a function type, then we're instantiating a function
1369 // that was declared via a typedef, e.g.,
1370 //
1371 // typedef int functype(int, int);
1372 // functype func;
1373 //
1374 // In this case, we'll just go instantiate the ParmVarDecls that we
1375 // synthesized in the method declaration.
1376 if (!isa<FunctionProtoType>(T.IgnoreParens())) {
1377 assert(!Params.size() && "Instantiating type could not yield parameters");
1378 SmallVector<QualType, 4> ParamTypes;
1379 if (SemaRef.SubstParmTypes(D->getLocation(), D->param_begin(),
1380 D->getNumParams(), TemplateArgs, ParamTypes,
1381 &Params))
1382 return 0;
1383 }
1384
1385 NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
1386 if (QualifierLoc) {
1387 QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
1388 TemplateArgs);
1389 if (!QualifierLoc)
1390 return 0;
1391 }
1392
1393 DeclContext *DC = Owner;
1394 if (isFriend) {
1395 if (QualifierLoc) {
1396 CXXScopeSpec SS;
1397 SS.Adopt(QualifierLoc);
1398 DC = SemaRef.computeDeclContext(SS);
1399
1400 if (DC && SemaRef.RequireCompleteDeclContext(SS, DC))
1401 return 0;
1402 } else {
1403 DC = SemaRef.FindInstantiatedContext(D->getLocation(),
1404 D->getDeclContext(),
1405 TemplateArgs);
1406 }
1407 if (!DC) return 0;
1408 }
1409
1410 // Build the instantiated method declaration.
1411 CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
1412 CXXMethodDecl *Method = 0;
1413
1414 SourceLocation StartLoc = D->getInnerLocStart();
1415 DeclarationNameInfo NameInfo
1416 = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
1417 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
1418 Method = CXXConstructorDecl::Create(SemaRef.Context, Record,
1419 StartLoc, NameInfo, T, TInfo,
1420 Constructor->isExplicit(),
1421 Constructor->isInlineSpecified(),
1422 false, Constructor->isConstexpr());
1423 } else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(D)) {
1424 Method = CXXDestructorDecl::Create(SemaRef.Context, Record,
1425 StartLoc, NameInfo, T, TInfo,
1426 Destructor->isInlineSpecified(),
1427 false);
1428 } else if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) {
1429 Method = CXXConversionDecl::Create(SemaRef.Context, Record,
1430 StartLoc, NameInfo, T, TInfo,
1431 Conversion->isInlineSpecified(),
1432 Conversion->isExplicit(),
1433 Conversion->isConstexpr(),
1434 Conversion->getLocEnd());
1435 } else {
1436 Method = CXXMethodDecl::Create(SemaRef.Context, Record,
1437 StartLoc, NameInfo, T, TInfo,
1438 D->isStatic(),
1439 D->getStorageClassAsWritten(),
1440 D->isInlineSpecified(),
1441 D->isConstexpr(), D->getLocEnd());
1442 }
1443
1444 if (QualifierLoc)
1445 Method->setQualifierInfo(QualifierLoc);
1446
1447 if (TemplateParams) {
1448 // Our resulting instantiation is actually a function template, since we
1449 // are substituting only the outer template parameters. For example, given
1450 //
1451 // template<typename T>
1452 // struct X {
1453 // template<typename U> void f(T, U);
1454 // };
1455 //
1456 // X<int> x;
1457 //
1458 // We are instantiating the member template "f" within X<int>, which means
1459 // substituting int for T, but leaving "f" as a member function template.
1460 // Build the function template itself.
1461 FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, Record,
1462 Method->getLocation(),
1463 Method->getDeclName(),
1464 TemplateParams, Method);
1465 if (isFriend) {
1466 FunctionTemplate->setLexicalDeclContext(Owner);
1467 FunctionTemplate->setObjectOfFriendDecl(true);
1468 } else if (D->isOutOfLine())
1469 FunctionTemplate->setLexicalDeclContext(D->getLexicalDeclContext());
1470 Method->setDescribedFunctionTemplate(FunctionTemplate);
1471 } else if (FunctionTemplate) {
1472 // Record this function template specialization.
1473 std::pair<const TemplateArgument *, unsigned> Innermost
1474 = TemplateArgs.getInnermost();
1475 Method->setFunctionTemplateSpecialization(FunctionTemplate,
1476 TemplateArgumentList::CreateCopy(SemaRef.Context,
1477 Innermost.first,
1478 Innermost.second),
1479 /*InsertPos=*/0);
1480 } else if (!isFriend) {
1481 // Record that this is an instantiation of a member function.
1482 Method->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation);
1483 }
1484
1485 // If we are instantiating a member function defined
1486 // out-of-line, the instantiation will have the same lexical
1487 // context (which will be a namespace scope) as the template.
1488 if (isFriend) {
1489 if (NumTempParamLists)
1490 Method->setTemplateParameterListsInfo(SemaRef.Context,
1491 NumTempParamLists,
1492 TempParamLists.data());
1493
1494 Method->setLexicalDeclContext(Owner);
1495 Method->setObjectOfFriendDecl(true);
1496 } else if (D->isOutOfLine())
1497 Method->setLexicalDeclContext(D->getLexicalDeclContext());
1498
1499 // Attach the parameters
1500 for (unsigned P = 0; P < Params.size(); ++P)
1501 Params[P]->setOwningFunction(Method);
1502 Method->setParams(Params);
1503
1504 if (InitMethodInstantiation(Method, D))
1505 Method->setInvalidDecl();
1506
1507 LookupResult Previous(SemaRef, NameInfo, Sema::LookupOrdinaryName,
1508 Sema::ForRedeclaration);
1509
1510 if (!FunctionTemplate || TemplateParams || isFriend) {
1511 SemaRef.LookupQualifiedName(Previous, Record);
1512
1513 // In C++, the previous declaration we find might be a tag type
1514 // (class or enum). In this case, the new declaration will hide the
1515 // tag type. Note that this does does not apply if we're declaring a
1516 // typedef (C++ [dcl.typedef]p4).
1517 if (Previous.isSingleTagDecl())
1518 Previous.clear();
1519 }
1520
1521 if (!IsClassScopeSpecialization)
1522 SemaRef.CheckFunctionDeclaration(0, Method, Previous, false);
1523
1524 if (D->isPure())
1525 SemaRef.CheckPureMethod(Method, SourceRange());
1526
1527 Method->setAccess(D->getAccess());
1528
1529 SemaRef.CheckOverrideControl(Method);
1530
1531 // If a function is defined as defaulted or deleted, mark it as such now.
1532 if (D->isDefaulted())
1533 Method->setDefaulted();
1534 if (D->isDeletedAsWritten())
1535 Method->setDeletedAsWritten();
1536
1537 if (FunctionTemplate) {
1538 // If there's a function template, let our caller handle it.
1539 } else if (Method->isInvalidDecl() && !Previous.empty()) {
1540 // Don't hide a (potentially) valid declaration with an invalid one.
1541 } else {
1542 NamedDecl *DeclToAdd = (TemplateParams
1543 ? cast<NamedDecl>(FunctionTemplate)
1544 : Method);
1545 if (isFriend)
1546 Record->makeDeclVisibleInContext(DeclToAdd);
1547 else if (!IsClassScopeSpecialization)
1548 Owner->addDecl(DeclToAdd);
1549 }
1550
1551 if (D->isExplicitlyDefaulted()) {
1552 SemaRef.SetDeclDefaulted(Method, Method->getLocation());
1553 } else {
1554 assert(!D->isDefaulted() &&
1555 "should not implicitly default uninstantiated function");
1556 }
1557
1558 return Method;
1559 }
1560
VisitCXXConstructorDecl(CXXConstructorDecl * D)1561 Decl *TemplateDeclInstantiator::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
1562 return VisitCXXMethodDecl(D);
1563 }
1564
VisitCXXDestructorDecl(CXXDestructorDecl * D)1565 Decl *TemplateDeclInstantiator::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
1566 return VisitCXXMethodDecl(D);
1567 }
1568
VisitCXXConversionDecl(CXXConversionDecl * D)1569 Decl *TemplateDeclInstantiator::VisitCXXConversionDecl(CXXConversionDecl *D) {
1570 return VisitCXXMethodDecl(D);
1571 }
1572
VisitParmVarDecl(ParmVarDecl * D)1573 ParmVarDecl *TemplateDeclInstantiator::VisitParmVarDecl(ParmVarDecl *D) {
1574 return SemaRef.SubstParmVarDecl(D, TemplateArgs, /*indexAdjustment*/ 0,
1575 llvm::Optional<unsigned>(),
1576 /*ExpectParameterPack=*/false);
1577 }
1578
VisitTemplateTypeParmDecl(TemplateTypeParmDecl * D)1579 Decl *TemplateDeclInstantiator::VisitTemplateTypeParmDecl(
1580 TemplateTypeParmDecl *D) {
1581 // TODO: don't always clone when decls are refcounted.
1582 assert(D->getTypeForDecl()->isTemplateTypeParmType());
1583
1584 TemplateTypeParmDecl *Inst =
1585 TemplateTypeParmDecl::Create(SemaRef.Context, Owner,
1586 D->getLocStart(), D->getLocation(),
1587 D->getDepth() - TemplateArgs.getNumLevels(),
1588 D->getIndex(), D->getIdentifier(),
1589 D->wasDeclaredWithTypename(),
1590 D->isParameterPack());
1591 Inst->setAccess(AS_public);
1592
1593 if (D->hasDefaultArgument())
1594 Inst->setDefaultArgument(D->getDefaultArgumentInfo(), false);
1595
1596 // Introduce this template parameter's instantiation into the instantiation
1597 // scope.
1598 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Inst);
1599
1600 return Inst;
1601 }
1602
VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl * D)1603 Decl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl(
1604 NonTypeTemplateParmDecl *D) {
1605 // Substitute into the type of the non-type template parameter.
1606 TypeLoc TL = D->getTypeSourceInfo()->getTypeLoc();
1607 SmallVector<TypeSourceInfo *, 4> ExpandedParameterPackTypesAsWritten;
1608 SmallVector<QualType, 4> ExpandedParameterPackTypes;
1609 bool IsExpandedParameterPack = false;
1610 TypeSourceInfo *DI;
1611 QualType T;
1612 bool Invalid = false;
1613
1614 if (D->isExpandedParameterPack()) {
1615 // The non-type template parameter pack is an already-expanded pack
1616 // expansion of types. Substitute into each of the expanded types.
1617 ExpandedParameterPackTypes.reserve(D->getNumExpansionTypes());
1618 ExpandedParameterPackTypesAsWritten.reserve(D->getNumExpansionTypes());
1619 for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
1620 TypeSourceInfo *NewDI =SemaRef.SubstType(D->getExpansionTypeSourceInfo(I),
1621 TemplateArgs,
1622 D->getLocation(),
1623 D->getDeclName());
1624 if (!NewDI)
1625 return 0;
1626
1627 ExpandedParameterPackTypesAsWritten.push_back(NewDI);
1628 QualType NewT =SemaRef.CheckNonTypeTemplateParameterType(NewDI->getType(),
1629 D->getLocation());
1630 if (NewT.isNull())
1631 return 0;
1632 ExpandedParameterPackTypes.push_back(NewT);
1633 }
1634
1635 IsExpandedParameterPack = true;
1636 DI = D->getTypeSourceInfo();
1637 T = DI->getType();
1638 } else if (isa<PackExpansionTypeLoc>(TL)) {
1639 // The non-type template parameter pack's type is a pack expansion of types.
1640 // Determine whether we need to expand this parameter pack into separate
1641 // types.
1642 PackExpansionTypeLoc Expansion = cast<PackExpansionTypeLoc>(TL);
1643 TypeLoc Pattern = Expansion.getPatternLoc();
1644 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
1645 SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded);
1646
1647 // Determine whether the set of unexpanded parameter packs can and should
1648 // be expanded.
1649 bool Expand = true;
1650 bool RetainExpansion = false;
1651 llvm::Optional<unsigned> OrigNumExpansions
1652 = Expansion.getTypePtr()->getNumExpansions();
1653 llvm::Optional<unsigned> NumExpansions = OrigNumExpansions;
1654 if (SemaRef.CheckParameterPacksForExpansion(Expansion.getEllipsisLoc(),
1655 Pattern.getSourceRange(),
1656 Unexpanded,
1657 TemplateArgs,
1658 Expand, RetainExpansion,
1659 NumExpansions))
1660 return 0;
1661
1662 if (Expand) {
1663 for (unsigned I = 0; I != *NumExpansions; ++I) {
1664 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
1665 TypeSourceInfo *NewDI = SemaRef.SubstType(Pattern, TemplateArgs,
1666 D->getLocation(),
1667 D->getDeclName());
1668 if (!NewDI)
1669 return 0;
1670
1671 ExpandedParameterPackTypesAsWritten.push_back(NewDI);
1672 QualType NewT = SemaRef.CheckNonTypeTemplateParameterType(
1673 NewDI->getType(),
1674 D->getLocation());
1675 if (NewT.isNull())
1676 return 0;
1677 ExpandedParameterPackTypes.push_back(NewT);
1678 }
1679
1680 // Note that we have an expanded parameter pack. The "type" of this
1681 // expanded parameter pack is the original expansion type, but callers
1682 // will end up using the expanded parameter pack types for type-checking.
1683 IsExpandedParameterPack = true;
1684 DI = D->getTypeSourceInfo();
1685 T = DI->getType();
1686 } else {
1687 // We cannot fully expand the pack expansion now, so substitute into the
1688 // pattern and create a new pack expansion type.
1689 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
1690 TypeSourceInfo *NewPattern = SemaRef.SubstType(Pattern, TemplateArgs,
1691 D->getLocation(),
1692 D->getDeclName());
1693 if (!NewPattern)
1694 return 0;
1695
1696 DI = SemaRef.CheckPackExpansion(NewPattern, Expansion.getEllipsisLoc(),
1697 NumExpansions);
1698 if (!DI)
1699 return 0;
1700
1701 T = DI->getType();
1702 }
1703 } else {
1704 // Simple case: substitution into a parameter that is not a parameter pack.
1705 DI = SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs,
1706 D->getLocation(), D->getDeclName());
1707 if (!DI)
1708 return 0;
1709
1710 // Check that this type is acceptable for a non-type template parameter.
1711 T = SemaRef.CheckNonTypeTemplateParameterType(DI->getType(),
1712 D->getLocation());
1713 if (T.isNull()) {
1714 T = SemaRef.Context.IntTy;
1715 Invalid = true;
1716 }
1717 }
1718
1719 NonTypeTemplateParmDecl *Param;
1720 if (IsExpandedParameterPack)
1721 Param = NonTypeTemplateParmDecl::Create(SemaRef.Context, Owner,
1722 D->getInnerLocStart(),
1723 D->getLocation(),
1724 D->getDepth() - TemplateArgs.getNumLevels(),
1725 D->getPosition(),
1726 D->getIdentifier(), T,
1727 DI,
1728 ExpandedParameterPackTypes.data(),
1729 ExpandedParameterPackTypes.size(),
1730 ExpandedParameterPackTypesAsWritten.data());
1731 else
1732 Param = NonTypeTemplateParmDecl::Create(SemaRef.Context, Owner,
1733 D->getInnerLocStart(),
1734 D->getLocation(),
1735 D->getDepth() - TemplateArgs.getNumLevels(),
1736 D->getPosition(),
1737 D->getIdentifier(), T,
1738 D->isParameterPack(), DI);
1739
1740 Param->setAccess(AS_public);
1741 if (Invalid)
1742 Param->setInvalidDecl();
1743
1744 Param->setDefaultArgument(D->getDefaultArgument(), false);
1745
1746 // Introduce this template parameter's instantiation into the instantiation
1747 // scope.
1748 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);
1749 return Param;
1750 }
1751
1752 Decl *
VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl * D)1753 TemplateDeclInstantiator::VisitTemplateTemplateParmDecl(
1754 TemplateTemplateParmDecl *D) {
1755 // Instantiate the template parameter list of the template template parameter.
1756 TemplateParameterList *TempParams = D->getTemplateParameters();
1757 TemplateParameterList *InstParams;
1758 {
1759 // Perform the actual substitution of template parameters within a new,
1760 // local instantiation scope.
1761 LocalInstantiationScope Scope(SemaRef);
1762 InstParams = SubstTemplateParams(TempParams);
1763 if (!InstParams)
1764 return NULL;
1765 }
1766
1767 // Build the template template parameter.
1768 TemplateTemplateParmDecl *Param
1769 = TemplateTemplateParmDecl::Create(SemaRef.Context, Owner, D->getLocation(),
1770 D->getDepth() - TemplateArgs.getNumLevels(),
1771 D->getPosition(), D->isParameterPack(),
1772 D->getIdentifier(), InstParams);
1773 Param->setDefaultArgument(D->getDefaultArgument(), false);
1774 Param->setAccess(AS_public);
1775
1776 // Introduce this template parameter's instantiation into the instantiation
1777 // scope.
1778 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);
1779
1780 return Param;
1781 }
1782
VisitUsingDirectiveDecl(UsingDirectiveDecl * D)1783 Decl *TemplateDeclInstantiator::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
1784 // Using directives are never dependent (and never contain any types or
1785 // expressions), so they require no explicit instantiation work.
1786
1787 UsingDirectiveDecl *Inst
1788 = UsingDirectiveDecl::Create(SemaRef.Context, Owner, D->getLocation(),
1789 D->getNamespaceKeyLocation(),
1790 D->getQualifierLoc(),
1791 D->getIdentLocation(),
1792 D->getNominatedNamespace(),
1793 D->getCommonAncestor());
1794 Owner->addDecl(Inst);
1795 return Inst;
1796 }
1797
VisitUsingDecl(UsingDecl * D)1798 Decl *TemplateDeclInstantiator::VisitUsingDecl(UsingDecl *D) {
1799
1800 // The nested name specifier may be dependent, for example
1801 // template <typename T> struct t {
1802 // struct s1 { T f1(); };
1803 // struct s2 : s1 { using s1::f1; };
1804 // };
1805 // template struct t<int>;
1806 // Here, in using s1::f1, s1 refers to t<T>::s1;
1807 // we need to substitute for t<int>::s1.
1808 NestedNameSpecifierLoc QualifierLoc
1809 = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(),
1810 TemplateArgs);
1811 if (!QualifierLoc)
1812 return 0;
1813
1814 // The name info is non-dependent, so no transformation
1815 // is required.
1816 DeclarationNameInfo NameInfo = D->getNameInfo();
1817
1818 // We only need to do redeclaration lookups if we're in a class
1819 // scope (in fact, it's not really even possible in non-class
1820 // scopes).
1821 bool CheckRedeclaration = Owner->isRecord();
1822
1823 LookupResult Prev(SemaRef, NameInfo, Sema::LookupUsingDeclName,
1824 Sema::ForRedeclaration);
1825
1826 UsingDecl *NewUD = UsingDecl::Create(SemaRef.Context, Owner,
1827 D->getUsingLocation(),
1828 QualifierLoc,
1829 NameInfo,
1830 D->isTypeName());
1831
1832 CXXScopeSpec SS;
1833 SS.Adopt(QualifierLoc);
1834 if (CheckRedeclaration) {
1835 Prev.setHideTags(false);
1836 SemaRef.LookupQualifiedName(Prev, Owner);
1837
1838 // Check for invalid redeclarations.
1839 if (SemaRef.CheckUsingDeclRedeclaration(D->getUsingLocation(),
1840 D->isTypeName(), SS,
1841 D->getLocation(), Prev))
1842 NewUD->setInvalidDecl();
1843
1844 }
1845
1846 if (!NewUD->isInvalidDecl() &&
1847 SemaRef.CheckUsingDeclQualifier(D->getUsingLocation(), SS,
1848 D->getLocation()))
1849 NewUD->setInvalidDecl();
1850
1851 SemaRef.Context.setInstantiatedFromUsingDecl(NewUD, D);
1852 NewUD->setAccess(D->getAccess());
1853 Owner->addDecl(NewUD);
1854
1855 // Don't process the shadow decls for an invalid decl.
1856 if (NewUD->isInvalidDecl())
1857 return NewUD;
1858
1859 if (NameInfo.getName().getNameKind() == DeclarationName::CXXConstructorName) {
1860 if (SemaRef.CheckInheritingConstructorUsingDecl(NewUD))
1861 NewUD->setInvalidDecl();
1862 return NewUD;
1863 }
1864
1865 bool isFunctionScope = Owner->isFunctionOrMethod();
1866
1867 // Process the shadow decls.
1868 for (UsingDecl::shadow_iterator I = D->shadow_begin(), E = D->shadow_end();
1869 I != E; ++I) {
1870 UsingShadowDecl *Shadow = *I;
1871 NamedDecl *InstTarget =
1872 cast_or_null<NamedDecl>(SemaRef.FindInstantiatedDecl(
1873 Shadow->getLocation(),
1874 Shadow->getTargetDecl(),
1875 TemplateArgs));
1876 if (!InstTarget)
1877 return 0;
1878
1879 if (CheckRedeclaration &&
1880 SemaRef.CheckUsingShadowDecl(NewUD, InstTarget, Prev))
1881 continue;
1882
1883 UsingShadowDecl *InstShadow
1884 = SemaRef.BuildUsingShadowDecl(/*Scope*/ 0, NewUD, InstTarget);
1885 SemaRef.Context.setInstantiatedFromUsingShadowDecl(InstShadow, Shadow);
1886
1887 if (isFunctionScope)
1888 SemaRef.CurrentInstantiationScope->InstantiatedLocal(Shadow, InstShadow);
1889 }
1890
1891 return NewUD;
1892 }
1893
VisitUsingShadowDecl(UsingShadowDecl * D)1894 Decl *TemplateDeclInstantiator::VisitUsingShadowDecl(UsingShadowDecl *D) {
1895 // Ignore these; we handle them in bulk when processing the UsingDecl.
1896 return 0;
1897 }
1898
1899 Decl * TemplateDeclInstantiator
VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl * D)1900 ::VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D) {
1901 NestedNameSpecifierLoc QualifierLoc
1902 = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(),
1903 TemplateArgs);
1904 if (!QualifierLoc)
1905 return 0;
1906
1907 CXXScopeSpec SS;
1908 SS.Adopt(QualifierLoc);
1909
1910 // Since NameInfo refers to a typename, it cannot be a C++ special name.
1911 // Hence, no tranformation is required for it.
1912 DeclarationNameInfo NameInfo(D->getDeclName(), D->getLocation());
1913 NamedDecl *UD =
1914 SemaRef.BuildUsingDeclaration(/*Scope*/ 0, D->getAccess(),
1915 D->getUsingLoc(), SS, NameInfo, 0,
1916 /*instantiation*/ true,
1917 /*typename*/ true, D->getTypenameLoc());
1918 if (UD)
1919 SemaRef.Context.setInstantiatedFromUsingDecl(cast<UsingDecl>(UD), D);
1920
1921 return UD;
1922 }
1923
1924 Decl * TemplateDeclInstantiator
VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl * D)1925 ::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
1926 NestedNameSpecifierLoc QualifierLoc
1927 = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(), TemplateArgs);
1928 if (!QualifierLoc)
1929 return 0;
1930
1931 CXXScopeSpec SS;
1932 SS.Adopt(QualifierLoc);
1933
1934 DeclarationNameInfo NameInfo
1935 = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
1936
1937 NamedDecl *UD =
1938 SemaRef.BuildUsingDeclaration(/*Scope*/ 0, D->getAccess(),
1939 D->getUsingLoc(), SS, NameInfo, 0,
1940 /*instantiation*/ true,
1941 /*typename*/ false, SourceLocation());
1942 if (UD)
1943 SemaRef.Context.setInstantiatedFromUsingDecl(cast<UsingDecl>(UD), D);
1944
1945 return UD;
1946 }
1947
1948
VisitClassScopeFunctionSpecializationDecl(ClassScopeFunctionSpecializationDecl * Decl)1949 Decl *TemplateDeclInstantiator::VisitClassScopeFunctionSpecializationDecl(
1950 ClassScopeFunctionSpecializationDecl *Decl) {
1951 CXXMethodDecl *OldFD = Decl->getSpecialization();
1952 CXXMethodDecl *NewFD = cast<CXXMethodDecl>(VisitCXXMethodDecl(OldFD, 0, true));
1953
1954 LookupResult Previous(SemaRef, NewFD->getNameInfo(), Sema::LookupOrdinaryName,
1955 Sema::ForRedeclaration);
1956
1957 SemaRef.LookupQualifiedName(Previous, SemaRef.CurContext);
1958 if (SemaRef.CheckFunctionTemplateSpecialization(NewFD, 0, Previous)) {
1959 NewFD->setInvalidDecl();
1960 return NewFD;
1961 }
1962
1963 // Associate the specialization with the pattern.
1964 FunctionDecl *Specialization = cast<FunctionDecl>(Previous.getFoundDecl());
1965 assert(Specialization && "Class scope Specialization is null");
1966 SemaRef.Context.setClassScopeSpecializationPattern(Specialization, OldFD);
1967
1968 return NewFD;
1969 }
1970
SubstDecl(Decl * D,DeclContext * Owner,const MultiLevelTemplateArgumentList & TemplateArgs)1971 Decl *Sema::SubstDecl(Decl *D, DeclContext *Owner,
1972 const MultiLevelTemplateArgumentList &TemplateArgs) {
1973 TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs);
1974 if (D->isInvalidDecl())
1975 return 0;
1976
1977 return Instantiator.Visit(D);
1978 }
1979
1980 /// \brief Instantiates a nested template parameter list in the current
1981 /// instantiation context.
1982 ///
1983 /// \param L The parameter list to instantiate
1984 ///
1985 /// \returns NULL if there was an error
1986 TemplateParameterList *
SubstTemplateParams(TemplateParameterList * L)1987 TemplateDeclInstantiator::SubstTemplateParams(TemplateParameterList *L) {
1988 // Get errors for all the parameters before bailing out.
1989 bool Invalid = false;
1990
1991 unsigned N = L->size();
1992 typedef SmallVector<NamedDecl *, 8> ParamVector;
1993 ParamVector Params;
1994 Params.reserve(N);
1995 for (TemplateParameterList::iterator PI = L->begin(), PE = L->end();
1996 PI != PE; ++PI) {
1997 NamedDecl *D = cast_or_null<NamedDecl>(Visit(*PI));
1998 Params.push_back(D);
1999 Invalid = Invalid || !D || D->isInvalidDecl();
2000 }
2001
2002 // Clean up if we had an error.
2003 if (Invalid)
2004 return NULL;
2005
2006 TemplateParameterList *InstL
2007 = TemplateParameterList::Create(SemaRef.Context, L->getTemplateLoc(),
2008 L->getLAngleLoc(), &Params.front(), N,
2009 L->getRAngleLoc());
2010 return InstL;
2011 }
2012
2013 /// \brief Instantiate the declaration of a class template partial
2014 /// specialization.
2015 ///
2016 /// \param ClassTemplate the (instantiated) class template that is partially
2017 // specialized by the instantiation of \p PartialSpec.
2018 ///
2019 /// \param PartialSpec the (uninstantiated) class template partial
2020 /// specialization that we are instantiating.
2021 ///
2022 /// \returns The instantiated partial specialization, if successful; otherwise,
2023 /// NULL to indicate an error.
2024 ClassTemplatePartialSpecializationDecl *
InstantiateClassTemplatePartialSpecialization(ClassTemplateDecl * ClassTemplate,ClassTemplatePartialSpecializationDecl * PartialSpec)2025 TemplateDeclInstantiator::InstantiateClassTemplatePartialSpecialization(
2026 ClassTemplateDecl *ClassTemplate,
2027 ClassTemplatePartialSpecializationDecl *PartialSpec) {
2028 // Create a local instantiation scope for this class template partial
2029 // specialization, which will contain the instantiations of the template
2030 // parameters.
2031 LocalInstantiationScope Scope(SemaRef);
2032
2033 // Substitute into the template parameters of the class template partial
2034 // specialization.
2035 TemplateParameterList *TempParams = PartialSpec->getTemplateParameters();
2036 TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
2037 if (!InstParams)
2038 return 0;
2039
2040 // Substitute into the template arguments of the class template partial
2041 // specialization.
2042 TemplateArgumentListInfo InstTemplateArgs; // no angle locations
2043 if (SemaRef.Subst(PartialSpec->getTemplateArgsAsWritten(),
2044 PartialSpec->getNumTemplateArgsAsWritten(),
2045 InstTemplateArgs, TemplateArgs))
2046 return 0;
2047
2048 // Check that the template argument list is well-formed for this
2049 // class template.
2050 SmallVector<TemplateArgument, 4> Converted;
2051 if (SemaRef.CheckTemplateArgumentList(ClassTemplate,
2052 PartialSpec->getLocation(),
2053 InstTemplateArgs,
2054 false,
2055 Converted))
2056 return 0;
2057
2058 // Figure out where to insert this class template partial specialization
2059 // in the member template's set of class template partial specializations.
2060 void *InsertPos = 0;
2061 ClassTemplateSpecializationDecl *PrevDecl
2062 = ClassTemplate->findPartialSpecialization(Converted.data(),
2063 Converted.size(), InsertPos);
2064
2065 // Build the canonical type that describes the converted template
2066 // arguments of the class template partial specialization.
2067 QualType CanonType
2068 = SemaRef.Context.getTemplateSpecializationType(TemplateName(ClassTemplate),
2069 Converted.data(),
2070 Converted.size());
2071
2072 // Build the fully-sugared type for this class template
2073 // specialization as the user wrote in the specialization
2074 // itself. This means that we'll pretty-print the type retrieved
2075 // from the specialization's declaration the way that the user
2076 // actually wrote the specialization, rather than formatting the
2077 // name based on the "canonical" representation used to store the
2078 // template arguments in the specialization.
2079 TypeSourceInfo *WrittenTy
2080 = SemaRef.Context.getTemplateSpecializationTypeInfo(
2081 TemplateName(ClassTemplate),
2082 PartialSpec->getLocation(),
2083 InstTemplateArgs,
2084 CanonType);
2085
2086 if (PrevDecl) {
2087 // We've already seen a partial specialization with the same template
2088 // parameters and template arguments. This can happen, for example, when
2089 // substituting the outer template arguments ends up causing two
2090 // class template partial specializations of a member class template
2091 // to have identical forms, e.g.,
2092 //
2093 // template<typename T, typename U>
2094 // struct Outer {
2095 // template<typename X, typename Y> struct Inner;
2096 // template<typename Y> struct Inner<T, Y>;
2097 // template<typename Y> struct Inner<U, Y>;
2098 // };
2099 //
2100 // Outer<int, int> outer; // error: the partial specializations of Inner
2101 // // have the same signature.
2102 SemaRef.Diag(PartialSpec->getLocation(), diag::err_partial_spec_redeclared)
2103 << WrittenTy->getType();
2104 SemaRef.Diag(PrevDecl->getLocation(), diag::note_prev_partial_spec_here)
2105 << SemaRef.Context.getTypeDeclType(PrevDecl);
2106 return 0;
2107 }
2108
2109
2110 // Create the class template partial specialization declaration.
2111 ClassTemplatePartialSpecializationDecl *InstPartialSpec
2112 = ClassTemplatePartialSpecializationDecl::Create(SemaRef.Context,
2113 PartialSpec->getTagKind(),
2114 Owner,
2115 PartialSpec->getLocStart(),
2116 PartialSpec->getLocation(),
2117 InstParams,
2118 ClassTemplate,
2119 Converted.data(),
2120 Converted.size(),
2121 InstTemplateArgs,
2122 CanonType,
2123 0,
2124 ClassTemplate->getNextPartialSpecSequenceNumber());
2125 // Substitute the nested name specifier, if any.
2126 if (SubstQualifier(PartialSpec, InstPartialSpec))
2127 return 0;
2128
2129 InstPartialSpec->setInstantiatedFromMember(PartialSpec);
2130 InstPartialSpec->setTypeAsWritten(WrittenTy);
2131
2132 // Add this partial specialization to the set of class template partial
2133 // specializations.
2134 ClassTemplate->AddPartialSpecialization(InstPartialSpec, /*InsertPos=*/0);
2135 return InstPartialSpec;
2136 }
2137
2138 TypeSourceInfo*
SubstFunctionType(FunctionDecl * D,SmallVectorImpl<ParmVarDecl * > & Params)2139 TemplateDeclInstantiator::SubstFunctionType(FunctionDecl *D,
2140 SmallVectorImpl<ParmVarDecl *> &Params) {
2141 TypeSourceInfo *OldTInfo = D->getTypeSourceInfo();
2142 assert(OldTInfo && "substituting function without type source info");
2143 assert(Params.empty() && "parameter vector is non-empty at start");
2144
2145 CXXRecordDecl *ThisContext = 0;
2146 unsigned ThisTypeQuals = 0;
2147 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
2148 ThisContext = Method->getParent();
2149 ThisTypeQuals = Method->getTypeQualifiers();
2150 }
2151
2152 TypeSourceInfo *NewTInfo
2153 = SemaRef.SubstFunctionDeclType(OldTInfo, TemplateArgs,
2154 D->getTypeSpecStartLoc(),
2155 D->getDeclName(),
2156 ThisContext, ThisTypeQuals);
2157 if (!NewTInfo)
2158 return 0;
2159
2160 if (NewTInfo != OldTInfo) {
2161 // Get parameters from the new type info.
2162 TypeLoc OldTL = OldTInfo->getTypeLoc().IgnoreParens();
2163 if (FunctionProtoTypeLoc *OldProtoLoc
2164 = dyn_cast<FunctionProtoTypeLoc>(&OldTL)) {
2165 TypeLoc NewTL = NewTInfo->getTypeLoc().IgnoreParens();
2166 FunctionProtoTypeLoc *NewProtoLoc = cast<FunctionProtoTypeLoc>(&NewTL);
2167 assert(NewProtoLoc && "Missing prototype?");
2168 unsigned NewIdx = 0, NumNewParams = NewProtoLoc->getNumArgs();
2169 for (unsigned OldIdx = 0, NumOldParams = OldProtoLoc->getNumArgs();
2170 OldIdx != NumOldParams; ++OldIdx) {
2171 ParmVarDecl *OldParam = OldProtoLoc->getArg(OldIdx);
2172 if (!OldParam->isParameterPack() ||
2173 // FIXME: Is this right? OldParam could expand to an empty parameter
2174 // pack and the next parameter could be an unexpanded parameter pack
2175 (NewIdx < NumNewParams &&
2176 NewProtoLoc->getArg(NewIdx)->isParameterPack())) {
2177 // Simple case: normal parameter, or a parameter pack that's
2178 // instantiated to a (still-dependent) parameter pack.
2179 ParmVarDecl *NewParam = NewProtoLoc->getArg(NewIdx++);
2180 Params.push_back(NewParam);
2181 SemaRef.CurrentInstantiationScope->InstantiatedLocal(OldParam,
2182 NewParam);
2183 continue;
2184 }
2185
2186 // Parameter pack: make the instantiation an argument pack.
2187 SemaRef.CurrentInstantiationScope->MakeInstantiatedLocalArgPack(
2188 OldParam);
2189 unsigned NumArgumentsInExpansion
2190 = SemaRef.getNumArgumentsInExpansion(OldParam->getType(),
2191 TemplateArgs);
2192 while (NumArgumentsInExpansion--) {
2193 ParmVarDecl *NewParam = NewProtoLoc->getArg(NewIdx++);
2194 Params.push_back(NewParam);
2195 SemaRef.CurrentInstantiationScope->InstantiatedLocalPackArg(OldParam,
2196 NewParam);
2197 }
2198 }
2199 }
2200 } else {
2201 // The function type itself was not dependent and therefore no
2202 // substitution occurred. However, we still need to instantiate
2203 // the function parameters themselves.
2204 TypeLoc OldTL = OldTInfo->getTypeLoc().IgnoreParens();
2205 if (FunctionProtoTypeLoc *OldProtoLoc
2206 = dyn_cast<FunctionProtoTypeLoc>(&OldTL)) {
2207 for (unsigned i = 0, i_end = OldProtoLoc->getNumArgs(); i != i_end; ++i) {
2208 ParmVarDecl *Parm = VisitParmVarDecl(OldProtoLoc->getArg(i));
2209 if (!Parm)
2210 return 0;
2211 Params.push_back(Parm);
2212 }
2213 }
2214 }
2215 return NewTInfo;
2216 }
2217
2218 /// Introduce the instantiated function parameters into the local
2219 /// instantiation scope, and set the parameter names to those used
2220 /// in the template.
addInstantiatedParametersToScope(Sema & S,FunctionDecl * Function,const FunctionDecl * PatternDecl,LocalInstantiationScope & Scope,const MultiLevelTemplateArgumentList & TemplateArgs)2221 static void addInstantiatedParametersToScope(Sema &S, FunctionDecl *Function,
2222 const FunctionDecl *PatternDecl,
2223 LocalInstantiationScope &Scope,
2224 const MultiLevelTemplateArgumentList &TemplateArgs) {
2225 unsigned FParamIdx = 0;
2226 for (unsigned I = 0, N = PatternDecl->getNumParams(); I != N; ++I) {
2227 const ParmVarDecl *PatternParam = PatternDecl->getParamDecl(I);
2228 if (!PatternParam->isParameterPack()) {
2229 // Simple case: not a parameter pack.
2230 assert(FParamIdx < Function->getNumParams());
2231 ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx);
2232 FunctionParam->setDeclName(PatternParam->getDeclName());
2233 Scope.InstantiatedLocal(PatternParam, FunctionParam);
2234 ++FParamIdx;
2235 continue;
2236 }
2237
2238 // Expand the parameter pack.
2239 Scope.MakeInstantiatedLocalArgPack(PatternParam);
2240 unsigned NumArgumentsInExpansion
2241 = S.getNumArgumentsInExpansion(PatternParam->getType(), TemplateArgs);
2242 for (unsigned Arg = 0; Arg < NumArgumentsInExpansion; ++Arg) {
2243 ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx);
2244 FunctionParam->setDeclName(PatternParam->getDeclName());
2245 Scope.InstantiatedLocalPackArg(PatternParam, FunctionParam);
2246 ++FParamIdx;
2247 }
2248 }
2249 }
2250
InstantiateExceptionSpec(Sema & SemaRef,FunctionDecl * New,const FunctionProtoType * Proto,const MultiLevelTemplateArgumentList & TemplateArgs)2251 static void InstantiateExceptionSpec(Sema &SemaRef, FunctionDecl *New,
2252 const FunctionProtoType *Proto,
2253 const MultiLevelTemplateArgumentList &TemplateArgs) {
2254 assert(Proto->getExceptionSpecType() != EST_Uninstantiated);
2255
2256 // C++11 [expr.prim.general]p3:
2257 // If a declaration declares a member function or member function
2258 // template of a class X, the expression this is a prvalue of type
2259 // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq
2260 // and the end of the function-definition, member-declarator, or
2261 // declarator.
2262 CXXRecordDecl *ThisContext = 0;
2263 unsigned ThisTypeQuals = 0;
2264 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(New)) {
2265 ThisContext = Method->getParent();
2266 ThisTypeQuals = Method->getTypeQualifiers();
2267 }
2268 Sema::CXXThisScopeRAII ThisScope(SemaRef, ThisContext, ThisTypeQuals,
2269 SemaRef.getLangOpts().CPlusPlus0x);
2270
2271 // The function has an exception specification or a "noreturn"
2272 // attribute. Substitute into each of the exception types.
2273 SmallVector<QualType, 4> Exceptions;
2274 for (unsigned I = 0, N = Proto->getNumExceptions(); I != N; ++I) {
2275 // FIXME: Poor location information!
2276 if (const PackExpansionType *PackExpansion
2277 = Proto->getExceptionType(I)->getAs<PackExpansionType>()) {
2278 // We have a pack expansion. Instantiate it.
2279 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
2280 SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(),
2281 Unexpanded);
2282 assert(!Unexpanded.empty() &&
2283 "Pack expansion without parameter packs?");
2284
2285 bool Expand = false;
2286 bool RetainExpansion = false;
2287 llvm::Optional<unsigned> NumExpansions
2288 = PackExpansion->getNumExpansions();
2289 if (SemaRef.CheckParameterPacksForExpansion(New->getLocation(),
2290 SourceRange(),
2291 Unexpanded,
2292 TemplateArgs,
2293 Expand,
2294 RetainExpansion,
2295 NumExpansions))
2296 break;
2297
2298 if (!Expand) {
2299 // We can't expand this pack expansion into separate arguments yet;
2300 // just substitute into the pattern and create a new pack expansion
2301 // type.
2302 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
2303 QualType T = SemaRef.SubstType(PackExpansion->getPattern(),
2304 TemplateArgs,
2305 New->getLocation(), New->getDeclName());
2306 if (T.isNull())
2307 break;
2308
2309 T = SemaRef.Context.getPackExpansionType(T, NumExpansions);
2310 Exceptions.push_back(T);
2311 continue;
2312 }
2313
2314 // Substitute into the pack expansion pattern for each template
2315 bool Invalid = false;
2316 for (unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
2317 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, ArgIdx);
2318
2319 QualType T = SemaRef.SubstType(PackExpansion->getPattern(),
2320 TemplateArgs,
2321 New->getLocation(), New->getDeclName());
2322 if (T.isNull()) {
2323 Invalid = true;
2324 break;
2325 }
2326
2327 Exceptions.push_back(T);
2328 }
2329
2330 if (Invalid)
2331 break;
2332
2333 continue;
2334 }
2335
2336 QualType T
2337 = SemaRef.SubstType(Proto->getExceptionType(I), TemplateArgs,
2338 New->getLocation(), New->getDeclName());
2339 if (T.isNull() ||
2340 SemaRef.CheckSpecifiedExceptionType(T, New->getLocation()))
2341 continue;
2342
2343 Exceptions.push_back(T);
2344 }
2345 Expr *NoexceptExpr = 0;
2346 if (Expr *OldNoexceptExpr = Proto->getNoexceptExpr()) {
2347 EnterExpressionEvaluationContext Unevaluated(SemaRef,
2348 Sema::ConstantEvaluated);
2349 ExprResult E = SemaRef.SubstExpr(OldNoexceptExpr, TemplateArgs);
2350 if (E.isUsable())
2351 E = SemaRef.CheckBooleanCondition(E.get(), E.get()->getLocStart());
2352
2353 if (E.isUsable()) {
2354 NoexceptExpr = E.take();
2355 if (!NoexceptExpr->isTypeDependent() &&
2356 !NoexceptExpr->isValueDependent())
2357 NoexceptExpr = SemaRef.VerifyIntegerConstantExpression(NoexceptExpr,
2358 0, SemaRef.PDiag(diag::err_noexcept_needs_constant_expression),
2359 /*AllowFold*/ false).take();
2360 }
2361 }
2362
2363 // Rebuild the function type
2364 const FunctionProtoType *NewProto
2365 = New->getType()->getAs<FunctionProtoType>();
2366 assert(NewProto && "Template instantiation without function prototype?");
2367
2368 FunctionProtoType::ExtProtoInfo EPI = NewProto->getExtProtoInfo();
2369 EPI.ExceptionSpecType = Proto->getExceptionSpecType();
2370 EPI.NumExceptions = Exceptions.size();
2371 EPI.Exceptions = Exceptions.data();
2372 EPI.NoexceptExpr = NoexceptExpr;
2373
2374 New->setType(SemaRef.Context.getFunctionType(NewProto->getResultType(),
2375 NewProto->arg_type_begin(),
2376 NewProto->getNumArgs(),
2377 EPI));
2378 }
2379
InstantiateExceptionSpec(SourceLocation PointOfInstantiation,FunctionDecl * Decl)2380 void Sema::InstantiateExceptionSpec(SourceLocation PointOfInstantiation,
2381 FunctionDecl *Decl) {
2382 const FunctionProtoType *Proto = Decl->getType()->castAs<FunctionProtoType>();
2383 if (Proto->getExceptionSpecType() != EST_Uninstantiated)
2384 return;
2385
2386 InstantiatingTemplate Inst(*this, PointOfInstantiation, Decl,
2387 InstantiatingTemplate::ExceptionSpecification());
2388 if (Inst)
2389 return;
2390
2391 // Enter the scope of this instantiation. We don't use
2392 // PushDeclContext because we don't have a scope.
2393 Sema::ContextRAII savedContext(*this, Decl);
2394 LocalInstantiationScope Scope(*this);
2395
2396 MultiLevelTemplateArgumentList TemplateArgs =
2397 getTemplateInstantiationArgs(Decl, 0, /*RelativeToPrimary*/true);
2398
2399 FunctionDecl *Template = Proto->getExceptionSpecTemplate();
2400 addInstantiatedParametersToScope(*this, Decl, Template, Scope, TemplateArgs);
2401
2402 ::InstantiateExceptionSpec(*this, Decl,
2403 Template->getType()->castAs<FunctionProtoType>(),
2404 TemplateArgs);
2405 }
2406
2407 /// \brief Initializes the common fields of an instantiation function
2408 /// declaration (New) from the corresponding fields of its template (Tmpl).
2409 ///
2410 /// \returns true if there was an error
2411 bool
InitFunctionInstantiation(FunctionDecl * New,FunctionDecl * Tmpl)2412 TemplateDeclInstantiator::InitFunctionInstantiation(FunctionDecl *New,
2413 FunctionDecl *Tmpl) {
2414 if (Tmpl->isDeletedAsWritten())
2415 New->setDeletedAsWritten();
2416
2417 // If we are performing substituting explicitly-specified template arguments
2418 // or deduced template arguments into a function template and we reach this
2419 // point, we are now past the point where SFINAE applies and have committed
2420 // to keeping the new function template specialization. We therefore
2421 // convert the active template instantiation for the function template
2422 // into a template instantiation for this specific function template
2423 // specialization, which is not a SFINAE context, so that we diagnose any
2424 // further errors in the declaration itself.
2425 typedef Sema::ActiveTemplateInstantiation ActiveInstType;
2426 ActiveInstType &ActiveInst = SemaRef.ActiveTemplateInstantiations.back();
2427 if (ActiveInst.Kind == ActiveInstType::ExplicitTemplateArgumentSubstitution ||
2428 ActiveInst.Kind == ActiveInstType::DeducedTemplateArgumentSubstitution) {
2429 if (FunctionTemplateDecl *FunTmpl
2430 = dyn_cast<FunctionTemplateDecl>((Decl *)ActiveInst.Entity)) {
2431 assert(FunTmpl->getTemplatedDecl() == Tmpl &&
2432 "Deduction from the wrong function template?");
2433 (void) FunTmpl;
2434 ActiveInst.Kind = ActiveInstType::TemplateInstantiation;
2435 ActiveInst.Entity = reinterpret_cast<uintptr_t>(New);
2436 --SemaRef.NonInstantiationEntries;
2437 }
2438 }
2439
2440 const FunctionProtoType *Proto = Tmpl->getType()->getAs<FunctionProtoType>();
2441 assert(Proto && "Function template without prototype?");
2442
2443 if (Proto->hasExceptionSpec() || Proto->getNoReturnAttr()) {
2444 FunctionProtoType::ExtProtoInfo EPI = Proto->getExtProtoInfo();
2445
2446 // DR1330: In C++11, defer instantiation of a non-trivial
2447 // exception specification.
2448 if (SemaRef.getLangOpts().CPlusPlus0x &&
2449 EPI.ExceptionSpecType != EST_None &&
2450 EPI.ExceptionSpecType != EST_DynamicNone &&
2451 EPI.ExceptionSpecType != EST_BasicNoexcept) {
2452 FunctionDecl *ExceptionSpecTemplate = Tmpl;
2453 if (EPI.ExceptionSpecType == EST_Uninstantiated)
2454 ExceptionSpecTemplate = EPI.ExceptionSpecTemplate;
2455
2456 // Mark the function has having an uninstantiated exception specification.
2457 const FunctionProtoType *NewProto
2458 = New->getType()->getAs<FunctionProtoType>();
2459 assert(NewProto && "Template instantiation without function prototype?");
2460 EPI = NewProto->getExtProtoInfo();
2461 EPI.ExceptionSpecType = EST_Uninstantiated;
2462 EPI.ExceptionSpecDecl = New;
2463 EPI.ExceptionSpecTemplate = ExceptionSpecTemplate;
2464 New->setType(SemaRef.Context.getFunctionType(NewProto->getResultType(),
2465 NewProto->arg_type_begin(),
2466 NewProto->getNumArgs(),
2467 EPI));
2468 } else {
2469 ::InstantiateExceptionSpec(SemaRef, New, Proto, TemplateArgs);
2470 }
2471 }
2472
2473 // Get the definition. Leaves the variable unchanged if undefined.
2474 const FunctionDecl *Definition = Tmpl;
2475 Tmpl->isDefined(Definition);
2476
2477 SemaRef.InstantiateAttrs(TemplateArgs, Definition, New,
2478 LateAttrs, StartingScope);
2479
2480 return false;
2481 }
2482
2483 /// \brief Initializes common fields of an instantiated method
2484 /// declaration (New) from the corresponding fields of its template
2485 /// (Tmpl).
2486 ///
2487 /// \returns true if there was an error
2488 bool
InitMethodInstantiation(CXXMethodDecl * New,CXXMethodDecl * Tmpl)2489 TemplateDeclInstantiator::InitMethodInstantiation(CXXMethodDecl *New,
2490 CXXMethodDecl *Tmpl) {
2491 if (InitFunctionInstantiation(New, Tmpl))
2492 return true;
2493
2494 New->setAccess(Tmpl->getAccess());
2495 if (Tmpl->isVirtualAsWritten())
2496 New->setVirtualAsWritten(true);
2497
2498 // FIXME: attributes
2499 // FIXME: New needs a pointer to Tmpl
2500 return false;
2501 }
2502
2503 /// \brief Instantiate the definition of the given function from its
2504 /// template.
2505 ///
2506 /// \param PointOfInstantiation the point at which the instantiation was
2507 /// required. Note that this is not precisely a "point of instantiation"
2508 /// for the function, but it's close.
2509 ///
2510 /// \param Function the already-instantiated declaration of a
2511 /// function template specialization or member function of a class template
2512 /// specialization.
2513 ///
2514 /// \param Recursive if true, recursively instantiates any functions that
2515 /// are required by this instantiation.
2516 ///
2517 /// \param DefinitionRequired if true, then we are performing an explicit
2518 /// instantiation where the body of the function is required. Complain if
2519 /// there is no such body.
InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,FunctionDecl * Function,bool Recursive,bool DefinitionRequired)2520 void Sema::InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
2521 FunctionDecl *Function,
2522 bool Recursive,
2523 bool DefinitionRequired) {
2524 if (Function->isInvalidDecl() || Function->isDefined())
2525 return;
2526
2527 // Never instantiate an explicit specialization except if it is a class scope
2528 // explicit specialization.
2529 if (Function->getTemplateSpecializationKind() == TSK_ExplicitSpecialization &&
2530 !Function->getClassScopeSpecializationPattern())
2531 return;
2532
2533 // Find the function body that we'll be substituting.
2534 const FunctionDecl *PatternDecl = Function->getTemplateInstantiationPattern();
2535 assert(PatternDecl && "instantiating a non-template");
2536
2537 Stmt *Pattern = PatternDecl->getBody(PatternDecl);
2538 assert(PatternDecl && "template definition is not a template");
2539 if (!Pattern) {
2540 // Try to find a defaulted definition
2541 PatternDecl->isDefined(PatternDecl);
2542 }
2543 assert(PatternDecl && "template definition is not a template");
2544
2545 // Postpone late parsed template instantiations.
2546 if (PatternDecl->isLateTemplateParsed() &&
2547 !LateTemplateParser) {
2548 PendingInstantiations.push_back(
2549 std::make_pair(Function, PointOfInstantiation));
2550 return;
2551 }
2552
2553 // Call the LateTemplateParser callback if there a need to late parse
2554 // a templated function definition.
2555 if (!Pattern && PatternDecl->isLateTemplateParsed() &&
2556 LateTemplateParser) {
2557 LateTemplateParser(OpaqueParser, PatternDecl);
2558 Pattern = PatternDecl->getBody(PatternDecl);
2559 }
2560
2561 if (!Pattern && !PatternDecl->isDefaulted()) {
2562 if (DefinitionRequired) {
2563 if (Function->getPrimaryTemplate())
2564 Diag(PointOfInstantiation,
2565 diag::err_explicit_instantiation_undefined_func_template)
2566 << Function->getPrimaryTemplate();
2567 else
2568 Diag(PointOfInstantiation,
2569 diag::err_explicit_instantiation_undefined_member)
2570 << 1 << Function->getDeclName() << Function->getDeclContext();
2571
2572 if (PatternDecl)
2573 Diag(PatternDecl->getLocation(),
2574 diag::note_explicit_instantiation_here);
2575 Function->setInvalidDecl();
2576 } else if (Function->getTemplateSpecializationKind()
2577 == TSK_ExplicitInstantiationDefinition) {
2578 PendingInstantiations.push_back(
2579 std::make_pair(Function, PointOfInstantiation));
2580 }
2581
2582 return;
2583 }
2584
2585 // C++0x [temp.explicit]p9:
2586 // Except for inline functions, other explicit instantiation declarations
2587 // have the effect of suppressing the implicit instantiation of the entity
2588 // to which they refer.
2589 if (Function->getTemplateSpecializationKind()
2590 == TSK_ExplicitInstantiationDeclaration &&
2591 !PatternDecl->isInlined())
2592 return;
2593
2594 InstantiatingTemplate Inst(*this, PointOfInstantiation, Function);
2595 if (Inst)
2596 return;
2597
2598 // Copy the inner loc start from the pattern.
2599 Function->setInnerLocStart(PatternDecl->getInnerLocStart());
2600
2601 // If we're performing recursive template instantiation, create our own
2602 // queue of pending implicit instantiations that we will instantiate later,
2603 // while we're still within our own instantiation context.
2604 SmallVector<VTableUse, 16> SavedVTableUses;
2605 std::deque<PendingImplicitInstantiation> SavedPendingInstantiations;
2606 if (Recursive) {
2607 VTableUses.swap(SavedVTableUses);
2608 PendingInstantiations.swap(SavedPendingInstantiations);
2609 }
2610
2611 EnterExpressionEvaluationContext EvalContext(*this,
2612 Sema::PotentiallyEvaluated);
2613 ActOnStartOfFunctionDef(0, Function);
2614
2615 // Introduce a new scope where local variable instantiations will be
2616 // recorded, unless we're actually a member function within a local
2617 // class, in which case we need to merge our results with the parent
2618 // scope (of the enclosing function).
2619 bool MergeWithParentScope = false;
2620 if (CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Function->getDeclContext()))
2621 MergeWithParentScope = Rec->isLocalClass();
2622
2623 LocalInstantiationScope Scope(*this, MergeWithParentScope);
2624
2625 // Enter the scope of this instantiation. We don't use
2626 // PushDeclContext because we don't have a scope.
2627 Sema::ContextRAII savedContext(*this, Function);
2628
2629 MultiLevelTemplateArgumentList TemplateArgs =
2630 getTemplateInstantiationArgs(Function, 0, false, PatternDecl);
2631
2632 addInstantiatedParametersToScope(*this, Function, PatternDecl, Scope,
2633 TemplateArgs);
2634
2635 if (PatternDecl->isDefaulted()) {
2636 ActOnFinishFunctionBody(Function, 0, /*IsInstantiation=*/true);
2637
2638 SetDeclDefaulted(Function, PatternDecl->getLocation());
2639 } else {
2640 // If this is a constructor, instantiate the member initializers.
2641 if (const CXXConstructorDecl *Ctor =
2642 dyn_cast<CXXConstructorDecl>(PatternDecl)) {
2643 InstantiateMemInitializers(cast<CXXConstructorDecl>(Function), Ctor,
2644 TemplateArgs);
2645 }
2646
2647 // Instantiate the function body.
2648 StmtResult Body = SubstStmt(Pattern, TemplateArgs);
2649
2650 if (Body.isInvalid())
2651 Function->setInvalidDecl();
2652
2653 ActOnFinishFunctionBody(Function, Body.get(),
2654 /*IsInstantiation=*/true);
2655 }
2656
2657 PerformDependentDiagnostics(PatternDecl, TemplateArgs);
2658
2659 savedContext.pop();
2660
2661 DeclGroupRef DG(Function);
2662 Consumer.HandleTopLevelDecl(DG);
2663
2664 // This class may have local implicit instantiations that need to be
2665 // instantiation within this scope.
2666 PerformPendingInstantiations(/*LocalOnly=*/true);
2667 Scope.Exit();
2668
2669 if (Recursive) {
2670 // Define any pending vtables.
2671 DefineUsedVTables();
2672
2673 // Instantiate any pending implicit instantiations found during the
2674 // instantiation of this template.
2675 PerformPendingInstantiations();
2676
2677 // Restore the set of pending vtables.
2678 assert(VTableUses.empty() &&
2679 "VTableUses should be empty before it is discarded.");
2680 VTableUses.swap(SavedVTableUses);
2681
2682 // Restore the set of pending implicit instantiations.
2683 assert(PendingInstantiations.empty() &&
2684 "PendingInstantiations should be empty before it is discarded.");
2685 PendingInstantiations.swap(SavedPendingInstantiations);
2686 }
2687 }
2688
2689 /// \brief Instantiate the definition of the given variable from its
2690 /// template.
2691 ///
2692 /// \param PointOfInstantiation the point at which the instantiation was
2693 /// required. Note that this is not precisely a "point of instantiation"
2694 /// for the function, but it's close.
2695 ///
2696 /// \param Var the already-instantiated declaration of a static member
2697 /// variable of a class template specialization.
2698 ///
2699 /// \param Recursive if true, recursively instantiates any functions that
2700 /// are required by this instantiation.
2701 ///
2702 /// \param DefinitionRequired if true, then we are performing an explicit
2703 /// instantiation where an out-of-line definition of the member variable
2704 /// is required. Complain if there is no such definition.
InstantiateStaticDataMemberDefinition(SourceLocation PointOfInstantiation,VarDecl * Var,bool Recursive,bool DefinitionRequired)2705 void Sema::InstantiateStaticDataMemberDefinition(
2706 SourceLocation PointOfInstantiation,
2707 VarDecl *Var,
2708 bool Recursive,
2709 bool DefinitionRequired) {
2710 if (Var->isInvalidDecl())
2711 return;
2712
2713 // Find the out-of-line definition of this static data member.
2714 VarDecl *Def = Var->getInstantiatedFromStaticDataMember();
2715 assert(Def && "This data member was not instantiated from a template?");
2716 assert(Def->isStaticDataMember() && "Not a static data member?");
2717 Def = Def->getOutOfLineDefinition();
2718
2719 if (!Def) {
2720 // We did not find an out-of-line definition of this static data member,
2721 // so we won't perform any instantiation. Rather, we rely on the user to
2722 // instantiate this definition (or provide a specialization for it) in
2723 // another translation unit.
2724 if (DefinitionRequired) {
2725 Def = Var->getInstantiatedFromStaticDataMember();
2726 Diag(PointOfInstantiation,
2727 diag::err_explicit_instantiation_undefined_member)
2728 << 2 << Var->getDeclName() << Var->getDeclContext();
2729 Diag(Def->getLocation(), diag::note_explicit_instantiation_here);
2730 } else if (Var->getTemplateSpecializationKind()
2731 == TSK_ExplicitInstantiationDefinition) {
2732 PendingInstantiations.push_back(
2733 std::make_pair(Var, PointOfInstantiation));
2734 }
2735
2736 return;
2737 }
2738
2739 TemplateSpecializationKind TSK = Var->getTemplateSpecializationKind();
2740
2741 // Never instantiate an explicit specialization.
2742 if (TSK == TSK_ExplicitSpecialization)
2743 return;
2744
2745 // C++0x [temp.explicit]p9:
2746 // Except for inline functions, other explicit instantiation declarations
2747 // have the effect of suppressing the implicit instantiation of the entity
2748 // to which they refer.
2749 if (TSK == TSK_ExplicitInstantiationDeclaration)
2750 return;
2751
2752 Consumer.HandleCXXStaticMemberVarInstantiation(Var);
2753
2754 // If we already have a definition, we're done.
2755 if (VarDecl *Def = Var->getDefinition()) {
2756 // We may be explicitly instantiating something we've already implicitly
2757 // instantiated.
2758 Def->setTemplateSpecializationKind(Var->getTemplateSpecializationKind(),
2759 PointOfInstantiation);
2760 return;
2761 }
2762
2763 InstantiatingTemplate Inst(*this, PointOfInstantiation, Var);
2764 if (Inst)
2765 return;
2766
2767 // If we're performing recursive template instantiation, create our own
2768 // queue of pending implicit instantiations that we will instantiate later,
2769 // while we're still within our own instantiation context.
2770 SmallVector<VTableUse, 16> SavedVTableUses;
2771 std::deque<PendingImplicitInstantiation> SavedPendingInstantiations;
2772 if (Recursive) {
2773 VTableUses.swap(SavedVTableUses);
2774 PendingInstantiations.swap(SavedPendingInstantiations);
2775 }
2776
2777 // Enter the scope of this instantiation. We don't use
2778 // PushDeclContext because we don't have a scope.
2779 ContextRAII previousContext(*this, Var->getDeclContext());
2780 LocalInstantiationScope Local(*this);
2781
2782 VarDecl *OldVar = Var;
2783 Var = cast_or_null<VarDecl>(SubstDecl(Def, Var->getDeclContext(),
2784 getTemplateInstantiationArgs(Var)));
2785
2786 previousContext.pop();
2787
2788 if (Var) {
2789 MemberSpecializationInfo *MSInfo = OldVar->getMemberSpecializationInfo();
2790 assert(MSInfo && "Missing member specialization information?");
2791 Var->setTemplateSpecializationKind(MSInfo->getTemplateSpecializationKind(),
2792 MSInfo->getPointOfInstantiation());
2793 DeclGroupRef DG(Var);
2794 Consumer.HandleTopLevelDecl(DG);
2795 }
2796 Local.Exit();
2797
2798 if (Recursive) {
2799 // Define any newly required vtables.
2800 DefineUsedVTables();
2801
2802 // Instantiate any pending implicit instantiations found during the
2803 // instantiation of this template.
2804 PerformPendingInstantiations();
2805
2806 // Restore the set of pending vtables.
2807 assert(VTableUses.empty() &&
2808 "VTableUses should be empty before it is discarded, "
2809 "while instantiating static data member.");
2810 VTableUses.swap(SavedVTableUses);
2811
2812 // Restore the set of pending implicit instantiations.
2813 assert(PendingInstantiations.empty() &&
2814 "PendingInstantiations should be empty before it is discarded, "
2815 "while instantiating static data member.");
2816 PendingInstantiations.swap(SavedPendingInstantiations);
2817 }
2818 }
2819
2820 void
InstantiateMemInitializers(CXXConstructorDecl * New,const CXXConstructorDecl * Tmpl,const MultiLevelTemplateArgumentList & TemplateArgs)2821 Sema::InstantiateMemInitializers(CXXConstructorDecl *New,
2822 const CXXConstructorDecl *Tmpl,
2823 const MultiLevelTemplateArgumentList &TemplateArgs) {
2824
2825 SmallVector<CXXCtorInitializer*, 4> NewInits;
2826 bool AnyErrors = false;
2827
2828 // Instantiate all the initializers.
2829 for (CXXConstructorDecl::init_const_iterator Inits = Tmpl->init_begin(),
2830 InitsEnd = Tmpl->init_end();
2831 Inits != InitsEnd; ++Inits) {
2832 CXXCtorInitializer *Init = *Inits;
2833
2834 // Only instantiate written initializers, let Sema re-construct implicit
2835 // ones.
2836 if (!Init->isWritten())
2837 continue;
2838
2839 SourceLocation EllipsisLoc;
2840
2841 if (Init->isPackExpansion()) {
2842 // This is a pack expansion. We should expand it now.
2843 TypeLoc BaseTL = Init->getTypeSourceInfo()->getTypeLoc();
2844 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
2845 collectUnexpandedParameterPacks(BaseTL, Unexpanded);
2846 bool ShouldExpand = false;
2847 bool RetainExpansion = false;
2848 llvm::Optional<unsigned> NumExpansions;
2849 if (CheckParameterPacksForExpansion(Init->getEllipsisLoc(),
2850 BaseTL.getSourceRange(),
2851 Unexpanded,
2852 TemplateArgs, ShouldExpand,
2853 RetainExpansion,
2854 NumExpansions)) {
2855 AnyErrors = true;
2856 New->setInvalidDecl();
2857 continue;
2858 }
2859 assert(ShouldExpand && "Partial instantiation of base initializer?");
2860
2861 // Loop over all of the arguments in the argument pack(s),
2862 for (unsigned I = 0; I != *NumExpansions; ++I) {
2863 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, I);
2864
2865 // Instantiate the initializer.
2866 ExprResult TempInit = SubstInitializer(Init->getInit(), TemplateArgs,
2867 /*CXXDirectInit=*/true);
2868 if (TempInit.isInvalid()) {
2869 AnyErrors = true;
2870 break;
2871 }
2872
2873 // Instantiate the base type.
2874 TypeSourceInfo *BaseTInfo = SubstType(Init->getTypeSourceInfo(),
2875 TemplateArgs,
2876 Init->getSourceLocation(),
2877 New->getDeclName());
2878 if (!BaseTInfo) {
2879 AnyErrors = true;
2880 break;
2881 }
2882
2883 // Build the initializer.
2884 MemInitResult NewInit = BuildBaseInitializer(BaseTInfo->getType(),
2885 BaseTInfo, TempInit.take(),
2886 New->getParent(),
2887 SourceLocation());
2888 if (NewInit.isInvalid()) {
2889 AnyErrors = true;
2890 break;
2891 }
2892
2893 NewInits.push_back(NewInit.get());
2894 }
2895
2896 continue;
2897 }
2898
2899 // Instantiate the initializer.
2900 ExprResult TempInit = SubstInitializer(Init->getInit(), TemplateArgs,
2901 /*CXXDirectInit=*/true);
2902 if (TempInit.isInvalid()) {
2903 AnyErrors = true;
2904 continue;
2905 }
2906
2907 MemInitResult NewInit;
2908 if (Init->isDelegatingInitializer() || Init->isBaseInitializer()) {
2909 TypeSourceInfo *TInfo = SubstType(Init->getTypeSourceInfo(),
2910 TemplateArgs,
2911 Init->getSourceLocation(),
2912 New->getDeclName());
2913 if (!TInfo) {
2914 AnyErrors = true;
2915 New->setInvalidDecl();
2916 continue;
2917 }
2918
2919 if (Init->isBaseInitializer())
2920 NewInit = BuildBaseInitializer(TInfo->getType(), TInfo, TempInit.take(),
2921 New->getParent(), EllipsisLoc);
2922 else
2923 NewInit = BuildDelegatingInitializer(TInfo, TempInit.take(),
2924 cast<CXXRecordDecl>(CurContext->getParent()));
2925 } else if (Init->isMemberInitializer()) {
2926 FieldDecl *Member = cast_or_null<FieldDecl>(FindInstantiatedDecl(
2927 Init->getMemberLocation(),
2928 Init->getMember(),
2929 TemplateArgs));
2930 if (!Member) {
2931 AnyErrors = true;
2932 New->setInvalidDecl();
2933 continue;
2934 }
2935
2936 NewInit = BuildMemberInitializer(Member, TempInit.take(),
2937 Init->getSourceLocation());
2938 } else if (Init->isIndirectMemberInitializer()) {
2939 IndirectFieldDecl *IndirectMember =
2940 cast_or_null<IndirectFieldDecl>(FindInstantiatedDecl(
2941 Init->getMemberLocation(),
2942 Init->getIndirectMember(), TemplateArgs));
2943
2944 if (!IndirectMember) {
2945 AnyErrors = true;
2946 New->setInvalidDecl();
2947 continue;
2948 }
2949
2950 NewInit = BuildMemberInitializer(IndirectMember, TempInit.take(),
2951 Init->getSourceLocation());
2952 }
2953
2954 if (NewInit.isInvalid()) {
2955 AnyErrors = true;
2956 New->setInvalidDecl();
2957 } else {
2958 NewInits.push_back(NewInit.get());
2959 }
2960 }
2961
2962 // Assign all the initializers to the new constructor.
2963 ActOnMemInitializers(New,
2964 /*FIXME: ColonLoc */
2965 SourceLocation(),
2966 NewInits.data(), NewInits.size(),
2967 AnyErrors);
2968 }
2969
SubstInitializer(Expr * Init,const MultiLevelTemplateArgumentList & TemplateArgs,bool CXXDirectInit)2970 ExprResult Sema::SubstInitializer(Expr *Init,
2971 const MultiLevelTemplateArgumentList &TemplateArgs,
2972 bool CXXDirectInit) {
2973 // Initializers are instantiated like expressions, except that various outer
2974 // layers are stripped.
2975 if (!Init)
2976 return Owned(Init);
2977
2978 if (ExprWithCleanups *ExprTemp = dyn_cast<ExprWithCleanups>(Init))
2979 Init = ExprTemp->getSubExpr();
2980
2981 while (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(Init))
2982 Init = Binder->getSubExpr();
2983
2984 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Init))
2985 Init = ICE->getSubExprAsWritten();
2986
2987 // If this is a direct-initializer, we take apart CXXConstructExprs.
2988 // Everything else is passed through.
2989 CXXConstructExpr *Construct;
2990 if (!CXXDirectInit || !(Construct = dyn_cast<CXXConstructExpr>(Init)) ||
2991 isa<CXXTemporaryObjectExpr>(Construct))
2992 return SubstExpr(Init, TemplateArgs);
2993
2994 ASTOwningVector<Expr*> NewArgs(*this);
2995 if (SubstExprs(Construct->getArgs(), Construct->getNumArgs(), true,
2996 TemplateArgs, NewArgs))
2997 return ExprError();
2998
2999 // Treat an empty initializer like none.
3000 if (NewArgs.empty())
3001 return Owned((Expr*)0);
3002
3003 // Build a ParenListExpr to represent anything else.
3004 // FIXME: Fake locations!
3005 SourceLocation Loc = PP.getLocForEndOfToken(Init->getLocStart());
3006 return ActOnParenListExpr(Loc, Loc, move_arg(NewArgs));
3007 }
3008
3009 // TODO: this could be templated if the various decl types used the
3010 // same method name.
isInstantiationOf(ClassTemplateDecl * Pattern,ClassTemplateDecl * Instance)3011 static bool isInstantiationOf(ClassTemplateDecl *Pattern,
3012 ClassTemplateDecl *Instance) {
3013 Pattern = Pattern->getCanonicalDecl();
3014
3015 do {
3016 Instance = Instance->getCanonicalDecl();
3017 if (Pattern == Instance) return true;
3018 Instance = Instance->getInstantiatedFromMemberTemplate();
3019 } while (Instance);
3020
3021 return false;
3022 }
3023
isInstantiationOf(FunctionTemplateDecl * Pattern,FunctionTemplateDecl * Instance)3024 static bool isInstantiationOf(FunctionTemplateDecl *Pattern,
3025 FunctionTemplateDecl *Instance) {
3026 Pattern = Pattern->getCanonicalDecl();
3027
3028 do {
3029 Instance = Instance->getCanonicalDecl();
3030 if (Pattern == Instance) return true;
3031 Instance = Instance->getInstantiatedFromMemberTemplate();
3032 } while (Instance);
3033
3034 return false;
3035 }
3036
3037 static bool
isInstantiationOf(ClassTemplatePartialSpecializationDecl * Pattern,ClassTemplatePartialSpecializationDecl * Instance)3038 isInstantiationOf(ClassTemplatePartialSpecializationDecl *Pattern,
3039 ClassTemplatePartialSpecializationDecl *Instance) {
3040 Pattern
3041 = cast<ClassTemplatePartialSpecializationDecl>(Pattern->getCanonicalDecl());
3042 do {
3043 Instance = cast<ClassTemplatePartialSpecializationDecl>(
3044 Instance->getCanonicalDecl());
3045 if (Pattern == Instance)
3046 return true;
3047 Instance = Instance->getInstantiatedFromMember();
3048 } while (Instance);
3049
3050 return false;
3051 }
3052
isInstantiationOf(CXXRecordDecl * Pattern,CXXRecordDecl * Instance)3053 static bool isInstantiationOf(CXXRecordDecl *Pattern,
3054 CXXRecordDecl *Instance) {
3055 Pattern = Pattern->getCanonicalDecl();
3056
3057 do {
3058 Instance = Instance->getCanonicalDecl();
3059 if (Pattern == Instance) return true;
3060 Instance = Instance->getInstantiatedFromMemberClass();
3061 } while (Instance);
3062
3063 return false;
3064 }
3065
isInstantiationOf(FunctionDecl * Pattern,FunctionDecl * Instance)3066 static bool isInstantiationOf(FunctionDecl *Pattern,
3067 FunctionDecl *Instance) {
3068 Pattern = Pattern->getCanonicalDecl();
3069
3070 do {
3071 Instance = Instance->getCanonicalDecl();
3072 if (Pattern == Instance) return true;
3073 Instance = Instance->getInstantiatedFromMemberFunction();
3074 } while (Instance);
3075
3076 return false;
3077 }
3078
isInstantiationOf(EnumDecl * Pattern,EnumDecl * Instance)3079 static bool isInstantiationOf(EnumDecl *Pattern,
3080 EnumDecl *Instance) {
3081 Pattern = Pattern->getCanonicalDecl();
3082
3083 do {
3084 Instance = Instance->getCanonicalDecl();
3085 if (Pattern == Instance) return true;
3086 Instance = Instance->getInstantiatedFromMemberEnum();
3087 } while (Instance);
3088
3089 return false;
3090 }
3091
isInstantiationOf(UsingShadowDecl * Pattern,UsingShadowDecl * Instance,ASTContext & C)3092 static bool isInstantiationOf(UsingShadowDecl *Pattern,
3093 UsingShadowDecl *Instance,
3094 ASTContext &C) {
3095 return C.getInstantiatedFromUsingShadowDecl(Instance) == Pattern;
3096 }
3097
isInstantiationOf(UsingDecl * Pattern,UsingDecl * Instance,ASTContext & C)3098 static bool isInstantiationOf(UsingDecl *Pattern,
3099 UsingDecl *Instance,
3100 ASTContext &C) {
3101 return C.getInstantiatedFromUsingDecl(Instance) == Pattern;
3102 }
3103
isInstantiationOf(UnresolvedUsingValueDecl * Pattern,UsingDecl * Instance,ASTContext & C)3104 static bool isInstantiationOf(UnresolvedUsingValueDecl *Pattern,
3105 UsingDecl *Instance,
3106 ASTContext &C) {
3107 return C.getInstantiatedFromUsingDecl(Instance) == Pattern;
3108 }
3109
isInstantiationOf(UnresolvedUsingTypenameDecl * Pattern,UsingDecl * Instance,ASTContext & C)3110 static bool isInstantiationOf(UnresolvedUsingTypenameDecl *Pattern,
3111 UsingDecl *Instance,
3112 ASTContext &C) {
3113 return C.getInstantiatedFromUsingDecl(Instance) == Pattern;
3114 }
3115
isInstantiationOfStaticDataMember(VarDecl * Pattern,VarDecl * Instance)3116 static bool isInstantiationOfStaticDataMember(VarDecl *Pattern,
3117 VarDecl *Instance) {
3118 assert(Instance->isStaticDataMember());
3119
3120 Pattern = Pattern->getCanonicalDecl();
3121
3122 do {
3123 Instance = Instance->getCanonicalDecl();
3124 if (Pattern == Instance) return true;
3125 Instance = Instance->getInstantiatedFromStaticDataMember();
3126 } while (Instance);
3127
3128 return false;
3129 }
3130
3131 // Other is the prospective instantiation
3132 // D is the prospective pattern
isInstantiationOf(ASTContext & Ctx,NamedDecl * D,Decl * Other)3133 static bool isInstantiationOf(ASTContext &Ctx, NamedDecl *D, Decl *Other) {
3134 if (D->getKind() != Other->getKind()) {
3135 if (UnresolvedUsingTypenameDecl *UUD
3136 = dyn_cast<UnresolvedUsingTypenameDecl>(D)) {
3137 if (UsingDecl *UD = dyn_cast<UsingDecl>(Other)) {
3138 return isInstantiationOf(UUD, UD, Ctx);
3139 }
3140 }
3141
3142 if (UnresolvedUsingValueDecl *UUD
3143 = dyn_cast<UnresolvedUsingValueDecl>(D)) {
3144 if (UsingDecl *UD = dyn_cast<UsingDecl>(Other)) {
3145 return isInstantiationOf(UUD, UD, Ctx);
3146 }
3147 }
3148
3149 return false;
3150 }
3151
3152 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Other))
3153 return isInstantiationOf(cast<CXXRecordDecl>(D), Record);
3154
3155 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Other))
3156 return isInstantiationOf(cast<FunctionDecl>(D), Function);
3157
3158 if (EnumDecl *Enum = dyn_cast<EnumDecl>(Other))
3159 return isInstantiationOf(cast<EnumDecl>(D), Enum);
3160
3161 if (VarDecl *Var = dyn_cast<VarDecl>(Other))
3162 if (Var->isStaticDataMember())
3163 return isInstantiationOfStaticDataMember(cast<VarDecl>(D), Var);
3164
3165 if (ClassTemplateDecl *Temp = dyn_cast<ClassTemplateDecl>(Other))
3166 return isInstantiationOf(cast<ClassTemplateDecl>(D), Temp);
3167
3168 if (FunctionTemplateDecl *Temp = dyn_cast<FunctionTemplateDecl>(Other))
3169 return isInstantiationOf(cast<FunctionTemplateDecl>(D), Temp);
3170
3171 if (ClassTemplatePartialSpecializationDecl *PartialSpec
3172 = dyn_cast<ClassTemplatePartialSpecializationDecl>(Other))
3173 return isInstantiationOf(cast<ClassTemplatePartialSpecializationDecl>(D),
3174 PartialSpec);
3175
3176 if (FieldDecl *Field = dyn_cast<FieldDecl>(Other)) {
3177 if (!Field->getDeclName()) {
3178 // This is an unnamed field.
3179 return Ctx.getInstantiatedFromUnnamedFieldDecl(Field) ==
3180 cast<FieldDecl>(D);
3181 }
3182 }
3183
3184 if (UsingDecl *Using = dyn_cast<UsingDecl>(Other))
3185 return isInstantiationOf(cast<UsingDecl>(D), Using, Ctx);
3186
3187 if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(Other))
3188 return isInstantiationOf(cast<UsingShadowDecl>(D), Shadow, Ctx);
3189
3190 return D->getDeclName() && isa<NamedDecl>(Other) &&
3191 D->getDeclName() == cast<NamedDecl>(Other)->getDeclName();
3192 }
3193
3194 template<typename ForwardIterator>
findInstantiationOf(ASTContext & Ctx,NamedDecl * D,ForwardIterator first,ForwardIterator last)3195 static NamedDecl *findInstantiationOf(ASTContext &Ctx,
3196 NamedDecl *D,
3197 ForwardIterator first,
3198 ForwardIterator last) {
3199 for (; first != last; ++first)
3200 if (isInstantiationOf(Ctx, D, *first))
3201 return cast<NamedDecl>(*first);
3202
3203 return 0;
3204 }
3205
3206 /// \brief Finds the instantiation of the given declaration context
3207 /// within the current instantiation.
3208 ///
3209 /// \returns NULL if there was an error
FindInstantiatedContext(SourceLocation Loc,DeclContext * DC,const MultiLevelTemplateArgumentList & TemplateArgs)3210 DeclContext *Sema::FindInstantiatedContext(SourceLocation Loc, DeclContext* DC,
3211 const MultiLevelTemplateArgumentList &TemplateArgs) {
3212 if (NamedDecl *D = dyn_cast<NamedDecl>(DC)) {
3213 Decl* ID = FindInstantiatedDecl(Loc, D, TemplateArgs);
3214 return cast_or_null<DeclContext>(ID);
3215 } else return DC;
3216 }
3217
3218 /// \brief Find the instantiation of the given declaration within the
3219 /// current instantiation.
3220 ///
3221 /// This routine is intended to be used when \p D is a declaration
3222 /// referenced from within a template, that needs to mapped into the
3223 /// corresponding declaration within an instantiation. For example,
3224 /// given:
3225 ///
3226 /// \code
3227 /// template<typename T>
3228 /// struct X {
3229 /// enum Kind {
3230 /// KnownValue = sizeof(T)
3231 /// };
3232 ///
3233 /// bool getKind() const { return KnownValue; }
3234 /// };
3235 ///
3236 /// template struct X<int>;
3237 /// \endcode
3238 ///
3239 /// In the instantiation of X<int>::getKind(), we need to map the
3240 /// EnumConstantDecl for KnownValue (which refers to
3241 /// X<T>::<Kind>::KnownValue) to its instantiation
3242 /// (X<int>::<Kind>::KnownValue). InstantiateCurrentDeclRef() performs
3243 /// this mapping from within the instantiation of X<int>.
FindInstantiatedDecl(SourceLocation Loc,NamedDecl * D,const MultiLevelTemplateArgumentList & TemplateArgs)3244 NamedDecl *Sema::FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D,
3245 const MultiLevelTemplateArgumentList &TemplateArgs) {
3246 DeclContext *ParentDC = D->getDeclContext();
3247 if (isa<ParmVarDecl>(D) || isa<NonTypeTemplateParmDecl>(D) ||
3248 isa<TemplateTypeParmDecl>(D) || isa<TemplateTemplateParmDecl>(D) ||
3249 (ParentDC->isFunctionOrMethod() && ParentDC->isDependentContext()) ||
3250 (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda())) {
3251 // D is a local of some kind. Look into the map of local
3252 // declarations to their instantiations.
3253 typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
3254 llvm::PointerUnion<Decl *, DeclArgumentPack *> *Found
3255 = CurrentInstantiationScope->findInstantiationOf(D);
3256
3257 if (Found) {
3258 if (Decl *FD = Found->dyn_cast<Decl *>())
3259 return cast<NamedDecl>(FD);
3260
3261 unsigned PackIdx = ArgumentPackSubstitutionIndex;
3262 return cast<NamedDecl>((*Found->get<DeclArgumentPack *>())[PackIdx]);
3263 }
3264
3265 // If we didn't find the decl, then we must have a label decl that hasn't
3266 // been found yet. Lazily instantiate it and return it now.
3267 assert(isa<LabelDecl>(D));
3268
3269 Decl *Inst = SubstDecl(D, CurContext, TemplateArgs);
3270 assert(Inst && "Failed to instantiate label??");
3271
3272 CurrentInstantiationScope->InstantiatedLocal(D, Inst);
3273 return cast<LabelDecl>(Inst);
3274 }
3275
3276 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
3277 if (!Record->isDependentContext())
3278 return D;
3279
3280 // Determine whether this record is the "templated" declaration describing
3281 // a class template or class template partial specialization.
3282 ClassTemplateDecl *ClassTemplate = Record->getDescribedClassTemplate();
3283 if (ClassTemplate)
3284 ClassTemplate = ClassTemplate->getCanonicalDecl();
3285 else if (ClassTemplatePartialSpecializationDecl *PartialSpec
3286 = dyn_cast<ClassTemplatePartialSpecializationDecl>(Record))
3287 ClassTemplate = PartialSpec->getSpecializedTemplate()->getCanonicalDecl();
3288
3289 // Walk the current context to find either the record or an instantiation of
3290 // it.
3291 DeclContext *DC = CurContext;
3292 while (!DC->isFileContext()) {
3293 // If we're performing substitution while we're inside the template
3294 // definition, we'll find our own context. We're done.
3295 if (DC->Equals(Record))
3296 return Record;
3297
3298 if (CXXRecordDecl *InstRecord = dyn_cast<CXXRecordDecl>(DC)) {
3299 // Check whether we're in the process of instantiating a class template
3300 // specialization of the template we're mapping.
3301 if (ClassTemplateSpecializationDecl *InstSpec
3302 = dyn_cast<ClassTemplateSpecializationDecl>(InstRecord)){
3303 ClassTemplateDecl *SpecTemplate = InstSpec->getSpecializedTemplate();
3304 if (ClassTemplate && isInstantiationOf(ClassTemplate, SpecTemplate))
3305 return InstRecord;
3306 }
3307
3308 // Check whether we're in the process of instantiating a member class.
3309 if (isInstantiationOf(Record, InstRecord))
3310 return InstRecord;
3311 }
3312
3313
3314 // Move to the outer template scope.
3315 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(DC)) {
3316 if (FD->getFriendObjectKind() && FD->getDeclContext()->isFileContext()){
3317 DC = FD->getLexicalDeclContext();
3318 continue;
3319 }
3320 }
3321
3322 DC = DC->getParent();
3323 }
3324
3325 // Fall through to deal with other dependent record types (e.g.,
3326 // anonymous unions in class templates).
3327 }
3328
3329 if (!ParentDC->isDependentContext())
3330 return D;
3331
3332 ParentDC = FindInstantiatedContext(Loc, ParentDC, TemplateArgs);
3333 if (!ParentDC)
3334 return 0;
3335
3336 if (ParentDC != D->getDeclContext()) {
3337 // We performed some kind of instantiation in the parent context,
3338 // so now we need to look into the instantiated parent context to
3339 // find the instantiation of the declaration D.
3340
3341 // If our context used to be dependent, we may need to instantiate
3342 // it before performing lookup into that context.
3343 bool IsBeingInstantiated = false;
3344 if (CXXRecordDecl *Spec = dyn_cast<CXXRecordDecl>(ParentDC)) {
3345 if (!Spec->isDependentContext()) {
3346 QualType T = Context.getTypeDeclType(Spec);
3347 const RecordType *Tag = T->getAs<RecordType>();
3348 assert(Tag && "type of non-dependent record is not a RecordType");
3349 if (Tag->isBeingDefined())
3350 IsBeingInstantiated = true;
3351 if (!Tag->isBeingDefined() &&
3352 RequireCompleteType(Loc, T, diag::err_incomplete_type))
3353 return 0;
3354
3355 ParentDC = Tag->getDecl();
3356 }
3357 }
3358
3359 NamedDecl *Result = 0;
3360 if (D->getDeclName()) {
3361 DeclContext::lookup_result Found = ParentDC->lookup(D->getDeclName());
3362 Result = findInstantiationOf(Context, D, Found.first, Found.second);
3363 } else {
3364 // Since we don't have a name for the entity we're looking for,
3365 // our only option is to walk through all of the declarations to
3366 // find that name. This will occur in a few cases:
3367 //
3368 // - anonymous struct/union within a template
3369 // - unnamed class/struct/union/enum within a template
3370 //
3371 // FIXME: Find a better way to find these instantiations!
3372 Result = findInstantiationOf(Context, D,
3373 ParentDC->decls_begin(),
3374 ParentDC->decls_end());
3375 }
3376
3377 if (!Result) {
3378 if (isa<UsingShadowDecl>(D)) {
3379 // UsingShadowDecls can instantiate to nothing because of using hiding.
3380 } else if (Diags.hasErrorOccurred()) {
3381 // We've already complained about something, so most likely this
3382 // declaration failed to instantiate. There's no point in complaining
3383 // further, since this is normal in invalid code.
3384 } else if (IsBeingInstantiated) {
3385 // The class in which this member exists is currently being
3386 // instantiated, and we haven't gotten around to instantiating this
3387 // member yet. This can happen when the code uses forward declarations
3388 // of member classes, and introduces ordering dependencies via
3389 // template instantiation.
3390 Diag(Loc, diag::err_member_not_yet_instantiated)
3391 << D->getDeclName()
3392 << Context.getTypeDeclType(cast<CXXRecordDecl>(ParentDC));
3393 Diag(D->getLocation(), diag::note_non_instantiated_member_here);
3394 } else if (EnumConstantDecl *ED = dyn_cast<EnumConstantDecl>(D)) {
3395 // This enumeration constant was found when the template was defined,
3396 // but can't be found in the instantiation. This can happen if an
3397 // unscoped enumeration member is explicitly specialized.
3398 EnumDecl *Enum = cast<EnumDecl>(ED->getLexicalDeclContext());
3399 EnumDecl *Spec = cast<EnumDecl>(FindInstantiatedDecl(Loc, Enum,
3400 TemplateArgs));
3401 assert(Spec->getTemplateSpecializationKind() ==
3402 TSK_ExplicitSpecialization);
3403 Diag(Loc, diag::err_enumerator_does_not_exist)
3404 << D->getDeclName()
3405 << Context.getTypeDeclType(cast<TypeDecl>(Spec->getDeclContext()));
3406 Diag(Spec->getLocation(), diag::note_enum_specialized_here)
3407 << Context.getTypeDeclType(Spec);
3408 } else {
3409 // We should have found something, but didn't.
3410 llvm_unreachable("Unable to find instantiation of declaration!");
3411 }
3412 }
3413
3414 D = Result;
3415 }
3416
3417 return D;
3418 }
3419
3420 /// \brief Performs template instantiation for all implicit template
3421 /// instantiations we have seen until this point.
PerformPendingInstantiations(bool LocalOnly)3422 void Sema::PerformPendingInstantiations(bool LocalOnly) {
3423 // Load pending instantiations from the external source.
3424 if (!LocalOnly && ExternalSource) {
3425 SmallVector<std::pair<ValueDecl *, SourceLocation>, 4> Pending;
3426 ExternalSource->ReadPendingInstantiations(Pending);
3427 PendingInstantiations.insert(PendingInstantiations.begin(),
3428 Pending.begin(), Pending.end());
3429 }
3430
3431 while (!PendingLocalImplicitInstantiations.empty() ||
3432 (!LocalOnly && !PendingInstantiations.empty())) {
3433 PendingImplicitInstantiation Inst;
3434
3435 if (PendingLocalImplicitInstantiations.empty()) {
3436 Inst = PendingInstantiations.front();
3437 PendingInstantiations.pop_front();
3438 } else {
3439 Inst = PendingLocalImplicitInstantiations.front();
3440 PendingLocalImplicitInstantiations.pop_front();
3441 }
3442
3443 // Instantiate function definitions
3444 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Inst.first)) {
3445 PrettyDeclStackTraceEntry CrashInfo(*this, Function, SourceLocation(),
3446 "instantiating function definition");
3447 bool DefinitionRequired = Function->getTemplateSpecializationKind() ==
3448 TSK_ExplicitInstantiationDefinition;
3449 InstantiateFunctionDefinition(/*FIXME:*/Inst.second, Function, true,
3450 DefinitionRequired);
3451 continue;
3452 }
3453
3454 // Instantiate static data member definitions.
3455 VarDecl *Var = cast<VarDecl>(Inst.first);
3456 assert(Var->isStaticDataMember() && "Not a static data member?");
3457
3458 // Don't try to instantiate declarations if the most recent redeclaration
3459 // is invalid.
3460 if (Var->getMostRecentDecl()->isInvalidDecl())
3461 continue;
3462
3463 // Check if the most recent declaration has changed the specialization kind
3464 // and removed the need for implicit instantiation.
3465 switch (Var->getMostRecentDecl()->getTemplateSpecializationKind()) {
3466 case TSK_Undeclared:
3467 llvm_unreachable("Cannot instantitiate an undeclared specialization.");
3468 case TSK_ExplicitInstantiationDeclaration:
3469 case TSK_ExplicitSpecialization:
3470 continue; // No longer need to instantiate this type.
3471 case TSK_ExplicitInstantiationDefinition:
3472 // We only need an instantiation if the pending instantiation *is* the
3473 // explicit instantiation.
3474 if (Var != Var->getMostRecentDecl()) continue;
3475 case TSK_ImplicitInstantiation:
3476 break;
3477 }
3478
3479 PrettyDeclStackTraceEntry CrashInfo(*this, Var, Var->getLocation(),
3480 "instantiating static data member "
3481 "definition");
3482
3483 bool DefinitionRequired = Var->getTemplateSpecializationKind() ==
3484 TSK_ExplicitInstantiationDefinition;
3485 InstantiateStaticDataMemberDefinition(/*FIXME:*/Inst.second, Var, true,
3486 DefinitionRequired);
3487 }
3488 }
3489
PerformDependentDiagnostics(const DeclContext * Pattern,const MultiLevelTemplateArgumentList & TemplateArgs)3490 void Sema::PerformDependentDiagnostics(const DeclContext *Pattern,
3491 const MultiLevelTemplateArgumentList &TemplateArgs) {
3492 for (DeclContext::ddiag_iterator I = Pattern->ddiag_begin(),
3493 E = Pattern->ddiag_end(); I != E; ++I) {
3494 DependentDiagnostic *DD = *I;
3495
3496 switch (DD->getKind()) {
3497 case DependentDiagnostic::Access:
3498 HandleDependentAccessCheck(*DD, TemplateArgs);
3499 break;
3500 }
3501 }
3502 }
3503