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