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