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