SemaTemplateInstantiate.cpp revision 193326
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 "clang/AST/ASTConsumer.h" 15#include "clang/AST/ASTContext.h" 16#include "clang/AST/Expr.h" 17#include "clang/AST/DeclTemplate.h" 18#include "clang/Parse/DeclSpec.h" 19#include "clang/Basic/LangOptions.h" 20#include "llvm/Support/Compiler.h" 21 22using namespace clang; 23 24//===----------------------------------------------------------------------===/ 25// Template Instantiation Support 26//===----------------------------------------------------------------------===/ 27 28/// \brief Retrieve the template argument list that should be used to 29/// instantiate the given declaration. 30const TemplateArgumentList & 31Sema::getTemplateInstantiationArgs(NamedDecl *D) { 32 if (ClassTemplateSpecializationDecl *Spec 33 = dyn_cast<ClassTemplateSpecializationDecl>(D)) 34 return Spec->getTemplateArgs(); 35 36 DeclContext *EnclosingTemplateCtx = D->getDeclContext(); 37 while (!isa<ClassTemplateSpecializationDecl>(EnclosingTemplateCtx)) { 38 assert(!EnclosingTemplateCtx->isFileContext() && 39 "Tried to get the instantiation arguments of a non-template"); 40 EnclosingTemplateCtx = EnclosingTemplateCtx->getParent(); 41 } 42 43 ClassTemplateSpecializationDecl *EnclosingTemplate 44 = cast<ClassTemplateSpecializationDecl>(EnclosingTemplateCtx); 45 return EnclosingTemplate->getTemplateArgs(); 46} 47 48Sema::InstantiatingTemplate:: 49InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 50 Decl *Entity, 51 SourceRange InstantiationRange) 52 : SemaRef(SemaRef) { 53 54 Invalid = CheckInstantiationDepth(PointOfInstantiation, 55 InstantiationRange); 56 if (!Invalid) { 57 ActiveTemplateInstantiation Inst; 58 Inst.Kind = ActiveTemplateInstantiation::TemplateInstantiation; 59 Inst.PointOfInstantiation = PointOfInstantiation; 60 Inst.Entity = reinterpret_cast<uintptr_t>(Entity); 61 Inst.TemplateArgs = 0; 62 Inst.NumTemplateArgs = 0; 63 Inst.InstantiationRange = InstantiationRange; 64 SemaRef.ActiveTemplateInstantiations.push_back(Inst); 65 Invalid = false; 66 } 67} 68 69Sema::InstantiatingTemplate::InstantiatingTemplate(Sema &SemaRef, 70 SourceLocation PointOfInstantiation, 71 TemplateDecl *Template, 72 const TemplateArgument *TemplateArgs, 73 unsigned NumTemplateArgs, 74 SourceRange InstantiationRange) 75 : SemaRef(SemaRef) { 76 77 Invalid = CheckInstantiationDepth(PointOfInstantiation, 78 InstantiationRange); 79 if (!Invalid) { 80 ActiveTemplateInstantiation Inst; 81 Inst.Kind 82 = ActiveTemplateInstantiation::DefaultTemplateArgumentInstantiation; 83 Inst.PointOfInstantiation = PointOfInstantiation; 84 Inst.Entity = reinterpret_cast<uintptr_t>(Template); 85 Inst.TemplateArgs = TemplateArgs; 86 Inst.NumTemplateArgs = NumTemplateArgs; 87 Inst.InstantiationRange = InstantiationRange; 88 SemaRef.ActiveTemplateInstantiations.push_back(Inst); 89 Invalid = false; 90 } 91} 92 93void Sema::InstantiatingTemplate::Clear() { 94 if (!Invalid) { 95 SemaRef.ActiveTemplateInstantiations.pop_back(); 96 Invalid = true; 97 } 98} 99 100bool Sema::InstantiatingTemplate::CheckInstantiationDepth( 101 SourceLocation PointOfInstantiation, 102 SourceRange InstantiationRange) { 103 if (SemaRef.ActiveTemplateInstantiations.size() 104 <= SemaRef.getLangOptions().InstantiationDepth) 105 return false; 106 107 SemaRef.Diag(PointOfInstantiation, 108 diag::err_template_recursion_depth_exceeded) 109 << SemaRef.getLangOptions().InstantiationDepth 110 << InstantiationRange; 111 SemaRef.Diag(PointOfInstantiation, diag::note_template_recursion_depth) 112 << SemaRef.getLangOptions().InstantiationDepth; 113 return true; 114} 115 116/// \brief Prints the current instantiation stack through a series of 117/// notes. 118void Sema::PrintInstantiationStack() { 119 for (llvm::SmallVector<ActiveTemplateInstantiation, 16>::reverse_iterator 120 Active = ActiveTemplateInstantiations.rbegin(), 121 ActiveEnd = ActiveTemplateInstantiations.rend(); 122 Active != ActiveEnd; 123 ++Active) { 124 switch (Active->Kind) { 125 case ActiveTemplateInstantiation::TemplateInstantiation: { 126 Decl *D = reinterpret_cast<Decl *>(Active->Entity); 127 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) { 128 unsigned DiagID = diag::note_template_member_class_here; 129 if (isa<ClassTemplateSpecializationDecl>(Record)) 130 DiagID = diag::note_template_class_instantiation_here; 131 Diags.Report(FullSourceLoc(Active->PointOfInstantiation, SourceMgr), 132 DiagID) 133 << Context.getTypeDeclType(Record) 134 << Active->InstantiationRange; 135 } else { 136 FunctionDecl *Function = cast<FunctionDecl>(D); 137 unsigned DiagID = diag::note_template_member_function_here; 138 // FIXME: check for a function template 139 Diags.Report(FullSourceLoc(Active->PointOfInstantiation, SourceMgr), 140 DiagID) 141 << Function 142 << Active->InstantiationRange; 143 } 144 break; 145 } 146 147 case ActiveTemplateInstantiation::DefaultTemplateArgumentInstantiation: { 148 TemplateDecl *Template = cast<TemplateDecl>((Decl *)Active->Entity); 149 std::string TemplateArgsStr 150 = TemplateSpecializationType::PrintTemplateArgumentList( 151 Active->TemplateArgs, 152 Active->NumTemplateArgs, 153 Context.PrintingPolicy); 154 Diags.Report(FullSourceLoc(Active->PointOfInstantiation, SourceMgr), 155 diag::note_default_arg_instantiation_here) 156 << (Template->getNameAsString() + TemplateArgsStr) 157 << Active->InstantiationRange; 158 break; 159 } 160 } 161 } 162} 163 164//===----------------------------------------------------------------------===/ 165// Template Instantiation for Types 166//===----------------------------------------------------------------------===/ 167namespace { 168 class VISIBILITY_HIDDEN TemplateTypeInstantiator { 169 Sema &SemaRef; 170 const TemplateArgumentList &TemplateArgs; 171 SourceLocation Loc; 172 DeclarationName Entity; 173 174 public: 175 TemplateTypeInstantiator(Sema &SemaRef, 176 const TemplateArgumentList &TemplateArgs, 177 SourceLocation Loc, 178 DeclarationName Entity) 179 : SemaRef(SemaRef), TemplateArgs(TemplateArgs), 180 Loc(Loc), Entity(Entity) { } 181 182 QualType operator()(QualType T) const { return Instantiate(T); } 183 184 QualType Instantiate(QualType T) const; 185 186 // Declare instantiate functions for each type. 187#define TYPE(Class, Base) \ 188 QualType Instantiate##Class##Type(const Class##Type *T, \ 189 unsigned Quals) const; 190#define ABSTRACT_TYPE(Class, Base) 191#include "clang/AST/TypeNodes.def" 192 }; 193} 194 195QualType 196TemplateTypeInstantiator::InstantiateExtQualType(const ExtQualType *T, 197 unsigned Quals) const { 198 // FIXME: Implement this 199 assert(false && "Cannot instantiate ExtQualType yet"); 200 return QualType(); 201} 202 203QualType 204TemplateTypeInstantiator::InstantiateBuiltinType(const BuiltinType *T, 205 unsigned Quals) const { 206 assert(false && "Builtin types are not dependent and cannot be instantiated"); 207 return QualType(T, Quals); 208} 209 210QualType 211TemplateTypeInstantiator:: 212InstantiateFixedWidthIntType(const FixedWidthIntType *T, unsigned Quals) const { 213 // FIXME: Implement this 214 assert(false && "Cannot instantiate FixedWidthIntType yet"); 215 return QualType(); 216} 217 218QualType 219TemplateTypeInstantiator::InstantiateComplexType(const ComplexType *T, 220 unsigned Quals) const { 221 // FIXME: Implement this 222 assert(false && "Cannot instantiate ComplexType yet"); 223 return QualType(); 224} 225 226QualType 227TemplateTypeInstantiator::InstantiatePointerType(const PointerType *T, 228 unsigned Quals) const { 229 QualType PointeeType = Instantiate(T->getPointeeType()); 230 if (PointeeType.isNull()) 231 return QualType(); 232 233 return SemaRef.BuildPointerType(PointeeType, Quals, Loc, Entity); 234} 235 236QualType 237TemplateTypeInstantiator::InstantiateBlockPointerType(const BlockPointerType *T, 238 unsigned Quals) const { 239 // FIXME: Implement this 240 assert(false && "Cannot instantiate BlockPointerType yet"); 241 return QualType(); 242} 243 244QualType 245TemplateTypeInstantiator::InstantiateLValueReferenceType( 246 const LValueReferenceType *T, unsigned Quals) const { 247 QualType ReferentType = Instantiate(T->getPointeeType()); 248 if (ReferentType.isNull()) 249 return QualType(); 250 251 return SemaRef.BuildReferenceType(ReferentType, true, Quals, Loc, Entity); 252} 253 254QualType 255TemplateTypeInstantiator::InstantiateRValueReferenceType( 256 const RValueReferenceType *T, unsigned Quals) const { 257 QualType ReferentType = Instantiate(T->getPointeeType()); 258 if (ReferentType.isNull()) 259 return QualType(); 260 261 return SemaRef.BuildReferenceType(ReferentType, false, Quals, Loc, Entity); 262} 263 264QualType 265TemplateTypeInstantiator:: 266InstantiateMemberPointerType(const MemberPointerType *T, 267 unsigned Quals) const { 268 // FIXME: Implement this 269 assert(false && "Cannot instantiate MemberPointerType yet"); 270 return QualType(); 271} 272 273QualType 274TemplateTypeInstantiator:: 275InstantiateConstantArrayType(const ConstantArrayType *T, 276 unsigned Quals) const { 277 QualType ElementType = Instantiate(T->getElementType()); 278 if (ElementType.isNull()) 279 return ElementType; 280 281 // Build a temporary integer literal to specify the size for 282 // BuildArrayType. Since we have already checked the size as part of 283 // creating the dependent array type in the first place, we know 284 // there aren't any errors. However, we do need to determine what 285 // C++ type to give the size expression. 286 llvm::APInt Size = T->getSize(); 287 QualType Types[] = { 288 SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy, 289 SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy, 290 SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty 291 }; 292 const unsigned NumTypes = sizeof(Types) / sizeof(QualType); 293 QualType SizeType; 294 for (unsigned I = 0; I != NumTypes; ++I) 295 if (Size.getBitWidth() == SemaRef.Context.getIntWidth(Types[I])) { 296 SizeType = Types[I]; 297 break; 298 } 299 300 if (SizeType.isNull()) 301 SizeType = SemaRef.Context.getFixedWidthIntType(Size.getBitWidth(), false); 302 303 IntegerLiteral ArraySize(Size, SizeType, Loc); 304 return SemaRef.BuildArrayType(ElementType, T->getSizeModifier(), 305 &ArraySize, T->getIndexTypeQualifier(), 306 Loc, Entity); 307} 308 309QualType 310TemplateTypeInstantiator:: 311InstantiateIncompleteArrayType(const IncompleteArrayType *T, 312 unsigned Quals) const { 313 QualType ElementType = Instantiate(T->getElementType()); 314 if (ElementType.isNull()) 315 return ElementType; 316 317 return SemaRef.BuildArrayType(ElementType, T->getSizeModifier(), 318 0, T->getIndexTypeQualifier(), 319 Loc, Entity); 320} 321 322QualType 323TemplateTypeInstantiator:: 324InstantiateVariableArrayType(const VariableArrayType *T, 325 unsigned Quals) const { 326 // FIXME: Implement this 327 assert(false && "Cannot instantiate VariableArrayType yet"); 328 return QualType(); 329} 330 331QualType 332TemplateTypeInstantiator:: 333InstantiateDependentSizedArrayType(const DependentSizedArrayType *T, 334 unsigned Quals) const { 335 Expr *ArraySize = T->getSizeExpr(); 336 assert(ArraySize->isValueDependent() && 337 "dependent sized array types must have value dependent size expr"); 338 339 // Instantiate the element type if needed 340 QualType ElementType = T->getElementType(); 341 if (ElementType->isDependentType()) { 342 ElementType = Instantiate(ElementType); 343 if (ElementType.isNull()) 344 return QualType(); 345 } 346 347 // Instantiate the size expression 348 Sema::OwningExprResult InstantiatedArraySize = 349 SemaRef.InstantiateExpr(ArraySize, TemplateArgs); 350 if (InstantiatedArraySize.isInvalid()) 351 return QualType(); 352 353 return SemaRef.BuildArrayType(ElementType, T->getSizeModifier(), 354 InstantiatedArraySize.takeAs<Expr>(), 355 T->getIndexTypeQualifier(), Loc, Entity); 356} 357 358QualType 359TemplateTypeInstantiator::InstantiateVectorType(const VectorType *T, 360 unsigned Quals) const { 361 // FIXME: Implement this 362 assert(false && "Cannot instantiate VectorType yet"); 363 return QualType(); 364} 365 366QualType 367TemplateTypeInstantiator::InstantiateExtVectorType(const ExtVectorType *T, 368 unsigned Quals) const { 369 // FIXME: Implement this 370 assert(false && "Cannot instantiate ExtVectorType yet"); 371 return QualType(); 372} 373 374QualType 375TemplateTypeInstantiator:: 376InstantiateFunctionProtoType(const FunctionProtoType *T, 377 unsigned Quals) const { 378 QualType ResultType = Instantiate(T->getResultType()); 379 if (ResultType.isNull()) 380 return ResultType; 381 382 llvm::SmallVector<QualType, 4> ParamTypes; 383 for (FunctionProtoType::arg_type_iterator Param = T->arg_type_begin(), 384 ParamEnd = T->arg_type_end(); 385 Param != ParamEnd; ++Param) { 386 QualType P = Instantiate(*Param); 387 if (P.isNull()) 388 return P; 389 390 ParamTypes.push_back(P); 391 } 392 393 return SemaRef.BuildFunctionType(ResultType, &ParamTypes[0], 394 ParamTypes.size(), 395 T->isVariadic(), T->getTypeQuals(), 396 Loc, Entity); 397} 398 399QualType 400TemplateTypeInstantiator:: 401InstantiateFunctionNoProtoType(const FunctionNoProtoType *T, 402 unsigned Quals) const { 403 assert(false && "Functions without prototypes cannot be dependent."); 404 return QualType(); 405} 406 407QualType 408TemplateTypeInstantiator::InstantiateTypedefType(const TypedefType *T, 409 unsigned Quals) const { 410 TypedefDecl *Typedef 411 = cast_or_null<TypedefDecl>( 412 SemaRef.InstantiateCurrentDeclRef(T->getDecl())); 413 if (!Typedef) 414 return QualType(); 415 416 return SemaRef.Context.getTypeDeclType(Typedef); 417} 418 419QualType 420TemplateTypeInstantiator::InstantiateTypeOfExprType(const TypeOfExprType *T, 421 unsigned Quals) const { 422 Sema::OwningExprResult E 423 = SemaRef.InstantiateExpr(T->getUnderlyingExpr(), TemplateArgs); 424 if (E.isInvalid()) 425 return QualType(); 426 427 return SemaRef.Context.getTypeOfExprType(E.takeAs<Expr>()); 428} 429 430QualType 431TemplateTypeInstantiator::InstantiateTypeOfType(const TypeOfType *T, 432 unsigned Quals) const { 433 QualType Underlying = Instantiate(T->getUnderlyingType()); 434 if (Underlying.isNull()) 435 return QualType(); 436 437 return SemaRef.Context.getTypeOfType(Underlying); 438} 439 440QualType 441TemplateTypeInstantiator::InstantiateRecordType(const RecordType *T, 442 unsigned Quals) const { 443 RecordDecl *Record 444 = cast_or_null<RecordDecl>(SemaRef.InstantiateCurrentDeclRef(T->getDecl())); 445 if (!Record) 446 return QualType(); 447 448 return SemaRef.Context.getTypeDeclType(Record); 449} 450 451QualType 452TemplateTypeInstantiator::InstantiateEnumType(const EnumType *T, 453 unsigned Quals) const { 454 EnumDecl *Enum 455 = cast_or_null<EnumDecl>(SemaRef.InstantiateCurrentDeclRef(T->getDecl())); 456 if (!Enum) 457 return QualType(); 458 459 return SemaRef.Context.getTypeDeclType(Enum); 460} 461 462QualType 463TemplateTypeInstantiator:: 464InstantiateTemplateTypeParmType(const TemplateTypeParmType *T, 465 unsigned Quals) const { 466 if (T->getDepth() == 0) { 467 // Replace the template type parameter with its corresponding 468 // template argument. 469 assert(TemplateArgs[T->getIndex()].getKind() == TemplateArgument::Type && 470 "Template argument kind mismatch"); 471 QualType Result = TemplateArgs[T->getIndex()].getAsType(); 472 if (Result.isNull() || !Quals) 473 return Result; 474 475 // C++ [dcl.ref]p1: 476 // [...] Cv-qualified references are ill-formed except when 477 // the cv-qualifiers are introduced through the use of a 478 // typedef (7.1.3) or of a template type argument (14.3), in 479 // which case the cv-qualifiers are ignored. 480 if (Quals && Result->isReferenceType()) 481 Quals = 0; 482 483 return QualType(Result.getTypePtr(), Quals | Result.getCVRQualifiers()); 484 } 485 486 // The template type parameter comes from an inner template (e.g., 487 // the template parameter list of a member template inside the 488 // template we are instantiating). Create a new template type 489 // parameter with the template "level" reduced by one. 490 return SemaRef.Context.getTemplateTypeParmType(T->getDepth() - 1, 491 T->getIndex(), 492 T->getName()) 493 .getQualifiedType(Quals); 494} 495 496QualType 497TemplateTypeInstantiator:: 498InstantiateTemplateSpecializationType( 499 const TemplateSpecializationType *T, 500 unsigned Quals) const { 501 llvm::SmallVector<TemplateArgument, 4> InstantiatedTemplateArgs; 502 InstantiatedTemplateArgs.reserve(T->getNumArgs()); 503 for (TemplateSpecializationType::iterator Arg = T->begin(), ArgEnd = T->end(); 504 Arg != ArgEnd; ++Arg) { 505 switch (Arg->getKind()) { 506 case TemplateArgument::Type: { 507 QualType T = SemaRef.InstantiateType(Arg->getAsType(), 508 TemplateArgs, 509 Arg->getLocation(), 510 DeclarationName()); 511 if (T.isNull()) 512 return QualType(); 513 514 InstantiatedTemplateArgs.push_back( 515 TemplateArgument(Arg->getLocation(), T)); 516 break; 517 } 518 519 case TemplateArgument::Declaration: 520 case TemplateArgument::Integral: 521 InstantiatedTemplateArgs.push_back(*Arg); 522 break; 523 524 case TemplateArgument::Expression: 525 Sema::OwningExprResult E 526 = SemaRef.InstantiateExpr(Arg->getAsExpr(), TemplateArgs); 527 if (E.isInvalid()) 528 return QualType(); 529 InstantiatedTemplateArgs.push_back(E.takeAs<Expr>()); 530 break; 531 } 532 } 533 534 // FIXME: We're missing the locations of the template name, '<', and '>'. 535 536 TemplateName Name = SemaRef.InstantiateTemplateName(T->getTemplateName(), 537 Loc, 538 TemplateArgs); 539 540 return SemaRef.CheckTemplateIdType(Name, Loc, SourceLocation(), 541 &InstantiatedTemplateArgs[0], 542 InstantiatedTemplateArgs.size(), 543 SourceLocation()); 544} 545 546QualType 547TemplateTypeInstantiator:: 548InstantiateQualifiedNameType(const QualifiedNameType *T, 549 unsigned Quals) const { 550 // When we instantiated a qualified name type, there's no point in 551 // keeping the qualification around in the instantiated result. So, 552 // just instantiate the named type. 553 return (*this)(T->getNamedType()); 554} 555 556QualType 557TemplateTypeInstantiator:: 558InstantiateTypenameType(const TypenameType *T, unsigned Quals) const { 559 if (const TemplateSpecializationType *TemplateId = T->getTemplateId()) { 560 // When the typename type refers to a template-id, the template-id 561 // is dependent and has enough information to instantiate the 562 // result of the typename type. Since we don't care about keeping 563 // the spelling of the typename type in template instantiations, 564 // we just instantiate the template-id. 565 return InstantiateTemplateSpecializationType(TemplateId, Quals); 566 } 567 568 NestedNameSpecifier *NNS 569 = SemaRef.InstantiateNestedNameSpecifier(T->getQualifier(), 570 SourceRange(Loc), 571 TemplateArgs); 572 if (!NNS) 573 return QualType(); 574 575 return SemaRef.CheckTypenameType(NNS, *T->getIdentifier(), SourceRange(Loc)); 576} 577 578QualType 579TemplateTypeInstantiator:: 580InstantiateObjCInterfaceType(const ObjCInterfaceType *T, 581 unsigned Quals) const { 582 assert(false && "Objective-C types cannot be dependent"); 583 return QualType(); 584} 585 586QualType 587TemplateTypeInstantiator:: 588InstantiateObjCQualifiedInterfaceType(const ObjCQualifiedInterfaceType *T, 589 unsigned Quals) const { 590 assert(false && "Objective-C types cannot be dependent"); 591 return QualType(); 592} 593 594QualType 595TemplateTypeInstantiator:: 596InstantiateObjCQualifiedIdType(const ObjCQualifiedIdType *T, 597 unsigned Quals) const { 598 assert(false && "Objective-C types cannot be dependent"); 599 return QualType(); 600} 601 602/// \brief The actual implementation of Sema::InstantiateType(). 603QualType TemplateTypeInstantiator::Instantiate(QualType T) const { 604 // If T is not a dependent type, there is nothing to do. 605 if (!T->isDependentType()) 606 return T; 607 608 switch (T->getTypeClass()) { 609#define TYPE(Class, Base) \ 610 case Type::Class: \ 611 return Instantiate##Class##Type(cast<Class##Type>(T.getTypePtr()), \ 612 T.getCVRQualifiers()); 613#define ABSTRACT_TYPE(Class, Base) 614#include "clang/AST/TypeNodes.def" 615 } 616 617 assert(false && "Not all types have been decoded for instantiation"); 618 return QualType(); 619} 620 621/// \brief Instantiate the type T with a given set of template arguments. 622/// 623/// This routine substitutes the given template arguments into the 624/// type T and produces the instantiated type. 625/// 626/// \param T the type into which the template arguments will be 627/// substituted. If this type is not dependent, it will be returned 628/// immediately. 629/// 630/// \param TemplateArgs the template arguments that will be 631/// substituted for the top-level template parameters within T. 632/// 633/// \param Loc the location in the source code where this substitution 634/// is being performed. It will typically be the location of the 635/// declarator (if we're instantiating the type of some declaration) 636/// or the location of the type in the source code (if, e.g., we're 637/// instantiating the type of a cast expression). 638/// 639/// \param Entity the name of the entity associated with a declaration 640/// being instantiated (if any). May be empty to indicate that there 641/// is no such entity (if, e.g., this is a type that occurs as part of 642/// a cast expression) or that the entity has no name (e.g., an 643/// unnamed function parameter). 644/// 645/// \returns If the instantiation succeeds, the instantiated 646/// type. Otherwise, produces diagnostics and returns a NULL type. 647QualType Sema::InstantiateType(QualType T, 648 const TemplateArgumentList &TemplateArgs, 649 SourceLocation Loc, DeclarationName Entity) { 650 assert(!ActiveTemplateInstantiations.empty() && 651 "Cannot perform an instantiation without some context on the " 652 "instantiation stack"); 653 654 // If T is not a dependent type, there is nothing to do. 655 if (!T->isDependentType()) 656 return T; 657 658 TemplateTypeInstantiator Instantiator(*this, TemplateArgs, Loc, Entity); 659 return Instantiator(T); 660} 661 662/// \brief Instantiate the base class specifiers of the given class 663/// template specialization. 664/// 665/// Produces a diagnostic and returns true on error, returns false and 666/// attaches the instantiated base classes to the class template 667/// specialization if successful. 668bool 669Sema::InstantiateBaseSpecifiers(CXXRecordDecl *Instantiation, 670 CXXRecordDecl *Pattern, 671 const TemplateArgumentList &TemplateArgs) { 672 bool Invalid = false; 673 llvm::SmallVector<CXXBaseSpecifier*, 4> InstantiatedBases; 674 for (ClassTemplateSpecializationDecl::base_class_iterator 675 Base = Pattern->bases_begin(), BaseEnd = Pattern->bases_end(); 676 Base != BaseEnd; ++Base) { 677 if (!Base->getType()->isDependentType()) { 678 // FIXME: Allocate via ASTContext 679 InstantiatedBases.push_back(new CXXBaseSpecifier(*Base)); 680 continue; 681 } 682 683 QualType BaseType = InstantiateType(Base->getType(), 684 TemplateArgs, 685 Base->getSourceRange().getBegin(), 686 DeclarationName()); 687 if (BaseType.isNull()) { 688 Invalid = true; 689 continue; 690 } 691 692 if (CXXBaseSpecifier *InstantiatedBase 693 = CheckBaseSpecifier(Instantiation, 694 Base->getSourceRange(), 695 Base->isVirtual(), 696 Base->getAccessSpecifierAsWritten(), 697 BaseType, 698 /*FIXME: Not totally accurate */ 699 Base->getSourceRange().getBegin())) 700 InstantiatedBases.push_back(InstantiatedBase); 701 else 702 Invalid = true; 703 } 704 705 if (!Invalid && 706 AttachBaseSpecifiers(Instantiation, InstantiatedBases.data(), 707 InstantiatedBases.size())) 708 Invalid = true; 709 710 return Invalid; 711} 712 713/// \brief Instantiate the definition of a class from a given pattern. 714/// 715/// \param PointOfInstantiation The point of instantiation within the 716/// source code. 717/// 718/// \param Instantiation is the declaration whose definition is being 719/// instantiated. This will be either a class template specialization 720/// or a member class of a class template specialization. 721/// 722/// \param Pattern is the pattern from which the instantiation 723/// occurs. This will be either the declaration of a class template or 724/// the declaration of a member class of a class template. 725/// 726/// \param TemplateArgs The template arguments to be substituted into 727/// the pattern. 728/// 729/// \returns true if an error occurred, false otherwise. 730bool 731Sema::InstantiateClass(SourceLocation PointOfInstantiation, 732 CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern, 733 const TemplateArgumentList &TemplateArgs, 734 bool ExplicitInstantiation) { 735 bool Invalid = false; 736 737 CXXRecordDecl *PatternDef 738 = cast_or_null<CXXRecordDecl>(Pattern->getDefinition(Context)); 739 if (!PatternDef) { 740 if (Pattern == Instantiation->getInstantiatedFromMemberClass()) { 741 Diag(PointOfInstantiation, 742 diag::err_implicit_instantiate_member_undefined) 743 << Context.getTypeDeclType(Instantiation); 744 Diag(Pattern->getLocation(), diag::note_member_of_template_here); 745 } else { 746 Diag(PointOfInstantiation, diag::err_template_instantiate_undefined) 747 << ExplicitInstantiation 748 << Context.getTypeDeclType(Instantiation); 749 Diag(Pattern->getLocation(), diag::note_template_decl_here); 750 } 751 return true; 752 } 753 Pattern = PatternDef; 754 755 InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation); 756 if (Inst) 757 return true; 758 759 // Enter the scope of this instantiation. We don't use 760 // PushDeclContext because we don't have a scope. 761 DeclContext *PreviousContext = CurContext; 762 CurContext = Instantiation; 763 764 // Start the definition of this instantiation. 765 Instantiation->startDefinition(); 766 767 // Instantiate the base class specifiers. 768 if (InstantiateBaseSpecifiers(Instantiation, Pattern, TemplateArgs)) 769 Invalid = true; 770 771 llvm::SmallVector<DeclPtrTy, 4> Fields; 772 for (RecordDecl::decl_iterator Member = Pattern->decls_begin(Context), 773 MemberEnd = Pattern->decls_end(Context); 774 Member != MemberEnd; ++Member) { 775 Decl *NewMember = InstantiateDecl(*Member, Instantiation, TemplateArgs); 776 if (NewMember) { 777 if (NewMember->isInvalidDecl()) 778 Invalid = true; 779 else if (FieldDecl *Field = dyn_cast<FieldDecl>(NewMember)) 780 Fields.push_back(DeclPtrTy::make(Field)); 781 } else { 782 // FIXME: Eventually, a NULL return will mean that one of the 783 // instantiations was a semantic disaster, and we'll want to set Invalid = 784 // true. For now, we expect to skip some members that we can't yet handle. 785 } 786 } 787 788 // Finish checking fields. 789 ActOnFields(0, Instantiation->getLocation(), DeclPtrTy::make(Instantiation), 790 Fields.data(), Fields.size(), SourceLocation(), SourceLocation(), 791 0); 792 793 // Add any implicitly-declared members that we might need. 794 AddImplicitlyDeclaredMembersToClass(Instantiation); 795 796 // Exit the scope of this instantiation. 797 CurContext = PreviousContext; 798 799 if (!Invalid) 800 Consumer.HandleTagDeclDefinition(Instantiation); 801 802 // If this is an explicit instantiation, instantiate our members, too. 803 if (!Invalid && ExplicitInstantiation) { 804 Inst.Clear(); 805 InstantiateClassMembers(PointOfInstantiation, Instantiation, TemplateArgs); 806 } 807 808 return Invalid; 809} 810 811bool 812Sema::InstantiateClassTemplateSpecialization( 813 ClassTemplateSpecializationDecl *ClassTemplateSpec, 814 bool ExplicitInstantiation) { 815 // Perform the actual instantiation on the canonical declaration. 816 ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>( 817 Context.getCanonicalDecl(ClassTemplateSpec)); 818 819 // We can only instantiate something that hasn't already been 820 // instantiated or specialized. Fail without any diagnostics: our 821 // caller will provide an error message. 822 if (ClassTemplateSpec->getSpecializationKind() != TSK_Undeclared) 823 return true; 824 825 ClassTemplateDecl *Template = ClassTemplateSpec->getSpecializedTemplate(); 826 CXXRecordDecl *Pattern = Template->getTemplatedDecl(); 827 const TemplateArgumentList *TemplateArgs 828 = &ClassTemplateSpec->getTemplateArgs(); 829 830 // Determine whether any class template partial specializations 831 // match the given template arguments. 832 llvm::SmallVector<ClassTemplatePartialSpecializationDecl *, 4> Matched; 833 for (llvm::FoldingSet<ClassTemplatePartialSpecializationDecl>::iterator 834 Partial = Template->getPartialSpecializations().begin(), 835 PartialEnd = Template->getPartialSpecializations().end(); 836 Partial != PartialEnd; 837 ++Partial) { 838 if (DeduceTemplateArguments(&*Partial, ClassTemplateSpec->getTemplateArgs())) 839 Matched.push_back(&*Partial); 840 } 841 842 if (Matched.size() == 1) { 843 Pattern = Matched[0]; 844 // FIXME: set TemplateArgs to the template arguments of the 845 // partial specialization, instantiated with the deduced template 846 // arguments. 847 } else if (Matched.size() > 1) { 848 // FIXME: Implement partial ordering of class template partial 849 // specializations. 850 Diag(ClassTemplateSpec->getLocation(), 851 diag::unsup_template_partial_spec_ordering); 852 } 853 854 // Note that this is an instantiation. 855 ClassTemplateSpec->setSpecializationKind( 856 ExplicitInstantiation? TSK_ExplicitInstantiation 857 : TSK_ImplicitInstantiation); 858 859 return InstantiateClass(ClassTemplateSpec->getLocation(), 860 ClassTemplateSpec, Pattern, *TemplateArgs, 861 ExplicitInstantiation); 862} 863 864/// \brief Instantiate the definitions of all of the member of the 865/// given class, which is an instantiation of a class template or a 866/// member class of a template. 867void 868Sema::InstantiateClassMembers(SourceLocation PointOfInstantiation, 869 CXXRecordDecl *Instantiation, 870 const TemplateArgumentList &TemplateArgs) { 871 for (DeclContext::decl_iterator D = Instantiation->decls_begin(Context), 872 DEnd = Instantiation->decls_end(Context); 873 D != DEnd; ++D) { 874 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(*D)) { 875 if (!Function->getBody(Context)) 876 InstantiateFunctionDefinition(PointOfInstantiation, Function); 877 } else if (VarDecl *Var = dyn_cast<VarDecl>(*D)) { 878 const VarDecl *Def = 0; 879 if (!Var->getDefinition(Def)) 880 InstantiateVariableDefinition(Var); 881 } else if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(*D)) { 882 if (!Record->isInjectedClassName() && !Record->getDefinition(Context)) { 883 assert(Record->getInstantiatedFromMemberClass() && 884 "Missing instantiated-from-template information"); 885 InstantiateClass(PointOfInstantiation, Record, 886 Record->getInstantiatedFromMemberClass(), 887 TemplateArgs, true); 888 } 889 } 890 } 891} 892 893/// \brief Instantiate the definitions of all of the members of the 894/// given class template specialization, which was named as part of an 895/// explicit instantiation. 896void Sema::InstantiateClassTemplateSpecializationMembers( 897 SourceLocation PointOfInstantiation, 898 ClassTemplateSpecializationDecl *ClassTemplateSpec) { 899 // C++0x [temp.explicit]p7: 900 // An explicit instantiation that names a class template 901 // specialization is an explicit instantion of the same kind 902 // (declaration or definition) of each of its members (not 903 // including members inherited from base classes) that has not 904 // been previously explicitly specialized in the translation unit 905 // containing the explicit instantiation, except as described 906 // below. 907 InstantiateClassMembers(PointOfInstantiation, ClassTemplateSpec, 908 ClassTemplateSpec->getTemplateArgs()); 909} 910 911/// \brief Instantiate a nested-name-specifier. 912NestedNameSpecifier * 913Sema::InstantiateNestedNameSpecifier(NestedNameSpecifier *NNS, 914 SourceRange Range, 915 const TemplateArgumentList &TemplateArgs) { 916 // Instantiate the prefix of this nested name specifier. 917 NestedNameSpecifier *Prefix = NNS->getPrefix(); 918 if (Prefix) { 919 Prefix = InstantiateNestedNameSpecifier(Prefix, Range, TemplateArgs); 920 if (!Prefix) 921 return 0; 922 } 923 924 switch (NNS->getKind()) { 925 case NestedNameSpecifier::Identifier: { 926 assert(Prefix && 927 "Can't have an identifier nested-name-specifier with no prefix"); 928 CXXScopeSpec SS; 929 // FIXME: The source location information is all wrong. 930 SS.setRange(Range); 931 SS.setScopeRep(Prefix); 932 return static_cast<NestedNameSpecifier *>( 933 ActOnCXXNestedNameSpecifier(0, SS, 934 Range.getEnd(), 935 Range.getEnd(), 936 *NNS->getAsIdentifier())); 937 break; 938 } 939 940 case NestedNameSpecifier::Namespace: 941 case NestedNameSpecifier::Global: 942 return NNS; 943 944 case NestedNameSpecifier::TypeSpecWithTemplate: 945 case NestedNameSpecifier::TypeSpec: { 946 QualType T = QualType(NNS->getAsType(), 0); 947 if (!T->isDependentType()) 948 return NNS; 949 950 T = InstantiateType(T, TemplateArgs, Range.getBegin(), DeclarationName()); 951 if (T.isNull()) 952 return 0; 953 954 if (T->isRecordType() || 955 (getLangOptions().CPlusPlus0x && T->isEnumeralType())) { 956 assert(T.getCVRQualifiers() == 0 && "Can't get cv-qualifiers here"); 957 return NestedNameSpecifier::Create(Context, Prefix, 958 NNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate, 959 T.getTypePtr()); 960 } 961 962 Diag(Range.getBegin(), diag::err_nested_name_spec_non_tag) << T; 963 return 0; 964 } 965 } 966 967 // Required to silence a GCC warning 968 return 0; 969} 970 971TemplateName 972Sema::InstantiateTemplateName(TemplateName Name, SourceLocation Loc, 973 const TemplateArgumentList &TemplateArgs) { 974 if (TemplateTemplateParmDecl *TTP 975 = dyn_cast_or_null<TemplateTemplateParmDecl>( 976 Name.getAsTemplateDecl())) { 977 assert(TTP->getDepth() == 0 && 978 "Cannot reduce depth of a template template parameter"); 979 assert(TemplateArgs[TTP->getPosition()].getAsDecl() && 980 "Wrong kind of template template argument"); 981 ClassTemplateDecl *ClassTemplate 982 = dyn_cast<ClassTemplateDecl>( 983 TemplateArgs[TTP->getPosition()].getAsDecl()); 984 assert(ClassTemplate && "Expected a class template"); 985 if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) { 986 NestedNameSpecifier *NNS 987 = InstantiateNestedNameSpecifier(QTN->getQualifier(), 988 /*FIXME=*/SourceRange(Loc), 989 TemplateArgs); 990 if (NNS) 991 return Context.getQualifiedTemplateName(NNS, 992 QTN->hasTemplateKeyword(), 993 ClassTemplate); 994 } 995 996 return TemplateName(ClassTemplate); 997 } else if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) { 998 NestedNameSpecifier *NNS 999 = InstantiateNestedNameSpecifier(DTN->getQualifier(), 1000 /*FIXME=*/SourceRange(Loc), 1001 TemplateArgs); 1002 1003 if (!NNS) // FIXME: Not the best recovery strategy. 1004 return Name; 1005 1006 if (NNS->isDependent()) 1007 return Context.getDependentTemplateName(NNS, DTN->getName()); 1008 1009 // Somewhat redundant with ActOnDependentTemplateName. 1010 CXXScopeSpec SS; 1011 SS.setRange(SourceRange(Loc)); 1012 SS.setScopeRep(NNS); 1013 TemplateTy Template; 1014 TemplateNameKind TNK = isTemplateName(*DTN->getName(), 0, Template, &SS); 1015 if (TNK == TNK_Non_template) { 1016 Diag(Loc, diag::err_template_kw_refers_to_non_template) 1017 << DTN->getName(); 1018 return Name; 1019 } else if (TNK == TNK_Function_template) { 1020 Diag(Loc, diag::err_template_kw_refers_to_non_template) 1021 << DTN->getName(); 1022 return Name; 1023 } 1024 1025 return Template.getAsVal<TemplateName>(); 1026 } 1027 1028 1029 1030 // FIXME: Even if we're referring to a Decl that isn't a template template 1031 // parameter, we may need to instantiate the outer contexts of that 1032 // Decl. However, this won't be needed until we implement member templates. 1033 return Name; 1034} 1035