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