SemaTemplateInstantiateDecl.cpp revision 88dff5f420c1adb91b60e18defc4e732982df7bf
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 "Sema.h" 13#include "clang/AST/ASTConsumer.h" 14#include "clang/AST/ASTContext.h" 15#include "clang/AST/DeclTemplate.h" 16#include "clang/AST/DeclVisitor.h" 17#include "clang/AST/Expr.h" 18#include "clang/Basic/PrettyStackTrace.h" 19#include "clang/Lex/Preprocessor.h" 20#include "llvm/Support/Compiler.h" 21 22using namespace clang; 23 24namespace { 25 class VISIBILITY_HIDDEN TemplateDeclInstantiator 26 : public DeclVisitor<TemplateDeclInstantiator, Decl *> { 27 Sema &SemaRef; 28 DeclContext *Owner; 29 const MultiLevelTemplateArgumentList &TemplateArgs; 30 31 public: 32 typedef Sema::OwningExprResult OwningExprResult; 33 34 TemplateDeclInstantiator(Sema &SemaRef, DeclContext *Owner, 35 const MultiLevelTemplateArgumentList &TemplateArgs) 36 : SemaRef(SemaRef), Owner(Owner), TemplateArgs(TemplateArgs) { } 37 38 // FIXME: Once we get closer to completion, replace these manually-written 39 // declarations with automatically-generated ones from 40 // clang/AST/DeclNodes.def. 41 Decl *VisitTranslationUnitDecl(TranslationUnitDecl *D); 42 Decl *VisitNamespaceDecl(NamespaceDecl *D); 43 Decl *VisitTypedefDecl(TypedefDecl *D); 44 Decl *VisitVarDecl(VarDecl *D); 45 Decl *VisitFieldDecl(FieldDecl *D); 46 Decl *VisitStaticAssertDecl(StaticAssertDecl *D); 47 Decl *VisitEnumDecl(EnumDecl *D); 48 Decl *VisitEnumConstantDecl(EnumConstantDecl *D); 49 Decl *VisitFriendDecl(FriendDecl *D); 50 Decl *VisitFunctionDecl(FunctionDecl *D, 51 TemplateParameterList *TemplateParams = 0); 52 Decl *VisitCXXRecordDecl(CXXRecordDecl *D); 53 Decl *VisitCXXMethodDecl(CXXMethodDecl *D, 54 TemplateParameterList *TemplateParams = 0); 55 Decl *VisitCXXConstructorDecl(CXXConstructorDecl *D); 56 Decl *VisitCXXDestructorDecl(CXXDestructorDecl *D); 57 Decl *VisitCXXConversionDecl(CXXConversionDecl *D); 58 ParmVarDecl *VisitParmVarDecl(ParmVarDecl *D); 59 Decl *VisitClassTemplateDecl(ClassTemplateDecl *D); 60 Decl *VisitClassTemplatePartialSpecializationDecl( 61 ClassTemplatePartialSpecializationDecl *D); 62 Decl *VisitFunctionTemplateDecl(FunctionTemplateDecl *D); 63 Decl *VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D); 64 Decl *VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D); 65 Decl *VisitUnresolvedUsingDecl(UnresolvedUsingDecl *D); 66 67 // Base case. FIXME: Remove once we can instantiate everything. 68 Decl *VisitDecl(Decl *) { 69 assert(false && "Template instantiation of unknown declaration kind!"); 70 return 0; 71 } 72 73 const LangOptions &getLangOptions() { 74 return SemaRef.getLangOptions(); 75 } 76 77 // Helper functions for instantiating methods. 78 QualType SubstFunctionType(FunctionDecl *D, 79 llvm::SmallVectorImpl<ParmVarDecl *> &Params); 80 bool InitFunctionInstantiation(FunctionDecl *New, FunctionDecl *Tmpl); 81 bool InitMethodInstantiation(CXXMethodDecl *New, CXXMethodDecl *Tmpl); 82 83 TemplateParameterList * 84 SubstTemplateParams(TemplateParameterList *List); 85 86 bool InstantiateClassTemplatePartialSpecialization( 87 ClassTemplateDecl *ClassTemplate, 88 ClassTemplatePartialSpecializationDecl *PartialSpec); 89 }; 90} 91 92Decl * 93TemplateDeclInstantiator::VisitTranslationUnitDecl(TranslationUnitDecl *D) { 94 assert(false && "Translation units cannot be instantiated"); 95 return D; 96} 97 98Decl * 99TemplateDeclInstantiator::VisitNamespaceDecl(NamespaceDecl *D) { 100 assert(false && "Namespaces cannot be instantiated"); 101 return D; 102} 103 104Decl *TemplateDeclInstantiator::VisitTypedefDecl(TypedefDecl *D) { 105 bool Invalid = false; 106 DeclaratorInfo *DI = D->getTypeDeclaratorInfo(); 107 if (DI->getType()->isDependentType()) { 108 DI = SemaRef.SubstType(DI, TemplateArgs, 109 D->getLocation(), D->getDeclName()); 110 if (!DI) { 111 Invalid = true; 112 DI = SemaRef.Context.getTrivialDeclaratorInfo(SemaRef.Context.IntTy); 113 } 114 } 115 116 // Create the new typedef 117 TypedefDecl *Typedef 118 = TypedefDecl::Create(SemaRef.Context, Owner, D->getLocation(), 119 D->getIdentifier(), DI); 120 if (Invalid) 121 Typedef->setInvalidDecl(); 122 123 Owner->addDecl(Typedef); 124 125 return Typedef; 126} 127 128Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D) { 129 // Do substitution on the type of the declaration 130 DeclaratorInfo *DI = SemaRef.SubstType(D->getDeclaratorInfo(), 131 TemplateArgs, 132 D->getTypeSpecStartLoc(), 133 D->getDeclName()); 134 if (!DI) 135 return 0; 136 137 // Build the instantiated declaration 138 VarDecl *Var = VarDecl::Create(SemaRef.Context, Owner, 139 D->getLocation(), D->getIdentifier(), 140 DI->getType(), DI, 141 D->getStorageClass()); 142 Var->setThreadSpecified(D->isThreadSpecified()); 143 Var->setCXXDirectInitializer(D->hasCXXDirectInitializer()); 144 Var->setDeclaredInCondition(D->isDeclaredInCondition()); 145 146 // If we are instantiating a static data member defined 147 // out-of-line, the instantiation will have the same lexical 148 // context (which will be a namespace scope) as the template. 149 if (D->isOutOfLine()) 150 Var->setLexicalDeclContext(D->getLexicalDeclContext()); 151 152 // FIXME: In theory, we could have a previous declaration for variables that 153 // are not static data members. 154 bool Redeclaration = false; 155 SemaRef.CheckVariableDeclaration(Var, 0, Redeclaration); 156 157 if (D->isOutOfLine()) { 158 D->getLexicalDeclContext()->addDecl(Var); 159 Owner->makeDeclVisibleInContext(Var); 160 } else { 161 Owner->addDecl(Var); 162 } 163 164 // Link instantiations of static data members back to the template from 165 // which they were instantiated. 166 if (Var->isStaticDataMember()) 167 SemaRef.Context.setInstantiatedFromStaticDataMember(Var, D, 168 TSK_ImplicitInstantiation); 169 170 if (D->getInit()) { 171 OwningExprResult Init 172 = SemaRef.SubstExpr(D->getInit(), TemplateArgs); 173 if (Init.isInvalid()) 174 Var->setInvalidDecl(); 175 else if (ParenListExpr *PLE = dyn_cast<ParenListExpr>((Expr *)Init.get())) { 176 // FIXME: We're faking all of the comma locations, which is suboptimal. 177 // Do we even need these comma locations? 178 llvm::SmallVector<SourceLocation, 4> FakeCommaLocs; 179 if (PLE->getNumExprs() > 0) { 180 FakeCommaLocs.reserve(PLE->getNumExprs() - 1); 181 for (unsigned I = 0, N = PLE->getNumExprs() - 1; I != N; ++I) { 182 Expr *E = PLE->getExpr(I)->Retain(); 183 FakeCommaLocs.push_back( 184 SemaRef.PP.getLocForEndOfToken(E->getLocEnd())); 185 } 186 PLE->getExpr(PLE->getNumExprs() - 1)->Retain(); 187 } 188 189 // Add the direct initializer to the declaration. 190 SemaRef.AddCXXDirectInitializerToDecl(Sema::DeclPtrTy::make(Var), 191 PLE->getLParenLoc(), 192 Sema::MultiExprArg(SemaRef, 193 (void**)PLE->getExprs(), 194 PLE->getNumExprs()), 195 FakeCommaLocs.data(), 196 PLE->getRParenLoc()); 197 198 // When Init is destroyed, it will destroy the instantiated ParenListExpr; 199 // we've explicitly retained all of its subexpressions already. 200 } else 201 SemaRef.AddInitializerToDecl(Sema::DeclPtrTy::make(Var), move(Init), 202 D->hasCXXDirectInitializer()); 203 } else if (!Var->isStaticDataMember() || Var->isOutOfLine()) 204 SemaRef.ActOnUninitializedDecl(Sema::DeclPtrTy::make(Var), false); 205 206 return Var; 207} 208 209Decl *TemplateDeclInstantiator::VisitFieldDecl(FieldDecl *D) { 210 bool Invalid = false; 211 DeclaratorInfo *DI = D->getDeclaratorInfo(); 212 if (DI->getType()->isDependentType()) { 213 DI = SemaRef.SubstType(DI, TemplateArgs, 214 D->getLocation(), D->getDeclName()); 215 if (!DI) { 216 DI = D->getDeclaratorInfo(); 217 Invalid = true; 218 } else if (DI->getType()->isFunctionType()) { 219 // C++ [temp.arg.type]p3: 220 // If a declaration acquires a function type through a type 221 // dependent on a template-parameter and this causes a 222 // declaration that does not use the syntactic form of a 223 // function declarator to have function type, the program is 224 // ill-formed. 225 SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function) 226 << DI->getType(); 227 Invalid = true; 228 } 229 } 230 231 Expr *BitWidth = D->getBitWidth(); 232 if (Invalid) 233 BitWidth = 0; 234 else if (BitWidth) { 235 // The bit-width expression is not potentially evaluated. 236 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 237 238 OwningExprResult InstantiatedBitWidth 239 = SemaRef.SubstExpr(BitWidth, TemplateArgs); 240 if (InstantiatedBitWidth.isInvalid()) { 241 Invalid = true; 242 BitWidth = 0; 243 } else 244 BitWidth = InstantiatedBitWidth.takeAs<Expr>(); 245 } 246 247 FieldDecl *Field = SemaRef.CheckFieldDecl(D->getDeclName(), 248 DI->getType(), DI, 249 cast<RecordDecl>(Owner), 250 D->getLocation(), 251 D->isMutable(), 252 BitWidth, 253 D->getTypeSpecStartLoc(), 254 D->getAccess(), 255 0); 256 if (!Field) { 257 cast<Decl>(Owner)->setInvalidDecl(); 258 return 0; 259 } 260 261 if (Invalid) 262 Field->setInvalidDecl(); 263 264 if (!Field->getDeclName()) { 265 // Keep track of where this decl came from. 266 SemaRef.Context.setInstantiatedFromUnnamedFieldDecl(Field, D); 267 } 268 269 Field->setImplicit(D->isImplicit()); 270 Owner->addDecl(Field); 271 272 return Field; 273} 274 275Decl *TemplateDeclInstantiator::VisitFriendDecl(FriendDecl *D) { 276 FriendDecl::FriendUnion FU; 277 278 // Handle friend type expressions by simply substituting template 279 // parameters into the pattern type. 280 if (Type *Ty = D->getFriendType()) { 281 QualType T = SemaRef.SubstType(QualType(Ty,0), TemplateArgs, 282 D->getLocation(), DeclarationName()); 283 if (T.isNull()) return 0; 284 285 assert(getLangOptions().CPlusPlus0x || T->isRecordType()); 286 FU = T.getTypePtr(); 287 288 // Handle everything else by appropriate substitution. 289 } else { 290 NamedDecl *ND = D->getFriendDecl(); 291 assert(ND && "friend decl must be a decl or a type!"); 292 293 // FIXME: We have a problem here, because the nested call to Visit(ND) 294 // will inject the thing that the friend references into the current 295 // owner, which is wrong. 296 Decl *NewND = Visit(ND); 297 if (!NewND) return 0; 298 299 FU = cast<NamedDecl>(NewND); 300 } 301 302 FriendDecl *FD = 303 FriendDecl::Create(SemaRef.Context, Owner, D->getLocation(), FU, 304 D->getFriendLoc()); 305 FD->setAccess(AS_public); 306 Owner->addDecl(FD); 307 return FD; 308} 309 310Decl *TemplateDeclInstantiator::VisitStaticAssertDecl(StaticAssertDecl *D) { 311 Expr *AssertExpr = D->getAssertExpr(); 312 313 // The expression in a static assertion is not potentially evaluated. 314 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 315 316 OwningExprResult InstantiatedAssertExpr 317 = SemaRef.SubstExpr(AssertExpr, TemplateArgs); 318 if (InstantiatedAssertExpr.isInvalid()) 319 return 0; 320 321 OwningExprResult Message(SemaRef, D->getMessage()); 322 D->getMessage()->Retain(); 323 Decl *StaticAssert 324 = SemaRef.ActOnStaticAssertDeclaration(D->getLocation(), 325 move(InstantiatedAssertExpr), 326 move(Message)).getAs<Decl>(); 327 return StaticAssert; 328} 329 330Decl *TemplateDeclInstantiator::VisitEnumDecl(EnumDecl *D) { 331 EnumDecl *Enum = EnumDecl::Create(SemaRef.Context, Owner, 332 D->getLocation(), D->getIdentifier(), 333 D->getTagKeywordLoc(), 334 /*PrevDecl=*/0); 335 Enum->setInstantiationOfMemberEnum(D); 336 Enum->setAccess(D->getAccess()); 337 Owner->addDecl(Enum); 338 Enum->startDefinition(); 339 340 llvm::SmallVector<Sema::DeclPtrTy, 4> Enumerators; 341 342 EnumConstantDecl *LastEnumConst = 0; 343 for (EnumDecl::enumerator_iterator EC = D->enumerator_begin(), 344 ECEnd = D->enumerator_end(); 345 EC != ECEnd; ++EC) { 346 // The specified value for the enumerator. 347 OwningExprResult Value = SemaRef.Owned((Expr *)0); 348 if (Expr *UninstValue = EC->getInitExpr()) { 349 // The enumerator's value expression is not potentially evaluated. 350 EnterExpressionEvaluationContext Unevaluated(SemaRef, 351 Action::Unevaluated); 352 353 Value = SemaRef.SubstExpr(UninstValue, TemplateArgs); 354 } 355 356 // Drop the initial value and continue. 357 bool isInvalid = false; 358 if (Value.isInvalid()) { 359 Value = SemaRef.Owned((Expr *)0); 360 isInvalid = true; 361 } 362 363 EnumConstantDecl *EnumConst 364 = SemaRef.CheckEnumConstant(Enum, LastEnumConst, 365 EC->getLocation(), EC->getIdentifier(), 366 move(Value)); 367 368 if (isInvalid) { 369 if (EnumConst) 370 EnumConst->setInvalidDecl(); 371 Enum->setInvalidDecl(); 372 } 373 374 if (EnumConst) { 375 Enum->addDecl(EnumConst); 376 Enumerators.push_back(Sema::DeclPtrTy::make(EnumConst)); 377 LastEnumConst = EnumConst; 378 } 379 } 380 381 // FIXME: Fixup LBraceLoc and RBraceLoc 382 // FIXME: Empty Scope and AttributeList (required to handle attribute packed). 383 SemaRef.ActOnEnumBody(Enum->getLocation(), SourceLocation(), SourceLocation(), 384 Sema::DeclPtrTy::make(Enum), 385 &Enumerators[0], Enumerators.size(), 386 0, 0); 387 388 return Enum; 389} 390 391Decl *TemplateDeclInstantiator::VisitEnumConstantDecl(EnumConstantDecl *D) { 392 assert(false && "EnumConstantDecls can only occur within EnumDecls."); 393 return 0; 394} 395 396namespace { 397 class SortDeclByLocation { 398 SourceManager &SourceMgr; 399 400 public: 401 explicit SortDeclByLocation(SourceManager &SourceMgr) 402 : SourceMgr(SourceMgr) { } 403 404 bool operator()(const Decl *X, const Decl *Y) const { 405 return SourceMgr.isBeforeInTranslationUnit(X->getLocation(), 406 Y->getLocation()); 407 } 408 }; 409} 410 411Decl *TemplateDeclInstantiator::VisitClassTemplateDecl(ClassTemplateDecl *D) { 412 TemplateParameterList *TempParams = D->getTemplateParameters(); 413 TemplateParameterList *InstParams = SubstTemplateParams(TempParams); 414 if (!InstParams) 415 return NULL; 416 417 CXXRecordDecl *Pattern = D->getTemplatedDecl(); 418 CXXRecordDecl *RecordInst 419 = CXXRecordDecl::Create(SemaRef.Context, Pattern->getTagKind(), Owner, 420 Pattern->getLocation(), Pattern->getIdentifier(), 421 Pattern->getTagKeywordLoc(), /*PrevDecl=*/ NULL, 422 /*DelayTypeCreation=*/true); 423 424 ClassTemplateDecl *Inst 425 = ClassTemplateDecl::Create(SemaRef.Context, Owner, D->getLocation(), 426 D->getIdentifier(), InstParams, RecordInst, 0); 427 RecordInst->setDescribedClassTemplate(Inst); 428 if (D->getFriendObjectKind()) 429 Inst->setObjectOfFriendDecl(true); 430 else 431 Inst->setAccess(D->getAccess()); 432 Inst->setInstantiatedFromMemberTemplate(D); 433 434 // Trigger creation of the type for the instantiation. 435 SemaRef.Context.getTypeDeclType(RecordInst); 436 437 // We're done with friends now. 438 if (Inst->getFriendObjectKind()) 439 return Inst; 440 441 Owner->addDecl(Inst); 442 443 // First, we sort the partial specializations by location, so 444 // that we instantiate them in the order they were declared. 445 llvm::SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs; 446 for (llvm::FoldingSet<ClassTemplatePartialSpecializationDecl>::iterator 447 P = D->getPartialSpecializations().begin(), 448 PEnd = D->getPartialSpecializations().end(); 449 P != PEnd; ++P) 450 PartialSpecs.push_back(&*P); 451 std::sort(PartialSpecs.begin(), PartialSpecs.end(), 452 SortDeclByLocation(SemaRef.SourceMgr)); 453 454 // Instantiate all of the partial specializations of this member class 455 // template. 456 for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) 457 InstantiateClassTemplatePartialSpecialization(Inst, PartialSpecs[I]); 458 459 return Inst; 460} 461 462Decl * 463TemplateDeclInstantiator::VisitClassTemplatePartialSpecializationDecl( 464 ClassTemplatePartialSpecializationDecl *D) { 465 ClassTemplateDecl *ClassTemplate = D->getSpecializedTemplate(); 466 467 // Lookup the already-instantiated declaration in the instantiation 468 // of the class template and return that. 469 DeclContext::lookup_result Found 470 = Owner->lookup(ClassTemplate->getDeclName()); 471 if (Found.first == Found.second) 472 return 0; 473 474 ClassTemplateDecl *InstClassTemplate 475 = dyn_cast<ClassTemplateDecl>(*Found.first); 476 if (!InstClassTemplate) 477 return 0; 478 479 Decl *DCanon = D->getCanonicalDecl(); 480 for (llvm::FoldingSet<ClassTemplatePartialSpecializationDecl>::iterator 481 P = InstClassTemplate->getPartialSpecializations().begin(), 482 PEnd = InstClassTemplate->getPartialSpecializations().end(); 483 P != PEnd; ++P) { 484 if (P->getInstantiatedFromMember()->getCanonicalDecl() == DCanon) 485 return &*P; 486 } 487 488 return 0; 489} 490 491Decl * 492TemplateDeclInstantiator::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) { 493 // FIXME: Dig out the out-of-line definition of this function template? 494 495 TemplateParameterList *TempParams = D->getTemplateParameters(); 496 TemplateParameterList *InstParams = SubstTemplateParams(TempParams); 497 if (!InstParams) 498 return NULL; 499 500 FunctionDecl *Instantiated = 0; 501 if (CXXMethodDecl *DMethod = dyn_cast<CXXMethodDecl>(D->getTemplatedDecl())) 502 Instantiated = cast_or_null<FunctionDecl>(VisitCXXMethodDecl(DMethod, 503 InstParams)); 504 else 505 Instantiated = cast_or_null<FunctionDecl>(VisitFunctionDecl( 506 D->getTemplatedDecl(), 507 InstParams)); 508 509 if (!Instantiated) 510 return 0; 511 512 // Link the instantiated function template declaration to the function 513 // template from which it was instantiated. 514 FunctionTemplateDecl *InstTemplate 515 = Instantiated->getDescribedFunctionTemplate(); 516 InstTemplate->setAccess(D->getAccess()); 517 assert(InstTemplate && 518 "VisitFunctionDecl/CXXMethodDecl didn't create a template!"); 519 if (!InstTemplate->getInstantiatedFromMemberTemplate()) 520 InstTemplate->setInstantiatedFromMemberTemplate(D); 521 522 // Add non-friends into the owner. 523 if (!InstTemplate->getFriendObjectKind()) 524 Owner->addDecl(InstTemplate); 525 return InstTemplate; 526} 527 528Decl *TemplateDeclInstantiator::VisitCXXRecordDecl(CXXRecordDecl *D) { 529 CXXRecordDecl *PrevDecl = 0; 530 if (D->isInjectedClassName()) 531 PrevDecl = cast<CXXRecordDecl>(Owner); 532 533 CXXRecordDecl *Record 534 = CXXRecordDecl::Create(SemaRef.Context, D->getTagKind(), Owner, 535 D->getLocation(), D->getIdentifier(), 536 D->getTagKeywordLoc(), PrevDecl); 537 Record->setImplicit(D->isImplicit()); 538 // FIXME: Check against AS_none is an ugly hack to work around the issue that 539 // the tag decls introduced by friend class declarations don't have an access 540 // specifier. Remove once this area of the code gets sorted out. 541 if (D->getAccess() != AS_none) 542 Record->setAccess(D->getAccess()); 543 if (!D->isInjectedClassName()) 544 Record->setInstantiationOfMemberClass(D, TSK_ImplicitInstantiation); 545 546 // If the original function was part of a friend declaration, 547 // inherit its namespace state. 548 if (Decl::FriendObjectKind FOK = D->getFriendObjectKind()) 549 Record->setObjectOfFriendDecl(FOK == Decl::FOK_Declared); 550 551 Record->setAnonymousStructOrUnion(D->isAnonymousStructOrUnion()); 552 553 Owner->addDecl(Record); 554 return Record; 555} 556 557/// Normal class members are of more specific types and therefore 558/// don't make it here. This function serves two purposes: 559/// 1) instantiating function templates 560/// 2) substituting friend declarations 561/// FIXME: preserve function definitions in case #2 562 Decl *TemplateDeclInstantiator::VisitFunctionDecl(FunctionDecl *D, 563 TemplateParameterList *TemplateParams) { 564 // Check whether there is already a function template specialization for 565 // this declaration. 566 FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate(); 567 void *InsertPos = 0; 568 if (FunctionTemplate && !TemplateParams) { 569 llvm::FoldingSetNodeID ID; 570 FunctionTemplateSpecializationInfo::Profile(ID, 571 TemplateArgs.getInnermost().getFlatArgumentList(), 572 TemplateArgs.getInnermost().flat_size(), 573 SemaRef.Context); 574 575 FunctionTemplateSpecializationInfo *Info 576 = FunctionTemplate->getSpecializations().FindNodeOrInsertPos(ID, 577 InsertPos); 578 579 // If we already have a function template specialization, return it. 580 if (Info) 581 return Info->Function; 582 } 583 584 Sema::LocalInstantiationScope Scope(SemaRef); 585 586 llvm::SmallVector<ParmVarDecl *, 4> Params; 587 QualType T = SubstFunctionType(D, Params); 588 if (T.isNull()) 589 return 0; 590 591 // Build the instantiated method declaration. 592 DeclContext *DC = SemaRef.FindInstantiatedContext(D->getDeclContext(), 593 TemplateArgs); 594 FunctionDecl *Function = 595 FunctionDecl::Create(SemaRef.Context, DC, D->getLocation(), 596 D->getDeclName(), T, D->getDeclaratorInfo(), 597 D->getStorageClass(), 598 D->isInlineSpecified(), D->hasWrittenPrototype()); 599 Function->setLexicalDeclContext(Owner); 600 601 // Attach the parameters 602 for (unsigned P = 0; P < Params.size(); ++P) 603 Params[P]->setOwningFunction(Function); 604 Function->setParams(SemaRef.Context, Params.data(), Params.size()); 605 606 if (TemplateParams) { 607 // Our resulting instantiation is actually a function template, since we 608 // are substituting only the outer template parameters. For example, given 609 // 610 // template<typename T> 611 // struct X { 612 // template<typename U> friend void f(T, U); 613 // }; 614 // 615 // X<int> x; 616 // 617 // We are instantiating the friend function template "f" within X<int>, 618 // which means substituting int for T, but leaving "f" as a friend function 619 // template. 620 // Build the function template itself. 621 FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, Owner, 622 Function->getLocation(), 623 Function->getDeclName(), 624 TemplateParams, Function); 625 Function->setDescribedFunctionTemplate(FunctionTemplate); 626 FunctionTemplate->setLexicalDeclContext(D->getLexicalDeclContext()); 627 } 628 629 if (InitFunctionInstantiation(Function, D)) 630 Function->setInvalidDecl(); 631 632 bool Redeclaration = false; 633 bool OverloadableAttrRequired = false; 634 635 NamedDecl *PrevDecl = 0; 636 if (TemplateParams || !FunctionTemplate) { 637 // Look only into the namespace where the friend would be declared to 638 // find a previous declaration. This is the innermost enclosing namespace, 639 // as described in ActOnFriendFunctionDecl. 640 Sema::LookupResult R; 641 SemaRef.LookupQualifiedName(R, DC, Function->getDeclName(), 642 Sema::LookupOrdinaryName, true); 643 644 PrevDecl = R.getAsSingleDecl(SemaRef.Context); 645 646 // In C++, the previous declaration we find might be a tag type 647 // (class or enum). In this case, the new declaration will hide the 648 // tag type. Note that this does does not apply if we're declaring a 649 // typedef (C++ [dcl.typedef]p4). 650 if (PrevDecl && PrevDecl->getIdentifierNamespace() == Decl::IDNS_Tag) 651 PrevDecl = 0; 652 } 653 654 SemaRef.CheckFunctionDeclaration(Function, PrevDecl, false, Redeclaration, 655 /*FIXME:*/OverloadableAttrRequired); 656 657 // If the original function was part of a friend declaration, 658 // inherit its namespace state and add it to the owner. 659 NamedDecl *FromFriendD 660 = TemplateParams? cast<NamedDecl>(D->getDescribedFunctionTemplate()) : D; 661 if (FromFriendD->getFriendObjectKind()) { 662 NamedDecl *ToFriendD = 0; 663 if (TemplateParams) { 664 ToFriendD = cast<NamedDecl>(FunctionTemplate); 665 PrevDecl = FunctionTemplate->getPreviousDeclaration(); 666 } else { 667 ToFriendD = Function; 668 PrevDecl = Function->getPreviousDeclaration(); 669 } 670 ToFriendD->setObjectOfFriendDecl(PrevDecl != NULL); 671 if (!Owner->isDependentContext() && !PrevDecl) 672 DC->makeDeclVisibleInContext(ToFriendD, /* Recoverable = */ false); 673 674 if (!TemplateParams) 675 Function->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation); 676 } 677 678 if (FunctionTemplate && !TemplateParams) { 679 // Record this function template specialization. 680 Function->setFunctionTemplateSpecialization(SemaRef.Context, 681 FunctionTemplate, 682 &TemplateArgs.getInnermost(), 683 InsertPos); 684 } 685 686 return Function; 687} 688 689Decl * 690TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D, 691 TemplateParameterList *TemplateParams) { 692 FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate(); 693 void *InsertPos = 0; 694 if (FunctionTemplate && !TemplateParams) { 695 // We are creating a function template specialization from a function 696 // template. Check whether there is already a function template 697 // specialization for this particular set of template arguments. 698 llvm::FoldingSetNodeID ID; 699 FunctionTemplateSpecializationInfo::Profile(ID, 700 TemplateArgs.getInnermost().getFlatArgumentList(), 701 TemplateArgs.getInnermost().flat_size(), 702 SemaRef.Context); 703 704 FunctionTemplateSpecializationInfo *Info 705 = FunctionTemplate->getSpecializations().FindNodeOrInsertPos(ID, 706 InsertPos); 707 708 // If we already have a function template specialization, return it. 709 if (Info) 710 return Info->Function; 711 } 712 713 Sema::LocalInstantiationScope Scope(SemaRef); 714 715 llvm::SmallVector<ParmVarDecl *, 4> Params; 716 QualType T = SubstFunctionType(D, Params); 717 if (T.isNull()) 718 return 0; 719 720 // Build the instantiated method declaration. 721 CXXRecordDecl *Record = cast<CXXRecordDecl>(Owner); 722 CXXMethodDecl *Method = 0; 723 724 DeclarationName Name = D->getDeclName(); 725 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) { 726 QualType ClassTy = SemaRef.Context.getTypeDeclType(Record); 727 Name = SemaRef.Context.DeclarationNames.getCXXConstructorName( 728 SemaRef.Context.getCanonicalType(ClassTy)); 729 Method = CXXConstructorDecl::Create(SemaRef.Context, Record, 730 Constructor->getLocation(), 731 Name, T, 732 Constructor->getDeclaratorInfo(), 733 Constructor->isExplicit(), 734 Constructor->isInlineSpecified(), false); 735 } else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(D)) { 736 QualType ClassTy = SemaRef.Context.getTypeDeclType(Record); 737 Name = SemaRef.Context.DeclarationNames.getCXXDestructorName( 738 SemaRef.Context.getCanonicalType(ClassTy)); 739 Method = CXXDestructorDecl::Create(SemaRef.Context, Record, 740 Destructor->getLocation(), Name, 741 T, Destructor->isInlineSpecified(), false); 742 } else if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) { 743 CanQualType ConvTy 744 = SemaRef.Context.getCanonicalType( 745 T->getAs<FunctionType>()->getResultType()); 746 Name = SemaRef.Context.DeclarationNames.getCXXConversionFunctionName( 747 ConvTy); 748 Method = CXXConversionDecl::Create(SemaRef.Context, Record, 749 Conversion->getLocation(), Name, 750 T, Conversion->getDeclaratorInfo(), 751 Conversion->isInlineSpecified(), 752 Conversion->isExplicit()); 753 } else { 754 Method = CXXMethodDecl::Create(SemaRef.Context, Record, D->getLocation(), 755 D->getDeclName(), T, D->getDeclaratorInfo(), 756 D->isStatic(), D->isInlineSpecified()); 757 } 758 759 if (TemplateParams) { 760 // Our resulting instantiation is actually a function template, since we 761 // are substituting only the outer template parameters. For example, given 762 // 763 // template<typename T> 764 // struct X { 765 // template<typename U> void f(T, U); 766 // }; 767 // 768 // X<int> x; 769 // 770 // We are instantiating the member template "f" within X<int>, which means 771 // substituting int for T, but leaving "f" as a member function template. 772 // Build the function template itself. 773 FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, Record, 774 Method->getLocation(), 775 Method->getDeclName(), 776 TemplateParams, Method); 777 if (D->isOutOfLine()) 778 FunctionTemplate->setLexicalDeclContext(D->getLexicalDeclContext()); 779 Method->setDescribedFunctionTemplate(FunctionTemplate); 780 } else if (!FunctionTemplate) 781 Method->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation); 782 783 // If we are instantiating a member function defined 784 // out-of-line, the instantiation will have the same lexical 785 // context (which will be a namespace scope) as the template. 786 if (D->isOutOfLine()) 787 Method->setLexicalDeclContext(D->getLexicalDeclContext()); 788 789 // Attach the parameters 790 for (unsigned P = 0; P < Params.size(); ++P) 791 Params[P]->setOwningFunction(Method); 792 Method->setParams(SemaRef.Context, Params.data(), Params.size()); 793 794 if (InitMethodInstantiation(Method, D)) 795 Method->setInvalidDecl(); 796 797 NamedDecl *PrevDecl = 0; 798 799 if (!FunctionTemplate || TemplateParams) { 800 Sema::LookupResult R; 801 SemaRef.LookupQualifiedName(R, Owner, Name, Sema::LookupOrdinaryName, true); 802 PrevDecl = R.getAsSingleDecl(SemaRef.Context); 803 804 // In C++, the previous declaration we find might be a tag type 805 // (class or enum). In this case, the new declaration will hide the 806 // tag type. Note that this does does not apply if we're declaring a 807 // typedef (C++ [dcl.typedef]p4). 808 if (PrevDecl && PrevDecl->getIdentifierNamespace() == Decl::IDNS_Tag) 809 PrevDecl = 0; 810 } 811 812 if (FunctionTemplate && !TemplateParams) 813 // Record this function template specialization. 814 Method->setFunctionTemplateSpecialization(SemaRef.Context, 815 FunctionTemplate, 816 &TemplateArgs.getInnermost(), 817 InsertPos); 818 819 bool Redeclaration = false; 820 bool OverloadableAttrRequired = false; 821 SemaRef.CheckFunctionDeclaration(Method, PrevDecl, false, Redeclaration, 822 /*FIXME:*/OverloadableAttrRequired); 823 824 if (!FunctionTemplate && (!Method->isInvalidDecl() || !PrevDecl) && 825 !Method->getFriendObjectKind()) 826 Owner->addDecl(Method); 827 828 return Method; 829} 830 831Decl *TemplateDeclInstantiator::VisitCXXConstructorDecl(CXXConstructorDecl *D) { 832 return VisitCXXMethodDecl(D); 833} 834 835Decl *TemplateDeclInstantiator::VisitCXXDestructorDecl(CXXDestructorDecl *D) { 836 return VisitCXXMethodDecl(D); 837} 838 839Decl *TemplateDeclInstantiator::VisitCXXConversionDecl(CXXConversionDecl *D) { 840 return VisitCXXMethodDecl(D); 841} 842 843ParmVarDecl *TemplateDeclInstantiator::VisitParmVarDecl(ParmVarDecl *D) { 844 QualType T; 845 DeclaratorInfo *DI = D->getDeclaratorInfo(); 846 if (DI) { 847 DI = SemaRef.SubstType(DI, TemplateArgs, D->getLocation(), 848 D->getDeclName()); 849 if (DI) T = DI->getType(); 850 } else { 851 T = SemaRef.SubstType(D->getType(), TemplateArgs, D->getLocation(), 852 D->getDeclName()); 853 DI = 0; 854 } 855 856 if (T.isNull()) 857 return 0; 858 859 T = SemaRef.adjustParameterType(T); 860 861 // Allocate the parameter 862 ParmVarDecl *Param 863 = ParmVarDecl::Create(SemaRef.Context, Owner, D->getLocation(), 864 D->getIdentifier(), T, DI, D->getStorageClass(), 0); 865 866 // Mark the default argument as being uninstantiated. 867 if (D->hasUninstantiatedDefaultArg()) 868 Param->setUninstantiatedDefaultArg(D->getUninstantiatedDefaultArg()); 869 else if (Expr *Arg = D->getDefaultArg()) 870 Param->setUninstantiatedDefaultArg(Arg); 871 872 // Note: we don't try to instantiate function parameters until after 873 // we've instantiated the function's type. Therefore, we don't have 874 // to check for 'void' parameter types here. 875 SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param); 876 return Param; 877} 878 879Decl *TemplateDeclInstantiator::VisitTemplateTypeParmDecl( 880 TemplateTypeParmDecl *D) { 881 // TODO: don't always clone when decls are refcounted. 882 const Type* T = D->getTypeForDecl(); 883 assert(T->isTemplateTypeParmType()); 884 const TemplateTypeParmType *TTPT = T->getAs<TemplateTypeParmType>(); 885 886 TemplateTypeParmDecl *Inst = 887 TemplateTypeParmDecl::Create(SemaRef.Context, Owner, D->getLocation(), 888 TTPT->getDepth(), TTPT->getIndex(), 889 TTPT->getName(), 890 D->wasDeclaredWithTypename(), 891 D->isParameterPack()); 892 893 // FIXME: Do we actually want to perform substitution here? I don't think 894 // we do. 895 if (D->hasDefaultArgument()) { 896 DeclaratorInfo *DefaultPattern = D->getDefaultArgumentInfo(); 897 DeclaratorInfo *DefaultInst 898 = SemaRef.SubstType(DefaultPattern, TemplateArgs, 899 D->getDefaultArgumentLoc(), 900 D->getDeclName()); 901 902 Inst->setDefaultArgument(DefaultInst, 903 D->defaultArgumentWasInherited() /* preserve? */); 904 } 905 906 return Inst; 907} 908 909Decl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl( 910 NonTypeTemplateParmDecl *D) { 911 // Substitute into the type of the non-type template parameter. 912 QualType T; 913 DeclaratorInfo *DI = D->getDeclaratorInfo(); 914 if (DI) { 915 DI = SemaRef.SubstType(DI, TemplateArgs, D->getLocation(), 916 D->getDeclName()); 917 if (DI) T = DI->getType(); 918 } else { 919 T = SemaRef.SubstType(D->getType(), TemplateArgs, D->getLocation(), 920 D->getDeclName()); 921 DI = 0; 922 } 923 if (T.isNull()) 924 return 0; 925 926 // Check that this type is acceptable for a non-type template parameter. 927 bool Invalid = false; 928 T = SemaRef.CheckNonTypeTemplateParameterType(T, D->getLocation()); 929 if (T.isNull()) { 930 T = SemaRef.Context.IntTy; 931 Invalid = true; 932 } 933 934 NonTypeTemplateParmDecl *Param 935 = NonTypeTemplateParmDecl::Create(SemaRef.Context, Owner, D->getLocation(), 936 D->getDepth() - 1, D->getPosition(), 937 D->getIdentifier(), T, DI); 938 if (Invalid) 939 Param->setInvalidDecl(); 940 941 Param->setDefaultArgument(D->getDefaultArgument()); 942 return Param; 943} 944 945Decl * 946TemplateDeclInstantiator::VisitUnresolvedUsingDecl(UnresolvedUsingDecl *D) { 947 NestedNameSpecifier *NNS = 948 SemaRef.SubstNestedNameSpecifier(D->getTargetNestedNameSpecifier(), 949 D->getTargetNestedNameRange(), 950 TemplateArgs); 951 if (!NNS) 952 return 0; 953 954 CXXScopeSpec SS; 955 SS.setRange(D->getTargetNestedNameRange()); 956 SS.setScopeRep(NNS); 957 958 NamedDecl *UD = 959 SemaRef.BuildUsingDeclaration(D->getLocation(), SS, 960 D->getTargetNameLocation(), 961 D->getTargetName(), 0, D->isTypeName()); 962 if (UD) 963 SemaRef.Context.setInstantiatedFromUnresolvedUsingDecl(cast<UsingDecl>(UD), 964 D); 965 return UD; 966} 967 968Decl *Sema::SubstDecl(Decl *D, DeclContext *Owner, 969 const MultiLevelTemplateArgumentList &TemplateArgs) { 970 TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs); 971 return Instantiator.Visit(D); 972} 973 974/// \brief Instantiates a nested template parameter list in the current 975/// instantiation context. 976/// 977/// \param L The parameter list to instantiate 978/// 979/// \returns NULL if there was an error 980TemplateParameterList * 981TemplateDeclInstantiator::SubstTemplateParams(TemplateParameterList *L) { 982 // Get errors for all the parameters before bailing out. 983 bool Invalid = false; 984 985 unsigned N = L->size(); 986 typedef llvm::SmallVector<NamedDecl *, 8> ParamVector; 987 ParamVector Params; 988 Params.reserve(N); 989 for (TemplateParameterList::iterator PI = L->begin(), PE = L->end(); 990 PI != PE; ++PI) { 991 NamedDecl *D = cast_or_null<NamedDecl>(Visit(*PI)); 992 Params.push_back(D); 993 Invalid = Invalid || !D; 994 } 995 996 // Clean up if we had an error. 997 if (Invalid) { 998 for (ParamVector::iterator PI = Params.begin(), PE = Params.end(); 999 PI != PE; ++PI) 1000 if (*PI) 1001 (*PI)->Destroy(SemaRef.Context); 1002 return NULL; 1003 } 1004 1005 TemplateParameterList *InstL 1006 = TemplateParameterList::Create(SemaRef.Context, L->getTemplateLoc(), 1007 L->getLAngleLoc(), &Params.front(), N, 1008 L->getRAngleLoc()); 1009 return InstL; 1010} 1011 1012/// \brief Instantiate the declaration of a class template partial 1013/// specialization. 1014/// 1015/// \param ClassTemplate the (instantiated) class template that is partially 1016// specialized by the instantiation of \p PartialSpec. 1017/// 1018/// \param PartialSpec the (uninstantiated) class template partial 1019/// specialization that we are instantiating. 1020/// 1021/// \returns true if there was an error, false otherwise. 1022bool 1023TemplateDeclInstantiator::InstantiateClassTemplatePartialSpecialization( 1024 ClassTemplateDecl *ClassTemplate, 1025 ClassTemplatePartialSpecializationDecl *PartialSpec) { 1026 // Substitute into the template parameters of the class template partial 1027 // specialization. 1028 TemplateParameterList *TempParams = PartialSpec->getTemplateParameters(); 1029 TemplateParameterList *InstParams = SubstTemplateParams(TempParams); 1030 if (!InstParams) 1031 return true; 1032 1033 // Substitute into the template arguments of the class template partial 1034 // specialization. 1035 const TemplateArgumentLoc *PartialSpecTemplateArgs 1036 = PartialSpec->getTemplateArgsAsWritten(); 1037 unsigned N = PartialSpec->getNumTemplateArgsAsWritten(); 1038 1039 llvm::SmallVector<TemplateArgumentLoc, 4> InstTemplateArgs(N); 1040 for (unsigned I = 0; I != N; ++I) { 1041 if (SemaRef.Subst(PartialSpecTemplateArgs[I], InstTemplateArgs[I], 1042 TemplateArgs)) 1043 return true; 1044 } 1045 1046 1047 // Check that the template argument list is well-formed for this 1048 // class template. 1049 TemplateArgumentListBuilder Converted(ClassTemplate->getTemplateParameters(), 1050 InstTemplateArgs.size()); 1051 if (SemaRef.CheckTemplateArgumentList(ClassTemplate, 1052 PartialSpec->getLocation(), 1053 /*FIXME:*/PartialSpec->getLocation(), 1054 InstTemplateArgs.data(), 1055 InstTemplateArgs.size(), 1056 /*FIXME:*/PartialSpec->getLocation(), 1057 false, 1058 Converted)) 1059 return true; 1060 1061 // Figure out where to insert this class template partial specialization 1062 // in the member template's set of class template partial specializations. 1063 llvm::FoldingSetNodeID ID; 1064 ClassTemplatePartialSpecializationDecl::Profile(ID, 1065 Converted.getFlatArguments(), 1066 Converted.flatSize(), 1067 SemaRef.Context); 1068 void *InsertPos = 0; 1069 ClassTemplateSpecializationDecl *PrevDecl 1070 = ClassTemplate->getPartialSpecializations().FindNodeOrInsertPos(ID, 1071 InsertPos); 1072 1073 // Build the canonical type that describes the converted template 1074 // arguments of the class template partial specialization. 1075 QualType CanonType 1076 = SemaRef.Context.getTemplateSpecializationType(TemplateName(ClassTemplate), 1077 Converted.getFlatArguments(), 1078 Converted.flatSize()); 1079 1080 // Build the fully-sugared type for this class template 1081 // specialization as the user wrote in the specialization 1082 // itself. This means that we'll pretty-print the type retrieved 1083 // from the specialization's declaration the way that the user 1084 // actually wrote the specialization, rather than formatting the 1085 // name based on the "canonical" representation used to store the 1086 // template arguments in the specialization. 1087 QualType WrittenTy 1088 = SemaRef.Context.getTemplateSpecializationType(TemplateName(ClassTemplate), 1089 InstTemplateArgs.data(), 1090 InstTemplateArgs.size(), 1091 CanonType); 1092 1093 if (PrevDecl) { 1094 // We've already seen a partial specialization with the same template 1095 // parameters and template arguments. This can happen, for example, when 1096 // substituting the outer template arguments ends up causing two 1097 // class template partial specializations of a member class template 1098 // to have identical forms, e.g., 1099 // 1100 // template<typename T, typename U> 1101 // struct Outer { 1102 // template<typename X, typename Y> struct Inner; 1103 // template<typename Y> struct Inner<T, Y>; 1104 // template<typename Y> struct Inner<U, Y>; 1105 // }; 1106 // 1107 // Outer<int, int> outer; // error: the partial specializations of Inner 1108 // // have the same signature. 1109 SemaRef.Diag(PartialSpec->getLocation(), diag::err_partial_spec_redeclared) 1110 << WrittenTy; 1111 SemaRef.Diag(PrevDecl->getLocation(), diag::note_prev_partial_spec_here) 1112 << SemaRef.Context.getTypeDeclType(PrevDecl); 1113 return true; 1114 } 1115 1116 1117 // Create the class template partial specialization declaration. 1118 ClassTemplatePartialSpecializationDecl *InstPartialSpec 1119 = ClassTemplatePartialSpecializationDecl::Create(SemaRef.Context, Owner, 1120 PartialSpec->getLocation(), 1121 InstParams, 1122 ClassTemplate, 1123 Converted, 1124 InstTemplateArgs.data(), 1125 InstTemplateArgs.size(), 1126 0); 1127 InstPartialSpec->setInstantiatedFromMember(PartialSpec); 1128 InstPartialSpec->setTypeAsWritten(WrittenTy); 1129 1130 // Add this partial specialization to the set of class template partial 1131 // specializations. 1132 ClassTemplate->getPartialSpecializations().InsertNode(InstPartialSpec, 1133 InsertPos); 1134 return false; 1135} 1136 1137/// \brief Does substitution on the type of the given function, including 1138/// all of the function parameters. 1139/// 1140/// \param D The function whose type will be the basis of the substitution 1141/// 1142/// \param Params the instantiated parameter declarations 1143 1144/// \returns the instantiated function's type if successful, a NULL 1145/// type if there was an error. 1146QualType 1147TemplateDeclInstantiator::SubstFunctionType(FunctionDecl *D, 1148 llvm::SmallVectorImpl<ParmVarDecl *> &Params) { 1149 bool InvalidDecl = false; 1150 1151 // Substitute all of the function's formal parameter types. 1152 TemplateDeclInstantiator ParamInstantiator(SemaRef, 0, TemplateArgs); 1153 llvm::SmallVector<QualType, 4> ParamTys; 1154 for (FunctionDecl::param_iterator P = D->param_begin(), 1155 PEnd = D->param_end(); 1156 P != PEnd; ++P) { 1157 if (ParmVarDecl *PInst = ParamInstantiator.VisitParmVarDecl(*P)) { 1158 if (PInst->getType()->isVoidType()) { 1159 SemaRef.Diag(PInst->getLocation(), diag::err_param_with_void_type); 1160 PInst->setInvalidDecl(); 1161 } else if (SemaRef.RequireNonAbstractType(PInst->getLocation(), 1162 PInst->getType(), 1163 diag::err_abstract_type_in_decl, 1164 Sema::AbstractParamType)) 1165 PInst->setInvalidDecl(); 1166 1167 Params.push_back(PInst); 1168 ParamTys.push_back(PInst->getType()); 1169 1170 if (PInst->isInvalidDecl()) 1171 InvalidDecl = true; 1172 } else 1173 InvalidDecl = true; 1174 } 1175 1176 // FIXME: Deallocate dead declarations. 1177 if (InvalidDecl) 1178 return QualType(); 1179 1180 const FunctionProtoType *Proto = D->getType()->getAs<FunctionProtoType>(); 1181 assert(Proto && "Missing prototype?"); 1182 QualType ResultType 1183 = SemaRef.SubstType(Proto->getResultType(), TemplateArgs, 1184 D->getLocation(), D->getDeclName()); 1185 if (ResultType.isNull()) 1186 return QualType(); 1187 1188 return SemaRef.BuildFunctionType(ResultType, ParamTys.data(), ParamTys.size(), 1189 Proto->isVariadic(), Proto->getTypeQuals(), 1190 D->getLocation(), D->getDeclName()); 1191} 1192 1193/// \brief Initializes the common fields of an instantiation function 1194/// declaration (New) from the corresponding fields of its template (Tmpl). 1195/// 1196/// \returns true if there was an error 1197bool 1198TemplateDeclInstantiator::InitFunctionInstantiation(FunctionDecl *New, 1199 FunctionDecl *Tmpl) { 1200 if (Tmpl->isDeleted()) 1201 New->setDeleted(); 1202 1203 // If we are performing substituting explicitly-specified template arguments 1204 // or deduced template arguments into a function template and we reach this 1205 // point, we are now past the point where SFINAE applies and have committed 1206 // to keeping the new function template specialization. We therefore 1207 // convert the active template instantiation for the function template 1208 // into a template instantiation for this specific function template 1209 // specialization, which is not a SFINAE context, so that we diagnose any 1210 // further errors in the declaration itself. 1211 typedef Sema::ActiveTemplateInstantiation ActiveInstType; 1212 ActiveInstType &ActiveInst = SemaRef.ActiveTemplateInstantiations.back(); 1213 if (ActiveInst.Kind == ActiveInstType::ExplicitTemplateArgumentSubstitution || 1214 ActiveInst.Kind == ActiveInstType::DeducedTemplateArgumentSubstitution) { 1215 if (FunctionTemplateDecl *FunTmpl 1216 = dyn_cast<FunctionTemplateDecl>((Decl *)ActiveInst.Entity)) { 1217 assert(FunTmpl->getTemplatedDecl() == Tmpl && 1218 "Deduction from the wrong function template?"); 1219 (void) FunTmpl; 1220 ActiveInst.Kind = ActiveInstType::TemplateInstantiation; 1221 ActiveInst.Entity = reinterpret_cast<uintptr_t>(New); 1222 } 1223 } 1224 1225 return false; 1226} 1227 1228/// \brief Initializes common fields of an instantiated method 1229/// declaration (New) from the corresponding fields of its template 1230/// (Tmpl). 1231/// 1232/// \returns true if there was an error 1233bool 1234TemplateDeclInstantiator::InitMethodInstantiation(CXXMethodDecl *New, 1235 CXXMethodDecl *Tmpl) { 1236 if (InitFunctionInstantiation(New, Tmpl)) 1237 return true; 1238 1239 CXXRecordDecl *Record = cast<CXXRecordDecl>(Owner); 1240 New->setAccess(Tmpl->getAccess()); 1241 if (Tmpl->isVirtualAsWritten()) { 1242 New->setVirtualAsWritten(true); 1243 Record->setAggregate(false); 1244 Record->setPOD(false); 1245 Record->setEmpty(false); 1246 Record->setPolymorphic(true); 1247 } 1248 if (Tmpl->isPure()) { 1249 New->setPure(); 1250 Record->setAbstract(true); 1251 } 1252 1253 // FIXME: attributes 1254 // FIXME: New needs a pointer to Tmpl 1255 return false; 1256} 1257 1258/// \brief Instantiate the definition of the given function from its 1259/// template. 1260/// 1261/// \param PointOfInstantiation the point at which the instantiation was 1262/// required. Note that this is not precisely a "point of instantiation" 1263/// for the function, but it's close. 1264/// 1265/// \param Function the already-instantiated declaration of a 1266/// function template specialization or member function of a class template 1267/// specialization. 1268/// 1269/// \param Recursive if true, recursively instantiates any functions that 1270/// are required by this instantiation. 1271/// 1272/// \param DefinitionRequired if true, then we are performing an explicit 1273/// instantiation where the body of the function is required. Complain if 1274/// there is no such body. 1275void Sema::InstantiateFunctionDefinition(SourceLocation PointOfInstantiation, 1276 FunctionDecl *Function, 1277 bool Recursive, 1278 bool DefinitionRequired) { 1279 if (Function->isInvalidDecl()) 1280 return; 1281 1282 assert(!Function->getBody() && "Already instantiated!"); 1283 1284 // Never instantiate an explicit specialization. 1285 if (Function->getTemplateSpecializationKind() == TSK_ExplicitSpecialization) 1286 return; 1287 1288 // Find the function body that we'll be substituting. 1289 const FunctionDecl *PatternDecl = Function->getTemplateInstantiationPattern(); 1290 Stmt *Pattern = 0; 1291 if (PatternDecl) 1292 Pattern = PatternDecl->getBody(PatternDecl); 1293 1294 if (!Pattern) { 1295 if (DefinitionRequired) { 1296 if (Function->getPrimaryTemplate()) 1297 Diag(PointOfInstantiation, 1298 diag::err_explicit_instantiation_undefined_func_template) 1299 << Function->getPrimaryTemplate(); 1300 else 1301 Diag(PointOfInstantiation, 1302 diag::err_explicit_instantiation_undefined_member) 1303 << 1 << Function->getDeclName() << Function->getDeclContext(); 1304 1305 if (PatternDecl) 1306 Diag(PatternDecl->getLocation(), 1307 diag::note_explicit_instantiation_here); 1308 } 1309 1310 return; 1311 } 1312 1313 // C++0x [temp.explicit]p9: 1314 // Except for inline functions, other explicit instantiation declarations 1315 // have the effect of suppressing the implicit instantiation of the entity 1316 // to which they refer. 1317 if (Function->getTemplateSpecializationKind() 1318 == TSK_ExplicitInstantiationDeclaration && 1319 !PatternDecl->isInlined()) 1320 return; 1321 1322 InstantiatingTemplate Inst(*this, PointOfInstantiation, Function); 1323 if (Inst) 1324 return; 1325 1326 // If we're performing recursive template instantiation, create our own 1327 // queue of pending implicit instantiations that we will instantiate later, 1328 // while we're still within our own instantiation context. 1329 std::deque<PendingImplicitInstantiation> SavedPendingImplicitInstantiations; 1330 if (Recursive) 1331 PendingImplicitInstantiations.swap(SavedPendingImplicitInstantiations); 1332 1333 ActOnStartOfFunctionDef(0, DeclPtrTy::make(Function)); 1334 1335 // Introduce a new scope where local variable instantiations will be 1336 // recorded. 1337 LocalInstantiationScope Scope(*this); 1338 1339 // Introduce the instantiated function parameters into the local 1340 // instantiation scope. 1341 for (unsigned I = 0, N = PatternDecl->getNumParams(); I != N; ++I) 1342 Scope.InstantiatedLocal(PatternDecl->getParamDecl(I), 1343 Function->getParamDecl(I)); 1344 1345 // Enter the scope of this instantiation. We don't use 1346 // PushDeclContext because we don't have a scope. 1347 DeclContext *PreviousContext = CurContext; 1348 CurContext = Function; 1349 1350 MultiLevelTemplateArgumentList TemplateArgs = 1351 getTemplateInstantiationArgs(Function); 1352 1353 // If this is a constructor, instantiate the member initializers. 1354 if (const CXXConstructorDecl *Ctor = 1355 dyn_cast<CXXConstructorDecl>(PatternDecl)) { 1356 InstantiateMemInitializers(cast<CXXConstructorDecl>(Function), Ctor, 1357 TemplateArgs); 1358 } 1359 1360 // Instantiate the function body. 1361 OwningStmtResult Body = SubstStmt(Pattern, TemplateArgs); 1362 1363 if (Body.isInvalid()) 1364 Function->setInvalidDecl(); 1365 1366 ActOnFinishFunctionBody(DeclPtrTy::make(Function), move(Body), 1367 /*IsInstantiation=*/true); 1368 1369 CurContext = PreviousContext; 1370 1371 DeclGroupRef DG(Function); 1372 Consumer.HandleTopLevelDecl(DG); 1373 1374 if (Recursive) { 1375 // Instantiate any pending implicit instantiations found during the 1376 // instantiation of this template. 1377 PerformPendingImplicitInstantiations(); 1378 1379 // Restore the set of pending implicit instantiations. 1380 PendingImplicitInstantiations.swap(SavedPendingImplicitInstantiations); 1381 } 1382} 1383 1384/// \brief Instantiate the definition of the given variable from its 1385/// template. 1386/// 1387/// \param PointOfInstantiation the point at which the instantiation was 1388/// required. Note that this is not precisely a "point of instantiation" 1389/// for the function, but it's close. 1390/// 1391/// \param Var the already-instantiated declaration of a static member 1392/// variable of a class template specialization. 1393/// 1394/// \param Recursive if true, recursively instantiates any functions that 1395/// are required by this instantiation. 1396/// 1397/// \param DefinitionRequired if true, then we are performing an explicit 1398/// instantiation where an out-of-line definition of the member variable 1399/// is required. Complain if there is no such definition. 1400void Sema::InstantiateStaticDataMemberDefinition( 1401 SourceLocation PointOfInstantiation, 1402 VarDecl *Var, 1403 bool Recursive, 1404 bool DefinitionRequired) { 1405 if (Var->isInvalidDecl()) 1406 return; 1407 1408 // Find the out-of-line definition of this static data member. 1409 VarDecl *Def = Var->getInstantiatedFromStaticDataMember(); 1410 assert(Def && "This data member was not instantiated from a template?"); 1411 assert(Def->isStaticDataMember() && "Not a static data member?"); 1412 Def = Def->getOutOfLineDefinition(); 1413 1414 if (!Def) { 1415 // We did not find an out-of-line definition of this static data member, 1416 // so we won't perform any instantiation. Rather, we rely on the user to 1417 // instantiate this definition (or provide a specialization for it) in 1418 // another translation unit. 1419 if (DefinitionRequired) { 1420 Def = Var->getInstantiatedFromStaticDataMember(); 1421 Diag(PointOfInstantiation, 1422 diag::err_explicit_instantiation_undefined_member) 1423 << 2 << Var->getDeclName() << Var->getDeclContext(); 1424 Diag(Def->getLocation(), diag::note_explicit_instantiation_here); 1425 } 1426 1427 return; 1428 } 1429 1430 // Never instantiate an explicit specialization. 1431 if (Var->getTemplateSpecializationKind() == TSK_ExplicitSpecialization) 1432 return; 1433 1434 // C++0x [temp.explicit]p9: 1435 // Except for inline functions, other explicit instantiation declarations 1436 // have the effect of suppressing the implicit instantiation of the entity 1437 // to which they refer. 1438 if (Var->getTemplateSpecializationKind() 1439 == TSK_ExplicitInstantiationDeclaration) 1440 return; 1441 1442 InstantiatingTemplate Inst(*this, PointOfInstantiation, Var); 1443 if (Inst) 1444 return; 1445 1446 // If we're performing recursive template instantiation, create our own 1447 // queue of pending implicit instantiations that we will instantiate later, 1448 // while we're still within our own instantiation context. 1449 std::deque<PendingImplicitInstantiation> SavedPendingImplicitInstantiations; 1450 if (Recursive) 1451 PendingImplicitInstantiations.swap(SavedPendingImplicitInstantiations); 1452 1453 // Enter the scope of this instantiation. We don't use 1454 // PushDeclContext because we don't have a scope. 1455 DeclContext *PreviousContext = CurContext; 1456 CurContext = Var->getDeclContext(); 1457 1458 VarDecl *OldVar = Var; 1459 Var = cast_or_null<VarDecl>(SubstDecl(Def, Var->getDeclContext(), 1460 getTemplateInstantiationArgs(Var))); 1461 CurContext = PreviousContext; 1462 1463 if (Var) { 1464 Var->setPreviousDeclaration(OldVar); 1465 MemberSpecializationInfo *MSInfo = OldVar->getMemberSpecializationInfo(); 1466 assert(MSInfo && "Missing member specialization information?"); 1467 Var->setTemplateSpecializationKind(MSInfo->getTemplateSpecializationKind(), 1468 MSInfo->getPointOfInstantiation()); 1469 DeclGroupRef DG(Var); 1470 Consumer.HandleTopLevelDecl(DG); 1471 } 1472 1473 if (Recursive) { 1474 // Instantiate any pending implicit instantiations found during the 1475 // instantiation of this template. 1476 PerformPendingImplicitInstantiations(); 1477 1478 // Restore the set of pending implicit instantiations. 1479 PendingImplicitInstantiations.swap(SavedPendingImplicitInstantiations); 1480 } 1481} 1482 1483void 1484Sema::InstantiateMemInitializers(CXXConstructorDecl *New, 1485 const CXXConstructorDecl *Tmpl, 1486 const MultiLevelTemplateArgumentList &TemplateArgs) { 1487 1488 llvm::SmallVector<MemInitTy*, 4> NewInits; 1489 1490 // Instantiate all the initializers. 1491 for (CXXConstructorDecl::init_const_iterator Inits = Tmpl->init_begin(), 1492 InitsEnd = Tmpl->init_end(); 1493 Inits != InitsEnd; ++Inits) { 1494 CXXBaseOrMemberInitializer *Init = *Inits; 1495 1496 ASTOwningVector<&ActionBase::DeleteExpr> NewArgs(*this); 1497 1498 // Instantiate all the arguments. 1499 for (ExprIterator Args = Init->arg_begin(), ArgsEnd = Init->arg_end(); 1500 Args != ArgsEnd; ++Args) { 1501 OwningExprResult NewArg = SubstExpr(*Args, TemplateArgs); 1502 1503 if (NewArg.isInvalid()) 1504 New->setInvalidDecl(); 1505 else 1506 NewArgs.push_back(NewArg.takeAs<Expr>()); 1507 } 1508 1509 MemInitResult NewInit; 1510 1511 if (Init->isBaseInitializer()) { 1512 QualType BaseType(Init->getBaseClass(), 0); 1513 BaseType = SubstType(BaseType, TemplateArgs, Init->getSourceLocation(), 1514 New->getDeclName()); 1515 1516 NewInit = BuildBaseInitializer(BaseType, 1517 (Expr **)NewArgs.data(), 1518 NewArgs.size(), 1519 Init->getSourceLocation(), 1520 Init->getRParenLoc(), 1521 New->getParent()); 1522 } else if (Init->isMemberInitializer()) { 1523 FieldDecl *Member; 1524 1525 // Is this an anonymous union? 1526 if (FieldDecl *UnionInit = Init->getAnonUnionMember()) 1527 Member = cast<FieldDecl>(FindInstantiatedDecl(UnionInit, TemplateArgs)); 1528 else 1529 Member = cast<FieldDecl>(FindInstantiatedDecl(Init->getMember(), 1530 TemplateArgs)); 1531 1532 NewInit = BuildMemberInitializer(Member, (Expr **)NewArgs.data(), 1533 NewArgs.size(), 1534 Init->getSourceLocation(), 1535 Init->getRParenLoc()); 1536 } 1537 1538 if (NewInit.isInvalid()) 1539 New->setInvalidDecl(); 1540 else { 1541 // FIXME: It would be nice if ASTOwningVector had a release function. 1542 NewArgs.take(); 1543 1544 NewInits.push_back((MemInitTy *)NewInit.get()); 1545 } 1546 } 1547 1548 // Assign all the initializers to the new constructor. 1549 ActOnMemInitializers(DeclPtrTy::make(New), 1550 /*FIXME: ColonLoc */ 1551 SourceLocation(), 1552 NewInits.data(), NewInits.size()); 1553} 1554 1555// TODO: this could be templated if the various decl types used the 1556// same method name. 1557static bool isInstantiationOf(ClassTemplateDecl *Pattern, 1558 ClassTemplateDecl *Instance) { 1559 Pattern = Pattern->getCanonicalDecl(); 1560 1561 do { 1562 Instance = Instance->getCanonicalDecl(); 1563 if (Pattern == Instance) return true; 1564 Instance = Instance->getInstantiatedFromMemberTemplate(); 1565 } while (Instance); 1566 1567 return false; 1568} 1569 1570static bool isInstantiationOf(FunctionTemplateDecl *Pattern, 1571 FunctionTemplateDecl *Instance) { 1572 Pattern = Pattern->getCanonicalDecl(); 1573 1574 do { 1575 Instance = Instance->getCanonicalDecl(); 1576 if (Pattern == Instance) return true; 1577 Instance = Instance->getInstantiatedFromMemberTemplate(); 1578 } while (Instance); 1579 1580 return false; 1581} 1582 1583static bool 1584isInstantiationOf(ClassTemplatePartialSpecializationDecl *Pattern, 1585 ClassTemplatePartialSpecializationDecl *Instance) { 1586 Pattern 1587 = cast<ClassTemplatePartialSpecializationDecl>(Pattern->getCanonicalDecl()); 1588 do { 1589 Instance = cast<ClassTemplatePartialSpecializationDecl>( 1590 Instance->getCanonicalDecl()); 1591 if (Pattern == Instance) 1592 return true; 1593 Instance = Instance->getInstantiatedFromMember(); 1594 } while (Instance); 1595 1596 return false; 1597} 1598 1599static bool isInstantiationOf(CXXRecordDecl *Pattern, 1600 CXXRecordDecl *Instance) { 1601 Pattern = Pattern->getCanonicalDecl(); 1602 1603 do { 1604 Instance = Instance->getCanonicalDecl(); 1605 if (Pattern == Instance) return true; 1606 Instance = Instance->getInstantiatedFromMemberClass(); 1607 } while (Instance); 1608 1609 return false; 1610} 1611 1612static bool isInstantiationOf(FunctionDecl *Pattern, 1613 FunctionDecl *Instance) { 1614 Pattern = Pattern->getCanonicalDecl(); 1615 1616 do { 1617 Instance = Instance->getCanonicalDecl(); 1618 if (Pattern == Instance) return true; 1619 Instance = Instance->getInstantiatedFromMemberFunction(); 1620 } while (Instance); 1621 1622 return false; 1623} 1624 1625static bool isInstantiationOf(EnumDecl *Pattern, 1626 EnumDecl *Instance) { 1627 Pattern = Pattern->getCanonicalDecl(); 1628 1629 do { 1630 Instance = Instance->getCanonicalDecl(); 1631 if (Pattern == Instance) return true; 1632 Instance = Instance->getInstantiatedFromMemberEnum(); 1633 } while (Instance); 1634 1635 return false; 1636} 1637 1638static bool isInstantiationOf(UnresolvedUsingDecl *Pattern, 1639 UsingDecl *Instance, 1640 ASTContext &C) { 1641 return C.getInstantiatedFromUnresolvedUsingDecl(Instance) == Pattern; 1642} 1643 1644static bool isInstantiationOfStaticDataMember(VarDecl *Pattern, 1645 VarDecl *Instance) { 1646 assert(Instance->isStaticDataMember()); 1647 1648 Pattern = Pattern->getCanonicalDecl(); 1649 1650 do { 1651 Instance = Instance->getCanonicalDecl(); 1652 if (Pattern == Instance) return true; 1653 Instance = Instance->getInstantiatedFromStaticDataMember(); 1654 } while (Instance); 1655 1656 return false; 1657} 1658 1659static bool isInstantiationOf(ASTContext &Ctx, NamedDecl *D, Decl *Other) { 1660 if (D->getKind() != Other->getKind()) { 1661 if (UnresolvedUsingDecl *UUD = dyn_cast<UnresolvedUsingDecl>(D)) { 1662 if (UsingDecl *UD = dyn_cast<UsingDecl>(Other)) { 1663 return isInstantiationOf(UUD, UD, Ctx); 1664 } 1665 } 1666 1667 return false; 1668 } 1669 1670 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Other)) 1671 return isInstantiationOf(cast<CXXRecordDecl>(D), Record); 1672 1673 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Other)) 1674 return isInstantiationOf(cast<FunctionDecl>(D), Function); 1675 1676 if (EnumDecl *Enum = dyn_cast<EnumDecl>(Other)) 1677 return isInstantiationOf(cast<EnumDecl>(D), Enum); 1678 1679 if (VarDecl *Var = dyn_cast<VarDecl>(Other)) 1680 if (Var->isStaticDataMember()) 1681 return isInstantiationOfStaticDataMember(cast<VarDecl>(D), Var); 1682 1683 if (ClassTemplateDecl *Temp = dyn_cast<ClassTemplateDecl>(Other)) 1684 return isInstantiationOf(cast<ClassTemplateDecl>(D), Temp); 1685 1686 if (FunctionTemplateDecl *Temp = dyn_cast<FunctionTemplateDecl>(Other)) 1687 return isInstantiationOf(cast<FunctionTemplateDecl>(D), Temp); 1688 1689 if (ClassTemplatePartialSpecializationDecl *PartialSpec 1690 = dyn_cast<ClassTemplatePartialSpecializationDecl>(Other)) 1691 return isInstantiationOf(cast<ClassTemplatePartialSpecializationDecl>(D), 1692 PartialSpec); 1693 1694 if (FieldDecl *Field = dyn_cast<FieldDecl>(Other)) { 1695 if (!Field->getDeclName()) { 1696 // This is an unnamed field. 1697 return Ctx.getInstantiatedFromUnnamedFieldDecl(Field) == 1698 cast<FieldDecl>(D); 1699 } 1700 } 1701 1702 return D->getDeclName() && isa<NamedDecl>(Other) && 1703 D->getDeclName() == cast<NamedDecl>(Other)->getDeclName(); 1704} 1705 1706template<typename ForwardIterator> 1707static NamedDecl *findInstantiationOf(ASTContext &Ctx, 1708 NamedDecl *D, 1709 ForwardIterator first, 1710 ForwardIterator last) { 1711 for (; first != last; ++first) 1712 if (isInstantiationOf(Ctx, D, *first)) 1713 return cast<NamedDecl>(*first); 1714 1715 return 0; 1716} 1717 1718/// \brief Finds the instantiation of the given declaration context 1719/// within the current instantiation. 1720/// 1721/// \returns NULL if there was an error 1722DeclContext *Sema::FindInstantiatedContext(DeclContext* DC, 1723 const MultiLevelTemplateArgumentList &TemplateArgs) { 1724 if (NamedDecl *D = dyn_cast<NamedDecl>(DC)) { 1725 Decl* ID = FindInstantiatedDecl(D, TemplateArgs); 1726 return cast_or_null<DeclContext>(ID); 1727 } else return DC; 1728} 1729 1730/// \brief Find the instantiation of the given declaration within the 1731/// current instantiation. 1732/// 1733/// This routine is intended to be used when \p D is a declaration 1734/// referenced from within a template, that needs to mapped into the 1735/// corresponding declaration within an instantiation. For example, 1736/// given: 1737/// 1738/// \code 1739/// template<typename T> 1740/// struct X { 1741/// enum Kind { 1742/// KnownValue = sizeof(T) 1743/// }; 1744/// 1745/// bool getKind() const { return KnownValue; } 1746/// }; 1747/// 1748/// template struct X<int>; 1749/// \endcode 1750/// 1751/// In the instantiation of X<int>::getKind(), we need to map the 1752/// EnumConstantDecl for KnownValue (which refers to 1753/// X<T>::<Kind>::KnownValue) to its instantiation 1754/// (X<int>::<Kind>::KnownValue). InstantiateCurrentDeclRef() performs 1755/// this mapping from within the instantiation of X<int>. 1756NamedDecl *Sema::FindInstantiatedDecl(NamedDecl *D, 1757 const MultiLevelTemplateArgumentList &TemplateArgs) { 1758 if (OverloadedFunctionDecl *Ovl = dyn_cast<OverloadedFunctionDecl>(D)) { 1759 // Transform all of the elements of the overloaded function set. 1760 OverloadedFunctionDecl *Result 1761 = OverloadedFunctionDecl::Create(Context, CurContext, Ovl->getDeclName()); 1762 1763 for (OverloadedFunctionDecl::function_iterator F = Ovl->function_begin(), 1764 FEnd = Ovl->function_end(); 1765 F != FEnd; ++F) { 1766 Result->addOverload( 1767 AnyFunctionDecl::getFromNamedDecl(FindInstantiatedDecl(*F, 1768 TemplateArgs))); 1769 } 1770 1771 return Result; 1772 } 1773 1774 DeclContext *ParentDC = D->getDeclContext(); 1775 if (isa<ParmVarDecl>(D) || ParentDC->isFunctionOrMethod()) { 1776 // D is a local of some kind. Look into the map of local 1777 // declarations to their instantiations. 1778 return cast<NamedDecl>(CurrentInstantiationScope->getInstantiationOf(D)); 1779 } 1780 1781 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) { 1782 if (!Record->isDependentContext()) 1783 return D; 1784 1785 // If the RecordDecl is actually the injected-class-name or a "templated" 1786 // declaration for a class template or class template partial 1787 // specialization, substitute into the injected-class-name of the 1788 // class template or partial specialization to find the new DeclContext. 1789 QualType T; 1790 ClassTemplateDecl *ClassTemplate = Record->getDescribedClassTemplate(); 1791 1792 if (ClassTemplate) { 1793 T = ClassTemplate->getInjectedClassNameType(Context); 1794 } else if (ClassTemplatePartialSpecializationDecl *PartialSpec 1795 = dyn_cast<ClassTemplatePartialSpecializationDecl>(Record)) { 1796 T = Context.getTypeDeclType(Record); 1797 ClassTemplate = PartialSpec->getSpecializedTemplate(); 1798 } 1799 1800 if (!T.isNull()) { 1801 // Substitute into the injected-class-name to get the type corresponding 1802 // to the instantiation we want. This substitution should never fail, 1803 // since we know we can instantiate the injected-class-name or we wouldn't 1804 // have gotten to the injected-class-name! 1805 // FIXME: Can we use the CurrentInstantiationScope to avoid this extra 1806 // instantiation in the common case? 1807 T = SubstType(T, TemplateArgs, SourceLocation(), DeclarationName()); 1808 assert(!T.isNull() && "Instantiation of injected-class-name cannot fail."); 1809 1810 if (!T->isDependentType()) { 1811 assert(T->isRecordType() && "Instantiation must produce a record type"); 1812 return T->getAs<RecordType>()->getDecl(); 1813 } 1814 1815 // We are performing "partial" template instantiation to create the 1816 // member declarations for the members of a class template 1817 // specialization. Therefore, D is actually referring to something in 1818 // the current instantiation. Look through the current context, 1819 // which contains actual instantiations, to find the instantiation of 1820 // the "current instantiation" that D refers to. 1821 for (DeclContext *DC = CurContext; !DC->isFileContext(); 1822 DC = DC->getParent()) { 1823 if (ClassTemplateSpecializationDecl *Spec 1824 = dyn_cast<ClassTemplateSpecializationDecl>(DC)) 1825 if (isInstantiationOf(ClassTemplate, 1826 Spec->getSpecializedTemplate())) 1827 return Spec; 1828 } 1829 1830 assert(false && 1831 "Unable to find declaration for the current instantiation"); 1832 return Record; 1833 } 1834 1835 // Fall through to deal with other dependent record types (e.g., 1836 // anonymous unions in class templates). 1837 } 1838 1839 if (!ParentDC->isDependentContext()) 1840 return D; 1841 1842 ParentDC = FindInstantiatedContext(ParentDC, TemplateArgs); 1843 if (!ParentDC) 1844 return 0; 1845 1846 if (ParentDC != D->getDeclContext()) { 1847 // We performed some kind of instantiation in the parent context, 1848 // so now we need to look into the instantiated parent context to 1849 // find the instantiation of the declaration D. 1850 NamedDecl *Result = 0; 1851 if (D->getDeclName()) { 1852 DeclContext::lookup_result Found = ParentDC->lookup(D->getDeclName()); 1853 Result = findInstantiationOf(Context, D, Found.first, Found.second); 1854 } else { 1855 // Since we don't have a name for the entity we're looking for, 1856 // our only option is to walk through all of the declarations to 1857 // find that name. This will occur in a few cases: 1858 // 1859 // - anonymous struct/union within a template 1860 // - unnamed class/struct/union/enum within a template 1861 // 1862 // FIXME: Find a better way to find these instantiations! 1863 Result = findInstantiationOf(Context, D, 1864 ParentDC->decls_begin(), 1865 ParentDC->decls_end()); 1866 } 1867 1868 assert(Result && "Unable to find instantiation of declaration!"); 1869 D = Result; 1870 } 1871 1872 return D; 1873} 1874 1875/// \brief Performs template instantiation for all implicit template 1876/// instantiations we have seen until this point. 1877void Sema::PerformPendingImplicitInstantiations() { 1878 while (!PendingImplicitInstantiations.empty()) { 1879 PendingImplicitInstantiation Inst = PendingImplicitInstantiations.front(); 1880 PendingImplicitInstantiations.pop_front(); 1881 1882 // Instantiate function definitions 1883 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Inst.first)) { 1884 PrettyStackTraceActionsDecl CrashInfo(DeclPtrTy::make(Function), 1885 Function->getLocation(), *this, 1886 Context.getSourceManager(), 1887 "instantiating function definition"); 1888 1889 if (!Function->getBody()) 1890 InstantiateFunctionDefinition(/*FIXME:*/Inst.second, Function, true); 1891 continue; 1892 } 1893 1894 // Instantiate static data member definitions. 1895 VarDecl *Var = cast<VarDecl>(Inst.first); 1896 assert(Var->isStaticDataMember() && "Not a static data member?"); 1897 1898 PrettyStackTraceActionsDecl CrashInfo(DeclPtrTy::make(Var), 1899 Var->getLocation(), *this, 1900 Context.getSourceManager(), 1901 "instantiating static data member " 1902 "definition"); 1903 1904 InstantiateStaticDataMemberDefinition(/*FIXME:*/Inst.second, Var, true); 1905 } 1906} 1907