SemaTemplateInstantiate.cpp revision 9d87976f7f2e258d12eb546a473518d493afedd7
1//===------- SemaTemplateInstantiate.cpp - C++ Template 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. 10// 11//===----------------------------------------------------------------------===/ 12 13#include "Sema.h" 14#include "TreeTransform.h" 15#include "clang/AST/ASTConsumer.h" 16#include "clang/AST/ASTContext.h" 17#include "clang/AST/Expr.h" 18#include "clang/AST/DeclTemplate.h" 19#include "clang/Parse/DeclSpec.h" 20#include "clang/Basic/LangOptions.h" 21#include "llvm/Support/Compiler.h" 22 23using namespace clang; 24 25//===----------------------------------------------------------------------===/ 26// Template Instantiation Support 27//===----------------------------------------------------------------------===/ 28 29/// \brief Retrieve the template argument list that should be used to 30/// instantiate the given declaration. 31const TemplateArgumentList & 32Sema::getTemplateInstantiationArgs(NamedDecl *D) { 33 // Template arguments for a class template specialization. 34 if (ClassTemplateSpecializationDecl *Spec 35 = dyn_cast<ClassTemplateSpecializationDecl>(D)) 36 return Spec->getTemplateInstantiationArgs(); 37 38 // Template arguments for a function template specialization. 39 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) 40 if (const TemplateArgumentList *TemplateArgs 41 = Function->getTemplateSpecializationArgs()) 42 return *TemplateArgs; 43 44 // Template arguments for a member of a class template specialization. 45 DeclContext *EnclosingTemplateCtx = D->getDeclContext(); 46 while (!isa<ClassTemplateSpecializationDecl>(EnclosingTemplateCtx)) { 47 assert(!EnclosingTemplateCtx->isFileContext() && 48 "Tried to get the instantiation arguments of a non-template"); 49 EnclosingTemplateCtx = EnclosingTemplateCtx->getParent(); 50 } 51 52 ClassTemplateSpecializationDecl *EnclosingTemplate 53 = cast<ClassTemplateSpecializationDecl>(EnclosingTemplateCtx); 54 return EnclosingTemplate->getTemplateInstantiationArgs(); 55} 56 57Sema::InstantiatingTemplate:: 58InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 59 Decl *Entity, 60 SourceRange InstantiationRange) 61 : SemaRef(SemaRef) { 62 63 Invalid = CheckInstantiationDepth(PointOfInstantiation, 64 InstantiationRange); 65 if (!Invalid) { 66 ActiveTemplateInstantiation Inst; 67 Inst.Kind = ActiveTemplateInstantiation::TemplateInstantiation; 68 Inst.PointOfInstantiation = PointOfInstantiation; 69 Inst.Entity = reinterpret_cast<uintptr_t>(Entity); 70 Inst.TemplateArgs = 0; 71 Inst.NumTemplateArgs = 0; 72 Inst.InstantiationRange = InstantiationRange; 73 SemaRef.ActiveTemplateInstantiations.push_back(Inst); 74 Invalid = false; 75 } 76} 77 78Sema::InstantiatingTemplate::InstantiatingTemplate(Sema &SemaRef, 79 SourceLocation PointOfInstantiation, 80 TemplateDecl *Template, 81 const TemplateArgument *TemplateArgs, 82 unsigned NumTemplateArgs, 83 SourceRange InstantiationRange) 84 : SemaRef(SemaRef) { 85 86 Invalid = CheckInstantiationDepth(PointOfInstantiation, 87 InstantiationRange); 88 if (!Invalid) { 89 ActiveTemplateInstantiation Inst; 90 Inst.Kind 91 = ActiveTemplateInstantiation::DefaultTemplateArgumentInstantiation; 92 Inst.PointOfInstantiation = PointOfInstantiation; 93 Inst.Entity = reinterpret_cast<uintptr_t>(Template); 94 Inst.TemplateArgs = TemplateArgs; 95 Inst.NumTemplateArgs = NumTemplateArgs; 96 Inst.InstantiationRange = InstantiationRange; 97 SemaRef.ActiveTemplateInstantiations.push_back(Inst); 98 Invalid = false; 99 } 100} 101 102Sema::InstantiatingTemplate::InstantiatingTemplate(Sema &SemaRef, 103 SourceLocation PointOfInstantiation, 104 FunctionTemplateDecl *FunctionTemplate, 105 const TemplateArgument *TemplateArgs, 106 unsigned NumTemplateArgs, 107 ActiveTemplateInstantiation::InstantiationKind Kind, 108 SourceRange InstantiationRange) 109: SemaRef(SemaRef) { 110 111 Invalid = CheckInstantiationDepth(PointOfInstantiation, 112 InstantiationRange); 113 if (!Invalid) { 114 ActiveTemplateInstantiation Inst; 115 Inst.Kind = Kind; 116 Inst.PointOfInstantiation = PointOfInstantiation; 117 Inst.Entity = reinterpret_cast<uintptr_t>(FunctionTemplate); 118 Inst.TemplateArgs = TemplateArgs; 119 Inst.NumTemplateArgs = NumTemplateArgs; 120 Inst.InstantiationRange = InstantiationRange; 121 SemaRef.ActiveTemplateInstantiations.push_back(Inst); 122 Invalid = false; 123 } 124} 125 126Sema::InstantiatingTemplate::InstantiatingTemplate(Sema &SemaRef, 127 SourceLocation PointOfInstantiation, 128 ClassTemplatePartialSpecializationDecl *PartialSpec, 129 const TemplateArgument *TemplateArgs, 130 unsigned NumTemplateArgs, 131 SourceRange InstantiationRange) 132 : SemaRef(SemaRef) { 133 134 Invalid = CheckInstantiationDepth(PointOfInstantiation, 135 InstantiationRange); 136 if (!Invalid) { 137 ActiveTemplateInstantiation Inst; 138 Inst.Kind 139 = ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution; 140 Inst.PointOfInstantiation = PointOfInstantiation; 141 Inst.Entity = reinterpret_cast<uintptr_t>(PartialSpec); 142 Inst.TemplateArgs = TemplateArgs; 143 Inst.NumTemplateArgs = NumTemplateArgs; 144 Inst.InstantiationRange = InstantiationRange; 145 SemaRef.ActiveTemplateInstantiations.push_back(Inst); 146 Invalid = false; 147 } 148} 149 150void Sema::InstantiatingTemplate::Clear() { 151 if (!Invalid) { 152 SemaRef.ActiveTemplateInstantiations.pop_back(); 153 Invalid = true; 154 } 155} 156 157bool Sema::InstantiatingTemplate::CheckInstantiationDepth( 158 SourceLocation PointOfInstantiation, 159 SourceRange InstantiationRange) { 160 if (SemaRef.ActiveTemplateInstantiations.size() 161 <= SemaRef.getLangOptions().InstantiationDepth) 162 return false; 163 164 SemaRef.Diag(PointOfInstantiation, 165 diag::err_template_recursion_depth_exceeded) 166 << SemaRef.getLangOptions().InstantiationDepth 167 << InstantiationRange; 168 SemaRef.Diag(PointOfInstantiation, diag::note_template_recursion_depth) 169 << SemaRef.getLangOptions().InstantiationDepth; 170 return true; 171} 172 173/// \brief Prints the current instantiation stack through a series of 174/// notes. 175void Sema::PrintInstantiationStack() { 176 // FIXME: In all of these cases, we need to show the template arguments 177 for (llvm::SmallVector<ActiveTemplateInstantiation, 16>::reverse_iterator 178 Active = ActiveTemplateInstantiations.rbegin(), 179 ActiveEnd = ActiveTemplateInstantiations.rend(); 180 Active != ActiveEnd; 181 ++Active) { 182 switch (Active->Kind) { 183 case ActiveTemplateInstantiation::TemplateInstantiation: { 184 Decl *D = reinterpret_cast<Decl *>(Active->Entity); 185 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) { 186 unsigned DiagID = diag::note_template_member_class_here; 187 if (isa<ClassTemplateSpecializationDecl>(Record)) 188 DiagID = diag::note_template_class_instantiation_here; 189 Diags.Report(FullSourceLoc(Active->PointOfInstantiation, SourceMgr), 190 DiagID) 191 << Context.getTypeDeclType(Record) 192 << Active->InstantiationRange; 193 } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) { 194 unsigned DiagID; 195 if (Function->getPrimaryTemplate()) 196 DiagID = diag::note_function_template_spec_here; 197 else 198 DiagID = diag::note_template_member_function_here; 199 Diags.Report(FullSourceLoc(Active->PointOfInstantiation, SourceMgr), 200 DiagID) 201 << Function 202 << Active->InstantiationRange; 203 } else { 204 Diags.Report(FullSourceLoc(Active->PointOfInstantiation, SourceMgr), 205 diag::note_template_static_data_member_def_here) 206 << cast<VarDecl>(D) 207 << Active->InstantiationRange; 208 } 209 break; 210 } 211 212 case ActiveTemplateInstantiation::DefaultTemplateArgumentInstantiation: { 213 TemplateDecl *Template = cast<TemplateDecl>((Decl *)Active->Entity); 214 std::string TemplateArgsStr 215 = TemplateSpecializationType::PrintTemplateArgumentList( 216 Active->TemplateArgs, 217 Active->NumTemplateArgs, 218 Context.PrintingPolicy); 219 Diags.Report(FullSourceLoc(Active->PointOfInstantiation, SourceMgr), 220 diag::note_default_arg_instantiation_here) 221 << (Template->getNameAsString() + TemplateArgsStr) 222 << Active->InstantiationRange; 223 break; 224 } 225 226 case ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution: { 227 FunctionTemplateDecl *FnTmpl 228 = cast<FunctionTemplateDecl>((Decl *)Active->Entity); 229 Diags.Report(FullSourceLoc(Active->PointOfInstantiation, SourceMgr), 230 diag::note_explicit_template_arg_substitution_here) 231 << FnTmpl << Active->InstantiationRange; 232 break; 233 } 234 235 case ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution: 236 if (ClassTemplatePartialSpecializationDecl *PartialSpec 237 = dyn_cast<ClassTemplatePartialSpecializationDecl>( 238 (Decl *)Active->Entity)) { 239 Diags.Report(FullSourceLoc(Active->PointOfInstantiation, SourceMgr), 240 diag::note_partial_spec_deduct_instantiation_here) 241 << Context.getTypeDeclType(PartialSpec) 242 << Active->InstantiationRange; 243 } else { 244 FunctionTemplateDecl *FnTmpl 245 = cast<FunctionTemplateDecl>((Decl *)Active->Entity); 246 Diags.Report(FullSourceLoc(Active->PointOfInstantiation, SourceMgr), 247 diag::note_function_template_deduction_instantiation_here) 248 << FnTmpl << Active->InstantiationRange; 249 } 250 break; 251 252 } 253 } 254} 255 256bool Sema::isSFINAEContext() const { 257 using llvm::SmallVector; 258 for (SmallVector<ActiveTemplateInstantiation, 16>::const_reverse_iterator 259 Active = ActiveTemplateInstantiations.rbegin(), 260 ActiveEnd = ActiveTemplateInstantiations.rend(); 261 Active != ActiveEnd; 262 ++Active) { 263 264 switch(Active->Kind) { 265 case ActiveTemplateInstantiation::TemplateInstantiation: 266 // This is a template instantiation, so there is no SFINAE. 267 return false; 268 269 case ActiveTemplateInstantiation::DefaultTemplateArgumentInstantiation: 270 // A default template argument instantiation may or may not be a 271 // SFINAE context; look further up the stack. 272 break; 273 274 case ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution: 275 case ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution: 276 // We're either substitution explicitly-specified template arguments 277 // or deduced template arguments, so SFINAE applies. 278 return true; 279 } 280 } 281 282 return false; 283} 284 285//===----------------------------------------------------------------------===/ 286// Template Instantiation for Types 287//===----------------------------------------------------------------------===/ 288namespace { 289 class VISIBILITY_HIDDEN TemplateInstantiator 290 : public TreeTransform<TemplateInstantiator> 291 { 292 const TemplateArgumentList &TemplateArgs; 293 SourceLocation Loc; 294 DeclarationName Entity; 295 296 public: 297 TemplateInstantiator(Sema &SemaRef, 298 const TemplateArgumentList &TemplateArgs, 299 SourceLocation Loc, 300 DeclarationName Entity) 301 : TreeTransform<TemplateInstantiator>(SemaRef), TemplateArgs(TemplateArgs), 302 Loc(Loc), Entity(Entity) { } 303 304 /// \brief Determine whether the given type \p T has already been 305 /// transformed. 306 /// 307 /// For the purposes of template instantiation, a type has already been 308 /// transformed if it is NULL or if it is not dependent. 309 bool AlreadyTransformed(QualType T) { 310 return T.isNull() || !T->isDependentType(); 311 } 312 313 /// \brief Returns the location of the entity being instantiated, if known. 314 SourceLocation getBaseLocation() { return Loc; } 315 316 /// \brief Returns the name of the entity being instantiated, if any. 317 DeclarationName getBaseEntity() { return Entity; } 318 319 /// \brief Transform the given declaration by instantiating a reference to 320 /// this declaration. 321 Decl *TransformDecl(Decl *D); 322 323 Sema::OwningStmtResult TransformStmt(Stmt *S) { 324 return SemaRef.InstantiateStmt(S, TemplateArgs); 325 } 326 327 Sema::OwningStmtResult TransformCompoundStmt(CompoundStmt *S, 328 bool IsStmtExpr) { 329 return SemaRef.InstantiateCompoundStmt(S, TemplateArgs, IsStmtExpr); 330 } 331 332 Sema::OwningExprResult TransformDeclRefExpr(DeclRefExpr *E); 333 334 Sema::OwningExprResult 335 TransformCXXConditionDeclExpr(CXXConditionDeclExpr *E); 336 337 /// \brief Transforms a template type parameter type by performing 338 /// substitution of the corresponding template type argument. 339 QualType TransformTemplateTypeParmType(const TemplateTypeParmType *T); 340 }; 341} 342 343Decl *TemplateInstantiator::TransformDecl(Decl *D) { 344 if (TemplateTemplateParmDecl *TTP 345 = dyn_cast_or_null<TemplateTemplateParmDecl>(D)) { 346 // FIXME: Depth reduction 347 assert(TTP->getDepth() == 0 && 348 "Cannot reduce depth of a template template parameter"); 349 assert(TemplateArgs[TTP->getPosition()].getAsDecl() && 350 "Wrong kind of template template argument"); 351 TemplateDecl *Template 352 = dyn_cast<TemplateDecl>(TemplateArgs[TTP->getPosition()].getAsDecl()); 353 assert(Template && "Expected a template"); 354 return Template; 355 } 356 357 return SemaRef.InstantiateCurrentDeclRef(cast_or_null<NamedDecl>(D)); 358} 359 360Sema::OwningExprResult 361TemplateInstantiator::TransformDeclRefExpr(DeclRefExpr *E) { 362 // FIXME: Clean this up a bit 363 NamedDecl *D = E->getDecl(); 364 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) { 365 assert(NTTP->getDepth() == 0 && "No nested templates yet"); 366 367 // If the corresponding template argument is NULL or non-existent, it's 368 // because we are performing instantiation from explicitly-specified 369 // template arguments in a function template, but there were some 370 // arguments left unspecified. 371 if (NTTP->getPosition() >= TemplateArgs.size() || 372 TemplateArgs[NTTP->getPosition()].isNull()) 373 return SemaRef.Owned(E); // FIXME: Clone the expression! 374 375 const TemplateArgument &Arg = TemplateArgs[NTTP->getPosition()]; 376 377 // The template argument itself might be an expression, in which 378 // case we just return that expression. 379 if (Arg.getKind() == TemplateArgument::Expression) 380 // FIXME: Clone the expression! 381 return SemaRef.Owned(Arg.getAsExpr()); 382 383 if (Arg.getKind() == TemplateArgument::Declaration) { 384 ValueDecl *VD = cast<ValueDecl>(Arg.getAsDecl()); 385 386 // FIXME: Can VD ever have a dependent type? 387 return SemaRef.BuildDeclRefExpr(VD, VD->getType(), E->getLocation(), 388 false, false); 389 } 390 391 assert(Arg.getKind() == TemplateArgument::Integral); 392 QualType T = Arg.getIntegralType(); 393 if (T->isCharType() || T->isWideCharType()) 394 return SemaRef.Owned(new (SemaRef.Context) CharacterLiteral( 395 Arg.getAsIntegral()->getZExtValue(), 396 T->isWideCharType(), 397 T, 398 E->getSourceRange().getBegin())); 399 if (T->isBooleanType()) 400 return SemaRef.Owned(new (SemaRef.Context) CXXBoolLiteralExpr( 401 Arg.getAsIntegral()->getBoolValue(), 402 T, 403 E->getSourceRange().getBegin())); 404 405 assert(Arg.getAsIntegral()->getBitWidth() == SemaRef.Context.getIntWidth(T)); 406 return SemaRef.Owned(new (SemaRef.Context) IntegerLiteral( 407 *Arg.getAsIntegral(), 408 T, 409 E->getSourceRange().getBegin())); 410 } 411 412 if (OverloadedFunctionDecl *Ovl = dyn_cast<OverloadedFunctionDecl>(D)) { 413 // FIXME: instantiate each decl in the overload set 414 return SemaRef.Owned(new (SemaRef.Context) DeclRefExpr(Ovl, 415 SemaRef.Context.OverloadTy, 416 E->getLocation(), 417 false, false)); 418 } 419 420 NamedDecl *InstD = SemaRef.InstantiateCurrentDeclRef(D); 421 if (!InstD) 422 return SemaRef.ExprError(); 423 424 // FIXME: nested-name-specifier for QualifiedDeclRefExpr 425 return SemaRef.BuildDeclarationNameExpr(E->getLocation(), InstD, 426 /*FIXME:*/false, 427 /*FIXME:*/0, 428 /*FIXME:*/false); 429} 430 431Sema::OwningExprResult 432TemplateInstantiator::TransformCXXConditionDeclExpr(CXXConditionDeclExpr *E) { 433 VarDecl *Var 434 = cast_or_null<VarDecl>(SemaRef.InstantiateDecl(E->getVarDecl(), 435 SemaRef.CurContext, 436 TemplateArgs)); 437 if (!Var) 438 return SemaRef.ExprError(); 439 440 SemaRef.CurrentInstantiationScope->InstantiatedLocal(E->getVarDecl(), Var); 441 return SemaRef.Owned(new (SemaRef.Context) CXXConditionDeclExpr( 442 E->getStartLoc(), 443 SourceLocation(), 444 Var)); 445} 446 447QualType 448TemplateInstantiator::TransformTemplateTypeParmType( 449 const TemplateTypeParmType *T) { 450 if (T->getDepth() == 0) { 451 // Replace the template type parameter with its corresponding 452 // template argument. 453 454 // FIXME: When dealing with member templates, we might end up with multiple 455 /// levels of template arguments that we're substituting into concurrently. 456 457 // If the corresponding template argument is NULL or doesn't exist, it's 458 // because we are performing instantiation from explicitly-specified 459 // template arguments in a function template class, but there were some 460 // arguments left unspecified. 461 if (T->getIndex() >= TemplateArgs.size() || 462 TemplateArgs[T->getIndex()].isNull()) 463 return QualType(T, 0); // Would be nice to keep the original type here 464 465 assert(TemplateArgs[T->getIndex()].getKind() == TemplateArgument::Type && 466 "Template argument kind mismatch"); 467 return TemplateArgs[T->getIndex()].getAsType(); 468 } 469 470 // The template type parameter comes from an inner template (e.g., 471 // the template parameter list of a member template inside the 472 // template we are instantiating). Create a new template type 473 // parameter with the template "level" reduced by one. 474 return getSema().Context.getTemplateTypeParmType(T->getDepth() - 1, 475 T->getIndex(), 476 T->isParameterPack(), 477 T->getName()); 478} 479 480/// \brief Instantiate the type T with a given set of template arguments. 481/// 482/// This routine substitutes the given template arguments into the 483/// type T and produces the instantiated type. 484/// 485/// \param T the type into which the template arguments will be 486/// substituted. If this type is not dependent, it will be returned 487/// immediately. 488/// 489/// \param TemplateArgs the template arguments that will be 490/// substituted for the top-level template parameters within T. 491/// 492/// \param Loc the location in the source code where this substitution 493/// is being performed. It will typically be the location of the 494/// declarator (if we're instantiating the type of some declaration) 495/// or the location of the type in the source code (if, e.g., we're 496/// instantiating the type of a cast expression). 497/// 498/// \param Entity the name of the entity associated with a declaration 499/// being instantiated (if any). May be empty to indicate that there 500/// is no such entity (if, e.g., this is a type that occurs as part of 501/// a cast expression) or that the entity has no name (e.g., an 502/// unnamed function parameter). 503/// 504/// \returns If the instantiation succeeds, the instantiated 505/// type. Otherwise, produces diagnostics and returns a NULL type. 506QualType Sema::InstantiateType(QualType T, 507 const TemplateArgumentList &TemplateArgs, 508 SourceLocation Loc, DeclarationName Entity) { 509 assert(!ActiveTemplateInstantiations.empty() && 510 "Cannot perform an instantiation without some context on the " 511 "instantiation stack"); 512 513 // If T is not a dependent type, there is nothing to do. 514 if (!T->isDependentType()) 515 return T; 516 517 TemplateInstantiator Instantiator(*this, TemplateArgs, Loc, Entity); 518 return Instantiator.TransformType(T); 519} 520 521/// \brief Instantiate the base class specifiers of the given class 522/// template specialization. 523/// 524/// Produces a diagnostic and returns true on error, returns false and 525/// attaches the instantiated base classes to the class template 526/// specialization if successful. 527bool 528Sema::InstantiateBaseSpecifiers(CXXRecordDecl *Instantiation, 529 CXXRecordDecl *Pattern, 530 const TemplateArgumentList &TemplateArgs) { 531 bool Invalid = false; 532 llvm::SmallVector<CXXBaseSpecifier*, 4> InstantiatedBases; 533 for (ClassTemplateSpecializationDecl::base_class_iterator 534 Base = Pattern->bases_begin(), BaseEnd = Pattern->bases_end(); 535 Base != BaseEnd; ++Base) { 536 if (!Base->getType()->isDependentType()) { 537 InstantiatedBases.push_back(new (Context) CXXBaseSpecifier(*Base)); 538 continue; 539 } 540 541 QualType BaseType = InstantiateType(Base->getType(), 542 TemplateArgs, 543 Base->getSourceRange().getBegin(), 544 DeclarationName()); 545 if (BaseType.isNull()) { 546 Invalid = true; 547 continue; 548 } 549 550 if (CXXBaseSpecifier *InstantiatedBase 551 = CheckBaseSpecifier(Instantiation, 552 Base->getSourceRange(), 553 Base->isVirtual(), 554 Base->getAccessSpecifierAsWritten(), 555 BaseType, 556 /*FIXME: Not totally accurate */ 557 Base->getSourceRange().getBegin())) 558 InstantiatedBases.push_back(InstantiatedBase); 559 else 560 Invalid = true; 561 } 562 563 if (!Invalid && 564 AttachBaseSpecifiers(Instantiation, InstantiatedBases.data(), 565 InstantiatedBases.size())) 566 Invalid = true; 567 568 return Invalid; 569} 570 571/// \brief Instantiate the definition of a class from a given pattern. 572/// 573/// \param PointOfInstantiation The point of instantiation within the 574/// source code. 575/// 576/// \param Instantiation is the declaration whose definition is being 577/// instantiated. This will be either a class template specialization 578/// or a member class of a class template specialization. 579/// 580/// \param Pattern is the pattern from which the instantiation 581/// occurs. This will be either the declaration of a class template or 582/// the declaration of a member class of a class template. 583/// 584/// \param TemplateArgs The template arguments to be substituted into 585/// the pattern. 586/// 587/// \returns true if an error occurred, false otherwise. 588bool 589Sema::InstantiateClass(SourceLocation PointOfInstantiation, 590 CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern, 591 const TemplateArgumentList &TemplateArgs, 592 bool ExplicitInstantiation) { 593 bool Invalid = false; 594 595 CXXRecordDecl *PatternDef 596 = cast_or_null<CXXRecordDecl>(Pattern->getDefinition(Context)); 597 if (!PatternDef) { 598 if (Pattern == Instantiation->getInstantiatedFromMemberClass()) { 599 Diag(PointOfInstantiation, 600 diag::err_implicit_instantiate_member_undefined) 601 << Context.getTypeDeclType(Instantiation); 602 Diag(Pattern->getLocation(), diag::note_member_of_template_here); 603 } else { 604 Diag(PointOfInstantiation, diag::err_template_instantiate_undefined) 605 << ExplicitInstantiation 606 << Context.getTypeDeclType(Instantiation); 607 Diag(Pattern->getLocation(), diag::note_template_decl_here); 608 } 609 return true; 610 } 611 Pattern = PatternDef; 612 613 InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation); 614 if (Inst) 615 return true; 616 617 // Enter the scope of this instantiation. We don't use 618 // PushDeclContext because we don't have a scope. 619 DeclContext *PreviousContext = CurContext; 620 CurContext = Instantiation; 621 622 // Start the definition of this instantiation. 623 Instantiation->startDefinition(); 624 625 // Instantiate the base class specifiers. 626 if (InstantiateBaseSpecifiers(Instantiation, Pattern, TemplateArgs)) 627 Invalid = true; 628 629 llvm::SmallVector<DeclPtrTy, 4> Fields; 630 for (RecordDecl::decl_iterator Member = Pattern->decls_begin(), 631 MemberEnd = Pattern->decls_end(); 632 Member != MemberEnd; ++Member) { 633 Decl *NewMember = InstantiateDecl(*Member, Instantiation, TemplateArgs); 634 if (NewMember) { 635 if (NewMember->isInvalidDecl()) 636 Invalid = true; 637 else if (FieldDecl *Field = dyn_cast<FieldDecl>(NewMember)) 638 Fields.push_back(DeclPtrTy::make(Field)); 639 } else { 640 // FIXME: Eventually, a NULL return will mean that one of the 641 // instantiations was a semantic disaster, and we'll want to set Invalid = 642 // true. For now, we expect to skip some members that we can't yet handle. 643 } 644 } 645 646 // Finish checking fields. 647 ActOnFields(0, Instantiation->getLocation(), DeclPtrTy::make(Instantiation), 648 Fields.data(), Fields.size(), SourceLocation(), SourceLocation(), 649 0); 650 651 // Add any implicitly-declared members that we might need. 652 AddImplicitlyDeclaredMembersToClass(Instantiation); 653 654 // Exit the scope of this instantiation. 655 CurContext = PreviousContext; 656 657 if (!Invalid) 658 Consumer.HandleTagDeclDefinition(Instantiation); 659 660 // If this is an explicit instantiation, instantiate our members, too. 661 if (!Invalid && ExplicitInstantiation) { 662 Inst.Clear(); 663 InstantiateClassMembers(PointOfInstantiation, Instantiation, TemplateArgs); 664 } 665 666 return Invalid; 667} 668 669bool 670Sema::InstantiateClassTemplateSpecialization( 671 ClassTemplateSpecializationDecl *ClassTemplateSpec, 672 bool ExplicitInstantiation) { 673 // Perform the actual instantiation on the canonical declaration. 674 ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>( 675 ClassTemplateSpec->getCanonicalDecl()); 676 677 // We can only instantiate something that hasn't already been 678 // instantiated or specialized. Fail without any diagnostics: our 679 // caller will provide an error message. 680 if (ClassTemplateSpec->getSpecializationKind() != TSK_Undeclared) 681 return true; 682 683 ClassTemplateDecl *Template = ClassTemplateSpec->getSpecializedTemplate(); 684 CXXRecordDecl *Pattern = Template->getTemplatedDecl(); 685 const TemplateArgumentList *TemplateArgs 686 = &ClassTemplateSpec->getTemplateArgs(); 687 688 // C++ [temp.class.spec.match]p1: 689 // When a class template is used in a context that requires an 690 // instantiation of the class, it is necessary to determine 691 // whether the instantiation is to be generated using the primary 692 // template or one of the partial specializations. This is done by 693 // matching the template arguments of the class template 694 // specialization with the template argument lists of the partial 695 // specializations. 696 typedef std::pair<ClassTemplatePartialSpecializationDecl *, 697 TemplateArgumentList *> MatchResult; 698 llvm::SmallVector<MatchResult, 4> Matched; 699 for (llvm::FoldingSet<ClassTemplatePartialSpecializationDecl>::iterator 700 Partial = Template->getPartialSpecializations().begin(), 701 PartialEnd = Template->getPartialSpecializations().end(); 702 Partial != PartialEnd; 703 ++Partial) { 704 TemplateDeductionInfo Info(Context); 705 if (TemplateDeductionResult Result 706 = DeduceTemplateArguments(&*Partial, 707 ClassTemplateSpec->getTemplateArgs(), 708 Info)) { 709 // FIXME: Store the failed-deduction information for use in 710 // diagnostics, later. 711 (void)Result; 712 } else { 713 Matched.push_back(std::make_pair(&*Partial, Info.take())); 714 } 715 } 716 717 if (Matched.size() == 1) { 718 // -- If exactly one matching specialization is found, the 719 // instantiation is generated from that specialization. 720 Pattern = Matched[0].first; 721 TemplateArgs = Matched[0].second; 722 ClassTemplateSpec->setInstantiationOf(Matched[0].first, Matched[0].second); 723 } else if (Matched.size() > 1) { 724 // -- If more than one matching specialization is found, the 725 // partial order rules (14.5.4.2) are used to determine 726 // whether one of the specializations is more specialized 727 // than the others. If none of the specializations is more 728 // specialized than all of the other matching 729 // specializations, then the use of the class template is 730 // ambiguous and the program is ill-formed. 731 // FIXME: Implement partial ordering of class template partial 732 // specializations. 733 Diag(ClassTemplateSpec->getLocation(), 734 diag::unsup_template_partial_spec_ordering); 735 } else { 736 // -- If no matches are found, the instantiation is generated 737 // from the primary template. 738 739 // Since we initialized the pattern and template arguments from 740 // the primary template, there is nothing more we need to do here. 741 } 742 743 // Note that this is an instantiation. 744 ClassTemplateSpec->setSpecializationKind( 745 ExplicitInstantiation? TSK_ExplicitInstantiation 746 : TSK_ImplicitInstantiation); 747 748 bool Result = InstantiateClass(ClassTemplateSpec->getLocation(), 749 ClassTemplateSpec, Pattern, *TemplateArgs, 750 ExplicitInstantiation); 751 752 for (unsigned I = 0, N = Matched.size(); I != N; ++I) { 753 // FIXME: Implement TemplateArgumentList::Destroy! 754 // if (Matched[I].first != Pattern) 755 // Matched[I].second->Destroy(Context); 756 } 757 758 return Result; 759} 760 761/// \brief Instantiate the definitions of all of the member of the 762/// given class, which is an instantiation of a class template or a 763/// member class of a template. 764void 765Sema::InstantiateClassMembers(SourceLocation PointOfInstantiation, 766 CXXRecordDecl *Instantiation, 767 const TemplateArgumentList &TemplateArgs) { 768 for (DeclContext::decl_iterator D = Instantiation->decls_begin(), 769 DEnd = Instantiation->decls_end(); 770 D != DEnd; ++D) { 771 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(*D)) { 772 if (!Function->getBody()) 773 InstantiateFunctionDefinition(PointOfInstantiation, Function); 774 } else if (VarDecl *Var = dyn_cast<VarDecl>(*D)) { 775 if (Var->isStaticDataMember()) 776 InstantiateStaticDataMemberDefinition(PointOfInstantiation, Var); 777 } else if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(*D)) { 778 if (!Record->isInjectedClassName() && !Record->getDefinition(Context)) { 779 assert(Record->getInstantiatedFromMemberClass() && 780 "Missing instantiated-from-template information"); 781 InstantiateClass(PointOfInstantiation, Record, 782 Record->getInstantiatedFromMemberClass(), 783 TemplateArgs, true); 784 } 785 } 786 } 787} 788 789/// \brief Instantiate the definitions of all of the members of the 790/// given class template specialization, which was named as part of an 791/// explicit instantiation. 792void Sema::InstantiateClassTemplateSpecializationMembers( 793 SourceLocation PointOfInstantiation, 794 ClassTemplateSpecializationDecl *ClassTemplateSpec) { 795 // C++0x [temp.explicit]p7: 796 // An explicit instantiation that names a class template 797 // specialization is an explicit instantion of the same kind 798 // (declaration or definition) of each of its members (not 799 // including members inherited from base classes) that has not 800 // been previously explicitly specialized in the translation unit 801 // containing the explicit instantiation, except as described 802 // below. 803 InstantiateClassMembers(PointOfInstantiation, ClassTemplateSpec, 804 ClassTemplateSpec->getTemplateArgs()); 805} 806 807Sema::OwningExprResult 808Sema::InstantiateExpr(Expr *E, const TemplateArgumentList &TemplateArgs) { 809 if (!E) 810 return Owned(E); 811 812 TemplateInstantiator Instantiator(*this, TemplateArgs, 813 SourceLocation(), 814 DeclarationName()); 815 return Instantiator.TransformExpr(E); 816} 817 818/// \brief Instantiate a nested-name-specifier. 819NestedNameSpecifier * 820Sema::InstantiateNestedNameSpecifier(NestedNameSpecifier *NNS, 821 SourceRange Range, 822 const TemplateArgumentList &TemplateArgs) { 823 TemplateInstantiator Instantiator(*this, TemplateArgs, Range.getBegin(), 824 DeclarationName()); 825 return Instantiator.TransformNestedNameSpecifier(NNS, Range); 826} 827 828TemplateName 829Sema::InstantiateTemplateName(TemplateName Name, SourceLocation Loc, 830 const TemplateArgumentList &TemplateArgs) { 831 TemplateInstantiator Instantiator(*this, TemplateArgs, Loc, 832 DeclarationName()); 833 return Instantiator.TransformTemplateName(Name); 834} 835 836TemplateArgument Sema::Instantiate(TemplateArgument Arg, 837 const TemplateArgumentList &TemplateArgs) { 838 TemplateInstantiator Instantiator(*this, TemplateArgs, SourceLocation(), 839 DeclarationName()); 840 return Instantiator.TransformTemplateArgument(Arg); 841} 842