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