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