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