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