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