SemaTemplate.cpp revision a57c339c88bf248af2aba7f1bae1c284c69e82dd
1//===------- SemaTemplate.cpp - Semantic Analysis for C++ Templates -------===/ 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 semantic analysis for C++ templates. 10//===----------------------------------------------------------------------===/ 11 12#include "Sema.h" 13#include "TreeTransform.h" 14#include "clang/AST/ASTContext.h" 15#include "clang/AST/Expr.h" 16#include "clang/AST/ExprCXX.h" 17#include "clang/AST/DeclTemplate.h" 18#include "clang/Parse/DeclSpec.h" 19#include "clang/Parse/Template.h" 20#include "clang/Basic/LangOptions.h" 21#include "clang/Basic/PartialDiagnostic.h" 22#include "llvm/Support/Compiler.h" 23#include "llvm/ADT/StringExtras.h" 24using namespace clang; 25 26/// \brief Determine whether the declaration found is acceptable as the name 27/// of a template and, if so, return that template declaration. Otherwise, 28/// returns NULL. 29static NamedDecl *isAcceptableTemplateName(ASTContext &Context, NamedDecl *D) { 30 if (!D) 31 return 0; 32 33 if (isa<TemplateDecl>(D)) 34 return D; 35 36 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) { 37 // C++ [temp.local]p1: 38 // Like normal (non-template) classes, class templates have an 39 // injected-class-name (Clause 9). The injected-class-name 40 // can be used with or without a template-argument-list. When 41 // it is used without a template-argument-list, it is 42 // equivalent to the injected-class-name followed by the 43 // template-parameters of the class template enclosed in 44 // <>. When it is used with a template-argument-list, it 45 // refers to the specified class template specialization, 46 // which could be the current specialization or another 47 // specialization. 48 if (Record->isInjectedClassName()) { 49 Record = cast<CXXRecordDecl>(Record->getDeclContext()); 50 if (Record->getDescribedClassTemplate()) 51 return Record->getDescribedClassTemplate(); 52 53 if (ClassTemplateSpecializationDecl *Spec 54 = dyn_cast<ClassTemplateSpecializationDecl>(Record)) 55 return Spec->getSpecializedTemplate(); 56 } 57 58 return 0; 59 } 60 61 OverloadedFunctionDecl *Ovl = dyn_cast<OverloadedFunctionDecl>(D); 62 if (!Ovl) 63 return 0; 64 65 for (OverloadedFunctionDecl::function_iterator F = Ovl->function_begin(), 66 FEnd = Ovl->function_end(); 67 F != FEnd; ++F) { 68 if (FunctionTemplateDecl *FuncTmpl = dyn_cast<FunctionTemplateDecl>(*F)) { 69 // We've found a function template. Determine whether there are 70 // any other function templates we need to bundle together in an 71 // OverloadedFunctionDecl 72 for (++F; F != FEnd; ++F) { 73 if (isa<FunctionTemplateDecl>(*F)) 74 break; 75 } 76 77 if (F != FEnd) { 78 // Build an overloaded function decl containing only the 79 // function templates in Ovl. 80 OverloadedFunctionDecl *OvlTemplate 81 = OverloadedFunctionDecl::Create(Context, 82 Ovl->getDeclContext(), 83 Ovl->getDeclName()); 84 OvlTemplate->addOverload(FuncTmpl); 85 OvlTemplate->addOverload(*F); 86 for (++F; F != FEnd; ++F) { 87 if (isa<FunctionTemplateDecl>(*F)) 88 OvlTemplate->addOverload(*F); 89 } 90 91 return OvlTemplate; 92 } 93 94 return FuncTmpl; 95 } 96 } 97 98 return 0; 99} 100 101TemplateNameKind Sema::isTemplateName(Scope *S, 102 const CXXScopeSpec &SS, 103 UnqualifiedId &Name, 104 TypeTy *ObjectTypePtr, 105 bool EnteringContext, 106 TemplateTy &TemplateResult) { 107 DeclarationName TName; 108 109 switch (Name.getKind()) { 110 case UnqualifiedId::IK_Identifier: 111 TName = DeclarationName(Name.Identifier); 112 break; 113 114 case UnqualifiedId::IK_OperatorFunctionId: 115 TName = Context.DeclarationNames.getCXXOperatorName( 116 Name.OperatorFunctionId.Operator); 117 break; 118 119 default: 120 return TNK_Non_template; 121 } 122 123 // Determine where to perform name lookup 124 DeclContext *LookupCtx = 0; 125 bool isDependent = false; 126 if (ObjectTypePtr) { 127 // This nested-name-specifier occurs in a member access expression, e.g., 128 // x->B::f, and we are looking into the type of the object. 129 assert(!SS.isSet() && "ObjectType and scope specifier cannot coexist"); 130 QualType ObjectType = QualType::getFromOpaquePtr(ObjectTypePtr); 131 LookupCtx = computeDeclContext(ObjectType); 132 isDependent = ObjectType->isDependentType(); 133 } else if (SS.isSet()) { 134 // This nested-name-specifier occurs after another nested-name-specifier, 135 // so long into the context associated with the prior nested-name-specifier. 136 137 LookupCtx = computeDeclContext(SS, EnteringContext); 138 isDependent = isDependentScopeSpecifier(SS); 139 } 140 141 LookupResult Found; 142 bool ObjectTypeSearchedInScope = false; 143 if (LookupCtx) { 144 // Perform "qualified" name lookup into the declaration context we 145 // computed, which is either the type of the base of a member access 146 // expression or the declaration context associated with a prior 147 // nested-name-specifier. 148 149 // The declaration context must be complete. 150 if (!LookupCtx->isDependentContext() && RequireCompleteDeclContext(SS)) 151 return TNK_Non_template; 152 153 LookupQualifiedName(Found, LookupCtx, TName, LookupOrdinaryName); 154 155 if (ObjectTypePtr && Found.getKind() == LookupResult::NotFound) { 156 // C++ [basic.lookup.classref]p1: 157 // In a class member access expression (5.2.5), if the . or -> token is 158 // immediately followed by an identifier followed by a <, the 159 // identifier must be looked up to determine whether the < is the 160 // beginning of a template argument list (14.2) or a less-than operator. 161 // The identifier is first looked up in the class of the object 162 // expression. If the identifier is not found, it is then looked up in 163 // the context of the entire postfix-expression and shall name a class 164 // or function template. 165 // 166 // FIXME: When we're instantiating a template, do we actually have to 167 // look in the scope of the template? Seems fishy... 168 LookupName(Found, S, TName, LookupOrdinaryName); 169 ObjectTypeSearchedInScope = true; 170 } 171 } else if (isDependent) { 172 // We cannot look into a dependent object type or 173 return TNK_Non_template; 174 } else { 175 // Perform unqualified name lookup in the current scope. 176 LookupName(Found, S, TName, LookupOrdinaryName); 177 } 178 179 // FIXME: Cope with ambiguous name-lookup results. 180 assert(!Found.isAmbiguous() && 181 "Cannot handle template name-lookup ambiguities"); 182 183 NamedDecl *Template 184 = isAcceptableTemplateName(Context, Found.getAsSingleDecl(Context)); 185 if (!Template) 186 return TNK_Non_template; 187 188 if (ObjectTypePtr && !ObjectTypeSearchedInScope) { 189 // C++ [basic.lookup.classref]p1: 190 // [...] If the lookup in the class of the object expression finds a 191 // template, the name is also looked up in the context of the entire 192 // postfix-expression and [...] 193 // 194 LookupResult FoundOuter; 195 LookupName(FoundOuter, S, TName, LookupOrdinaryName); 196 // FIXME: Handle ambiguities in this lookup better 197 NamedDecl *OuterTemplate 198 = isAcceptableTemplateName(Context, FoundOuter.getAsSingleDecl(Context)); 199 200 if (!OuterTemplate) { 201 // - if the name is not found, the name found in the class of the 202 // object expression is used, otherwise 203 } else if (!isa<ClassTemplateDecl>(OuterTemplate)) { 204 // - if the name is found in the context of the entire 205 // postfix-expression and does not name a class template, the name 206 // found in the class of the object expression is used, otherwise 207 } else { 208 // - if the name found is a class template, it must refer to the same 209 // entity as the one found in the class of the object expression, 210 // otherwise the program is ill-formed. 211 if (OuterTemplate->getCanonicalDecl() != Template->getCanonicalDecl()) { 212 Diag(Name.getSourceRange().getBegin(), 213 diag::err_nested_name_member_ref_lookup_ambiguous) 214 << TName 215 << Name.getSourceRange(); 216 Diag(Template->getLocation(), diag::note_ambig_member_ref_object_type) 217 << QualType::getFromOpaquePtr(ObjectTypePtr); 218 Diag(OuterTemplate->getLocation(), diag::note_ambig_member_ref_scope); 219 220 // Recover by taking the template that we found in the object 221 // expression's type. 222 } 223 } 224 } 225 226 if (SS.isSet() && !SS.isInvalid()) { 227 NestedNameSpecifier *Qualifier 228 = static_cast<NestedNameSpecifier *>(SS.getScopeRep()); 229 if (OverloadedFunctionDecl *Ovl 230 = dyn_cast<OverloadedFunctionDecl>(Template)) 231 TemplateResult 232 = TemplateTy::make(Context.getQualifiedTemplateName(Qualifier, false, 233 Ovl)); 234 else 235 TemplateResult 236 = TemplateTy::make(Context.getQualifiedTemplateName(Qualifier, false, 237 cast<TemplateDecl>(Template))); 238 } else if (OverloadedFunctionDecl *Ovl 239 = dyn_cast<OverloadedFunctionDecl>(Template)) { 240 TemplateResult = TemplateTy::make(TemplateName(Ovl)); 241 } else { 242 TemplateResult = TemplateTy::make( 243 TemplateName(cast<TemplateDecl>(Template))); 244 } 245 246 if (isa<ClassTemplateDecl>(Template) || 247 isa<TemplateTemplateParmDecl>(Template)) 248 return TNK_Type_template; 249 250 assert((isa<FunctionTemplateDecl>(Template) || 251 isa<OverloadedFunctionDecl>(Template)) && 252 "Unhandled template kind in Sema::isTemplateName"); 253 return TNK_Function_template; 254} 255 256/// DiagnoseTemplateParameterShadow - Produce a diagnostic complaining 257/// that the template parameter 'PrevDecl' is being shadowed by a new 258/// declaration at location Loc. Returns true to indicate that this is 259/// an error, and false otherwise. 260bool Sema::DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl) { 261 assert(PrevDecl->isTemplateParameter() && "Not a template parameter"); 262 263 // Microsoft Visual C++ permits template parameters to be shadowed. 264 if (getLangOptions().Microsoft) 265 return false; 266 267 // C++ [temp.local]p4: 268 // A template-parameter shall not be redeclared within its 269 // scope (including nested scopes). 270 Diag(Loc, diag::err_template_param_shadow) 271 << cast<NamedDecl>(PrevDecl)->getDeclName(); 272 Diag(PrevDecl->getLocation(), diag::note_template_param_here); 273 return true; 274} 275 276/// AdjustDeclIfTemplate - If the given decl happens to be a template, reset 277/// the parameter D to reference the templated declaration and return a pointer 278/// to the template declaration. Otherwise, do nothing to D and return null. 279TemplateDecl *Sema::AdjustDeclIfTemplate(DeclPtrTy &D) { 280 if (TemplateDecl *Temp = dyn_cast_or_null<TemplateDecl>(D.getAs<Decl>())) { 281 D = DeclPtrTy::make(Temp->getTemplatedDecl()); 282 return Temp; 283 } 284 return 0; 285} 286 287static TemplateArgumentLoc translateTemplateArgument(Sema &SemaRef, 288 const ParsedTemplateArgument &Arg) { 289 290 switch (Arg.getKind()) { 291 case ParsedTemplateArgument::Type: { 292 DeclaratorInfo *DI; 293 QualType T = SemaRef.GetTypeFromParser(Arg.getAsType(), &DI); 294 if (!DI) 295 DI = SemaRef.Context.getTrivialDeclaratorInfo(T, Arg.getLocation()); 296 return TemplateArgumentLoc(TemplateArgument(T), DI); 297 } 298 299 case ParsedTemplateArgument::NonType: { 300 Expr *E = static_cast<Expr *>(Arg.getAsExpr()); 301 return TemplateArgumentLoc(TemplateArgument(E), E); 302 } 303 304 case ParsedTemplateArgument::Template: { 305 TemplateName Template 306 = TemplateName::getFromVoidPointer(Arg.getAsTemplate().get()); 307 return TemplateArgumentLoc(TemplateArgument(Template), 308 Arg.getScopeSpec().getRange(), 309 Arg.getLocation()); 310 } 311 } 312 313 llvm::llvm_unreachable("Unhandled parsed template argument"); 314 return TemplateArgumentLoc(); 315} 316 317/// \brief Translates template arguments as provided by the parser 318/// into template arguments used by semantic analysis. 319void Sema::translateTemplateArguments(ASTTemplateArgsPtr &TemplateArgsIn, 320 llvm::SmallVectorImpl<TemplateArgumentLoc> &TemplateArgs) { 321 TemplateArgs.reserve(TemplateArgsIn.size()); 322 323 for (unsigned I = 0, Last = TemplateArgsIn.size(); I != Last; ++I) 324 TemplateArgs.push_back(translateTemplateArgument(*this, TemplateArgsIn[I])); 325} 326 327/// ActOnTypeParameter - Called when a C++ template type parameter 328/// (e.g., "typename T") has been parsed. Typename specifies whether 329/// the keyword "typename" was used to declare the type parameter 330/// (otherwise, "class" was used), and KeyLoc is the location of the 331/// "class" or "typename" keyword. ParamName is the name of the 332/// parameter (NULL indicates an unnamed template parameter) and 333/// ParamName is the location of the parameter name (if any). 334/// If the type parameter has a default argument, it will be added 335/// later via ActOnTypeParameterDefault. 336Sema::DeclPtrTy Sema::ActOnTypeParameter(Scope *S, bool Typename, bool Ellipsis, 337 SourceLocation EllipsisLoc, 338 SourceLocation KeyLoc, 339 IdentifierInfo *ParamName, 340 SourceLocation ParamNameLoc, 341 unsigned Depth, unsigned Position) { 342 assert(S->isTemplateParamScope() && 343 "Template type parameter not in template parameter scope!"); 344 bool Invalid = false; 345 346 if (ParamName) { 347 NamedDecl *PrevDecl = LookupSingleName(S, ParamName, LookupTagName); 348 if (PrevDecl && PrevDecl->isTemplateParameter()) 349 Invalid = Invalid || DiagnoseTemplateParameterShadow(ParamNameLoc, 350 PrevDecl); 351 } 352 353 SourceLocation Loc = ParamNameLoc; 354 if (!ParamName) 355 Loc = KeyLoc; 356 357 TemplateTypeParmDecl *Param 358 = TemplateTypeParmDecl::Create(Context, CurContext, Loc, 359 Depth, Position, ParamName, Typename, 360 Ellipsis); 361 if (Invalid) 362 Param->setInvalidDecl(); 363 364 if (ParamName) { 365 // Add the template parameter into the current scope. 366 S->AddDecl(DeclPtrTy::make(Param)); 367 IdResolver.AddDecl(Param); 368 } 369 370 return DeclPtrTy::make(Param); 371} 372 373/// ActOnTypeParameterDefault - Adds a default argument (the type 374/// Default) to the given template type parameter (TypeParam). 375void Sema::ActOnTypeParameterDefault(DeclPtrTy TypeParam, 376 SourceLocation EqualLoc, 377 SourceLocation DefaultLoc, 378 TypeTy *DefaultT) { 379 TemplateTypeParmDecl *Parm 380 = cast<TemplateTypeParmDecl>(TypeParam.getAs<Decl>()); 381 382 DeclaratorInfo *DefaultDInfo; 383 GetTypeFromParser(DefaultT, &DefaultDInfo); 384 385 assert(DefaultDInfo && "expected source information for type"); 386 387 // C++0x [temp.param]p9: 388 // A default template-argument may be specified for any kind of 389 // template-parameter that is not a template parameter pack. 390 if (Parm->isParameterPack()) { 391 Diag(DefaultLoc, diag::err_template_param_pack_default_arg); 392 return; 393 } 394 395 // C++ [temp.param]p14: 396 // A template-parameter shall not be used in its own default argument. 397 // FIXME: Implement this check! Needs a recursive walk over the types. 398 399 // Check the template argument itself. 400 if (CheckTemplateArgument(Parm, DefaultDInfo)) { 401 Parm->setInvalidDecl(); 402 return; 403 } 404 405 Parm->setDefaultArgument(DefaultDInfo, false); 406} 407 408/// \brief Check that the type of a non-type template parameter is 409/// well-formed. 410/// 411/// \returns the (possibly-promoted) parameter type if valid; 412/// otherwise, produces a diagnostic and returns a NULL type. 413QualType 414Sema::CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc) { 415 // C++ [temp.param]p4: 416 // 417 // A non-type template-parameter shall have one of the following 418 // (optionally cv-qualified) types: 419 // 420 // -- integral or enumeration type, 421 if (T->isIntegralType() || T->isEnumeralType() || 422 // -- pointer to object or pointer to function, 423 (T->isPointerType() && 424 (T->getAs<PointerType>()->getPointeeType()->isObjectType() || 425 T->getAs<PointerType>()->getPointeeType()->isFunctionType())) || 426 // -- reference to object or reference to function, 427 T->isReferenceType() || 428 // -- pointer to member. 429 T->isMemberPointerType() || 430 // If T is a dependent type, we can't do the check now, so we 431 // assume that it is well-formed. 432 T->isDependentType()) 433 return T; 434 // C++ [temp.param]p8: 435 // 436 // A non-type template-parameter of type "array of T" or 437 // "function returning T" is adjusted to be of type "pointer to 438 // T" or "pointer to function returning T", respectively. 439 else if (T->isArrayType()) 440 // FIXME: Keep the type prior to promotion? 441 return Context.getArrayDecayedType(T); 442 else if (T->isFunctionType()) 443 // FIXME: Keep the type prior to promotion? 444 return Context.getPointerType(T); 445 446 Diag(Loc, diag::err_template_nontype_parm_bad_type) 447 << T; 448 449 return QualType(); 450} 451 452/// ActOnNonTypeTemplateParameter - Called when a C++ non-type 453/// template parameter (e.g., "int Size" in "template<int Size> 454/// class Array") has been parsed. S is the current scope and D is 455/// the parsed declarator. 456Sema::DeclPtrTy Sema::ActOnNonTypeTemplateParameter(Scope *S, Declarator &D, 457 unsigned Depth, 458 unsigned Position) { 459 DeclaratorInfo *DInfo = 0; 460 QualType T = GetTypeForDeclarator(D, S, &DInfo); 461 462 assert(S->isTemplateParamScope() && 463 "Non-type template parameter not in template parameter scope!"); 464 bool Invalid = false; 465 466 IdentifierInfo *ParamName = D.getIdentifier(); 467 if (ParamName) { 468 NamedDecl *PrevDecl = LookupSingleName(S, ParamName, LookupTagName); 469 if (PrevDecl && PrevDecl->isTemplateParameter()) 470 Invalid = Invalid || DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), 471 PrevDecl); 472 } 473 474 T = CheckNonTypeTemplateParameterType(T, D.getIdentifierLoc()); 475 if (T.isNull()) { 476 T = Context.IntTy; // Recover with an 'int' type. 477 Invalid = true; 478 } 479 480 NonTypeTemplateParmDecl *Param 481 = NonTypeTemplateParmDecl::Create(Context, CurContext, D.getIdentifierLoc(), 482 Depth, Position, ParamName, T, DInfo); 483 if (Invalid) 484 Param->setInvalidDecl(); 485 486 if (D.getIdentifier()) { 487 // Add the template parameter into the current scope. 488 S->AddDecl(DeclPtrTy::make(Param)); 489 IdResolver.AddDecl(Param); 490 } 491 return DeclPtrTy::make(Param); 492} 493 494/// \brief Adds a default argument to the given non-type template 495/// parameter. 496void Sema::ActOnNonTypeTemplateParameterDefault(DeclPtrTy TemplateParamD, 497 SourceLocation EqualLoc, 498 ExprArg DefaultE) { 499 NonTypeTemplateParmDecl *TemplateParm 500 = cast<NonTypeTemplateParmDecl>(TemplateParamD.getAs<Decl>()); 501 Expr *Default = static_cast<Expr *>(DefaultE.get()); 502 503 // C++ [temp.param]p14: 504 // A template-parameter shall not be used in its own default argument. 505 // FIXME: Implement this check! Needs a recursive walk over the types. 506 507 // Check the well-formedness of the default template argument. 508 TemplateArgument Converted; 509 if (CheckTemplateArgument(TemplateParm, TemplateParm->getType(), Default, 510 Converted)) { 511 TemplateParm->setInvalidDecl(); 512 return; 513 } 514 515 TemplateParm->setDefaultArgument(DefaultE.takeAs<Expr>()); 516} 517 518 519/// ActOnTemplateTemplateParameter - Called when a C++ template template 520/// parameter (e.g. T in template <template <typename> class T> class array) 521/// has been parsed. S is the current scope. 522Sema::DeclPtrTy Sema::ActOnTemplateTemplateParameter(Scope* S, 523 SourceLocation TmpLoc, 524 TemplateParamsTy *Params, 525 IdentifierInfo *Name, 526 SourceLocation NameLoc, 527 unsigned Depth, 528 unsigned Position) { 529 assert(S->isTemplateParamScope() && 530 "Template template parameter not in template parameter scope!"); 531 532 // Construct the parameter object. 533 TemplateTemplateParmDecl *Param = 534 TemplateTemplateParmDecl::Create(Context, CurContext, TmpLoc, Depth, 535 Position, Name, 536 (TemplateParameterList*)Params); 537 538 // Make sure the parameter is valid. 539 // FIXME: Decl object is not currently invalidated anywhere so this doesn't 540 // do anything yet. However, if the template parameter list or (eventual) 541 // default value is ever invalidated, that will propagate here. 542 bool Invalid = false; 543 if (Invalid) { 544 Param->setInvalidDecl(); 545 } 546 547 // If the tt-param has a name, then link the identifier into the scope 548 // and lookup mechanisms. 549 if (Name) { 550 S->AddDecl(DeclPtrTy::make(Param)); 551 IdResolver.AddDecl(Param); 552 } 553 554 return DeclPtrTy::make(Param); 555} 556 557/// \brief Adds a default argument to the given template template 558/// parameter. 559void Sema::ActOnTemplateTemplateParameterDefault(DeclPtrTy TemplateParamD, 560 SourceLocation EqualLoc, 561 const ParsedTemplateArgument &Default) { 562 TemplateTemplateParmDecl *TemplateParm 563 = cast<TemplateTemplateParmDecl>(TemplateParamD.getAs<Decl>()); 564 565 // C++ [temp.param]p14: 566 // A template-parameter shall not be used in its own default argument. 567 // FIXME: Implement this check! Needs a recursive walk over the types. 568 569 // Check only that we have a template template argument. We don't want to 570 // try to check well-formedness now, because our template template parameter 571 // might have dependent types in its template parameters, which we wouldn't 572 // be able to match now. 573 // 574 // If none of the template template parameter's template arguments mention 575 // other template parameters, we could actually perform more checking here. 576 // However, it isn't worth doing. 577 TemplateArgumentLoc DefaultArg = translateTemplateArgument(*this, Default); 578 if (DefaultArg.getArgument().getAsTemplate().isNull()) { 579 Diag(DefaultArg.getLocation(), diag::err_template_arg_not_class_template) 580 << DefaultArg.getSourceRange(); 581 return; 582 } 583 584 TemplateParm->setDefaultArgument(DefaultArg); 585} 586 587/// ActOnTemplateParameterList - Builds a TemplateParameterList that 588/// contains the template parameters in Params/NumParams. 589Sema::TemplateParamsTy * 590Sema::ActOnTemplateParameterList(unsigned Depth, 591 SourceLocation ExportLoc, 592 SourceLocation TemplateLoc, 593 SourceLocation LAngleLoc, 594 DeclPtrTy *Params, unsigned NumParams, 595 SourceLocation RAngleLoc) { 596 if (ExportLoc.isValid()) 597 Diag(ExportLoc, diag::note_template_export_unsupported); 598 599 return TemplateParameterList::Create(Context, TemplateLoc, LAngleLoc, 600 (NamedDecl**)Params, NumParams, 601 RAngleLoc); 602} 603 604Sema::DeclResult 605Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK, 606 SourceLocation KWLoc, const CXXScopeSpec &SS, 607 IdentifierInfo *Name, SourceLocation NameLoc, 608 AttributeList *Attr, 609 TemplateParameterList *TemplateParams, 610 AccessSpecifier AS) { 611 assert(TemplateParams && TemplateParams->size() > 0 && 612 "No template parameters"); 613 assert(TUK != TUK_Reference && "Can only declare or define class templates"); 614 bool Invalid = false; 615 616 // Check that we can declare a template here. 617 if (CheckTemplateDeclScope(S, TemplateParams)) 618 return true; 619 620 TagDecl::TagKind Kind = TagDecl::getTagKindForTypeSpec(TagSpec); 621 assert(Kind != TagDecl::TK_enum && "can't build template of enumerated type"); 622 623 // There is no such thing as an unnamed class template. 624 if (!Name) { 625 Diag(KWLoc, diag::err_template_unnamed_class); 626 return true; 627 } 628 629 // Find any previous declaration with this name. 630 DeclContext *SemanticContext; 631 LookupResult Previous; 632 if (SS.isNotEmpty() && !SS.isInvalid()) { 633 if (RequireCompleteDeclContext(SS)) 634 return true; 635 636 SemanticContext = computeDeclContext(SS, true); 637 if (!SemanticContext) { 638 // FIXME: Produce a reasonable diagnostic here 639 return true; 640 } 641 642 LookupQualifiedName(Previous, SemanticContext, Name, LookupOrdinaryName, 643 true); 644 } else { 645 SemanticContext = CurContext; 646 LookupName(Previous, S, Name, LookupOrdinaryName, true); 647 } 648 649 assert(!Previous.isAmbiguous() && "Ambiguity in class template redecl?"); 650 NamedDecl *PrevDecl = 0; 651 if (Previous.begin() != Previous.end()) 652 PrevDecl = *Previous.begin(); 653 654 if (PrevDecl && TUK == TUK_Friend) { 655 // C++ [namespace.memdef]p3: 656 // [...] When looking for a prior declaration of a class or a function 657 // declared as a friend, and when the name of the friend class or 658 // function is neither a qualified name nor a template-id, scopes outside 659 // the innermost enclosing namespace scope are not considered. 660 DeclContext *OutermostContext = CurContext; 661 while (!OutermostContext->isFileContext()) 662 OutermostContext = OutermostContext->getLookupParent(); 663 664 if (OutermostContext->Equals(PrevDecl->getDeclContext()) || 665 OutermostContext->Encloses(PrevDecl->getDeclContext())) { 666 SemanticContext = PrevDecl->getDeclContext(); 667 } else { 668 // Declarations in outer scopes don't matter. However, the outermost 669 // context we computed is the semantic context for our new 670 // declaration. 671 PrevDecl = 0; 672 SemanticContext = OutermostContext; 673 } 674 675 if (CurContext->isDependentContext()) { 676 // If this is a dependent context, we don't want to link the friend 677 // class template to the template in scope, because that would perform 678 // checking of the template parameter lists that can't be performed 679 // until the outer context is instantiated. 680 PrevDecl = 0; 681 } 682 } else if (PrevDecl && !isDeclInScope(PrevDecl, SemanticContext, S)) 683 PrevDecl = 0; 684 685 // If there is a previous declaration with the same name, check 686 // whether this is a valid redeclaration. 687 ClassTemplateDecl *PrevClassTemplate 688 = dyn_cast_or_null<ClassTemplateDecl>(PrevDecl); 689 690 // We may have found the injected-class-name of a class template, 691 // class template partial specialization, or class template specialization. 692 // In these cases, grab the template that is being defined or specialized. 693 if (!PrevClassTemplate && PrevDecl && isa<CXXRecordDecl>(PrevDecl) && 694 cast<CXXRecordDecl>(PrevDecl)->isInjectedClassName()) { 695 PrevDecl = cast<CXXRecordDecl>(PrevDecl->getDeclContext()); 696 PrevClassTemplate 697 = cast<CXXRecordDecl>(PrevDecl)->getDescribedClassTemplate(); 698 if (!PrevClassTemplate && isa<ClassTemplateSpecializationDecl>(PrevDecl)) { 699 PrevClassTemplate 700 = cast<ClassTemplateSpecializationDecl>(PrevDecl) 701 ->getSpecializedTemplate(); 702 } 703 } 704 705 if (PrevClassTemplate) { 706 // Ensure that the template parameter lists are compatible. 707 if (!TemplateParameterListsAreEqual(TemplateParams, 708 PrevClassTemplate->getTemplateParameters(), 709 /*Complain=*/true)) 710 return true; 711 712 // C++ [temp.class]p4: 713 // In a redeclaration, partial specialization, explicit 714 // specialization or explicit instantiation of a class template, 715 // the class-key shall agree in kind with the original class 716 // template declaration (7.1.5.3). 717 RecordDecl *PrevRecordDecl = PrevClassTemplate->getTemplatedDecl(); 718 if (!isAcceptableTagRedeclaration(PrevRecordDecl, Kind, KWLoc, *Name)) { 719 Diag(KWLoc, diag::err_use_with_wrong_tag) 720 << Name 721 << CodeModificationHint::CreateReplacement(KWLoc, 722 PrevRecordDecl->getKindName()); 723 Diag(PrevRecordDecl->getLocation(), diag::note_previous_use); 724 Kind = PrevRecordDecl->getTagKind(); 725 } 726 727 // Check for redefinition of this class template. 728 if (TUK == TUK_Definition) { 729 if (TagDecl *Def = PrevRecordDecl->getDefinition(Context)) { 730 Diag(NameLoc, diag::err_redefinition) << Name; 731 Diag(Def->getLocation(), diag::note_previous_definition); 732 // FIXME: Would it make sense to try to "forget" the previous 733 // definition, as part of error recovery? 734 return true; 735 } 736 } 737 } else if (PrevDecl && PrevDecl->isTemplateParameter()) { 738 // Maybe we will complain about the shadowed template parameter. 739 DiagnoseTemplateParameterShadow(NameLoc, PrevDecl); 740 // Just pretend that we didn't see the previous declaration. 741 PrevDecl = 0; 742 } else if (PrevDecl) { 743 // C++ [temp]p5: 744 // A class template shall not have the same name as any other 745 // template, class, function, object, enumeration, enumerator, 746 // namespace, or type in the same scope (3.3), except as specified 747 // in (14.5.4). 748 Diag(NameLoc, diag::err_redefinition_different_kind) << Name; 749 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 750 return true; 751 } 752 753 // Check the template parameter list of this declaration, possibly 754 // merging in the template parameter list from the previous class 755 // template declaration. 756 if (CheckTemplateParameterList(TemplateParams, 757 PrevClassTemplate? PrevClassTemplate->getTemplateParameters() : 0)) 758 Invalid = true; 759 760 // FIXME: If we had a scope specifier, we better have a previous template 761 // declaration! 762 763 CXXRecordDecl *NewClass = 764 CXXRecordDecl::Create(Context, Kind, SemanticContext, NameLoc, Name, KWLoc, 765 PrevClassTemplate? 766 PrevClassTemplate->getTemplatedDecl() : 0, 767 /*DelayTypeCreation=*/true); 768 769 ClassTemplateDecl *NewTemplate 770 = ClassTemplateDecl::Create(Context, SemanticContext, NameLoc, 771 DeclarationName(Name), TemplateParams, 772 NewClass, PrevClassTemplate); 773 NewClass->setDescribedClassTemplate(NewTemplate); 774 775 // Build the type for the class template declaration now. 776 QualType T = 777 Context.getTypeDeclType(NewClass, 778 PrevClassTemplate? 779 PrevClassTemplate->getTemplatedDecl() : 0); 780 assert(T->isDependentType() && "Class template type is not dependent?"); 781 (void)T; 782 783 // If we are providing an explicit specialization of a member that is a 784 // class template, make a note of that. 785 if (PrevClassTemplate && 786 PrevClassTemplate->getInstantiatedFromMemberTemplate()) 787 PrevClassTemplate->setMemberSpecialization(); 788 789 // Set the access specifier. 790 if (!Invalid && TUK != TUK_Friend) 791 SetMemberAccessSpecifier(NewTemplate, PrevClassTemplate, AS); 792 793 // Set the lexical context of these templates 794 NewClass->setLexicalDeclContext(CurContext); 795 NewTemplate->setLexicalDeclContext(CurContext); 796 797 if (TUK == TUK_Definition) 798 NewClass->startDefinition(); 799 800 if (Attr) 801 ProcessDeclAttributeList(S, NewClass, Attr); 802 803 if (TUK != TUK_Friend) 804 PushOnScopeChains(NewTemplate, S); 805 else { 806 if (PrevClassTemplate && PrevClassTemplate->getAccess() != AS_none) { 807 NewTemplate->setAccess(PrevClassTemplate->getAccess()); 808 NewClass->setAccess(PrevClassTemplate->getAccess()); 809 } 810 811 NewTemplate->setObjectOfFriendDecl(/* PreviouslyDeclared = */ 812 PrevClassTemplate != NULL); 813 814 // Friend templates are visible in fairly strange ways. 815 if (!CurContext->isDependentContext()) { 816 DeclContext *DC = SemanticContext->getLookupContext(); 817 DC->makeDeclVisibleInContext(NewTemplate, /* Recoverable = */ false); 818 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC)) 819 PushOnScopeChains(NewTemplate, EnclosingScope, 820 /* AddToContext = */ false); 821 } 822 823 FriendDecl *Friend = FriendDecl::Create(Context, CurContext, 824 NewClass->getLocation(), 825 NewTemplate, 826 /*FIXME:*/NewClass->getLocation()); 827 Friend->setAccess(AS_public); 828 CurContext->addDecl(Friend); 829 } 830 831 if (Invalid) { 832 NewTemplate->setInvalidDecl(); 833 NewClass->setInvalidDecl(); 834 } 835 return DeclPtrTy::make(NewTemplate); 836} 837 838/// \brief Checks the validity of a template parameter list, possibly 839/// considering the template parameter list from a previous 840/// declaration. 841/// 842/// If an "old" template parameter list is provided, it must be 843/// equivalent (per TemplateParameterListsAreEqual) to the "new" 844/// template parameter list. 845/// 846/// \param NewParams Template parameter list for a new template 847/// declaration. This template parameter list will be updated with any 848/// default arguments that are carried through from the previous 849/// template parameter list. 850/// 851/// \param OldParams If provided, template parameter list from a 852/// previous declaration of the same template. Default template 853/// arguments will be merged from the old template parameter list to 854/// the new template parameter list. 855/// 856/// \returns true if an error occurred, false otherwise. 857bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams, 858 TemplateParameterList *OldParams) { 859 bool Invalid = false; 860 861 // C++ [temp.param]p10: 862 // The set of default template-arguments available for use with a 863 // template declaration or definition is obtained by merging the 864 // default arguments from the definition (if in scope) and all 865 // declarations in scope in the same way default function 866 // arguments are (8.3.6). 867 bool SawDefaultArgument = false; 868 SourceLocation PreviousDefaultArgLoc; 869 870 bool SawParameterPack = false; 871 SourceLocation ParameterPackLoc; 872 873 // Dummy initialization to avoid warnings. 874 TemplateParameterList::iterator OldParam = NewParams->end(); 875 if (OldParams) 876 OldParam = OldParams->begin(); 877 878 for (TemplateParameterList::iterator NewParam = NewParams->begin(), 879 NewParamEnd = NewParams->end(); 880 NewParam != NewParamEnd; ++NewParam) { 881 // Variables used to diagnose redundant default arguments 882 bool RedundantDefaultArg = false; 883 SourceLocation OldDefaultLoc; 884 SourceLocation NewDefaultLoc; 885 886 // Variables used to diagnose missing default arguments 887 bool MissingDefaultArg = false; 888 889 // C++0x [temp.param]p11: 890 // If a template parameter of a class template is a template parameter pack, 891 // it must be the last template parameter. 892 if (SawParameterPack) { 893 Diag(ParameterPackLoc, 894 diag::err_template_param_pack_must_be_last_template_parameter); 895 Invalid = true; 896 } 897 898 // Merge default arguments for template type parameters. 899 if (TemplateTypeParmDecl *NewTypeParm 900 = dyn_cast<TemplateTypeParmDecl>(*NewParam)) { 901 TemplateTypeParmDecl *OldTypeParm 902 = OldParams? cast<TemplateTypeParmDecl>(*OldParam) : 0; 903 904 if (NewTypeParm->isParameterPack()) { 905 assert(!NewTypeParm->hasDefaultArgument() && 906 "Parameter packs can't have a default argument!"); 907 SawParameterPack = true; 908 ParameterPackLoc = NewTypeParm->getLocation(); 909 } else if (OldTypeParm && OldTypeParm->hasDefaultArgument() && 910 NewTypeParm->hasDefaultArgument()) { 911 OldDefaultLoc = OldTypeParm->getDefaultArgumentLoc(); 912 NewDefaultLoc = NewTypeParm->getDefaultArgumentLoc(); 913 SawDefaultArgument = true; 914 RedundantDefaultArg = true; 915 PreviousDefaultArgLoc = NewDefaultLoc; 916 } else if (OldTypeParm && OldTypeParm->hasDefaultArgument()) { 917 // Merge the default argument from the old declaration to the 918 // new declaration. 919 SawDefaultArgument = true; 920 NewTypeParm->setDefaultArgument(OldTypeParm->getDefaultArgumentInfo(), 921 true); 922 PreviousDefaultArgLoc = OldTypeParm->getDefaultArgumentLoc(); 923 } else if (NewTypeParm->hasDefaultArgument()) { 924 SawDefaultArgument = true; 925 PreviousDefaultArgLoc = NewTypeParm->getDefaultArgumentLoc(); 926 } else if (SawDefaultArgument) 927 MissingDefaultArg = true; 928 } else if (NonTypeTemplateParmDecl *NewNonTypeParm 929 = dyn_cast<NonTypeTemplateParmDecl>(*NewParam)) { 930 // Merge default arguments for non-type template parameters 931 NonTypeTemplateParmDecl *OldNonTypeParm 932 = OldParams? cast<NonTypeTemplateParmDecl>(*OldParam) : 0; 933 if (OldNonTypeParm && OldNonTypeParm->hasDefaultArgument() && 934 NewNonTypeParm->hasDefaultArgument()) { 935 OldDefaultLoc = OldNonTypeParm->getDefaultArgumentLoc(); 936 NewDefaultLoc = NewNonTypeParm->getDefaultArgumentLoc(); 937 SawDefaultArgument = true; 938 RedundantDefaultArg = true; 939 PreviousDefaultArgLoc = NewDefaultLoc; 940 } else if (OldNonTypeParm && OldNonTypeParm->hasDefaultArgument()) { 941 // Merge the default argument from the old declaration to the 942 // new declaration. 943 SawDefaultArgument = true; 944 // FIXME: We need to create a new kind of "default argument" 945 // expression that points to a previous template template 946 // parameter. 947 NewNonTypeParm->setDefaultArgument( 948 OldNonTypeParm->getDefaultArgument()); 949 PreviousDefaultArgLoc = OldNonTypeParm->getDefaultArgumentLoc(); 950 } else if (NewNonTypeParm->hasDefaultArgument()) { 951 SawDefaultArgument = true; 952 PreviousDefaultArgLoc = NewNonTypeParm->getDefaultArgumentLoc(); 953 } else if (SawDefaultArgument) 954 MissingDefaultArg = true; 955 } else { 956 // Merge default arguments for template template parameters 957 TemplateTemplateParmDecl *NewTemplateParm 958 = cast<TemplateTemplateParmDecl>(*NewParam); 959 TemplateTemplateParmDecl *OldTemplateParm 960 = OldParams? cast<TemplateTemplateParmDecl>(*OldParam) : 0; 961 if (OldTemplateParm && OldTemplateParm->hasDefaultArgument() && 962 NewTemplateParm->hasDefaultArgument()) { 963 OldDefaultLoc = OldTemplateParm->getDefaultArgument().getLocation(); 964 NewDefaultLoc = NewTemplateParm->getDefaultArgument().getLocation(); 965 SawDefaultArgument = true; 966 RedundantDefaultArg = true; 967 PreviousDefaultArgLoc = NewDefaultLoc; 968 } else if (OldTemplateParm && OldTemplateParm->hasDefaultArgument()) { 969 // Merge the default argument from the old declaration to the 970 // new declaration. 971 SawDefaultArgument = true; 972 // FIXME: We need to create a new kind of "default argument" expression 973 // that points to a previous template template parameter. 974 NewTemplateParm->setDefaultArgument( 975 OldTemplateParm->getDefaultArgument()); 976 PreviousDefaultArgLoc 977 = OldTemplateParm->getDefaultArgument().getLocation(); 978 } else if (NewTemplateParm->hasDefaultArgument()) { 979 SawDefaultArgument = true; 980 PreviousDefaultArgLoc 981 = NewTemplateParm->getDefaultArgument().getLocation(); 982 } else if (SawDefaultArgument) 983 MissingDefaultArg = true; 984 } 985 986 if (RedundantDefaultArg) { 987 // C++ [temp.param]p12: 988 // A template-parameter shall not be given default arguments 989 // by two different declarations in the same scope. 990 Diag(NewDefaultLoc, diag::err_template_param_default_arg_redefinition); 991 Diag(OldDefaultLoc, diag::note_template_param_prev_default_arg); 992 Invalid = true; 993 } else if (MissingDefaultArg) { 994 // C++ [temp.param]p11: 995 // If a template-parameter has a default template-argument, 996 // all subsequent template-parameters shall have a default 997 // template-argument supplied. 998 Diag((*NewParam)->getLocation(), 999 diag::err_template_param_default_arg_missing); 1000 Diag(PreviousDefaultArgLoc, diag::note_template_param_prev_default_arg); 1001 Invalid = true; 1002 } 1003 1004 // If we have an old template parameter list that we're merging 1005 // in, move on to the next parameter. 1006 if (OldParams) 1007 ++OldParam; 1008 } 1009 1010 return Invalid; 1011} 1012 1013/// \brief Match the given template parameter lists to the given scope 1014/// specifier, returning the template parameter list that applies to the 1015/// name. 1016/// 1017/// \param DeclStartLoc the start of the declaration that has a scope 1018/// specifier or a template parameter list. 1019/// 1020/// \param SS the scope specifier that will be matched to the given template 1021/// parameter lists. This scope specifier precedes a qualified name that is 1022/// being declared. 1023/// 1024/// \param ParamLists the template parameter lists, from the outermost to the 1025/// innermost template parameter lists. 1026/// 1027/// \param NumParamLists the number of template parameter lists in ParamLists. 1028/// 1029/// \param IsExplicitSpecialization will be set true if the entity being 1030/// declared is an explicit specialization, false otherwise. 1031/// 1032/// \returns the template parameter list, if any, that corresponds to the 1033/// name that is preceded by the scope specifier @p SS. This template 1034/// parameter list may be have template parameters (if we're declaring a 1035/// template) or may have no template parameters (if we're declaring a 1036/// template specialization), or may be NULL (if we were's declaring isn't 1037/// itself a template). 1038TemplateParameterList * 1039Sema::MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc, 1040 const CXXScopeSpec &SS, 1041 TemplateParameterList **ParamLists, 1042 unsigned NumParamLists, 1043 bool &IsExplicitSpecialization) { 1044 IsExplicitSpecialization = false; 1045 1046 // Find the template-ids that occur within the nested-name-specifier. These 1047 // template-ids will match up with the template parameter lists. 1048 llvm::SmallVector<const TemplateSpecializationType *, 4> 1049 TemplateIdsInSpecifier; 1050 for (NestedNameSpecifier *NNS = (NestedNameSpecifier *)SS.getScopeRep(); 1051 NNS; NNS = NNS->getPrefix()) { 1052 if (const TemplateSpecializationType *SpecType 1053 = dyn_cast_or_null<TemplateSpecializationType>(NNS->getAsType())) { 1054 TemplateDecl *Template = SpecType->getTemplateName().getAsTemplateDecl(); 1055 if (!Template) 1056 continue; // FIXME: should this be an error? probably... 1057 1058 if (const RecordType *Record = SpecType->getAs<RecordType>()) { 1059 ClassTemplateSpecializationDecl *SpecDecl 1060 = cast<ClassTemplateSpecializationDecl>(Record->getDecl()); 1061 // If the nested name specifier refers to an explicit specialization, 1062 // we don't need a template<> header. 1063 // FIXME: revisit this approach once we cope with specializations 1064 // properly. 1065 if (SpecDecl->getSpecializationKind() == TSK_ExplicitSpecialization) 1066 continue; 1067 } 1068 1069 TemplateIdsInSpecifier.push_back(SpecType); 1070 } 1071 } 1072 1073 // Reverse the list of template-ids in the scope specifier, so that we can 1074 // more easily match up the template-ids and the template parameter lists. 1075 std::reverse(TemplateIdsInSpecifier.begin(), TemplateIdsInSpecifier.end()); 1076 1077 SourceLocation FirstTemplateLoc = DeclStartLoc; 1078 if (NumParamLists) 1079 FirstTemplateLoc = ParamLists[0]->getTemplateLoc(); 1080 1081 // Match the template-ids found in the specifier to the template parameter 1082 // lists. 1083 unsigned Idx = 0; 1084 for (unsigned NumTemplateIds = TemplateIdsInSpecifier.size(); 1085 Idx != NumTemplateIds; ++Idx) { 1086 QualType TemplateId = QualType(TemplateIdsInSpecifier[Idx], 0); 1087 bool DependentTemplateId = TemplateId->isDependentType(); 1088 if (Idx >= NumParamLists) { 1089 // We have a template-id without a corresponding template parameter 1090 // list. 1091 if (DependentTemplateId) { 1092 // FIXME: the location information here isn't great. 1093 Diag(SS.getRange().getBegin(), 1094 diag::err_template_spec_needs_template_parameters) 1095 << TemplateId 1096 << SS.getRange(); 1097 } else { 1098 Diag(SS.getRange().getBegin(), diag::err_template_spec_needs_header) 1099 << SS.getRange() 1100 << CodeModificationHint::CreateInsertion(FirstTemplateLoc, 1101 "template<> "); 1102 IsExplicitSpecialization = true; 1103 } 1104 return 0; 1105 } 1106 1107 // Check the template parameter list against its corresponding template-id. 1108 if (DependentTemplateId) { 1109 TemplateDecl *Template 1110 = TemplateIdsInSpecifier[Idx]->getTemplateName().getAsTemplateDecl(); 1111 1112 if (ClassTemplateDecl *ClassTemplate 1113 = dyn_cast<ClassTemplateDecl>(Template)) { 1114 TemplateParameterList *ExpectedTemplateParams = 0; 1115 // Is this template-id naming the primary template? 1116 if (Context.hasSameType(TemplateId, 1117 ClassTemplate->getInjectedClassNameType(Context))) 1118 ExpectedTemplateParams = ClassTemplate->getTemplateParameters(); 1119 // ... or a partial specialization? 1120 else if (ClassTemplatePartialSpecializationDecl *PartialSpec 1121 = ClassTemplate->findPartialSpecialization(TemplateId)) 1122 ExpectedTemplateParams = PartialSpec->getTemplateParameters(); 1123 1124 if (ExpectedTemplateParams) 1125 TemplateParameterListsAreEqual(ParamLists[Idx], 1126 ExpectedTemplateParams, 1127 true); 1128 } 1129 } else if (ParamLists[Idx]->size() > 0) 1130 Diag(ParamLists[Idx]->getTemplateLoc(), 1131 diag::err_template_param_list_matches_nontemplate) 1132 << TemplateId 1133 << ParamLists[Idx]->getSourceRange(); 1134 else 1135 IsExplicitSpecialization = true; 1136 } 1137 1138 // If there were at least as many template-ids as there were template 1139 // parameter lists, then there are no template parameter lists remaining for 1140 // the declaration itself. 1141 if (Idx >= NumParamLists) 1142 return 0; 1143 1144 // If there were too many template parameter lists, complain about that now. 1145 if (Idx != NumParamLists - 1) { 1146 while (Idx < NumParamLists - 1) { 1147 Diag(ParamLists[Idx]->getTemplateLoc(), 1148 diag::err_template_spec_extra_headers) 1149 << SourceRange(ParamLists[Idx]->getTemplateLoc(), 1150 ParamLists[Idx]->getRAngleLoc()); 1151 ++Idx; 1152 } 1153 } 1154 1155 // Return the last template parameter list, which corresponds to the 1156 // entity being declared. 1157 return ParamLists[NumParamLists - 1]; 1158} 1159 1160QualType Sema::CheckTemplateIdType(TemplateName Name, 1161 SourceLocation TemplateLoc, 1162 SourceLocation LAngleLoc, 1163 const TemplateArgumentLoc *TemplateArgs, 1164 unsigned NumTemplateArgs, 1165 SourceLocation RAngleLoc) { 1166 TemplateDecl *Template = Name.getAsTemplateDecl(); 1167 if (!Template) { 1168 // The template name does not resolve to a template, so we just 1169 // build a dependent template-id type. 1170 return Context.getTemplateSpecializationType(Name, TemplateArgs, 1171 NumTemplateArgs); 1172 } 1173 1174 // Check that the template argument list is well-formed for this 1175 // template. 1176 TemplateArgumentListBuilder Converted(Template->getTemplateParameters(), 1177 NumTemplateArgs); 1178 if (CheckTemplateArgumentList(Template, TemplateLoc, LAngleLoc, 1179 TemplateArgs, NumTemplateArgs, RAngleLoc, 1180 false, Converted)) 1181 return QualType(); 1182 1183 assert((Converted.structuredSize() == 1184 Template->getTemplateParameters()->size()) && 1185 "Converted template argument list is too short!"); 1186 1187 QualType CanonType; 1188 1189 if (TemplateSpecializationType::anyDependentTemplateArguments( 1190 TemplateArgs, 1191 NumTemplateArgs)) { 1192 // This class template specialization is a dependent 1193 // type. Therefore, its canonical type is another class template 1194 // specialization type that contains all of the converted 1195 // arguments in canonical form. This ensures that, e.g., A<T> and 1196 // A<T, T> have identical types when A is declared as: 1197 // 1198 // template<typename T, typename U = T> struct A; 1199 TemplateName CanonName = Context.getCanonicalTemplateName(Name); 1200 CanonType = Context.getTemplateSpecializationType(CanonName, 1201 Converted.getFlatArguments(), 1202 Converted.flatSize()); 1203 1204 // FIXME: CanonType is not actually the canonical type, and unfortunately 1205 // it is a TemplateSpecializationType that we will never use again. 1206 // In the future, we need to teach getTemplateSpecializationType to only 1207 // build the canonical type and return that to us. 1208 CanonType = Context.getCanonicalType(CanonType); 1209 } else if (ClassTemplateDecl *ClassTemplate 1210 = dyn_cast<ClassTemplateDecl>(Template)) { 1211 // Find the class template specialization declaration that 1212 // corresponds to these arguments. 1213 llvm::FoldingSetNodeID ID; 1214 ClassTemplateSpecializationDecl::Profile(ID, 1215 Converted.getFlatArguments(), 1216 Converted.flatSize(), 1217 Context); 1218 void *InsertPos = 0; 1219 ClassTemplateSpecializationDecl *Decl 1220 = ClassTemplate->getSpecializations().FindNodeOrInsertPos(ID, InsertPos); 1221 if (!Decl) { 1222 // This is the first time we have referenced this class template 1223 // specialization. Create the canonical declaration and add it to 1224 // the set of specializations. 1225 Decl = ClassTemplateSpecializationDecl::Create(Context, 1226 ClassTemplate->getDeclContext(), 1227 ClassTemplate->getLocation(), 1228 ClassTemplate, 1229 Converted, 0); 1230 ClassTemplate->getSpecializations().InsertNode(Decl, InsertPos); 1231 Decl->setLexicalDeclContext(CurContext); 1232 } 1233 1234 CanonType = Context.getTypeDeclType(Decl); 1235 } 1236 1237 // Build the fully-sugared type for this class template 1238 // specialization, which refers back to the class template 1239 // specialization we created or found. 1240 return Context.getTemplateSpecializationType(Name, TemplateArgs, 1241 NumTemplateArgs, CanonType); 1242} 1243 1244Action::TypeResult 1245Sema::ActOnTemplateIdType(TemplateTy TemplateD, SourceLocation TemplateLoc, 1246 SourceLocation LAngleLoc, 1247 ASTTemplateArgsPtr TemplateArgsIn, 1248 SourceLocation RAngleLoc) { 1249 TemplateName Template = TemplateD.getAsVal<TemplateName>(); 1250 1251 // Translate the parser's template argument list in our AST format. 1252 llvm::SmallVector<TemplateArgumentLoc, 16> TemplateArgs; 1253 translateTemplateArguments(TemplateArgsIn, TemplateArgs); 1254 1255 QualType Result = CheckTemplateIdType(Template, TemplateLoc, LAngleLoc, 1256 TemplateArgs.data(), 1257 TemplateArgs.size(), 1258 RAngleLoc); 1259 TemplateArgsIn.release(); 1260 1261 if (Result.isNull()) 1262 return true; 1263 1264 DeclaratorInfo *DI = Context.CreateDeclaratorInfo(Result); 1265 TemplateSpecializationTypeLoc TL 1266 = cast<TemplateSpecializationTypeLoc>(DI->getTypeLoc()); 1267 TL.setTemplateNameLoc(TemplateLoc); 1268 TL.setLAngleLoc(LAngleLoc); 1269 TL.setRAngleLoc(RAngleLoc); 1270 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 1271 TL.setArgLocInfo(i, TemplateArgs[i].getLocInfo()); 1272 1273 return CreateLocInfoType(Result, DI).getAsOpaquePtr(); 1274} 1275 1276Sema::TypeResult Sema::ActOnTagTemplateIdType(TypeResult TypeResult, 1277 TagUseKind TUK, 1278 DeclSpec::TST TagSpec, 1279 SourceLocation TagLoc) { 1280 if (TypeResult.isInvalid()) 1281 return Sema::TypeResult(); 1282 1283 // FIXME: preserve source info, ideally without copying the DI. 1284 DeclaratorInfo *DI; 1285 QualType Type = GetTypeFromParser(TypeResult.get(), &DI); 1286 1287 // Verify the tag specifier. 1288 TagDecl::TagKind TagKind = TagDecl::getTagKindForTypeSpec(TagSpec); 1289 1290 if (const RecordType *RT = Type->getAs<RecordType>()) { 1291 RecordDecl *D = RT->getDecl(); 1292 1293 IdentifierInfo *Id = D->getIdentifier(); 1294 assert(Id && "templated class must have an identifier"); 1295 1296 if (!isAcceptableTagRedeclaration(D, TagKind, TagLoc, *Id)) { 1297 Diag(TagLoc, diag::err_use_with_wrong_tag) 1298 << Type 1299 << CodeModificationHint::CreateReplacement(SourceRange(TagLoc), 1300 D->getKindName()); 1301 Diag(D->getLocation(), diag::note_previous_use); 1302 } 1303 } 1304 1305 QualType ElabType = Context.getElaboratedType(Type, TagKind); 1306 1307 return ElabType.getAsOpaquePtr(); 1308} 1309 1310Sema::OwningExprResult Sema::BuildTemplateIdExpr(NestedNameSpecifier *Qualifier, 1311 SourceRange QualifierRange, 1312 TemplateName Template, 1313 SourceLocation TemplateNameLoc, 1314 SourceLocation LAngleLoc, 1315 const TemplateArgumentLoc *TemplateArgs, 1316 unsigned NumTemplateArgs, 1317 SourceLocation RAngleLoc) { 1318 // FIXME: Can we do any checking at this point? I guess we could check the 1319 // template arguments that we have against the template name, if the template 1320 // name refers to a single template. That's not a terribly common case, 1321 // though. 1322 1323 // Cope with an implicit member access in a C++ non-static member function. 1324 NamedDecl *D = Template.getAsTemplateDecl(); 1325 if (!D) 1326 D = Template.getAsOverloadedFunctionDecl(); 1327 1328 CXXScopeSpec SS; 1329 SS.setRange(QualifierRange); 1330 SS.setScopeRep(Qualifier); 1331 QualType ThisType, MemberType; 1332 if (D && isImplicitMemberReference(&SS, D, TemplateNameLoc, 1333 ThisType, MemberType)) { 1334 Expr *This = new (Context) CXXThisExpr(SourceLocation(), ThisType); 1335 return Owned(MemberExpr::Create(Context, This, true, 1336 Qualifier, QualifierRange, 1337 D, TemplateNameLoc, true, 1338 LAngleLoc, TemplateArgs, 1339 NumTemplateArgs, RAngleLoc, 1340 Context.OverloadTy)); 1341 } 1342 1343 return Owned(TemplateIdRefExpr::Create(Context, Context.OverloadTy, 1344 Qualifier, QualifierRange, 1345 Template, TemplateNameLoc, LAngleLoc, 1346 TemplateArgs, 1347 NumTemplateArgs, RAngleLoc)); 1348} 1349 1350Sema::OwningExprResult Sema::ActOnTemplateIdExpr(const CXXScopeSpec &SS, 1351 TemplateTy TemplateD, 1352 SourceLocation TemplateNameLoc, 1353 SourceLocation LAngleLoc, 1354 ASTTemplateArgsPtr TemplateArgsIn, 1355 SourceLocation RAngleLoc) { 1356 TemplateName Template = TemplateD.getAsVal<TemplateName>(); 1357 1358 // Translate the parser's template argument list in our AST format. 1359 llvm::SmallVector<TemplateArgumentLoc, 16> TemplateArgs; 1360 translateTemplateArguments(TemplateArgsIn, TemplateArgs); 1361 TemplateArgsIn.release(); 1362 1363 return BuildTemplateIdExpr((NestedNameSpecifier *)SS.getScopeRep(), 1364 SS.getRange(), 1365 Template, TemplateNameLoc, LAngleLoc, 1366 TemplateArgs.data(), TemplateArgs.size(), 1367 RAngleLoc); 1368} 1369 1370/// \brief Form a dependent template name. 1371/// 1372/// This action forms a dependent template name given the template 1373/// name and its (presumably dependent) scope specifier. For 1374/// example, given "MetaFun::template apply", the scope specifier \p 1375/// SS will be "MetaFun::", \p TemplateKWLoc contains the location 1376/// of the "template" keyword, and "apply" is the \p Name. 1377Sema::TemplateTy 1378Sema::ActOnDependentTemplateName(SourceLocation TemplateKWLoc, 1379 const CXXScopeSpec &SS, 1380 UnqualifiedId &Name, 1381 TypeTy *ObjectType) { 1382 if ((ObjectType && 1383 computeDeclContext(QualType::getFromOpaquePtr(ObjectType))) || 1384 (SS.isSet() && computeDeclContext(SS, false))) { 1385 // C++0x [temp.names]p5: 1386 // If a name prefixed by the keyword template is not the name of 1387 // a template, the program is ill-formed. [Note: the keyword 1388 // template may not be applied to non-template members of class 1389 // templates. -end note ] [ Note: as is the case with the 1390 // typename prefix, the template prefix is allowed in cases 1391 // where it is not strictly necessary; i.e., when the 1392 // nested-name-specifier or the expression on the left of the -> 1393 // or . is not dependent on a template-parameter, or the use 1394 // does not appear in the scope of a template. -end note] 1395 // 1396 // Note: C++03 was more strict here, because it banned the use of 1397 // the "template" keyword prior to a template-name that was not a 1398 // dependent name. C++ DR468 relaxed this requirement (the 1399 // "template" keyword is now permitted). We follow the C++0x 1400 // rules, even in C++03 mode, retroactively applying the DR. 1401 TemplateTy Template; 1402 TemplateNameKind TNK = isTemplateName(0, SS, Name, ObjectType, 1403 false, Template); 1404 if (TNK == TNK_Non_template) { 1405 Diag(Name.getSourceRange().getBegin(), 1406 diag::err_template_kw_refers_to_non_template) 1407 << GetNameFromUnqualifiedId(Name) 1408 << Name.getSourceRange(); 1409 return TemplateTy(); 1410 } 1411 1412 return Template; 1413 } 1414 1415 NestedNameSpecifier *Qualifier 1416 = static_cast<NestedNameSpecifier *>(SS.getScopeRep()); 1417 1418 switch (Name.getKind()) { 1419 case UnqualifiedId::IK_Identifier: 1420 return TemplateTy::make(Context.getDependentTemplateName(Qualifier, 1421 Name.Identifier)); 1422 1423 case UnqualifiedId::IK_OperatorFunctionId: 1424 return TemplateTy::make(Context.getDependentTemplateName(Qualifier, 1425 Name.OperatorFunctionId.Operator)); 1426 1427 default: 1428 break; 1429 } 1430 1431 Diag(Name.getSourceRange().getBegin(), 1432 diag::err_template_kw_refers_to_non_template) 1433 << GetNameFromUnqualifiedId(Name) 1434 << Name.getSourceRange(); 1435 return TemplateTy(); 1436} 1437 1438bool Sema::CheckTemplateTypeArgument(TemplateTypeParmDecl *Param, 1439 const TemplateArgumentLoc &AL, 1440 TemplateArgumentListBuilder &Converted) { 1441 const TemplateArgument &Arg = AL.getArgument(); 1442 1443 // Check template type parameter. 1444 if (Arg.getKind() != TemplateArgument::Type) { 1445 // C++ [temp.arg.type]p1: 1446 // A template-argument for a template-parameter which is a 1447 // type shall be a type-id. 1448 1449 // We have a template type parameter but the template argument 1450 // is not a type. 1451 SourceRange SR = AL.getSourceRange(); 1452 Diag(SR.getBegin(), diag::err_template_arg_must_be_type) << SR; 1453 Diag(Param->getLocation(), diag::note_template_param_here); 1454 1455 return true; 1456 } 1457 1458 if (CheckTemplateArgument(Param, AL.getSourceDeclaratorInfo())) 1459 return true; 1460 1461 // Add the converted template type argument. 1462 Converted.Append( 1463 TemplateArgument(Context.getCanonicalType(Arg.getAsType()))); 1464 return false; 1465} 1466 1467/// \brief Substitute template arguments into the default template argument for 1468/// the given template type parameter. 1469/// 1470/// \param SemaRef the semantic analysis object for which we are performing 1471/// the substitution. 1472/// 1473/// \param Template the template that we are synthesizing template arguments 1474/// for. 1475/// 1476/// \param TemplateLoc the location of the template name that started the 1477/// template-id we are checking. 1478/// 1479/// \param RAngleLoc the location of the right angle bracket ('>') that 1480/// terminates the template-id. 1481/// 1482/// \param Param the template template parameter whose default we are 1483/// substituting into. 1484/// 1485/// \param Converted the list of template arguments provided for template 1486/// parameters that precede \p Param in the template parameter list. 1487/// 1488/// \returns the substituted template argument, or NULL if an error occurred. 1489static DeclaratorInfo * 1490SubstDefaultTemplateArgument(Sema &SemaRef, 1491 TemplateDecl *Template, 1492 SourceLocation TemplateLoc, 1493 SourceLocation RAngleLoc, 1494 TemplateTypeParmDecl *Param, 1495 TemplateArgumentListBuilder &Converted) { 1496 DeclaratorInfo *ArgType = Param->getDefaultArgumentInfo(); 1497 1498 // If the argument type is dependent, instantiate it now based 1499 // on the previously-computed template arguments. 1500 if (ArgType->getType()->isDependentType()) { 1501 TemplateArgumentList TemplateArgs(SemaRef.Context, Converted, 1502 /*TakeArgs=*/false); 1503 1504 MultiLevelTemplateArgumentList AllTemplateArgs 1505 = SemaRef.getTemplateInstantiationArgs(Template, &TemplateArgs); 1506 1507 Sema::InstantiatingTemplate Inst(SemaRef, TemplateLoc, 1508 Template, Converted.getFlatArguments(), 1509 Converted.flatSize(), 1510 SourceRange(TemplateLoc, RAngleLoc)); 1511 1512 ArgType = SemaRef.SubstType(ArgType, AllTemplateArgs, 1513 Param->getDefaultArgumentLoc(), 1514 Param->getDeclName()); 1515 } 1516 1517 return ArgType; 1518} 1519 1520/// \brief Substitute template arguments into the default template argument for 1521/// the given non-type template parameter. 1522/// 1523/// \param SemaRef the semantic analysis object for which we are performing 1524/// the substitution. 1525/// 1526/// \param Template the template that we are synthesizing template arguments 1527/// for. 1528/// 1529/// \param TemplateLoc the location of the template name that started the 1530/// template-id we are checking. 1531/// 1532/// \param RAngleLoc the location of the right angle bracket ('>') that 1533/// terminates the template-id. 1534/// 1535/// \param Param the non-type template parameter whose default we are 1536/// substituting into. 1537/// 1538/// \param Converted the list of template arguments provided for template 1539/// parameters that precede \p Param in the template parameter list. 1540/// 1541/// \returns the substituted template argument, or NULL if an error occurred. 1542static Sema::OwningExprResult 1543SubstDefaultTemplateArgument(Sema &SemaRef, 1544 TemplateDecl *Template, 1545 SourceLocation TemplateLoc, 1546 SourceLocation RAngleLoc, 1547 NonTypeTemplateParmDecl *Param, 1548 TemplateArgumentListBuilder &Converted) { 1549 TemplateArgumentList TemplateArgs(SemaRef.Context, Converted, 1550 /*TakeArgs=*/false); 1551 1552 MultiLevelTemplateArgumentList AllTemplateArgs 1553 = SemaRef.getTemplateInstantiationArgs(Template, &TemplateArgs); 1554 1555 Sema::InstantiatingTemplate Inst(SemaRef, TemplateLoc, 1556 Template, Converted.getFlatArguments(), 1557 Converted.flatSize(), 1558 SourceRange(TemplateLoc, RAngleLoc)); 1559 1560 return SemaRef.SubstExpr(Param->getDefaultArgument(), AllTemplateArgs); 1561} 1562 1563/// \brief Substitute template arguments into the default template argument for 1564/// the given template template parameter. 1565/// 1566/// \param SemaRef the semantic analysis object for which we are performing 1567/// the substitution. 1568/// 1569/// \param Template the template that we are synthesizing template arguments 1570/// for. 1571/// 1572/// \param TemplateLoc the location of the template name that started the 1573/// template-id we are checking. 1574/// 1575/// \param RAngleLoc the location of the right angle bracket ('>') that 1576/// terminates the template-id. 1577/// 1578/// \param Param the template template parameter whose default we are 1579/// substituting into. 1580/// 1581/// \param Converted the list of template arguments provided for template 1582/// parameters that precede \p Param in the template parameter list. 1583/// 1584/// \returns the substituted template argument, or NULL if an error occurred. 1585static TemplateName 1586SubstDefaultTemplateArgument(Sema &SemaRef, 1587 TemplateDecl *Template, 1588 SourceLocation TemplateLoc, 1589 SourceLocation RAngleLoc, 1590 TemplateTemplateParmDecl *Param, 1591 TemplateArgumentListBuilder &Converted) { 1592 TemplateArgumentList TemplateArgs(SemaRef.Context, Converted, 1593 /*TakeArgs=*/false); 1594 1595 MultiLevelTemplateArgumentList AllTemplateArgs 1596 = SemaRef.getTemplateInstantiationArgs(Template, &TemplateArgs); 1597 1598 Sema::InstantiatingTemplate Inst(SemaRef, TemplateLoc, 1599 Template, Converted.getFlatArguments(), 1600 Converted.flatSize(), 1601 SourceRange(TemplateLoc, RAngleLoc)); 1602 1603 return SemaRef.SubstTemplateName( 1604 Param->getDefaultArgument().getArgument().getAsTemplate(), 1605 Param->getDefaultArgument().getTemplateNameLoc(), 1606 AllTemplateArgs); 1607} 1608 1609/// \brief Check that the given template argument corresponds to the given 1610/// template parameter. 1611bool Sema::CheckTemplateArgument(NamedDecl *Param, 1612 const TemplateArgumentLoc &Arg, 1613 TemplateDecl *Template, 1614 SourceLocation TemplateLoc, 1615 SourceLocation RAngleLoc, 1616 TemplateArgumentListBuilder &Converted) { 1617 // Check template type parameters. 1618 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) 1619 return CheckTemplateTypeArgument(TTP, Arg, Converted); 1620 1621 // Check non-type template parameters. 1622 if (NonTypeTemplateParmDecl *NTTP =dyn_cast<NonTypeTemplateParmDecl>(Param)) { 1623 // Do substitution on the type of the non-type template parameter 1624 // with the template arguments we've seen thus far. 1625 QualType NTTPType = NTTP->getType(); 1626 if (NTTPType->isDependentType()) { 1627 // Do substitution on the type of the non-type template parameter. 1628 InstantiatingTemplate Inst(*this, TemplateLoc, Template, 1629 NTTP, Converted.getFlatArguments(), 1630 Converted.flatSize(), 1631 SourceRange(TemplateLoc, RAngleLoc)); 1632 1633 TemplateArgumentList TemplateArgs(Context, Converted, 1634 /*TakeArgs=*/false); 1635 NTTPType = SubstType(NTTPType, 1636 MultiLevelTemplateArgumentList(TemplateArgs), 1637 NTTP->getLocation(), 1638 NTTP->getDeclName()); 1639 // If that worked, check the non-type template parameter type 1640 // for validity. 1641 if (!NTTPType.isNull()) 1642 NTTPType = CheckNonTypeTemplateParameterType(NTTPType, 1643 NTTP->getLocation()); 1644 if (NTTPType.isNull()) 1645 return true; 1646 } 1647 1648 switch (Arg.getArgument().getKind()) { 1649 case TemplateArgument::Null: 1650 assert(false && "Should never see a NULL template argument here"); 1651 return true; 1652 1653 case TemplateArgument::Expression: { 1654 Expr *E = Arg.getArgument().getAsExpr(); 1655 TemplateArgument Result; 1656 if (CheckTemplateArgument(NTTP, NTTPType, E, Result)) 1657 return true; 1658 1659 Converted.Append(Result); 1660 break; 1661 } 1662 1663 case TemplateArgument::Declaration: 1664 case TemplateArgument::Integral: 1665 // We've already checked this template argument, so just copy 1666 // it to the list of converted arguments. 1667 Converted.Append(Arg.getArgument()); 1668 break; 1669 1670 case TemplateArgument::Template: 1671 // We were given a template template argument. It may not be ill-formed; 1672 // see below. 1673 if (DependentTemplateName *DTN 1674 = Arg.getArgument().getAsTemplate().getAsDependentTemplateName()) { 1675 // We have a template argument such as \c T::template X, which we 1676 // parsed as a template template argument. However, since we now 1677 // know that we need a non-type template argument, convert this 1678 // template name into an expression. 1679 Expr *E = new (Context) UnresolvedDeclRefExpr(DTN->getIdentifier(), 1680 Context.DependentTy, 1681 Arg.getTemplateNameLoc(), 1682 Arg.getTemplateQualifierRange(), 1683 DTN->getQualifier(), 1684 /*isAddressOfOperand=*/false); 1685 1686 TemplateArgument Result; 1687 if (CheckTemplateArgument(NTTP, NTTPType, E, Result)) 1688 return true; 1689 1690 Converted.Append(Result); 1691 break; 1692 } 1693 1694 // We have a template argument that actually does refer to a class 1695 // template, template alias, or template template parameter, and 1696 // therefore cannot be a non-type template argument. 1697 Diag(Arg.getLocation(), diag::err_template_arg_must_be_expr) 1698 << Arg.getSourceRange(); 1699 1700 Diag(Param->getLocation(), diag::note_template_param_here); 1701 return true; 1702 1703 case TemplateArgument::Type: { 1704 // We have a non-type template parameter but the template 1705 // argument is a type. 1706 1707 // C++ [temp.arg]p2: 1708 // In a template-argument, an ambiguity between a type-id and 1709 // an expression is resolved to a type-id, regardless of the 1710 // form of the corresponding template-parameter. 1711 // 1712 // We warn specifically about this case, since it can be rather 1713 // confusing for users. 1714 QualType T = Arg.getArgument().getAsType(); 1715 SourceRange SR = Arg.getSourceRange(); 1716 if (T->isFunctionType()) 1717 Diag(SR.getBegin(), diag::err_template_arg_nontype_ambig) << SR << T; 1718 else 1719 Diag(SR.getBegin(), diag::err_template_arg_must_be_expr) << SR; 1720 Diag(Param->getLocation(), diag::note_template_param_here); 1721 return true; 1722 } 1723 1724 case TemplateArgument::Pack: 1725 llvm::llvm_unreachable("Caller must expand template argument packs"); 1726 break; 1727 } 1728 1729 return false; 1730 } 1731 1732 1733 // Check template template parameters. 1734 TemplateTemplateParmDecl *TempParm = cast<TemplateTemplateParmDecl>(Param); 1735 1736 // Substitute into the template parameter list of the template 1737 // template parameter, since previously-supplied template arguments 1738 // may appear within the template template parameter. 1739 { 1740 // Set up a template instantiation context. 1741 LocalInstantiationScope Scope(*this); 1742 InstantiatingTemplate Inst(*this, TemplateLoc, Template, 1743 TempParm, Converted.getFlatArguments(), 1744 Converted.flatSize(), 1745 SourceRange(TemplateLoc, RAngleLoc)); 1746 1747 TemplateArgumentList TemplateArgs(Context, Converted, 1748 /*TakeArgs=*/false); 1749 TempParm = cast_or_null<TemplateTemplateParmDecl>( 1750 SubstDecl(TempParm, CurContext, 1751 MultiLevelTemplateArgumentList(TemplateArgs))); 1752 if (!TempParm) 1753 return true; 1754 1755 // FIXME: TempParam is leaked. 1756 } 1757 1758 switch (Arg.getArgument().getKind()) { 1759 case TemplateArgument::Null: 1760 assert(false && "Should never see a NULL template argument here"); 1761 return true; 1762 1763 case TemplateArgument::Template: 1764 if (CheckTemplateArgument(TempParm, Arg)) 1765 return true; 1766 1767 Converted.Append(Arg.getArgument()); 1768 break; 1769 1770 case TemplateArgument::Expression: 1771 case TemplateArgument::Type: 1772 // We have a template template parameter but the template 1773 // argument does not refer to a template. 1774 Diag(Arg.getLocation(), diag::err_template_arg_must_be_template); 1775 return true; 1776 1777 case TemplateArgument::Declaration: 1778 llvm::llvm_unreachable( 1779 "Declaration argument with template template parameter"); 1780 break; 1781 case TemplateArgument::Integral: 1782 llvm::llvm_unreachable( 1783 "Integral argument with template template parameter"); 1784 break; 1785 1786 case TemplateArgument::Pack: 1787 llvm::llvm_unreachable("Caller must expand template argument packs"); 1788 break; 1789 } 1790 1791 return false; 1792} 1793 1794/// \brief Check that the given template argument list is well-formed 1795/// for specializing the given template. 1796bool Sema::CheckTemplateArgumentList(TemplateDecl *Template, 1797 SourceLocation TemplateLoc, 1798 SourceLocation LAngleLoc, 1799 const TemplateArgumentLoc *TemplateArgs, 1800 unsigned NumTemplateArgs, 1801 SourceLocation RAngleLoc, 1802 bool PartialTemplateArgs, 1803 TemplateArgumentListBuilder &Converted) { 1804 TemplateParameterList *Params = Template->getTemplateParameters(); 1805 unsigned NumParams = Params->size(); 1806 unsigned NumArgs = NumTemplateArgs; 1807 bool Invalid = false; 1808 1809 bool HasParameterPack = 1810 NumParams > 0 && Params->getParam(NumParams - 1)->isTemplateParameterPack(); 1811 1812 if ((NumArgs > NumParams && !HasParameterPack) || 1813 (NumArgs < Params->getMinRequiredArguments() && 1814 !PartialTemplateArgs)) { 1815 // FIXME: point at either the first arg beyond what we can handle, 1816 // or the '>', depending on whether we have too many or too few 1817 // arguments. 1818 SourceRange Range; 1819 if (NumArgs > NumParams) 1820 Range = SourceRange(TemplateArgs[NumParams].getLocation(), RAngleLoc); 1821 Diag(TemplateLoc, diag::err_template_arg_list_different_arity) 1822 << (NumArgs > NumParams) 1823 << (isa<ClassTemplateDecl>(Template)? 0 : 1824 isa<FunctionTemplateDecl>(Template)? 1 : 1825 isa<TemplateTemplateParmDecl>(Template)? 2 : 3) 1826 << Template << Range; 1827 Diag(Template->getLocation(), diag::note_template_decl_here) 1828 << Params->getSourceRange(); 1829 Invalid = true; 1830 } 1831 1832 // C++ [temp.arg]p1: 1833 // [...] The type and form of each template-argument specified in 1834 // a template-id shall match the type and form specified for the 1835 // corresponding parameter declared by the template in its 1836 // template-parameter-list. 1837 unsigned ArgIdx = 0; 1838 for (TemplateParameterList::iterator Param = Params->begin(), 1839 ParamEnd = Params->end(); 1840 Param != ParamEnd; ++Param, ++ArgIdx) { 1841 if (ArgIdx > NumArgs && PartialTemplateArgs) 1842 break; 1843 1844 // If we have a template parameter pack, check every remaining template 1845 // argument against that template parameter pack. 1846 if ((*Param)->isTemplateParameterPack()) { 1847 Converted.BeginPack(); 1848 for (; ArgIdx < NumArgs; ++ArgIdx) { 1849 if (CheckTemplateArgument(*Param, TemplateArgs[ArgIdx], Template, 1850 TemplateLoc, RAngleLoc, Converted)) { 1851 Invalid = true; 1852 break; 1853 } 1854 } 1855 Converted.EndPack(); 1856 continue; 1857 } 1858 1859 if (ArgIdx < NumArgs) { 1860 // Check the template argument we were given. 1861 if (CheckTemplateArgument(*Param, TemplateArgs[ArgIdx], Template, 1862 TemplateLoc, RAngleLoc, Converted)) 1863 return true; 1864 1865 continue; 1866 } 1867 1868 // We have a default template argument that we will use. 1869 TemplateArgumentLoc Arg; 1870 1871 // Retrieve the default template argument from the template 1872 // parameter. For each kind of template parameter, we substitute the 1873 // template arguments provided thus far and any "outer" template arguments 1874 // (when the template parameter was part of a nested template) into 1875 // the default argument. 1876 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*Param)) { 1877 if (!TTP->hasDefaultArgument()) { 1878 assert((Invalid || PartialTemplateArgs) && "Missing default argument"); 1879 break; 1880 } 1881 1882 DeclaratorInfo *ArgType = SubstDefaultTemplateArgument(*this, 1883 Template, 1884 TemplateLoc, 1885 RAngleLoc, 1886 TTP, 1887 Converted); 1888 if (!ArgType) 1889 return true; 1890 1891 Arg = TemplateArgumentLoc(TemplateArgument(ArgType->getType()), 1892 ArgType); 1893 } else if (NonTypeTemplateParmDecl *NTTP 1894 = dyn_cast<NonTypeTemplateParmDecl>(*Param)) { 1895 if (!NTTP->hasDefaultArgument()) { 1896 assert((Invalid || PartialTemplateArgs) && "Missing default argument"); 1897 break; 1898 } 1899 1900 Sema::OwningExprResult E = SubstDefaultTemplateArgument(*this, Template, 1901 TemplateLoc, 1902 RAngleLoc, 1903 NTTP, 1904 Converted); 1905 if (E.isInvalid()) 1906 return true; 1907 1908 Expr *Ex = E.takeAs<Expr>(); 1909 Arg = TemplateArgumentLoc(TemplateArgument(Ex), Ex); 1910 } else { 1911 TemplateTemplateParmDecl *TempParm 1912 = cast<TemplateTemplateParmDecl>(*Param); 1913 1914 if (!TempParm->hasDefaultArgument()) { 1915 assert((Invalid || PartialTemplateArgs) && "Missing default argument"); 1916 break; 1917 } 1918 1919 TemplateName Name = SubstDefaultTemplateArgument(*this, Template, 1920 TemplateLoc, 1921 RAngleLoc, 1922 TempParm, 1923 Converted); 1924 if (Name.isNull()) 1925 return true; 1926 1927 Arg = TemplateArgumentLoc(TemplateArgument(Name), 1928 TempParm->getDefaultArgument().getTemplateQualifierRange(), 1929 TempParm->getDefaultArgument().getTemplateNameLoc()); 1930 } 1931 1932 // Introduce an instantiation record that describes where we are using 1933 // the default template argument. 1934 InstantiatingTemplate Instantiating(*this, RAngleLoc, Template, *Param, 1935 Converted.getFlatArguments(), 1936 Converted.flatSize(), 1937 SourceRange(TemplateLoc, RAngleLoc)); 1938 1939 // Check the default template argument. 1940 if (CheckTemplateArgument(*Param, Arg, Template, TemplateLoc, 1941 RAngleLoc, Converted)) 1942 return true; 1943 } 1944 1945 return Invalid; 1946} 1947 1948/// \brief Check a template argument against its corresponding 1949/// template type parameter. 1950/// 1951/// This routine implements the semantics of C++ [temp.arg.type]. It 1952/// returns true if an error occurred, and false otherwise. 1953bool Sema::CheckTemplateArgument(TemplateTypeParmDecl *Param, 1954 DeclaratorInfo *ArgInfo) { 1955 assert(ArgInfo && "invalid DeclaratorInfo"); 1956 QualType Arg = ArgInfo->getType(); 1957 1958 // C++ [temp.arg.type]p2: 1959 // A local type, a type with no linkage, an unnamed type or a type 1960 // compounded from any of these types shall not be used as a 1961 // template-argument for a template type-parameter. 1962 // 1963 // FIXME: Perform the recursive and no-linkage type checks. 1964 const TagType *Tag = 0; 1965 if (const EnumType *EnumT = Arg->getAs<EnumType>()) 1966 Tag = EnumT; 1967 else if (const RecordType *RecordT = Arg->getAs<RecordType>()) 1968 Tag = RecordT; 1969 if (Tag && Tag->getDecl()->getDeclContext()->isFunctionOrMethod()) { 1970 SourceRange SR = ArgInfo->getTypeLoc().getFullSourceRange(); 1971 return Diag(SR.getBegin(), diag::err_template_arg_local_type) 1972 << QualType(Tag, 0) << SR; 1973 } else if (Tag && !Tag->getDecl()->getDeclName() && 1974 !Tag->getDecl()->getTypedefForAnonDecl()) { 1975 SourceRange SR = ArgInfo->getTypeLoc().getFullSourceRange(); 1976 Diag(SR.getBegin(), diag::err_template_arg_unnamed_type) << SR; 1977 Diag(Tag->getDecl()->getLocation(), diag::note_template_unnamed_type_here); 1978 return true; 1979 } 1980 1981 return false; 1982} 1983 1984/// \brief Checks whether the given template argument is the address 1985/// of an object or function according to C++ [temp.arg.nontype]p1. 1986bool Sema::CheckTemplateArgumentAddressOfObjectOrFunction(Expr *Arg, 1987 NamedDecl *&Entity) { 1988 bool Invalid = false; 1989 1990 // See through any implicit casts we added to fix the type. 1991 while (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(Arg)) 1992 Arg = Cast->getSubExpr(); 1993 1994 // C++0x allows nullptr, and there's no further checking to be done for that. 1995 if (Arg->getType()->isNullPtrType()) 1996 return false; 1997 1998 // C++ [temp.arg.nontype]p1: 1999 // 2000 // A template-argument for a non-type, non-template 2001 // template-parameter shall be one of: [...] 2002 // 2003 // -- the address of an object or function with external 2004 // linkage, including function templates and function 2005 // template-ids but excluding non-static class members, 2006 // expressed as & id-expression where the & is optional if 2007 // the name refers to a function or array, or if the 2008 // corresponding template-parameter is a reference; or 2009 DeclRefExpr *DRE = 0; 2010 2011 // Ignore (and complain about) any excess parentheses. 2012 while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) { 2013 if (!Invalid) { 2014 Diag(Arg->getSourceRange().getBegin(), 2015 diag::err_template_arg_extra_parens) 2016 << Arg->getSourceRange(); 2017 Invalid = true; 2018 } 2019 2020 Arg = Parens->getSubExpr(); 2021 } 2022 2023 if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) { 2024 if (UnOp->getOpcode() == UnaryOperator::AddrOf) 2025 DRE = dyn_cast<DeclRefExpr>(UnOp->getSubExpr()); 2026 } else 2027 DRE = dyn_cast<DeclRefExpr>(Arg); 2028 2029 if (!DRE || !isa<ValueDecl>(DRE->getDecl())) 2030 return Diag(Arg->getSourceRange().getBegin(), 2031 diag::err_template_arg_not_object_or_func_form) 2032 << Arg->getSourceRange(); 2033 2034 // Cannot refer to non-static data members 2035 if (FieldDecl *Field = dyn_cast<FieldDecl>(DRE->getDecl())) 2036 return Diag(Arg->getSourceRange().getBegin(), diag::err_template_arg_field) 2037 << Field << Arg->getSourceRange(); 2038 2039 // Cannot refer to non-static member functions 2040 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(DRE->getDecl())) 2041 if (!Method->isStatic()) 2042 return Diag(Arg->getSourceRange().getBegin(), 2043 diag::err_template_arg_method) 2044 << Method << Arg->getSourceRange(); 2045 2046 // Functions must have external linkage. 2047 if (FunctionDecl *Func = dyn_cast<FunctionDecl>(DRE->getDecl())) { 2048 if (Func->getStorageClass() == FunctionDecl::Static) { 2049 Diag(Arg->getSourceRange().getBegin(), 2050 diag::err_template_arg_function_not_extern) 2051 << Func << Arg->getSourceRange(); 2052 Diag(Func->getLocation(), diag::note_template_arg_internal_object) 2053 << true; 2054 return true; 2055 } 2056 2057 // Okay: we've named a function with external linkage. 2058 Entity = Func; 2059 return Invalid; 2060 } 2061 2062 if (VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) { 2063 if (!Var->hasGlobalStorage()) { 2064 Diag(Arg->getSourceRange().getBegin(), 2065 diag::err_template_arg_object_not_extern) 2066 << Var << Arg->getSourceRange(); 2067 Diag(Var->getLocation(), diag::note_template_arg_internal_object) 2068 << true; 2069 return true; 2070 } 2071 2072 // Okay: we've named an object with external linkage 2073 Entity = Var; 2074 return Invalid; 2075 } 2076 2077 // We found something else, but we don't know specifically what it is. 2078 Diag(Arg->getSourceRange().getBegin(), 2079 diag::err_template_arg_not_object_or_func) 2080 << Arg->getSourceRange(); 2081 Diag(DRE->getDecl()->getLocation(), 2082 diag::note_template_arg_refers_here); 2083 return true; 2084} 2085 2086/// \brief Checks whether the given template argument is a pointer to 2087/// member constant according to C++ [temp.arg.nontype]p1. 2088bool 2089Sema::CheckTemplateArgumentPointerToMember(Expr *Arg, NamedDecl *&Member) { 2090 bool Invalid = false; 2091 2092 // See through any implicit casts we added to fix the type. 2093 while (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(Arg)) 2094 Arg = Cast->getSubExpr(); 2095 2096 // C++0x allows nullptr, and there's no further checking to be done for that. 2097 if (Arg->getType()->isNullPtrType()) 2098 return false; 2099 2100 // C++ [temp.arg.nontype]p1: 2101 // 2102 // A template-argument for a non-type, non-template 2103 // template-parameter shall be one of: [...] 2104 // 2105 // -- a pointer to member expressed as described in 5.3.1. 2106 DeclRefExpr *DRE = 0; 2107 2108 // Ignore (and complain about) any excess parentheses. 2109 while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) { 2110 if (!Invalid) { 2111 Diag(Arg->getSourceRange().getBegin(), 2112 diag::err_template_arg_extra_parens) 2113 << Arg->getSourceRange(); 2114 Invalid = true; 2115 } 2116 2117 Arg = Parens->getSubExpr(); 2118 } 2119 2120 if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) 2121 if (UnOp->getOpcode() == UnaryOperator::AddrOf) { 2122 DRE = dyn_cast<DeclRefExpr>(UnOp->getSubExpr()); 2123 if (DRE && !DRE->getQualifier()) 2124 DRE = 0; 2125 } 2126 2127 if (!DRE) 2128 return Diag(Arg->getSourceRange().getBegin(), 2129 diag::err_template_arg_not_pointer_to_member_form) 2130 << Arg->getSourceRange(); 2131 2132 if (isa<FieldDecl>(DRE->getDecl()) || isa<CXXMethodDecl>(DRE->getDecl())) { 2133 assert((isa<FieldDecl>(DRE->getDecl()) || 2134 !cast<CXXMethodDecl>(DRE->getDecl())->isStatic()) && 2135 "Only non-static member pointers can make it here"); 2136 2137 // Okay: this is the address of a non-static member, and therefore 2138 // a member pointer constant. 2139 Member = DRE->getDecl(); 2140 return Invalid; 2141 } 2142 2143 // We found something else, but we don't know specifically what it is. 2144 Diag(Arg->getSourceRange().getBegin(), 2145 diag::err_template_arg_not_pointer_to_member_form) 2146 << Arg->getSourceRange(); 2147 Diag(DRE->getDecl()->getLocation(), 2148 diag::note_template_arg_refers_here); 2149 return true; 2150} 2151 2152/// \brief Check a template argument against its corresponding 2153/// non-type template parameter. 2154/// 2155/// This routine implements the semantics of C++ [temp.arg.nontype]. 2156/// It returns true if an error occurred, and false otherwise. \p 2157/// InstantiatedParamType is the type of the non-type template 2158/// parameter after it has been instantiated. 2159/// 2160/// If no error was detected, Converted receives the converted template argument. 2161bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param, 2162 QualType InstantiatedParamType, Expr *&Arg, 2163 TemplateArgument &Converted) { 2164 SourceLocation StartLoc = Arg->getSourceRange().getBegin(); 2165 2166 // If either the parameter has a dependent type or the argument is 2167 // type-dependent, there's nothing we can check now. 2168 // FIXME: Add template argument to Converted! 2169 if (InstantiatedParamType->isDependentType() || Arg->isTypeDependent()) { 2170 // FIXME: Produce a cloned, canonical expression? 2171 Converted = TemplateArgument(Arg); 2172 return false; 2173 } 2174 2175 // C++ [temp.arg.nontype]p5: 2176 // The following conversions are performed on each expression used 2177 // as a non-type template-argument. If a non-type 2178 // template-argument cannot be converted to the type of the 2179 // corresponding template-parameter then the program is 2180 // ill-formed. 2181 // 2182 // -- for a non-type template-parameter of integral or 2183 // enumeration type, integral promotions (4.5) and integral 2184 // conversions (4.7) are applied. 2185 QualType ParamType = InstantiatedParamType; 2186 QualType ArgType = Arg->getType(); 2187 if (ParamType->isIntegralType() || ParamType->isEnumeralType()) { 2188 // C++ [temp.arg.nontype]p1: 2189 // A template-argument for a non-type, non-template 2190 // template-parameter shall be one of: 2191 // 2192 // -- an integral constant-expression of integral or enumeration 2193 // type; or 2194 // -- the name of a non-type template-parameter; or 2195 SourceLocation NonConstantLoc; 2196 llvm::APSInt Value; 2197 if (!ArgType->isIntegralType() && !ArgType->isEnumeralType()) { 2198 Diag(Arg->getSourceRange().getBegin(), 2199 diag::err_template_arg_not_integral_or_enumeral) 2200 << ArgType << Arg->getSourceRange(); 2201 Diag(Param->getLocation(), diag::note_template_param_here); 2202 return true; 2203 } else if (!Arg->isValueDependent() && 2204 !Arg->isIntegerConstantExpr(Value, Context, &NonConstantLoc)) { 2205 Diag(NonConstantLoc, diag::err_template_arg_not_ice) 2206 << ArgType << Arg->getSourceRange(); 2207 return true; 2208 } 2209 2210 // FIXME: We need some way to more easily get the unqualified form 2211 // of the types without going all the way to the 2212 // canonical type. 2213 if (Context.getCanonicalType(ParamType).getCVRQualifiers()) 2214 ParamType = Context.getCanonicalType(ParamType).getUnqualifiedType(); 2215 if (Context.getCanonicalType(ArgType).getCVRQualifiers()) 2216 ArgType = Context.getCanonicalType(ArgType).getUnqualifiedType(); 2217 2218 // Try to convert the argument to the parameter's type. 2219 if (Context.hasSameType(ParamType, ArgType)) { 2220 // Okay: no conversion necessary 2221 } else if (IsIntegralPromotion(Arg, ArgType, ParamType) || 2222 !ParamType->isEnumeralType()) { 2223 // This is an integral promotion or conversion. 2224 ImpCastExprToType(Arg, ParamType, CastExpr::CK_IntegralCast); 2225 } else { 2226 // We can't perform this conversion. 2227 Diag(Arg->getSourceRange().getBegin(), 2228 diag::err_template_arg_not_convertible) 2229 << Arg->getType() << InstantiatedParamType << Arg->getSourceRange(); 2230 Diag(Param->getLocation(), diag::note_template_param_here); 2231 return true; 2232 } 2233 2234 QualType IntegerType = Context.getCanonicalType(ParamType); 2235 if (const EnumType *Enum = IntegerType->getAs<EnumType>()) 2236 IntegerType = Context.getCanonicalType(Enum->getDecl()->getIntegerType()); 2237 2238 if (!Arg->isValueDependent()) { 2239 // Check that an unsigned parameter does not receive a negative 2240 // value. 2241 if (IntegerType->isUnsignedIntegerType() 2242 && (Value.isSigned() && Value.isNegative())) { 2243 Diag(Arg->getSourceRange().getBegin(), diag::err_template_arg_negative) 2244 << Value.toString(10) << Param->getType() 2245 << Arg->getSourceRange(); 2246 Diag(Param->getLocation(), diag::note_template_param_here); 2247 return true; 2248 } 2249 2250 // Check that we don't overflow the template parameter type. 2251 unsigned AllowedBits = Context.getTypeSize(IntegerType); 2252 if (Value.getActiveBits() > AllowedBits) { 2253 Diag(Arg->getSourceRange().getBegin(), 2254 diag::err_template_arg_too_large) 2255 << Value.toString(10) << Param->getType() 2256 << Arg->getSourceRange(); 2257 Diag(Param->getLocation(), diag::note_template_param_here); 2258 return true; 2259 } 2260 2261 if (Value.getBitWidth() != AllowedBits) 2262 Value.extOrTrunc(AllowedBits); 2263 Value.setIsSigned(IntegerType->isSignedIntegerType()); 2264 } 2265 2266 // Add the value of this argument to the list of converted 2267 // arguments. We use the bitwidth and signedness of the template 2268 // parameter. 2269 if (Arg->isValueDependent()) { 2270 // The argument is value-dependent. Create a new 2271 // TemplateArgument with the converted expression. 2272 Converted = TemplateArgument(Arg); 2273 return false; 2274 } 2275 2276 Converted = TemplateArgument(Value, 2277 ParamType->isEnumeralType() ? ParamType 2278 : IntegerType); 2279 return false; 2280 } 2281 2282 // Handle pointer-to-function, reference-to-function, and 2283 // pointer-to-member-function all in (roughly) the same way. 2284 if (// -- For a non-type template-parameter of type pointer to 2285 // function, only the function-to-pointer conversion (4.3) is 2286 // applied. If the template-argument represents a set of 2287 // overloaded functions (or a pointer to such), the matching 2288 // function is selected from the set (13.4). 2289 // In C++0x, any std::nullptr_t value can be converted. 2290 (ParamType->isPointerType() && 2291 ParamType->getAs<PointerType>()->getPointeeType()->isFunctionType()) || 2292 // -- For a non-type template-parameter of type reference to 2293 // function, no conversions apply. If the template-argument 2294 // represents a set of overloaded functions, the matching 2295 // function is selected from the set (13.4). 2296 (ParamType->isReferenceType() && 2297 ParamType->getAs<ReferenceType>()->getPointeeType()->isFunctionType()) || 2298 // -- For a non-type template-parameter of type pointer to 2299 // member function, no conversions apply. If the 2300 // template-argument represents a set of overloaded member 2301 // functions, the matching member function is selected from 2302 // the set (13.4). 2303 // Again, C++0x allows a std::nullptr_t value. 2304 (ParamType->isMemberPointerType() && 2305 ParamType->getAs<MemberPointerType>()->getPointeeType() 2306 ->isFunctionType())) { 2307 if (Context.hasSameUnqualifiedType(ArgType, 2308 ParamType.getNonReferenceType())) { 2309 // We don't have to do anything: the types already match. 2310 } else if (ArgType->isNullPtrType() && (ParamType->isPointerType() || 2311 ParamType->isMemberPointerType())) { 2312 ArgType = ParamType; 2313 if (ParamType->isMemberPointerType()) 2314 ImpCastExprToType(Arg, ParamType, CastExpr::CK_NullToMemberPointer); 2315 else 2316 ImpCastExprToType(Arg, ParamType, CastExpr::CK_BitCast); 2317 } else if (ArgType->isFunctionType() && ParamType->isPointerType()) { 2318 ArgType = Context.getPointerType(ArgType); 2319 ImpCastExprToType(Arg, ArgType, CastExpr::CK_FunctionToPointerDecay); 2320 } else if (FunctionDecl *Fn 2321 = ResolveAddressOfOverloadedFunction(Arg, ParamType, true)) { 2322 if (DiagnoseUseOfDecl(Fn, Arg->getSourceRange().getBegin())) 2323 return true; 2324 2325 Arg = FixOverloadedFunctionReference(Arg, Fn); 2326 ArgType = Arg->getType(); 2327 if (ArgType->isFunctionType() && ParamType->isPointerType()) { 2328 ArgType = Context.getPointerType(Arg->getType()); 2329 ImpCastExprToType(Arg, ArgType, CastExpr::CK_FunctionToPointerDecay); 2330 } 2331 } 2332 2333 if (!Context.hasSameUnqualifiedType(ArgType, 2334 ParamType.getNonReferenceType())) { 2335 // We can't perform this conversion. 2336 Diag(Arg->getSourceRange().getBegin(), 2337 diag::err_template_arg_not_convertible) 2338 << Arg->getType() << InstantiatedParamType << Arg->getSourceRange(); 2339 Diag(Param->getLocation(), diag::note_template_param_here); 2340 return true; 2341 } 2342 2343 if (ParamType->isMemberPointerType()) { 2344 NamedDecl *Member = 0; 2345 if (CheckTemplateArgumentPointerToMember(Arg, Member)) 2346 return true; 2347 2348 if (Member) 2349 Member = cast<NamedDecl>(Member->getCanonicalDecl()); 2350 Converted = TemplateArgument(Member); 2351 return false; 2352 } 2353 2354 NamedDecl *Entity = 0; 2355 if (CheckTemplateArgumentAddressOfObjectOrFunction(Arg, Entity)) 2356 return true; 2357 2358 if (Entity) 2359 Entity = cast<NamedDecl>(Entity->getCanonicalDecl()); 2360 Converted = TemplateArgument(Entity); 2361 return false; 2362 } 2363 2364 if (ParamType->isPointerType()) { 2365 // -- for a non-type template-parameter of type pointer to 2366 // object, qualification conversions (4.4) and the 2367 // array-to-pointer conversion (4.2) are applied. 2368 // C++0x also allows a value of std::nullptr_t. 2369 assert(ParamType->getAs<PointerType>()->getPointeeType()->isObjectType() && 2370 "Only object pointers allowed here"); 2371 2372 if (ArgType->isNullPtrType()) { 2373 ArgType = ParamType; 2374 ImpCastExprToType(Arg, ParamType, CastExpr::CK_BitCast); 2375 } else if (ArgType->isArrayType()) { 2376 ArgType = Context.getArrayDecayedType(ArgType); 2377 ImpCastExprToType(Arg, ArgType, CastExpr::CK_ArrayToPointerDecay); 2378 } 2379 2380 if (IsQualificationConversion(ArgType, ParamType)) { 2381 ArgType = ParamType; 2382 ImpCastExprToType(Arg, ParamType, CastExpr::CK_NoOp); 2383 } 2384 2385 if (!Context.hasSameUnqualifiedType(ArgType, ParamType)) { 2386 // We can't perform this conversion. 2387 Diag(Arg->getSourceRange().getBegin(), 2388 diag::err_template_arg_not_convertible) 2389 << Arg->getType() << InstantiatedParamType << Arg->getSourceRange(); 2390 Diag(Param->getLocation(), diag::note_template_param_here); 2391 return true; 2392 } 2393 2394 NamedDecl *Entity = 0; 2395 if (CheckTemplateArgumentAddressOfObjectOrFunction(Arg, Entity)) 2396 return true; 2397 2398 if (Entity) 2399 Entity = cast<NamedDecl>(Entity->getCanonicalDecl()); 2400 Converted = TemplateArgument(Entity); 2401 return false; 2402 } 2403 2404 if (const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>()) { 2405 // -- For a non-type template-parameter of type reference to 2406 // object, no conversions apply. The type referred to by the 2407 // reference may be more cv-qualified than the (otherwise 2408 // identical) type of the template-argument. The 2409 // template-parameter is bound directly to the 2410 // template-argument, which must be an lvalue. 2411 assert(ParamRefType->getPointeeType()->isObjectType() && 2412 "Only object references allowed here"); 2413 2414 if (!Context.hasSameUnqualifiedType(ParamRefType->getPointeeType(), ArgType)) { 2415 Diag(Arg->getSourceRange().getBegin(), 2416 diag::err_template_arg_no_ref_bind) 2417 << InstantiatedParamType << Arg->getType() 2418 << Arg->getSourceRange(); 2419 Diag(Param->getLocation(), diag::note_template_param_here); 2420 return true; 2421 } 2422 2423 unsigned ParamQuals 2424 = Context.getCanonicalType(ParamType).getCVRQualifiers(); 2425 unsigned ArgQuals = Context.getCanonicalType(ArgType).getCVRQualifiers(); 2426 2427 if ((ParamQuals | ArgQuals) != ParamQuals) { 2428 Diag(Arg->getSourceRange().getBegin(), 2429 diag::err_template_arg_ref_bind_ignores_quals) 2430 << InstantiatedParamType << Arg->getType() 2431 << Arg->getSourceRange(); 2432 Diag(Param->getLocation(), diag::note_template_param_here); 2433 return true; 2434 } 2435 2436 NamedDecl *Entity = 0; 2437 if (CheckTemplateArgumentAddressOfObjectOrFunction(Arg, Entity)) 2438 return true; 2439 2440 Entity = cast<NamedDecl>(Entity->getCanonicalDecl()); 2441 Converted = TemplateArgument(Entity); 2442 return false; 2443 } 2444 2445 // -- For a non-type template-parameter of type pointer to data 2446 // member, qualification conversions (4.4) are applied. 2447 // C++0x allows std::nullptr_t values. 2448 assert(ParamType->isMemberPointerType() && "Only pointers to members remain"); 2449 2450 if (Context.hasSameUnqualifiedType(ParamType, ArgType)) { 2451 // Types match exactly: nothing more to do here. 2452 } else if (ArgType->isNullPtrType()) { 2453 ImpCastExprToType(Arg, ParamType, CastExpr::CK_NullToMemberPointer); 2454 } else if (IsQualificationConversion(ArgType, ParamType)) { 2455 ImpCastExprToType(Arg, ParamType, CastExpr::CK_NoOp); 2456 } else { 2457 // We can't perform this conversion. 2458 Diag(Arg->getSourceRange().getBegin(), 2459 diag::err_template_arg_not_convertible) 2460 << Arg->getType() << InstantiatedParamType << Arg->getSourceRange(); 2461 Diag(Param->getLocation(), diag::note_template_param_here); 2462 return true; 2463 } 2464 2465 NamedDecl *Member = 0; 2466 if (CheckTemplateArgumentPointerToMember(Arg, Member)) 2467 return true; 2468 2469 if (Member) 2470 Member = cast<NamedDecl>(Member->getCanonicalDecl()); 2471 Converted = TemplateArgument(Member); 2472 return false; 2473} 2474 2475/// \brief Check a template argument against its corresponding 2476/// template template parameter. 2477/// 2478/// This routine implements the semantics of C++ [temp.arg.template]. 2479/// It returns true if an error occurred, and false otherwise. 2480bool Sema::CheckTemplateArgument(TemplateTemplateParmDecl *Param, 2481 const TemplateArgumentLoc &Arg) { 2482 TemplateName Name = Arg.getArgument().getAsTemplate(); 2483 TemplateDecl *Template = Name.getAsTemplateDecl(); 2484 if (!Template) { 2485 // Any dependent template name is fine. 2486 assert(Name.isDependent() && "Non-dependent template isn't a declaration?"); 2487 return false; 2488 } 2489 2490 // C++ [temp.arg.template]p1: 2491 // A template-argument for a template template-parameter shall be 2492 // the name of a class template, expressed as id-expression. Only 2493 // primary class templates are considered when matching the 2494 // template template argument with the corresponding parameter; 2495 // partial specializations are not considered even if their 2496 // parameter lists match that of the template template parameter. 2497 // 2498 // Note that we also allow template template parameters here, which 2499 // will happen when we are dealing with, e.g., class template 2500 // partial specializations. 2501 if (!isa<ClassTemplateDecl>(Template) && 2502 !isa<TemplateTemplateParmDecl>(Template)) { 2503 assert(isa<FunctionTemplateDecl>(Template) && 2504 "Only function templates are possible here"); 2505 Diag(Arg.getLocation(), diag::err_template_arg_not_class_template); 2506 Diag(Template->getLocation(), diag::note_template_arg_refers_here_func) 2507 << Template; 2508 } 2509 2510 return !TemplateParameterListsAreEqual(Template->getTemplateParameters(), 2511 Param->getTemplateParameters(), 2512 true, true, 2513 Arg.getLocation()); 2514} 2515 2516/// \brief Determine whether the given template parameter lists are 2517/// equivalent. 2518/// 2519/// \param New The new template parameter list, typically written in the 2520/// source code as part of a new template declaration. 2521/// 2522/// \param Old The old template parameter list, typically found via 2523/// name lookup of the template declared with this template parameter 2524/// list. 2525/// 2526/// \param Complain If true, this routine will produce a diagnostic if 2527/// the template parameter lists are not equivalent. 2528/// 2529/// \param IsTemplateTemplateParm If true, this routine is being 2530/// called to compare the template parameter lists of a template 2531/// template parameter. 2532/// 2533/// \param TemplateArgLoc If this source location is valid, then we 2534/// are actually checking the template parameter list of a template 2535/// argument (New) against the template parameter list of its 2536/// corresponding template template parameter (Old). We produce 2537/// slightly different diagnostics in this scenario. 2538/// 2539/// \returns True if the template parameter lists are equal, false 2540/// otherwise. 2541bool 2542Sema::TemplateParameterListsAreEqual(TemplateParameterList *New, 2543 TemplateParameterList *Old, 2544 bool Complain, 2545 bool IsTemplateTemplateParm, 2546 SourceLocation TemplateArgLoc) { 2547 if (Old->size() != New->size()) { 2548 if (Complain) { 2549 unsigned NextDiag = diag::err_template_param_list_different_arity; 2550 if (TemplateArgLoc.isValid()) { 2551 Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch); 2552 NextDiag = diag::note_template_param_list_different_arity; 2553 } 2554 Diag(New->getTemplateLoc(), NextDiag) 2555 << (New->size() > Old->size()) 2556 << IsTemplateTemplateParm 2557 << SourceRange(New->getTemplateLoc(), New->getRAngleLoc()); 2558 Diag(Old->getTemplateLoc(), diag::note_template_prev_declaration) 2559 << IsTemplateTemplateParm 2560 << SourceRange(Old->getTemplateLoc(), Old->getRAngleLoc()); 2561 } 2562 2563 return false; 2564 } 2565 2566 for (TemplateParameterList::iterator OldParm = Old->begin(), 2567 OldParmEnd = Old->end(), NewParm = New->begin(); 2568 OldParm != OldParmEnd; ++OldParm, ++NewParm) { 2569 if ((*OldParm)->getKind() != (*NewParm)->getKind()) { 2570 if (Complain) { 2571 unsigned NextDiag = diag::err_template_param_different_kind; 2572 if (TemplateArgLoc.isValid()) { 2573 Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch); 2574 NextDiag = diag::note_template_param_different_kind; 2575 } 2576 Diag((*NewParm)->getLocation(), NextDiag) 2577 << IsTemplateTemplateParm; 2578 Diag((*OldParm)->getLocation(), diag::note_template_prev_declaration) 2579 << IsTemplateTemplateParm; 2580 } 2581 return false; 2582 } 2583 2584 if (isa<TemplateTypeParmDecl>(*OldParm)) { 2585 // Okay; all template type parameters are equivalent (since we 2586 // know we're at the same index). 2587 } else if (NonTypeTemplateParmDecl *OldNTTP 2588 = dyn_cast<NonTypeTemplateParmDecl>(*OldParm)) { 2589 // The types of non-type template parameters must agree. 2590 NonTypeTemplateParmDecl *NewNTTP 2591 = cast<NonTypeTemplateParmDecl>(*NewParm); 2592 if (Context.getCanonicalType(OldNTTP->getType()) != 2593 Context.getCanonicalType(NewNTTP->getType())) { 2594 if (Complain) { 2595 unsigned NextDiag = diag::err_template_nontype_parm_different_type; 2596 if (TemplateArgLoc.isValid()) { 2597 Diag(TemplateArgLoc, 2598 diag::err_template_arg_template_params_mismatch); 2599 NextDiag = diag::note_template_nontype_parm_different_type; 2600 } 2601 Diag(NewNTTP->getLocation(), NextDiag) 2602 << NewNTTP->getType() 2603 << IsTemplateTemplateParm; 2604 Diag(OldNTTP->getLocation(), 2605 diag::note_template_nontype_parm_prev_declaration) 2606 << OldNTTP->getType(); 2607 } 2608 return false; 2609 } 2610 assert(OldNTTP->getDepth() == NewNTTP->getDepth() && 2611 "Non-type template parameter depth mismatch"); 2612 assert(OldNTTP->getPosition() == NewNTTP->getPosition() && 2613 "Non-type template parameter position mismatch"); 2614 } else { 2615 // The template parameter lists of template template 2616 // parameters must agree. 2617 assert(isa<TemplateTemplateParmDecl>(*OldParm) && 2618 "Only template template parameters handled here"); 2619 TemplateTemplateParmDecl *OldTTP 2620 = cast<TemplateTemplateParmDecl>(*OldParm); 2621 TemplateTemplateParmDecl *NewTTP 2622 = cast<TemplateTemplateParmDecl>(*NewParm); 2623 if (!TemplateParameterListsAreEqual(NewTTP->getTemplateParameters(), 2624 OldTTP->getTemplateParameters(), 2625 Complain, 2626 /*IsTemplateTemplateParm=*/true, 2627 TemplateArgLoc)) 2628 return false; 2629 2630 assert(OldTTP->getDepth() == NewTTP->getDepth() && 2631 "Template template parameter depth mismatch"); 2632 assert(OldTTP->getPosition() == NewTTP->getPosition() && 2633 "Template template parameter position mismatch"); 2634 } 2635 } 2636 2637 return true; 2638} 2639 2640/// \brief Check whether a template can be declared within this scope. 2641/// 2642/// If the template declaration is valid in this scope, returns 2643/// false. Otherwise, issues a diagnostic and returns true. 2644bool 2645Sema::CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams) { 2646 // Find the nearest enclosing declaration scope. 2647 while ((S->getFlags() & Scope::DeclScope) == 0 || 2648 (S->getFlags() & Scope::TemplateParamScope) != 0) 2649 S = S->getParent(); 2650 2651 // C++ [temp]p2: 2652 // A template-declaration can appear only as a namespace scope or 2653 // class scope declaration. 2654 DeclContext *Ctx = static_cast<DeclContext *>(S->getEntity()); 2655 if (Ctx && isa<LinkageSpecDecl>(Ctx) && 2656 cast<LinkageSpecDecl>(Ctx)->getLanguage() != LinkageSpecDecl::lang_cxx) 2657 return Diag(TemplateParams->getTemplateLoc(), diag::err_template_linkage) 2658 << TemplateParams->getSourceRange(); 2659 2660 while (Ctx && isa<LinkageSpecDecl>(Ctx)) 2661 Ctx = Ctx->getParent(); 2662 2663 if (Ctx && (Ctx->isFileContext() || Ctx->isRecord())) 2664 return false; 2665 2666 return Diag(TemplateParams->getTemplateLoc(), 2667 diag::err_template_outside_namespace_or_class_scope) 2668 << TemplateParams->getSourceRange(); 2669} 2670 2671/// \brief Determine what kind of template specialization the given declaration 2672/// is. 2673static TemplateSpecializationKind getTemplateSpecializationKind(NamedDecl *D) { 2674 if (!D) 2675 return TSK_Undeclared; 2676 2677 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) 2678 return Record->getTemplateSpecializationKind(); 2679 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) 2680 return Function->getTemplateSpecializationKind(); 2681 if (VarDecl *Var = dyn_cast<VarDecl>(D)) 2682 return Var->getTemplateSpecializationKind(); 2683 2684 return TSK_Undeclared; 2685} 2686 2687/// \brief Check whether a specialization is well-formed in the current 2688/// context. 2689/// 2690/// This routine determines whether a template specialization can be declared 2691/// in the current context (C++ [temp.expl.spec]p2). 2692/// 2693/// \param S the semantic analysis object for which this check is being 2694/// performed. 2695/// 2696/// \param Specialized the entity being specialized or instantiated, which 2697/// may be a kind of template (class template, function template, etc.) or 2698/// a member of a class template (member function, static data member, 2699/// member class). 2700/// 2701/// \param PrevDecl the previous declaration of this entity, if any. 2702/// 2703/// \param Loc the location of the explicit specialization or instantiation of 2704/// this entity. 2705/// 2706/// \param IsPartialSpecialization whether this is a partial specialization of 2707/// a class template. 2708/// 2709/// \returns true if there was an error that we cannot recover from, false 2710/// otherwise. 2711static bool CheckTemplateSpecializationScope(Sema &S, 2712 NamedDecl *Specialized, 2713 NamedDecl *PrevDecl, 2714 SourceLocation Loc, 2715 bool IsPartialSpecialization) { 2716 // Keep these "kind" numbers in sync with the %select statements in the 2717 // various diagnostics emitted by this routine. 2718 int EntityKind = 0; 2719 bool isTemplateSpecialization = false; 2720 if (isa<ClassTemplateDecl>(Specialized)) { 2721 EntityKind = IsPartialSpecialization? 1 : 0; 2722 isTemplateSpecialization = true; 2723 } else if (isa<FunctionTemplateDecl>(Specialized)) { 2724 EntityKind = 2; 2725 isTemplateSpecialization = true; 2726 } else if (isa<CXXMethodDecl>(Specialized)) 2727 EntityKind = 3; 2728 else if (isa<VarDecl>(Specialized)) 2729 EntityKind = 4; 2730 else if (isa<RecordDecl>(Specialized)) 2731 EntityKind = 5; 2732 else { 2733 S.Diag(Loc, diag::err_template_spec_unknown_kind); 2734 S.Diag(Specialized->getLocation(), diag::note_specialized_entity); 2735 return true; 2736 } 2737 2738 // C++ [temp.expl.spec]p2: 2739 // An explicit specialization shall be declared in the namespace 2740 // of which the template is a member, or, for member templates, in 2741 // the namespace of which the enclosing class or enclosing class 2742 // template is a member. An explicit specialization of a member 2743 // function, member class or static data member of a class 2744 // template shall be declared in the namespace of which the class 2745 // template is a member. Such a declaration may also be a 2746 // definition. If the declaration is not a definition, the 2747 // specialization may be defined later in the name- space in which 2748 // the explicit specialization was declared, or in a namespace 2749 // that encloses the one in which the explicit specialization was 2750 // declared. 2751 if (S.CurContext->getLookupContext()->isFunctionOrMethod()) { 2752 S.Diag(Loc, diag::err_template_spec_decl_function_scope) 2753 << Specialized; 2754 return true; 2755 } 2756 2757 if (S.CurContext->isRecord() && !IsPartialSpecialization) { 2758 S.Diag(Loc, diag::err_template_spec_decl_class_scope) 2759 << Specialized; 2760 return true; 2761 } 2762 2763 // C++ [temp.class.spec]p6: 2764 // A class template partial specialization may be declared or redeclared 2765 // in any namespace scope in which its definition may be defined (14.5.1 2766 // and 14.5.2). 2767 bool ComplainedAboutScope = false; 2768 DeclContext *SpecializedContext 2769 = Specialized->getDeclContext()->getEnclosingNamespaceContext(); 2770 DeclContext *DC = S.CurContext->getEnclosingNamespaceContext(); 2771 if ((!PrevDecl || 2772 getTemplateSpecializationKind(PrevDecl) == TSK_Undeclared || 2773 getTemplateSpecializationKind(PrevDecl) == TSK_ImplicitInstantiation)){ 2774 // There is no prior declaration of this entity, so this 2775 // specialization must be in the same context as the template 2776 // itself. 2777 if (!DC->Equals(SpecializedContext)) { 2778 if (isa<TranslationUnitDecl>(SpecializedContext)) 2779 S.Diag(Loc, diag::err_template_spec_decl_out_of_scope_global) 2780 << EntityKind << Specialized; 2781 else if (isa<NamespaceDecl>(SpecializedContext)) 2782 S.Diag(Loc, diag::err_template_spec_decl_out_of_scope) 2783 << EntityKind << Specialized 2784 << cast<NamedDecl>(SpecializedContext); 2785 2786 S.Diag(Specialized->getLocation(), diag::note_specialized_entity); 2787 ComplainedAboutScope = true; 2788 } 2789 } 2790 2791 // Make sure that this redeclaration (or definition) occurs in an enclosing 2792 // namespace. 2793 // Note that HandleDeclarator() performs this check for explicit 2794 // specializations of function templates, static data members, and member 2795 // functions, so we skip the check here for those kinds of entities. 2796 // FIXME: HandleDeclarator's diagnostics aren't quite as good, though. 2797 // Should we refactor that check, so that it occurs later? 2798 if (!ComplainedAboutScope && !DC->Encloses(SpecializedContext) && 2799 !(isa<FunctionTemplateDecl>(Specialized) || isa<VarDecl>(Specialized) || 2800 isa<FunctionDecl>(Specialized))) { 2801 if (isa<TranslationUnitDecl>(SpecializedContext)) 2802 S.Diag(Loc, diag::err_template_spec_redecl_global_scope) 2803 << EntityKind << Specialized; 2804 else if (isa<NamespaceDecl>(SpecializedContext)) 2805 S.Diag(Loc, diag::err_template_spec_redecl_out_of_scope) 2806 << EntityKind << Specialized 2807 << cast<NamedDecl>(SpecializedContext); 2808 2809 S.Diag(Specialized->getLocation(), diag::note_specialized_entity); 2810 } 2811 2812 // FIXME: check for specialization-after-instantiation errors and such. 2813 2814 return false; 2815} 2816 2817/// \brief Check the non-type template arguments of a class template 2818/// partial specialization according to C++ [temp.class.spec]p9. 2819/// 2820/// \param TemplateParams the template parameters of the primary class 2821/// template. 2822/// 2823/// \param TemplateArg the template arguments of the class template 2824/// partial specialization. 2825/// 2826/// \param MirrorsPrimaryTemplate will be set true if the class 2827/// template partial specialization arguments are identical to the 2828/// implicit template arguments of the primary template. This is not 2829/// necessarily an error (C++0x), and it is left to the caller to diagnose 2830/// this condition when it is an error. 2831/// 2832/// \returns true if there was an error, false otherwise. 2833bool Sema::CheckClassTemplatePartialSpecializationArgs( 2834 TemplateParameterList *TemplateParams, 2835 const TemplateArgumentListBuilder &TemplateArgs, 2836 bool &MirrorsPrimaryTemplate) { 2837 // FIXME: the interface to this function will have to change to 2838 // accommodate variadic templates. 2839 MirrorsPrimaryTemplate = true; 2840 2841 const TemplateArgument *ArgList = TemplateArgs.getFlatArguments(); 2842 2843 for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) { 2844 // Determine whether the template argument list of the partial 2845 // specialization is identical to the implicit argument list of 2846 // the primary template. The caller may need to diagnostic this as 2847 // an error per C++ [temp.class.spec]p9b3. 2848 if (MirrorsPrimaryTemplate) { 2849 if (TemplateTypeParmDecl *TTP 2850 = dyn_cast<TemplateTypeParmDecl>(TemplateParams->getParam(I))) { 2851 if (Context.getCanonicalType(Context.getTypeDeclType(TTP)) != 2852 Context.getCanonicalType(ArgList[I].getAsType())) 2853 MirrorsPrimaryTemplate = false; 2854 } else if (TemplateTemplateParmDecl *TTP 2855 = dyn_cast<TemplateTemplateParmDecl>( 2856 TemplateParams->getParam(I))) { 2857 TemplateName Name = ArgList[I].getAsTemplate(); 2858 TemplateTemplateParmDecl *ArgDecl 2859 = dyn_cast_or_null<TemplateTemplateParmDecl>(Name.getAsTemplateDecl()); 2860 if (!ArgDecl || 2861 ArgDecl->getIndex() != TTP->getIndex() || 2862 ArgDecl->getDepth() != TTP->getDepth()) 2863 MirrorsPrimaryTemplate = false; 2864 } 2865 } 2866 2867 NonTypeTemplateParmDecl *Param 2868 = dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->getParam(I)); 2869 if (!Param) { 2870 continue; 2871 } 2872 2873 Expr *ArgExpr = ArgList[I].getAsExpr(); 2874 if (!ArgExpr) { 2875 MirrorsPrimaryTemplate = false; 2876 continue; 2877 } 2878 2879 // C++ [temp.class.spec]p8: 2880 // A non-type argument is non-specialized if it is the name of a 2881 // non-type parameter. All other non-type arguments are 2882 // specialized. 2883 // 2884 // Below, we check the two conditions that only apply to 2885 // specialized non-type arguments, so skip any non-specialized 2886 // arguments. 2887 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ArgExpr)) 2888 if (NonTypeTemplateParmDecl *NTTP 2889 = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl())) { 2890 if (MirrorsPrimaryTemplate && 2891 (Param->getIndex() != NTTP->getIndex() || 2892 Param->getDepth() != NTTP->getDepth())) 2893 MirrorsPrimaryTemplate = false; 2894 2895 continue; 2896 } 2897 2898 // C++ [temp.class.spec]p9: 2899 // Within the argument list of a class template partial 2900 // specialization, the following restrictions apply: 2901 // -- A partially specialized non-type argument expression 2902 // shall not involve a template parameter of the partial 2903 // specialization except when the argument expression is a 2904 // simple identifier. 2905 if (ArgExpr->isTypeDependent() || ArgExpr->isValueDependent()) { 2906 Diag(ArgExpr->getLocStart(), 2907 diag::err_dependent_non_type_arg_in_partial_spec) 2908 << ArgExpr->getSourceRange(); 2909 return true; 2910 } 2911 2912 // -- The type of a template parameter corresponding to a 2913 // specialized non-type argument shall not be dependent on a 2914 // parameter of the specialization. 2915 if (Param->getType()->isDependentType()) { 2916 Diag(ArgExpr->getLocStart(), 2917 diag::err_dependent_typed_non_type_arg_in_partial_spec) 2918 << Param->getType() 2919 << ArgExpr->getSourceRange(); 2920 Diag(Param->getLocation(), diag::note_template_param_here); 2921 return true; 2922 } 2923 2924 MirrorsPrimaryTemplate = false; 2925 } 2926 2927 return false; 2928} 2929 2930Sema::DeclResult 2931Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, 2932 TagUseKind TUK, 2933 SourceLocation KWLoc, 2934 const CXXScopeSpec &SS, 2935 TemplateTy TemplateD, 2936 SourceLocation TemplateNameLoc, 2937 SourceLocation LAngleLoc, 2938 ASTTemplateArgsPtr TemplateArgsIn, 2939 SourceLocation RAngleLoc, 2940 AttributeList *Attr, 2941 MultiTemplateParamsArg TemplateParameterLists) { 2942 assert(TUK != TUK_Reference && "References are not specializations"); 2943 2944 // Find the class template we're specializing 2945 TemplateName Name = TemplateD.getAsVal<TemplateName>(); 2946 ClassTemplateDecl *ClassTemplate 2947 = cast<ClassTemplateDecl>(Name.getAsTemplateDecl()); 2948 2949 bool isExplicitSpecialization = false; 2950 bool isPartialSpecialization = false; 2951 2952 // Check the validity of the template headers that introduce this 2953 // template. 2954 // FIXME: We probably shouldn't complain about these headers for 2955 // friend declarations. 2956 TemplateParameterList *TemplateParams 2957 = MatchTemplateParametersToScopeSpecifier(TemplateNameLoc, SS, 2958 (TemplateParameterList**)TemplateParameterLists.get(), 2959 TemplateParameterLists.size(), 2960 isExplicitSpecialization); 2961 if (TemplateParams && TemplateParams->size() > 0) { 2962 isPartialSpecialization = true; 2963 2964 // C++ [temp.class.spec]p10: 2965 // The template parameter list of a specialization shall not 2966 // contain default template argument values. 2967 for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) { 2968 Decl *Param = TemplateParams->getParam(I); 2969 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) { 2970 if (TTP->hasDefaultArgument()) { 2971 Diag(TTP->getDefaultArgumentLoc(), 2972 diag::err_default_arg_in_partial_spec); 2973 TTP->removeDefaultArgument(); 2974 } 2975 } else if (NonTypeTemplateParmDecl *NTTP 2976 = dyn_cast<NonTypeTemplateParmDecl>(Param)) { 2977 if (Expr *DefArg = NTTP->getDefaultArgument()) { 2978 Diag(NTTP->getDefaultArgumentLoc(), 2979 diag::err_default_arg_in_partial_spec) 2980 << DefArg->getSourceRange(); 2981 NTTP->setDefaultArgument(0); 2982 DefArg->Destroy(Context); 2983 } 2984 } else { 2985 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(Param); 2986 if (TTP->hasDefaultArgument()) { 2987 Diag(TTP->getDefaultArgument().getLocation(), 2988 diag::err_default_arg_in_partial_spec) 2989 << TTP->getDefaultArgument().getSourceRange(); 2990 TTP->setDefaultArgument(TemplateArgumentLoc()); 2991 } 2992 } 2993 } 2994 } else if (TemplateParams) { 2995 if (TUK == TUK_Friend) 2996 Diag(KWLoc, diag::err_template_spec_friend) 2997 << CodeModificationHint::CreateRemoval( 2998 SourceRange(TemplateParams->getTemplateLoc(), 2999 TemplateParams->getRAngleLoc())) 3000 << SourceRange(LAngleLoc, RAngleLoc); 3001 else 3002 isExplicitSpecialization = true; 3003 } else if (TUK != TUK_Friend) { 3004 Diag(KWLoc, diag::err_template_spec_needs_header) 3005 << CodeModificationHint::CreateInsertion(KWLoc, "template<> "); 3006 isExplicitSpecialization = true; 3007 } 3008 3009 // Check that the specialization uses the same tag kind as the 3010 // original template. 3011 TagDecl::TagKind Kind; 3012 switch (TagSpec) { 3013 default: assert(0 && "Unknown tag type!"); 3014 case DeclSpec::TST_struct: Kind = TagDecl::TK_struct; break; 3015 case DeclSpec::TST_union: Kind = TagDecl::TK_union; break; 3016 case DeclSpec::TST_class: Kind = TagDecl::TK_class; break; 3017 } 3018 if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(), 3019 Kind, KWLoc, 3020 *ClassTemplate->getIdentifier())) { 3021 Diag(KWLoc, diag::err_use_with_wrong_tag) 3022 << ClassTemplate 3023 << CodeModificationHint::CreateReplacement(KWLoc, 3024 ClassTemplate->getTemplatedDecl()->getKindName()); 3025 Diag(ClassTemplate->getTemplatedDecl()->getLocation(), 3026 diag::note_previous_use); 3027 Kind = ClassTemplate->getTemplatedDecl()->getTagKind(); 3028 } 3029 3030 // Translate the parser's template argument list in our AST format. 3031 llvm::SmallVector<TemplateArgumentLoc, 16> TemplateArgs; 3032 translateTemplateArguments(TemplateArgsIn, TemplateArgs); 3033 3034 // Check that the template argument list is well-formed for this 3035 // template. 3036 TemplateArgumentListBuilder Converted(ClassTemplate->getTemplateParameters(), 3037 TemplateArgs.size()); 3038 if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc, LAngleLoc, 3039 TemplateArgs.data(), TemplateArgs.size(), 3040 RAngleLoc, false, Converted)) 3041 return true; 3042 3043 assert((Converted.structuredSize() == 3044 ClassTemplate->getTemplateParameters()->size()) && 3045 "Converted template argument list is too short!"); 3046 3047 // Find the class template (partial) specialization declaration that 3048 // corresponds to these arguments. 3049 llvm::FoldingSetNodeID ID; 3050 if (isPartialSpecialization) { 3051 bool MirrorsPrimaryTemplate; 3052 if (CheckClassTemplatePartialSpecializationArgs( 3053 ClassTemplate->getTemplateParameters(), 3054 Converted, MirrorsPrimaryTemplate)) 3055 return true; 3056 3057 if (MirrorsPrimaryTemplate) { 3058 // C++ [temp.class.spec]p9b3: 3059 // 3060 // -- The argument list of the specialization shall not be identical 3061 // to the implicit argument list of the primary template. 3062 Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template) 3063 << (TUK == TUK_Definition) 3064 << CodeModificationHint::CreateRemoval(SourceRange(LAngleLoc, 3065 RAngleLoc)); 3066 return CheckClassTemplate(S, TagSpec, TUK, KWLoc, SS, 3067 ClassTemplate->getIdentifier(), 3068 TemplateNameLoc, 3069 Attr, 3070 TemplateParams, 3071 AS_none); 3072 } 3073 3074 // FIXME: Diagnose friend partial specializations 3075 3076 // FIXME: Template parameter list matters, too 3077 ClassTemplatePartialSpecializationDecl::Profile(ID, 3078 Converted.getFlatArguments(), 3079 Converted.flatSize(), 3080 Context); 3081 } else 3082 ClassTemplateSpecializationDecl::Profile(ID, 3083 Converted.getFlatArguments(), 3084 Converted.flatSize(), 3085 Context); 3086 void *InsertPos = 0; 3087 ClassTemplateSpecializationDecl *PrevDecl = 0; 3088 3089 if (isPartialSpecialization) 3090 PrevDecl 3091 = ClassTemplate->getPartialSpecializations().FindNodeOrInsertPos(ID, 3092 InsertPos); 3093 else 3094 PrevDecl 3095 = ClassTemplate->getSpecializations().FindNodeOrInsertPos(ID, InsertPos); 3096 3097 ClassTemplateSpecializationDecl *Specialization = 0; 3098 3099 // Check whether we can declare a class template specialization in 3100 // the current scope. 3101 if (TUK != TUK_Friend && 3102 CheckTemplateSpecializationScope(*this, ClassTemplate, PrevDecl, 3103 TemplateNameLoc, 3104 isPartialSpecialization)) 3105 return true; 3106 3107 // The canonical type 3108 QualType CanonType; 3109 if (PrevDecl && 3110 (PrevDecl->getSpecializationKind() == TSK_Undeclared || 3111 TUK == TUK_Friend)) { 3112 // Since the only prior class template specialization with these 3113 // arguments was referenced but not declared, or we're only 3114 // referencing this specialization as a friend, reuse that 3115 // declaration node as our own, updating its source location to 3116 // reflect our new declaration. 3117 Specialization = PrevDecl; 3118 Specialization->setLocation(TemplateNameLoc); 3119 PrevDecl = 0; 3120 CanonType = Context.getTypeDeclType(Specialization); 3121 } else if (isPartialSpecialization) { 3122 // Build the canonical type that describes the converted template 3123 // arguments of the class template partial specialization. 3124 CanonType = Context.getTemplateSpecializationType( 3125 TemplateName(ClassTemplate), 3126 Converted.getFlatArguments(), 3127 Converted.flatSize()); 3128 3129 // Create a new class template partial specialization declaration node. 3130 ClassTemplatePartialSpecializationDecl *PrevPartial 3131 = cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl); 3132 ClassTemplatePartialSpecializationDecl *Partial 3133 = ClassTemplatePartialSpecializationDecl::Create(Context, 3134 ClassTemplate->getDeclContext(), 3135 TemplateNameLoc, 3136 TemplateParams, 3137 ClassTemplate, 3138 Converted, 3139 TemplateArgs.data(), 3140 TemplateArgs.size(), 3141 PrevPartial); 3142 3143 if (PrevPartial) { 3144 ClassTemplate->getPartialSpecializations().RemoveNode(PrevPartial); 3145 ClassTemplate->getPartialSpecializations().GetOrInsertNode(Partial); 3146 } else { 3147 ClassTemplate->getPartialSpecializations().InsertNode(Partial, InsertPos); 3148 } 3149 Specialization = Partial; 3150 3151 // If we are providing an explicit specialization of a member class 3152 // template specialization, make a note of that. 3153 if (PrevPartial && PrevPartial->getInstantiatedFromMember()) 3154 PrevPartial->setMemberSpecialization(); 3155 3156 // Check that all of the template parameters of the class template 3157 // partial specialization are deducible from the template 3158 // arguments. If not, this class template partial specialization 3159 // will never be used. 3160 llvm::SmallVector<bool, 8> DeducibleParams; 3161 DeducibleParams.resize(TemplateParams->size()); 3162 MarkUsedTemplateParameters(Partial->getTemplateArgs(), true, 3163 TemplateParams->getDepth(), 3164 DeducibleParams); 3165 unsigned NumNonDeducible = 0; 3166 for (unsigned I = 0, N = DeducibleParams.size(); I != N; ++I) 3167 if (!DeducibleParams[I]) 3168 ++NumNonDeducible; 3169 3170 if (NumNonDeducible) { 3171 Diag(TemplateNameLoc, diag::warn_partial_specs_not_deducible) 3172 << (NumNonDeducible > 1) 3173 << SourceRange(TemplateNameLoc, RAngleLoc); 3174 for (unsigned I = 0, N = DeducibleParams.size(); I != N; ++I) { 3175 if (!DeducibleParams[I]) { 3176 NamedDecl *Param = cast<NamedDecl>(TemplateParams->getParam(I)); 3177 if (Param->getDeclName()) 3178 Diag(Param->getLocation(), 3179 diag::note_partial_spec_unused_parameter) 3180 << Param->getDeclName(); 3181 else 3182 Diag(Param->getLocation(), 3183 diag::note_partial_spec_unused_parameter) 3184 << std::string("<anonymous>"); 3185 } 3186 } 3187 } 3188 } else { 3189 // Create a new class template specialization declaration node for 3190 // this explicit specialization or friend declaration. 3191 Specialization 3192 = ClassTemplateSpecializationDecl::Create(Context, 3193 ClassTemplate->getDeclContext(), 3194 TemplateNameLoc, 3195 ClassTemplate, 3196 Converted, 3197 PrevDecl); 3198 3199 if (PrevDecl) { 3200 ClassTemplate->getSpecializations().RemoveNode(PrevDecl); 3201 ClassTemplate->getSpecializations().GetOrInsertNode(Specialization); 3202 } else { 3203 ClassTemplate->getSpecializations().InsertNode(Specialization, 3204 InsertPos); 3205 } 3206 3207 CanonType = Context.getTypeDeclType(Specialization); 3208 } 3209 3210 // C++ [temp.expl.spec]p6: 3211 // If a template, a member template or the member of a class template is 3212 // explicitly specialized then that specialization shall be declared 3213 // before the first use of that specialization that would cause an implicit 3214 // instantiation to take place, in every translation unit in which such a 3215 // use occurs; no diagnostic is required. 3216 if (PrevDecl && PrevDecl->getPointOfInstantiation().isValid()) { 3217 SourceRange Range(TemplateNameLoc, RAngleLoc); 3218 Diag(TemplateNameLoc, diag::err_specialization_after_instantiation) 3219 << Context.getTypeDeclType(Specialization) << Range; 3220 3221 Diag(PrevDecl->getPointOfInstantiation(), 3222 diag::note_instantiation_required_here) 3223 << (PrevDecl->getTemplateSpecializationKind() 3224 != TSK_ImplicitInstantiation); 3225 return true; 3226 } 3227 3228 // If this is not a friend, note that this is an explicit specialization. 3229 if (TUK != TUK_Friend) 3230 Specialization->setSpecializationKind(TSK_ExplicitSpecialization); 3231 3232 // Check that this isn't a redefinition of this specialization. 3233 if (TUK == TUK_Definition) { 3234 if (RecordDecl *Def = Specialization->getDefinition(Context)) { 3235 SourceRange Range(TemplateNameLoc, RAngleLoc); 3236 Diag(TemplateNameLoc, diag::err_redefinition) 3237 << Context.getTypeDeclType(Specialization) << Range; 3238 Diag(Def->getLocation(), diag::note_previous_definition); 3239 Specialization->setInvalidDecl(); 3240 return true; 3241 } 3242 } 3243 3244 // Build the fully-sugared type for this class template 3245 // specialization as the user wrote in the specialization 3246 // itself. This means that we'll pretty-print the type retrieved 3247 // from the specialization's declaration the way that the user 3248 // actually wrote the specialization, rather than formatting the 3249 // name based on the "canonical" representation used to store the 3250 // template arguments in the specialization. 3251 QualType WrittenTy 3252 = Context.getTemplateSpecializationType(Name, 3253 TemplateArgs.data(), 3254 TemplateArgs.size(), 3255 CanonType); 3256 if (TUK != TUK_Friend) 3257 Specialization->setTypeAsWritten(WrittenTy); 3258 TemplateArgsIn.release(); 3259 3260 // C++ [temp.expl.spec]p9: 3261 // A template explicit specialization is in the scope of the 3262 // namespace in which the template was defined. 3263 // 3264 // We actually implement this paragraph where we set the semantic 3265 // context (in the creation of the ClassTemplateSpecializationDecl), 3266 // but we also maintain the lexical context where the actual 3267 // definition occurs. 3268 Specialization->setLexicalDeclContext(CurContext); 3269 3270 // We may be starting the definition of this specialization. 3271 if (TUK == TUK_Definition) 3272 Specialization->startDefinition(); 3273 3274 if (TUK == TUK_Friend) { 3275 FriendDecl *Friend = FriendDecl::Create(Context, CurContext, 3276 TemplateNameLoc, 3277 WrittenTy.getTypePtr(), 3278 /*FIXME:*/KWLoc); 3279 Friend->setAccess(AS_public); 3280 CurContext->addDecl(Friend); 3281 } else { 3282 // Add the specialization into its lexical context, so that it can 3283 // be seen when iterating through the list of declarations in that 3284 // context. However, specializations are not found by name lookup. 3285 CurContext->addDecl(Specialization); 3286 } 3287 return DeclPtrTy::make(Specialization); 3288} 3289 3290Sema::DeclPtrTy 3291Sema::ActOnTemplateDeclarator(Scope *S, 3292 MultiTemplateParamsArg TemplateParameterLists, 3293 Declarator &D) { 3294 return HandleDeclarator(S, D, move(TemplateParameterLists), false); 3295} 3296 3297Sema::DeclPtrTy 3298Sema::ActOnStartOfFunctionTemplateDef(Scope *FnBodyScope, 3299 MultiTemplateParamsArg TemplateParameterLists, 3300 Declarator &D) { 3301 assert(getCurFunctionDecl() == 0 && "Function parsing confused"); 3302 assert(D.getTypeObject(0).Kind == DeclaratorChunk::Function && 3303 "Not a function declarator!"); 3304 DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun; 3305 3306 if (FTI.hasPrototype) { 3307 // FIXME: Diagnose arguments without names in C. 3308 } 3309 3310 Scope *ParentScope = FnBodyScope->getParent(); 3311 3312 DeclPtrTy DP = HandleDeclarator(ParentScope, D, 3313 move(TemplateParameterLists), 3314 /*IsFunctionDefinition=*/true); 3315 if (FunctionTemplateDecl *FunctionTemplate 3316 = dyn_cast_or_null<FunctionTemplateDecl>(DP.getAs<Decl>())) 3317 return ActOnStartOfFunctionDef(FnBodyScope, 3318 DeclPtrTy::make(FunctionTemplate->getTemplatedDecl())); 3319 if (FunctionDecl *Function = dyn_cast_or_null<FunctionDecl>(DP.getAs<Decl>())) 3320 return ActOnStartOfFunctionDef(FnBodyScope, DeclPtrTy::make(Function)); 3321 return DeclPtrTy(); 3322} 3323 3324/// \brief Diagnose cases where we have an explicit template specialization 3325/// before/after an explicit template instantiation, producing diagnostics 3326/// for those cases where they are required and determining whether the 3327/// new specialization/instantiation will have any effect. 3328/// 3329/// \param NewLoc the location of the new explicit specialization or 3330/// instantiation. 3331/// 3332/// \param NewTSK the kind of the new explicit specialization or instantiation. 3333/// 3334/// \param PrevDecl the previous declaration of the entity. 3335/// 3336/// \param PrevTSK the kind of the old explicit specialization or instantiatin. 3337/// 3338/// \param PrevPointOfInstantiation if valid, indicates where the previus 3339/// declaration was instantiated (either implicitly or explicitly). 3340/// 3341/// \param SuppressNew will be set to true to indicate that the new 3342/// specialization or instantiation has no effect and should be ignored. 3343/// 3344/// \returns true if there was an error that should prevent the introduction of 3345/// the new declaration into the AST, false otherwise. 3346bool 3347Sema::CheckSpecializationInstantiationRedecl(SourceLocation NewLoc, 3348 TemplateSpecializationKind NewTSK, 3349 NamedDecl *PrevDecl, 3350 TemplateSpecializationKind PrevTSK, 3351 SourceLocation PrevPointOfInstantiation, 3352 bool &SuppressNew) { 3353 SuppressNew = false; 3354 3355 switch (NewTSK) { 3356 case TSK_Undeclared: 3357 case TSK_ImplicitInstantiation: 3358 assert(false && "Don't check implicit instantiations here"); 3359 return false; 3360 3361 case TSK_ExplicitSpecialization: 3362 switch (PrevTSK) { 3363 case TSK_Undeclared: 3364 case TSK_ExplicitSpecialization: 3365 // Okay, we're just specializing something that is either already 3366 // explicitly specialized or has merely been mentioned without any 3367 // instantiation. 3368 return false; 3369 3370 case TSK_ImplicitInstantiation: 3371 if (PrevPointOfInstantiation.isInvalid()) { 3372 // The declaration itself has not actually been instantiated, so it is 3373 // still okay to specialize it. 3374 return false; 3375 } 3376 // Fall through 3377 3378 case TSK_ExplicitInstantiationDeclaration: 3379 case TSK_ExplicitInstantiationDefinition: 3380 assert((PrevTSK == TSK_ImplicitInstantiation || 3381 PrevPointOfInstantiation.isValid()) && 3382 "Explicit instantiation without point of instantiation?"); 3383 3384 // C++ [temp.expl.spec]p6: 3385 // If a template, a member template or the member of a class template 3386 // is explicitly specialized then that specialization shall be declared 3387 // before the first use of that specialization that would cause an 3388 // implicit instantiation to take place, in every translation unit in 3389 // which such a use occurs; no diagnostic is required. 3390 Diag(NewLoc, diag::err_specialization_after_instantiation) 3391 << PrevDecl; 3392 Diag(PrevPointOfInstantiation, diag::note_instantiation_required_here) 3393 << (PrevTSK != TSK_ImplicitInstantiation); 3394 3395 return true; 3396 } 3397 break; 3398 3399 case TSK_ExplicitInstantiationDeclaration: 3400 switch (PrevTSK) { 3401 case TSK_ExplicitInstantiationDeclaration: 3402 // This explicit instantiation declaration is redundant (that's okay). 3403 SuppressNew = true; 3404 return false; 3405 3406 case TSK_Undeclared: 3407 case TSK_ImplicitInstantiation: 3408 // We're explicitly instantiating something that may have already been 3409 // implicitly instantiated; that's fine. 3410 return false; 3411 3412 case TSK_ExplicitSpecialization: 3413 // C++0x [temp.explicit]p4: 3414 // For a given set of template parameters, if an explicit instantiation 3415 // of a template appears after a declaration of an explicit 3416 // specialization for that template, the explicit instantiation has no 3417 // effect. 3418 return false; 3419 3420 case TSK_ExplicitInstantiationDefinition: 3421 // C++0x [temp.explicit]p10: 3422 // If an entity is the subject of both an explicit instantiation 3423 // declaration and an explicit instantiation definition in the same 3424 // translation unit, the definition shall follow the declaration. 3425 Diag(NewLoc, 3426 diag::err_explicit_instantiation_declaration_after_definition); 3427 Diag(PrevPointOfInstantiation, 3428 diag::note_explicit_instantiation_definition_here); 3429 assert(PrevPointOfInstantiation.isValid() && 3430 "Explicit instantiation without point of instantiation?"); 3431 SuppressNew = true; 3432 return false; 3433 } 3434 break; 3435 3436 case TSK_ExplicitInstantiationDefinition: 3437 switch (PrevTSK) { 3438 case TSK_Undeclared: 3439 case TSK_ImplicitInstantiation: 3440 // We're explicitly instantiating something that may have already been 3441 // implicitly instantiated; that's fine. 3442 return false; 3443 3444 case TSK_ExplicitSpecialization: 3445 // C++ DR 259, C++0x [temp.explicit]p4: 3446 // For a given set of template parameters, if an explicit 3447 // instantiation of a template appears after a declaration of 3448 // an explicit specialization for that template, the explicit 3449 // instantiation has no effect. 3450 // 3451 // In C++98/03 mode, we only give an extension warning here, because it 3452 // is not not harmful to try to explicitly instantiate something that 3453 // has been explicitly specialized. 3454 if (!getLangOptions().CPlusPlus0x) { 3455 Diag(NewLoc, diag::ext_explicit_instantiation_after_specialization) 3456 << PrevDecl; 3457 Diag(PrevDecl->getLocation(), 3458 diag::note_previous_template_specialization); 3459 } 3460 SuppressNew = true; 3461 return false; 3462 3463 case TSK_ExplicitInstantiationDeclaration: 3464 // We're explicity instantiating a definition for something for which we 3465 // were previously asked to suppress instantiations. That's fine. 3466 return false; 3467 3468 case TSK_ExplicitInstantiationDefinition: 3469 // C++0x [temp.spec]p5: 3470 // For a given template and a given set of template-arguments, 3471 // - an explicit instantiation definition shall appear at most once 3472 // in a program, 3473 Diag(NewLoc, diag::err_explicit_instantiation_duplicate) 3474 << PrevDecl; 3475 Diag(PrevPointOfInstantiation, 3476 diag::note_previous_explicit_instantiation); 3477 SuppressNew = true; 3478 return false; 3479 } 3480 break; 3481 } 3482 3483 assert(false && "Missing specialization/instantiation case?"); 3484 3485 return false; 3486} 3487 3488/// \brief Perform semantic analysis for the given function template 3489/// specialization. 3490/// 3491/// This routine performs all of the semantic analysis required for an 3492/// explicit function template specialization. On successful completion, 3493/// the function declaration \p FD will become a function template 3494/// specialization. 3495/// 3496/// \param FD the function declaration, which will be updated to become a 3497/// function template specialization. 3498/// 3499/// \param HasExplicitTemplateArgs whether any template arguments were 3500/// explicitly provided. 3501/// 3502/// \param LAngleLoc the location of the left angle bracket ('<'), if 3503/// template arguments were explicitly provided. 3504/// 3505/// \param ExplicitTemplateArgs the explicitly-provided template arguments, 3506/// if any. 3507/// 3508/// \param NumExplicitTemplateArgs the number of explicitly-provided template 3509/// arguments. This number may be zero even when HasExplicitTemplateArgs is 3510/// true as in, e.g., \c void sort<>(char*, char*); 3511/// 3512/// \param RAngleLoc the location of the right angle bracket ('>'), if 3513/// template arguments were explicitly provided. 3514/// 3515/// \param PrevDecl the set of declarations that 3516bool 3517Sema::CheckFunctionTemplateSpecialization(FunctionDecl *FD, 3518 bool HasExplicitTemplateArgs, 3519 SourceLocation LAngleLoc, 3520 const TemplateArgumentLoc *ExplicitTemplateArgs, 3521 unsigned NumExplicitTemplateArgs, 3522 SourceLocation RAngleLoc, 3523 NamedDecl *&PrevDecl) { 3524 // The set of function template specializations that could match this 3525 // explicit function template specialization. 3526 typedef llvm::SmallVector<FunctionDecl *, 8> CandidateSet; 3527 CandidateSet Candidates; 3528 3529 DeclContext *FDLookupContext = FD->getDeclContext()->getLookupContext(); 3530 for (OverloadIterator Ovl(PrevDecl), OvlEnd; Ovl != OvlEnd; ++Ovl) { 3531 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(*Ovl)) { 3532 // Only consider templates found within the same semantic lookup scope as 3533 // FD. 3534 if (!FDLookupContext->Equals(Ovl->getDeclContext()->getLookupContext())) 3535 continue; 3536 3537 // C++ [temp.expl.spec]p11: 3538 // A trailing template-argument can be left unspecified in the 3539 // template-id naming an explicit function template specialization 3540 // provided it can be deduced from the function argument type. 3541 // Perform template argument deduction to determine whether we may be 3542 // specializing this template. 3543 // FIXME: It is somewhat wasteful to build 3544 TemplateDeductionInfo Info(Context); 3545 FunctionDecl *Specialization = 0; 3546 if (TemplateDeductionResult TDK 3547 = DeduceTemplateArguments(FunTmpl, HasExplicitTemplateArgs, 3548 ExplicitTemplateArgs, 3549 NumExplicitTemplateArgs, 3550 FD->getType(), 3551 Specialization, 3552 Info)) { 3553 // FIXME: Template argument deduction failed; record why it failed, so 3554 // that we can provide nifty diagnostics. 3555 (void)TDK; 3556 continue; 3557 } 3558 3559 // Record this candidate. 3560 Candidates.push_back(Specialization); 3561 } 3562 } 3563 3564 // Find the most specialized function template. 3565 FunctionDecl *Specialization = getMostSpecialized(Candidates.data(), 3566 Candidates.size(), 3567 TPOC_Other, 3568 FD->getLocation(), 3569 PartialDiagnostic(diag::err_function_template_spec_no_match) 3570 << FD->getDeclName(), 3571 PartialDiagnostic(diag::err_function_template_spec_ambiguous) 3572 << FD->getDeclName() << HasExplicitTemplateArgs, 3573 PartialDiagnostic(diag::note_function_template_spec_matched)); 3574 if (!Specialization) 3575 return true; 3576 3577 // FIXME: Check if the prior specialization has a point of instantiation. 3578 // If so, we have run afoul of . 3579 3580 // Check the scope of this explicit specialization. 3581 if (CheckTemplateSpecializationScope(*this, 3582 Specialization->getPrimaryTemplate(), 3583 Specialization, FD->getLocation(), 3584 false)) 3585 return true; 3586 3587 // C++ [temp.expl.spec]p6: 3588 // If a template, a member template or the member of a class template is 3589 // explicitly specialized then that specialization shall be declared 3590 // before the first use of that specialization that would cause an implicit 3591 // instantiation to take place, in every translation unit in which such a 3592 // use occurs; no diagnostic is required. 3593 FunctionTemplateSpecializationInfo *SpecInfo 3594 = Specialization->getTemplateSpecializationInfo(); 3595 assert(SpecInfo && "Function template specialization info missing?"); 3596 if (SpecInfo->getPointOfInstantiation().isValid()) { 3597 Diag(FD->getLocation(), diag::err_specialization_after_instantiation) 3598 << FD; 3599 Diag(SpecInfo->getPointOfInstantiation(), 3600 diag::note_instantiation_required_here) 3601 << (Specialization->getTemplateSpecializationKind() 3602 != TSK_ImplicitInstantiation); 3603 return true; 3604 } 3605 3606 // Mark the prior declaration as an explicit specialization, so that later 3607 // clients know that this is an explicit specialization. 3608 SpecInfo->setTemplateSpecializationKind(TSK_ExplicitSpecialization); 3609 3610 // Turn the given function declaration into a function template 3611 // specialization, with the template arguments from the previous 3612 // specialization. 3613 FD->setFunctionTemplateSpecialization(Context, 3614 Specialization->getPrimaryTemplate(), 3615 new (Context) TemplateArgumentList( 3616 *Specialization->getTemplateSpecializationArgs()), 3617 /*InsertPos=*/0, 3618 TSK_ExplicitSpecialization); 3619 3620 // The "previous declaration" for this function template specialization is 3621 // the prior function template specialization. 3622 PrevDecl = Specialization; 3623 return false; 3624} 3625 3626/// \brief Perform semantic analysis for the given non-template member 3627/// specialization. 3628/// 3629/// This routine performs all of the semantic analysis required for an 3630/// explicit member function specialization. On successful completion, 3631/// the function declaration \p FD will become a member function 3632/// specialization. 3633/// 3634/// \param Member the member declaration, which will be updated to become a 3635/// specialization. 3636/// 3637/// \param PrevDecl the set of declarations, one of which may be specialized 3638/// by this function specialization. 3639bool 3640Sema::CheckMemberSpecialization(NamedDecl *Member, NamedDecl *&PrevDecl) { 3641 assert(!isa<TemplateDecl>(Member) && "Only for non-template members"); 3642 3643 // Try to find the member we are instantiating. 3644 NamedDecl *Instantiation = 0; 3645 NamedDecl *InstantiatedFrom = 0; 3646 MemberSpecializationInfo *MSInfo = 0; 3647 3648 if (!PrevDecl) { 3649 // Nowhere to look anyway. 3650 } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Member)) { 3651 for (OverloadIterator Ovl(PrevDecl), OvlEnd; Ovl != OvlEnd; ++Ovl) { 3652 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(*Ovl)) { 3653 if (Context.hasSameType(Function->getType(), Method->getType())) { 3654 Instantiation = Method; 3655 InstantiatedFrom = Method->getInstantiatedFromMemberFunction(); 3656 MSInfo = Method->getMemberSpecializationInfo(); 3657 break; 3658 } 3659 } 3660 } 3661 } else if (isa<VarDecl>(Member)) { 3662 if (VarDecl *PrevVar = dyn_cast<VarDecl>(PrevDecl)) 3663 if (PrevVar->isStaticDataMember()) { 3664 Instantiation = PrevDecl; 3665 InstantiatedFrom = PrevVar->getInstantiatedFromStaticDataMember(); 3666 MSInfo = PrevVar->getMemberSpecializationInfo(); 3667 } 3668 } else if (isa<RecordDecl>(Member)) { 3669 if (CXXRecordDecl *PrevRecord = dyn_cast<CXXRecordDecl>(PrevDecl)) { 3670 Instantiation = PrevDecl; 3671 InstantiatedFrom = PrevRecord->getInstantiatedFromMemberClass(); 3672 MSInfo = PrevRecord->getMemberSpecializationInfo(); 3673 } 3674 } 3675 3676 if (!Instantiation) { 3677 // There is no previous declaration that matches. Since member 3678 // specializations are always out-of-line, the caller will complain about 3679 // this mismatch later. 3680 return false; 3681 } 3682 3683 // Make sure that this is a specialization of a member. 3684 if (!InstantiatedFrom) { 3685 Diag(Member->getLocation(), diag::err_spec_member_not_instantiated) 3686 << Member; 3687 Diag(Instantiation->getLocation(), diag::note_specialized_decl); 3688 return true; 3689 } 3690 3691 // C++ [temp.expl.spec]p6: 3692 // If a template, a member template or the member of a class template is 3693 // explicitly specialized then that spe- cialization shall be declared 3694 // before the first use of that specialization that would cause an implicit 3695 // instantiation to take place, in every translation unit in which such a 3696 // use occurs; no diagnostic is required. 3697 assert(MSInfo && "Member specialization info missing?"); 3698 if (MSInfo->getPointOfInstantiation().isValid()) { 3699 Diag(Member->getLocation(), diag::err_specialization_after_instantiation) 3700 << Member; 3701 Diag(MSInfo->getPointOfInstantiation(), 3702 diag::note_instantiation_required_here) 3703 << (MSInfo->getTemplateSpecializationKind() != TSK_ImplicitInstantiation); 3704 return true; 3705 } 3706 3707 // Check the scope of this explicit specialization. 3708 if (CheckTemplateSpecializationScope(*this, 3709 InstantiatedFrom, 3710 Instantiation, Member->getLocation(), 3711 false)) 3712 return true; 3713 3714 // Note that this is an explicit instantiation of a member. 3715 // the original declaration to note that it is an explicit specialization 3716 // (if it was previously an implicit instantiation). This latter step 3717 // makes bookkeeping easier. 3718 if (isa<FunctionDecl>(Member)) { 3719 FunctionDecl *InstantiationFunction = cast<FunctionDecl>(Instantiation); 3720 if (InstantiationFunction->getTemplateSpecializationKind() == 3721 TSK_ImplicitInstantiation) { 3722 InstantiationFunction->setTemplateSpecializationKind( 3723 TSK_ExplicitSpecialization); 3724 InstantiationFunction->setLocation(Member->getLocation()); 3725 } 3726 3727 cast<FunctionDecl>(Member)->setInstantiationOfMemberFunction( 3728 cast<CXXMethodDecl>(InstantiatedFrom), 3729 TSK_ExplicitSpecialization); 3730 } else if (isa<VarDecl>(Member)) { 3731 VarDecl *InstantiationVar = cast<VarDecl>(Instantiation); 3732 if (InstantiationVar->getTemplateSpecializationKind() == 3733 TSK_ImplicitInstantiation) { 3734 InstantiationVar->setTemplateSpecializationKind( 3735 TSK_ExplicitSpecialization); 3736 InstantiationVar->setLocation(Member->getLocation()); 3737 } 3738 3739 Context.setInstantiatedFromStaticDataMember(cast<VarDecl>(Member), 3740 cast<VarDecl>(InstantiatedFrom), 3741 TSK_ExplicitSpecialization); 3742 } else { 3743 assert(isa<CXXRecordDecl>(Member) && "Only member classes remain"); 3744 CXXRecordDecl *InstantiationClass = cast<CXXRecordDecl>(Instantiation); 3745 if (InstantiationClass->getTemplateSpecializationKind() == 3746 TSK_ImplicitInstantiation) { 3747 InstantiationClass->setTemplateSpecializationKind( 3748 TSK_ExplicitSpecialization); 3749 InstantiationClass->setLocation(Member->getLocation()); 3750 } 3751 3752 cast<CXXRecordDecl>(Member)->setInstantiationOfMemberClass( 3753 cast<CXXRecordDecl>(InstantiatedFrom), 3754 TSK_ExplicitSpecialization); 3755 } 3756 3757 // Save the caller the trouble of having to figure out which declaration 3758 // this specialization matches. 3759 PrevDecl = Instantiation; 3760 return false; 3761} 3762 3763/// \brief Check the scope of an explicit instantiation. 3764static void CheckExplicitInstantiationScope(Sema &S, NamedDecl *D, 3765 SourceLocation InstLoc, 3766 bool WasQualifiedName) { 3767 DeclContext *ExpectedContext 3768 = D->getDeclContext()->getEnclosingNamespaceContext()->getLookupContext(); 3769 DeclContext *CurContext = S.CurContext->getLookupContext(); 3770 3771 // C++0x [temp.explicit]p2: 3772 // An explicit instantiation shall appear in an enclosing namespace of its 3773 // template. 3774 // 3775 // This is DR275, which we do not retroactively apply to C++98/03. 3776 if (S.getLangOptions().CPlusPlus0x && 3777 !CurContext->Encloses(ExpectedContext)) { 3778 if (NamespaceDecl *NS = dyn_cast<NamespaceDecl>(ExpectedContext)) 3779 S.Diag(InstLoc, diag::err_explicit_instantiation_out_of_scope) 3780 << D << NS; 3781 else 3782 S.Diag(InstLoc, diag::err_explicit_instantiation_must_be_global) 3783 << D; 3784 S.Diag(D->getLocation(), diag::note_explicit_instantiation_here); 3785 return; 3786 } 3787 3788 // C++0x [temp.explicit]p2: 3789 // If the name declared in the explicit instantiation is an unqualified 3790 // name, the explicit instantiation shall appear in the namespace where 3791 // its template is declared or, if that namespace is inline (7.3.1), any 3792 // namespace from its enclosing namespace set. 3793 if (WasQualifiedName) 3794 return; 3795 3796 if (CurContext->Equals(ExpectedContext)) 3797 return; 3798 3799 S.Diag(InstLoc, diag::err_explicit_instantiation_unqualified_wrong_namespace) 3800 << D << ExpectedContext; 3801 S.Diag(D->getLocation(), diag::note_explicit_instantiation_here); 3802} 3803 3804/// \brief Determine whether the given scope specifier has a template-id in it. 3805static bool ScopeSpecifierHasTemplateId(const CXXScopeSpec &SS) { 3806 if (!SS.isSet()) 3807 return false; 3808 3809 // C++0x [temp.explicit]p2: 3810 // If the explicit instantiation is for a member function, a member class 3811 // or a static data member of a class template specialization, the name of 3812 // the class template specialization in the qualified-id for the member 3813 // name shall be a simple-template-id. 3814 // 3815 // C++98 has the same restriction, just worded differently. 3816 for (NestedNameSpecifier *NNS = (NestedNameSpecifier *)SS.getScopeRep(); 3817 NNS; NNS = NNS->getPrefix()) 3818 if (Type *T = NNS->getAsType()) 3819 if (isa<TemplateSpecializationType>(T)) 3820 return true; 3821 3822 return false; 3823} 3824 3825// Explicit instantiation of a class template specialization 3826// FIXME: Implement extern template semantics 3827Sema::DeclResult 3828Sema::ActOnExplicitInstantiation(Scope *S, 3829 SourceLocation ExternLoc, 3830 SourceLocation TemplateLoc, 3831 unsigned TagSpec, 3832 SourceLocation KWLoc, 3833 const CXXScopeSpec &SS, 3834 TemplateTy TemplateD, 3835 SourceLocation TemplateNameLoc, 3836 SourceLocation LAngleLoc, 3837 ASTTemplateArgsPtr TemplateArgsIn, 3838 SourceLocation RAngleLoc, 3839 AttributeList *Attr) { 3840 // Find the class template we're specializing 3841 TemplateName Name = TemplateD.getAsVal<TemplateName>(); 3842 ClassTemplateDecl *ClassTemplate 3843 = cast<ClassTemplateDecl>(Name.getAsTemplateDecl()); 3844 3845 // Check that the specialization uses the same tag kind as the 3846 // original template. 3847 TagDecl::TagKind Kind; 3848 switch (TagSpec) { 3849 default: assert(0 && "Unknown tag type!"); 3850 case DeclSpec::TST_struct: Kind = TagDecl::TK_struct; break; 3851 case DeclSpec::TST_union: Kind = TagDecl::TK_union; break; 3852 case DeclSpec::TST_class: Kind = TagDecl::TK_class; break; 3853 } 3854 if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(), 3855 Kind, KWLoc, 3856 *ClassTemplate->getIdentifier())) { 3857 Diag(KWLoc, diag::err_use_with_wrong_tag) 3858 << ClassTemplate 3859 << CodeModificationHint::CreateReplacement(KWLoc, 3860 ClassTemplate->getTemplatedDecl()->getKindName()); 3861 Diag(ClassTemplate->getTemplatedDecl()->getLocation(), 3862 diag::note_previous_use); 3863 Kind = ClassTemplate->getTemplatedDecl()->getTagKind(); 3864 } 3865 3866 // C++0x [temp.explicit]p2: 3867 // There are two forms of explicit instantiation: an explicit instantiation 3868 // definition and an explicit instantiation declaration. An explicit 3869 // instantiation declaration begins with the extern keyword. [...] 3870 TemplateSpecializationKind TSK 3871 = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition 3872 : TSK_ExplicitInstantiationDeclaration; 3873 3874 // Translate the parser's template argument list in our AST format. 3875 llvm::SmallVector<TemplateArgumentLoc, 16> TemplateArgs; 3876 translateTemplateArguments(TemplateArgsIn, TemplateArgs); 3877 3878 // Check that the template argument list is well-formed for this 3879 // template. 3880 TemplateArgumentListBuilder Converted(ClassTemplate->getTemplateParameters(), 3881 TemplateArgs.size()); 3882 if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc, LAngleLoc, 3883 TemplateArgs.data(), TemplateArgs.size(), 3884 RAngleLoc, false, Converted)) 3885 return true; 3886 3887 assert((Converted.structuredSize() == 3888 ClassTemplate->getTemplateParameters()->size()) && 3889 "Converted template argument list is too short!"); 3890 3891 // Find the class template specialization declaration that 3892 // corresponds to these arguments. 3893 llvm::FoldingSetNodeID ID; 3894 ClassTemplateSpecializationDecl::Profile(ID, 3895 Converted.getFlatArguments(), 3896 Converted.flatSize(), 3897 Context); 3898 void *InsertPos = 0; 3899 ClassTemplateSpecializationDecl *PrevDecl 3900 = ClassTemplate->getSpecializations().FindNodeOrInsertPos(ID, InsertPos); 3901 3902 // C++0x [temp.explicit]p2: 3903 // [...] An explicit instantiation shall appear in an enclosing 3904 // namespace of its template. [...] 3905 // 3906 // This is C++ DR 275. 3907 CheckExplicitInstantiationScope(*this, ClassTemplate, TemplateNameLoc, 3908 SS.isSet()); 3909 3910 ClassTemplateSpecializationDecl *Specialization = 0; 3911 3912 if (PrevDecl) { 3913 bool SuppressNew = false; 3914 if (CheckSpecializationInstantiationRedecl(TemplateNameLoc, TSK, 3915 PrevDecl, 3916 PrevDecl->getSpecializationKind(), 3917 PrevDecl->getPointOfInstantiation(), 3918 SuppressNew)) 3919 return DeclPtrTy::make(PrevDecl); 3920 3921 if (SuppressNew) 3922 return DeclPtrTy::make(PrevDecl); 3923 3924 if (PrevDecl->getSpecializationKind() == TSK_ImplicitInstantiation || 3925 PrevDecl->getSpecializationKind() == TSK_Undeclared) { 3926 // Since the only prior class template specialization with these 3927 // arguments was referenced but not declared, reuse that 3928 // declaration node as our own, updating its source location to 3929 // reflect our new declaration. 3930 Specialization = PrevDecl; 3931 Specialization->setLocation(TemplateNameLoc); 3932 PrevDecl = 0; 3933 } 3934 } 3935 3936 if (!Specialization) { 3937 // Create a new class template specialization declaration node for 3938 // this explicit specialization. 3939 Specialization 3940 = ClassTemplateSpecializationDecl::Create(Context, 3941 ClassTemplate->getDeclContext(), 3942 TemplateNameLoc, 3943 ClassTemplate, 3944 Converted, PrevDecl); 3945 3946 if (PrevDecl) { 3947 // Remove the previous declaration from the folding set, since we want 3948 // to introduce a new declaration. 3949 ClassTemplate->getSpecializations().RemoveNode(PrevDecl); 3950 ClassTemplate->getSpecializations().FindNodeOrInsertPos(ID, InsertPos); 3951 } 3952 3953 // Insert the new specialization. 3954 ClassTemplate->getSpecializations().InsertNode(Specialization, InsertPos); 3955 } 3956 3957 // Build the fully-sugared type for this explicit instantiation as 3958 // the user wrote in the explicit instantiation itself. This means 3959 // that we'll pretty-print the type retrieved from the 3960 // specialization's declaration the way that the user actually wrote 3961 // the explicit instantiation, rather than formatting the name based 3962 // on the "canonical" representation used to store the template 3963 // arguments in the specialization. 3964 QualType WrittenTy 3965 = Context.getTemplateSpecializationType(Name, 3966 TemplateArgs.data(), 3967 TemplateArgs.size(), 3968 Context.getTypeDeclType(Specialization)); 3969 Specialization->setTypeAsWritten(WrittenTy); 3970 TemplateArgsIn.release(); 3971 3972 // Add the explicit instantiation into its lexical context. However, 3973 // since explicit instantiations are never found by name lookup, we 3974 // just put it into the declaration context directly. 3975 Specialization->setLexicalDeclContext(CurContext); 3976 CurContext->addDecl(Specialization); 3977 3978 // C++ [temp.explicit]p3: 3979 // A definition of a class template or class member template 3980 // shall be in scope at the point of the explicit instantiation of 3981 // the class template or class member template. 3982 // 3983 // This check comes when we actually try to perform the 3984 // instantiation. 3985 ClassTemplateSpecializationDecl *Def 3986 = cast_or_null<ClassTemplateSpecializationDecl>( 3987 Specialization->getDefinition(Context)); 3988 if (!Def) 3989 InstantiateClassTemplateSpecialization(TemplateNameLoc, Specialization, TSK); 3990 3991 // Instantiate the members of this class template specialization. 3992 Def = cast_or_null<ClassTemplateSpecializationDecl>( 3993 Specialization->getDefinition(Context)); 3994 if (Def) 3995 InstantiateClassTemplateSpecializationMembers(TemplateNameLoc, Def, TSK); 3996 3997 return DeclPtrTy::make(Specialization); 3998} 3999 4000// Explicit instantiation of a member class of a class template. 4001Sema::DeclResult 4002Sema::ActOnExplicitInstantiation(Scope *S, 4003 SourceLocation ExternLoc, 4004 SourceLocation TemplateLoc, 4005 unsigned TagSpec, 4006 SourceLocation KWLoc, 4007 const CXXScopeSpec &SS, 4008 IdentifierInfo *Name, 4009 SourceLocation NameLoc, 4010 AttributeList *Attr) { 4011 4012 bool Owned = false; 4013 bool IsDependent = false; 4014 DeclPtrTy TagD = ActOnTag(S, TagSpec, Action::TUK_Reference, 4015 KWLoc, SS, Name, NameLoc, Attr, AS_none, 4016 MultiTemplateParamsArg(*this, 0, 0), 4017 Owned, IsDependent); 4018 assert(!IsDependent && "explicit instantiation of dependent name not yet handled"); 4019 4020 if (!TagD) 4021 return true; 4022 4023 TagDecl *Tag = cast<TagDecl>(TagD.getAs<Decl>()); 4024 if (Tag->isEnum()) { 4025 Diag(TemplateLoc, diag::err_explicit_instantiation_enum) 4026 << Context.getTypeDeclType(Tag); 4027 return true; 4028 } 4029 4030 if (Tag->isInvalidDecl()) 4031 return true; 4032 4033 CXXRecordDecl *Record = cast<CXXRecordDecl>(Tag); 4034 CXXRecordDecl *Pattern = Record->getInstantiatedFromMemberClass(); 4035 if (!Pattern) { 4036 Diag(TemplateLoc, diag::err_explicit_instantiation_nontemplate_type) 4037 << Context.getTypeDeclType(Record); 4038 Diag(Record->getLocation(), diag::note_nontemplate_decl_here); 4039 return true; 4040 } 4041 4042 // C++0x [temp.explicit]p2: 4043 // If the explicit instantiation is for a class or member class, the 4044 // elaborated-type-specifier in the declaration shall include a 4045 // simple-template-id. 4046 // 4047 // C++98 has the same restriction, just worded differently. 4048 if (!ScopeSpecifierHasTemplateId(SS)) 4049 Diag(TemplateLoc, diag::err_explicit_instantiation_without_qualified_id) 4050 << Record << SS.getRange(); 4051 4052 // C++0x [temp.explicit]p2: 4053 // There are two forms of explicit instantiation: an explicit instantiation 4054 // definition and an explicit instantiation declaration. An explicit 4055 // instantiation declaration begins with the extern keyword. [...] 4056 TemplateSpecializationKind TSK 4057 = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition 4058 : TSK_ExplicitInstantiationDeclaration; 4059 4060 // C++0x [temp.explicit]p2: 4061 // [...] An explicit instantiation shall appear in an enclosing 4062 // namespace of its template. [...] 4063 // 4064 // This is C++ DR 275. 4065 CheckExplicitInstantiationScope(*this, Record, NameLoc, true); 4066 4067 // Verify that it is okay to explicitly instantiate here. 4068 CXXRecordDecl *PrevDecl 4069 = cast_or_null<CXXRecordDecl>(Record->getPreviousDeclaration()); 4070 if (!PrevDecl && Record->getDefinition(Context)) 4071 PrevDecl = Record; 4072 if (PrevDecl) { 4073 MemberSpecializationInfo *MSInfo = PrevDecl->getMemberSpecializationInfo(); 4074 bool SuppressNew = false; 4075 assert(MSInfo && "No member specialization information?"); 4076 if (CheckSpecializationInstantiationRedecl(TemplateLoc, TSK, 4077 PrevDecl, 4078 MSInfo->getTemplateSpecializationKind(), 4079 MSInfo->getPointOfInstantiation(), 4080 SuppressNew)) 4081 return true; 4082 if (SuppressNew) 4083 return TagD; 4084 } 4085 4086 CXXRecordDecl *RecordDef 4087 = cast_or_null<CXXRecordDecl>(Record->getDefinition(Context)); 4088 if (!RecordDef) { 4089 // C++ [temp.explicit]p3: 4090 // A definition of a member class of a class template shall be in scope 4091 // at the point of an explicit instantiation of the member class. 4092 CXXRecordDecl *Def 4093 = cast_or_null<CXXRecordDecl>(Pattern->getDefinition(Context)); 4094 if (!Def) { 4095 Diag(TemplateLoc, diag::err_explicit_instantiation_undefined_member) 4096 << 0 << Record->getDeclName() << Record->getDeclContext(); 4097 Diag(Pattern->getLocation(), diag::note_forward_declaration) 4098 << Pattern; 4099 return true; 4100 } else { 4101 if (InstantiateClass(NameLoc, Record, Def, 4102 getTemplateInstantiationArgs(Record), 4103 TSK)) 4104 return true; 4105 4106 RecordDef = cast_or_null<CXXRecordDecl>(Record->getDefinition(Context)); 4107 if (!RecordDef) 4108 return true; 4109 } 4110 } 4111 4112 // Instantiate all of the members of the class. 4113 InstantiateClassMembers(NameLoc, RecordDef, 4114 getTemplateInstantiationArgs(Record), TSK); 4115 4116 // FIXME: We don't have any representation for explicit instantiations of 4117 // member classes. Such a representation is not needed for compilation, but it 4118 // should be available for clients that want to see all of the declarations in 4119 // the source code. 4120 return TagD; 4121} 4122 4123Sema::DeclResult Sema::ActOnExplicitInstantiation(Scope *S, 4124 SourceLocation ExternLoc, 4125 SourceLocation TemplateLoc, 4126 Declarator &D) { 4127 // Explicit instantiations always require a name. 4128 DeclarationName Name = GetNameForDeclarator(D); 4129 if (!Name) { 4130 if (!D.isInvalidType()) 4131 Diag(D.getDeclSpec().getSourceRange().getBegin(), 4132 diag::err_explicit_instantiation_requires_name) 4133 << D.getDeclSpec().getSourceRange() 4134 << D.getSourceRange(); 4135 4136 return true; 4137 } 4138 4139 // The scope passed in may not be a decl scope. Zip up the scope tree until 4140 // we find one that is. 4141 while ((S->getFlags() & Scope::DeclScope) == 0 || 4142 (S->getFlags() & Scope::TemplateParamScope) != 0) 4143 S = S->getParent(); 4144 4145 // Determine the type of the declaration. 4146 QualType R = GetTypeForDeclarator(D, S, 0); 4147 if (R.isNull()) 4148 return true; 4149 4150 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) { 4151 // Cannot explicitly instantiate a typedef. 4152 Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_of_typedef) 4153 << Name; 4154 return true; 4155 } 4156 4157 // C++0x [temp.explicit]p1: 4158 // [...] An explicit instantiation of a function template shall not use the 4159 // inline or constexpr specifiers. 4160 // Presumably, this also applies to member functions of class templates as 4161 // well. 4162 if (D.getDeclSpec().isInlineSpecified() && getLangOptions().CPlusPlus0x) 4163 Diag(D.getDeclSpec().getInlineSpecLoc(), 4164 diag::err_explicit_instantiation_inline) 4165 << CodeModificationHint::CreateRemoval( 4166 SourceRange(D.getDeclSpec().getInlineSpecLoc())); 4167 4168 // FIXME: check for constexpr specifier. 4169 4170 // C++0x [temp.explicit]p2: 4171 // There are two forms of explicit instantiation: an explicit instantiation 4172 // definition and an explicit instantiation declaration. An explicit 4173 // instantiation declaration begins with the extern keyword. [...] 4174 TemplateSpecializationKind TSK 4175 = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition 4176 : TSK_ExplicitInstantiationDeclaration; 4177 4178 LookupResult Previous; 4179 LookupParsedName(Previous, S, &D.getCXXScopeSpec(), 4180 Name, LookupOrdinaryName); 4181 4182 if (!R->isFunctionType()) { 4183 // C++ [temp.explicit]p1: 4184 // A [...] static data member of a class template can be explicitly 4185 // instantiated from the member definition associated with its class 4186 // template. 4187 if (Previous.isAmbiguous()) { 4188 return DiagnoseAmbiguousLookup(Previous, Name, D.getIdentifierLoc(), 4189 D.getSourceRange()); 4190 } 4191 4192 VarDecl *Prev = dyn_cast_or_null<VarDecl>( 4193 Previous.getAsSingleDecl(Context)); 4194 if (!Prev || !Prev->isStaticDataMember()) { 4195 // We expect to see a data data member here. 4196 Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_not_known) 4197 << Name; 4198 for (LookupResult::iterator P = Previous.begin(), PEnd = Previous.end(); 4199 P != PEnd; ++P) 4200 Diag((*P)->getLocation(), diag::note_explicit_instantiation_here); 4201 return true; 4202 } 4203 4204 if (!Prev->getInstantiatedFromStaticDataMember()) { 4205 // FIXME: Check for explicit specialization? 4206 Diag(D.getIdentifierLoc(), 4207 diag::err_explicit_instantiation_data_member_not_instantiated) 4208 << Prev; 4209 Diag(Prev->getLocation(), diag::note_explicit_instantiation_here); 4210 // FIXME: Can we provide a note showing where this was declared? 4211 return true; 4212 } 4213 4214 // C++0x [temp.explicit]p2: 4215 // If the explicit instantiation is for a member function, a member class 4216 // or a static data member of a class template specialization, the name of 4217 // the class template specialization in the qualified-id for the member 4218 // name shall be a simple-template-id. 4219 // 4220 // C++98 has the same restriction, just worded differently. 4221 if (!ScopeSpecifierHasTemplateId(D.getCXXScopeSpec())) 4222 Diag(D.getIdentifierLoc(), 4223 diag::err_explicit_instantiation_without_qualified_id) 4224 << Prev << D.getCXXScopeSpec().getRange(); 4225 4226 // Check the scope of this explicit instantiation. 4227 CheckExplicitInstantiationScope(*this, Prev, D.getIdentifierLoc(), true); 4228 4229 // Verify that it is okay to explicitly instantiate here. 4230 MemberSpecializationInfo *MSInfo = Prev->getMemberSpecializationInfo(); 4231 assert(MSInfo && "Missing static data member specialization info?"); 4232 bool SuppressNew = false; 4233 if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK, Prev, 4234 MSInfo->getTemplateSpecializationKind(), 4235 MSInfo->getPointOfInstantiation(), 4236 SuppressNew)) 4237 return true; 4238 if (SuppressNew) 4239 return DeclPtrTy(); 4240 4241 // Instantiate static data member. 4242 Prev->setTemplateSpecializationKind(TSK, D.getIdentifierLoc()); 4243 if (TSK == TSK_ExplicitInstantiationDefinition) 4244 InstantiateStaticDataMemberDefinition(D.getIdentifierLoc(), Prev, false, 4245 /*DefinitionRequired=*/true); 4246 4247 // FIXME: Create an ExplicitInstantiation node? 4248 return DeclPtrTy(); 4249 } 4250 4251 // If the declarator is a template-id, translate the parser's template 4252 // argument list into our AST format. 4253 bool HasExplicitTemplateArgs = false; 4254 llvm::SmallVector<TemplateArgumentLoc, 16> TemplateArgs; 4255 if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) { 4256 TemplateIdAnnotation *TemplateId = D.getName().TemplateId; 4257 ASTTemplateArgsPtr TemplateArgsPtr(*this, 4258 TemplateId->getTemplateArgs(), 4259 TemplateId->NumArgs); 4260 translateTemplateArguments(TemplateArgsPtr, 4261 TemplateArgs); 4262 HasExplicitTemplateArgs = true; 4263 TemplateArgsPtr.release(); 4264 } 4265 4266 // C++ [temp.explicit]p1: 4267 // A [...] function [...] can be explicitly instantiated from its template. 4268 // A member function [...] of a class template can be explicitly 4269 // instantiated from the member definition associated with its class 4270 // template. 4271 llvm::SmallVector<FunctionDecl *, 8> Matches; 4272 for (LookupResult::iterator P = Previous.begin(), PEnd = Previous.end(); 4273 P != PEnd; ++P) { 4274 NamedDecl *Prev = *P; 4275 if (!HasExplicitTemplateArgs) { 4276 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Prev)) { 4277 if (Context.hasSameUnqualifiedType(Method->getType(), R)) { 4278 Matches.clear(); 4279 Matches.push_back(Method); 4280 break; 4281 } 4282 } 4283 } 4284 4285 FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Prev); 4286 if (!FunTmpl) 4287 continue; 4288 4289 TemplateDeductionInfo Info(Context); 4290 FunctionDecl *Specialization = 0; 4291 if (TemplateDeductionResult TDK 4292 = DeduceTemplateArguments(FunTmpl, HasExplicitTemplateArgs, 4293 TemplateArgs.data(), TemplateArgs.size(), 4294 R, Specialization, Info)) { 4295 // FIXME: Keep track of almost-matches? 4296 (void)TDK; 4297 continue; 4298 } 4299 4300 Matches.push_back(Specialization); 4301 } 4302 4303 // Find the most specialized function template specialization. 4304 FunctionDecl *Specialization 4305 = getMostSpecialized(Matches.data(), Matches.size(), TPOC_Other, 4306 D.getIdentifierLoc(), 4307 PartialDiagnostic(diag::err_explicit_instantiation_not_known) << Name, 4308 PartialDiagnostic(diag::err_explicit_instantiation_ambiguous) << Name, 4309 PartialDiagnostic(diag::note_explicit_instantiation_candidate)); 4310 4311 if (!Specialization) 4312 return true; 4313 4314 if (Specialization->getTemplateSpecializationKind() == TSK_Undeclared) { 4315 Diag(D.getIdentifierLoc(), 4316 diag::err_explicit_instantiation_member_function_not_instantiated) 4317 << Specialization 4318 << (Specialization->getTemplateSpecializationKind() == 4319 TSK_ExplicitSpecialization); 4320 Diag(Specialization->getLocation(), diag::note_explicit_instantiation_here); 4321 return true; 4322 } 4323 4324 FunctionDecl *PrevDecl = Specialization->getPreviousDeclaration(); 4325 if (!PrevDecl && Specialization->isThisDeclarationADefinition()) 4326 PrevDecl = Specialization; 4327 4328 if (PrevDecl) { 4329 bool SuppressNew = false; 4330 if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK, 4331 PrevDecl, 4332 PrevDecl->getTemplateSpecializationKind(), 4333 PrevDecl->getPointOfInstantiation(), 4334 SuppressNew)) 4335 return true; 4336 4337 // FIXME: We may still want to build some representation of this 4338 // explicit specialization. 4339 if (SuppressNew) 4340 return DeclPtrTy(); 4341 } 4342 4343 if (TSK == TSK_ExplicitInstantiationDefinition) 4344 InstantiateFunctionDefinition(D.getIdentifierLoc(), Specialization, 4345 false, /*DefinitionRequired=*/true); 4346 4347 Specialization->setTemplateSpecializationKind(TSK, D.getIdentifierLoc()); 4348 4349 // C++0x [temp.explicit]p2: 4350 // If the explicit instantiation is for a member function, a member class 4351 // or a static data member of a class template specialization, the name of 4352 // the class template specialization in the qualified-id for the member 4353 // name shall be a simple-template-id. 4354 // 4355 // C++98 has the same restriction, just worded differently. 4356 FunctionTemplateDecl *FunTmpl = Specialization->getPrimaryTemplate(); 4357 if (D.getName().getKind() != UnqualifiedId::IK_TemplateId && !FunTmpl && 4358 D.getCXXScopeSpec().isSet() && 4359 !ScopeSpecifierHasTemplateId(D.getCXXScopeSpec())) 4360 Diag(D.getIdentifierLoc(), 4361 diag::err_explicit_instantiation_without_qualified_id) 4362 << Specialization << D.getCXXScopeSpec().getRange(); 4363 4364 CheckExplicitInstantiationScope(*this, 4365 FunTmpl? (NamedDecl *)FunTmpl 4366 : Specialization->getInstantiatedFromMemberFunction(), 4367 D.getIdentifierLoc(), 4368 D.getCXXScopeSpec().isSet()); 4369 4370 // FIXME: Create some kind of ExplicitInstantiationDecl here. 4371 return DeclPtrTy(); 4372} 4373 4374Sema::TypeResult 4375Sema::ActOnDependentTag(Scope *S, unsigned TagSpec, TagUseKind TUK, 4376 const CXXScopeSpec &SS, IdentifierInfo *Name, 4377 SourceLocation TagLoc, SourceLocation NameLoc) { 4378 // This has to hold, because SS is expected to be defined. 4379 assert(Name && "Expected a name in a dependent tag"); 4380 4381 NestedNameSpecifier *NNS 4382 = static_cast<NestedNameSpecifier *>(SS.getScopeRep()); 4383 if (!NNS) 4384 return true; 4385 4386 QualType T = CheckTypenameType(NNS, *Name, SourceRange(TagLoc, NameLoc)); 4387 if (T.isNull()) 4388 return true; 4389 4390 TagDecl::TagKind TagKind = TagDecl::getTagKindForTypeSpec(TagSpec); 4391 QualType ElabType = Context.getElaboratedType(T, TagKind); 4392 4393 return ElabType.getAsOpaquePtr(); 4394} 4395 4396Sema::TypeResult 4397Sema::ActOnTypenameType(SourceLocation TypenameLoc, const CXXScopeSpec &SS, 4398 const IdentifierInfo &II, SourceLocation IdLoc) { 4399 NestedNameSpecifier *NNS 4400 = static_cast<NestedNameSpecifier *>(SS.getScopeRep()); 4401 if (!NNS) 4402 return true; 4403 4404 QualType T = CheckTypenameType(NNS, II, SourceRange(TypenameLoc, IdLoc)); 4405 if (T.isNull()) 4406 return true; 4407 return T.getAsOpaquePtr(); 4408} 4409 4410Sema::TypeResult 4411Sema::ActOnTypenameType(SourceLocation TypenameLoc, const CXXScopeSpec &SS, 4412 SourceLocation TemplateLoc, TypeTy *Ty) { 4413 QualType T = GetTypeFromParser(Ty); 4414 NestedNameSpecifier *NNS 4415 = static_cast<NestedNameSpecifier *>(SS.getScopeRep()); 4416 const TemplateSpecializationType *TemplateId 4417 = T->getAs<TemplateSpecializationType>(); 4418 assert(TemplateId && "Expected a template specialization type"); 4419 4420 if (computeDeclContext(SS, false)) { 4421 // If we can compute a declaration context, then the "typename" 4422 // keyword was superfluous. Just build a QualifiedNameType to keep 4423 // track of the nested-name-specifier. 4424 4425 // FIXME: Note that the QualifiedNameType had the "typename" keyword! 4426 return Context.getQualifiedNameType(NNS, T).getAsOpaquePtr(); 4427 } 4428 4429 return Context.getTypenameType(NNS, TemplateId).getAsOpaquePtr(); 4430} 4431 4432/// \brief Build the type that describes a C++ typename specifier, 4433/// e.g., "typename T::type". 4434QualType 4435Sema::CheckTypenameType(NestedNameSpecifier *NNS, const IdentifierInfo &II, 4436 SourceRange Range) { 4437 CXXRecordDecl *CurrentInstantiation = 0; 4438 if (NNS->isDependent()) { 4439 CurrentInstantiation = getCurrentInstantiationOf(NNS); 4440 4441 // If the nested-name-specifier does not refer to the current 4442 // instantiation, then build a typename type. 4443 if (!CurrentInstantiation) 4444 return Context.getTypenameType(NNS, &II); 4445 4446 // The nested-name-specifier refers to the current instantiation, so the 4447 // "typename" keyword itself is superfluous. In C++03, the program is 4448 // actually ill-formed. However, DR 382 (in C++0x CD1) allows such 4449 // extraneous "typename" keywords, and we retroactively apply this DR to 4450 // C++03 code. 4451 } 4452 4453 DeclContext *Ctx = 0; 4454 4455 if (CurrentInstantiation) 4456 Ctx = CurrentInstantiation; 4457 else { 4458 CXXScopeSpec SS; 4459 SS.setScopeRep(NNS); 4460 SS.setRange(Range); 4461 if (RequireCompleteDeclContext(SS)) 4462 return QualType(); 4463 4464 Ctx = computeDeclContext(SS); 4465 } 4466 assert(Ctx && "No declaration context?"); 4467 4468 DeclarationName Name(&II); 4469 LookupResult Result; 4470 LookupQualifiedName(Result, Ctx, Name, LookupOrdinaryName, false); 4471 unsigned DiagID = 0; 4472 Decl *Referenced = 0; 4473 switch (Result.getKind()) { 4474 case LookupResult::NotFound: 4475 DiagID = diag::err_typename_nested_not_found; 4476 break; 4477 4478 case LookupResult::Found: 4479 if (TypeDecl *Type = dyn_cast<TypeDecl>(Result.getFoundDecl())) { 4480 // We found a type. Build a QualifiedNameType, since the 4481 // typename-specifier was just sugar. FIXME: Tell 4482 // QualifiedNameType that it has a "typename" prefix. 4483 return Context.getQualifiedNameType(NNS, Context.getTypeDeclType(Type)); 4484 } 4485 4486 DiagID = diag::err_typename_nested_not_type; 4487 Referenced = Result.getFoundDecl(); 4488 break; 4489 4490 case LookupResult::FoundOverloaded: 4491 DiagID = diag::err_typename_nested_not_type; 4492 Referenced = *Result.begin(); 4493 break; 4494 4495 case LookupResult::Ambiguous: 4496 DiagnoseAmbiguousLookup(Result, Name, Range.getEnd(), Range); 4497 return QualType(); 4498 } 4499 4500 // If we get here, it's because name lookup did not find a 4501 // type. Emit an appropriate diagnostic and return an error. 4502 Diag(Range.getEnd(), DiagID) << Range << Name << Ctx; 4503 if (Referenced) 4504 Diag(Referenced->getLocation(), diag::note_typename_refers_here) 4505 << Name; 4506 return QualType(); 4507} 4508 4509namespace { 4510 // See Sema::RebuildTypeInCurrentInstantiation 4511 class VISIBILITY_HIDDEN CurrentInstantiationRebuilder 4512 : public TreeTransform<CurrentInstantiationRebuilder> { 4513 SourceLocation Loc; 4514 DeclarationName Entity; 4515 4516 public: 4517 CurrentInstantiationRebuilder(Sema &SemaRef, 4518 SourceLocation Loc, 4519 DeclarationName Entity) 4520 : TreeTransform<CurrentInstantiationRebuilder>(SemaRef), 4521 Loc(Loc), Entity(Entity) { } 4522 4523 /// \brief Determine whether the given type \p T has already been 4524 /// transformed. 4525 /// 4526 /// For the purposes of type reconstruction, a type has already been 4527 /// transformed if it is NULL or if it is not dependent. 4528 bool AlreadyTransformed(QualType T) { 4529 return T.isNull() || !T->isDependentType(); 4530 } 4531 4532 /// \brief Returns the location of the entity whose type is being 4533 /// rebuilt. 4534 SourceLocation getBaseLocation() { return Loc; } 4535 4536 /// \brief Returns the name of the entity whose type is being rebuilt. 4537 DeclarationName getBaseEntity() { return Entity; } 4538 4539 /// \brief Sets the "base" location and entity when that 4540 /// information is known based on another transformation. 4541 void setBase(SourceLocation Loc, DeclarationName Entity) { 4542 this->Loc = Loc; 4543 this->Entity = Entity; 4544 } 4545 4546 /// \brief Transforms an expression by returning the expression itself 4547 /// (an identity function). 4548 /// 4549 /// FIXME: This is completely unsafe; we will need to actually clone the 4550 /// expressions. 4551 Sema::OwningExprResult TransformExpr(Expr *E) { 4552 return getSema().Owned(E); 4553 } 4554 4555 /// \brief Transforms a typename type by determining whether the type now 4556 /// refers to a member of the current instantiation, and then 4557 /// type-checking and building a QualifiedNameType (when possible). 4558 QualType TransformTypenameType(TypeLocBuilder &TLB, TypenameTypeLoc TL); 4559 }; 4560} 4561 4562QualType 4563CurrentInstantiationRebuilder::TransformTypenameType(TypeLocBuilder &TLB, 4564 TypenameTypeLoc TL) { 4565 TypenameType *T = TL.getTypePtr(); 4566 4567 NestedNameSpecifier *NNS 4568 = TransformNestedNameSpecifier(T->getQualifier(), 4569 /*FIXME:*/SourceRange(getBaseLocation())); 4570 if (!NNS) 4571 return QualType(); 4572 4573 // If the nested-name-specifier did not change, and we cannot compute the 4574 // context corresponding to the nested-name-specifier, then this 4575 // typename type will not change; exit early. 4576 CXXScopeSpec SS; 4577 SS.setRange(SourceRange(getBaseLocation())); 4578 SS.setScopeRep(NNS); 4579 4580 QualType Result; 4581 if (NNS == T->getQualifier() && getSema().computeDeclContext(SS) == 0) 4582 Result = QualType(T, 0); 4583 4584 // Rebuild the typename type, which will probably turn into a 4585 // QualifiedNameType. 4586 else if (const TemplateSpecializationType *TemplateId = T->getTemplateId()) { 4587 QualType NewTemplateId 4588 = TransformType(QualType(TemplateId, 0)); 4589 if (NewTemplateId.isNull()) 4590 return QualType(); 4591 4592 if (NNS == T->getQualifier() && 4593 NewTemplateId == QualType(TemplateId, 0)) 4594 Result = QualType(T, 0); 4595 else 4596 Result = getDerived().RebuildTypenameType(NNS, NewTemplateId); 4597 } else 4598 Result = getDerived().RebuildTypenameType(NNS, T->getIdentifier(), 4599 SourceRange(TL.getNameLoc())); 4600 4601 TypenameTypeLoc NewTL = TLB.push<TypenameTypeLoc>(Result); 4602 NewTL.setNameLoc(TL.getNameLoc()); 4603 return Result; 4604} 4605 4606/// \brief Rebuilds a type within the context of the current instantiation. 4607/// 4608/// The type \p T is part of the type of an out-of-line member definition of 4609/// a class template (or class template partial specialization) that was parsed 4610/// and constructed before we entered the scope of the class template (or 4611/// partial specialization thereof). This routine will rebuild that type now 4612/// that we have entered the declarator's scope, which may produce different 4613/// canonical types, e.g., 4614/// 4615/// \code 4616/// template<typename T> 4617/// struct X { 4618/// typedef T* pointer; 4619/// pointer data(); 4620/// }; 4621/// 4622/// template<typename T> 4623/// typename X<T>::pointer X<T>::data() { ... } 4624/// \endcode 4625/// 4626/// Here, the type "typename X<T>::pointer" will be created as a TypenameType, 4627/// since we do not know that we can look into X<T> when we parsed the type. 4628/// This function will rebuild the type, performing the lookup of "pointer" 4629/// in X<T> and returning a QualifiedNameType whose canonical type is the same 4630/// as the canonical type of T*, allowing the return types of the out-of-line 4631/// definition and the declaration to match. 4632QualType Sema::RebuildTypeInCurrentInstantiation(QualType T, SourceLocation Loc, 4633 DeclarationName Name) { 4634 if (T.isNull() || !T->isDependentType()) 4635 return T; 4636 4637 CurrentInstantiationRebuilder Rebuilder(*this, Loc, Name); 4638 return Rebuilder.TransformType(T); 4639} 4640 4641/// \brief Produces a formatted string that describes the binding of 4642/// template parameters to template arguments. 4643std::string 4644Sema::getTemplateArgumentBindingsText(const TemplateParameterList *Params, 4645 const TemplateArgumentList &Args) { 4646 // FIXME: For variadic templates, we'll need to get the structured list. 4647 return getTemplateArgumentBindingsText(Params, Args.getFlatArgumentList(), 4648 Args.flat_size()); 4649} 4650 4651std::string 4652Sema::getTemplateArgumentBindingsText(const TemplateParameterList *Params, 4653 const TemplateArgument *Args, 4654 unsigned NumArgs) { 4655 std::string Result; 4656 4657 if (!Params || Params->size() == 0 || NumArgs == 0) 4658 return Result; 4659 4660 for (unsigned I = 0, N = Params->size(); I != N; ++I) { 4661 if (I >= NumArgs) 4662 break; 4663 4664 if (I == 0) 4665 Result += "[with "; 4666 else 4667 Result += ", "; 4668 4669 if (const IdentifierInfo *Id = Params->getParam(I)->getIdentifier()) { 4670 Result += Id->getName(); 4671 } else { 4672 Result += '$'; 4673 Result += llvm::utostr(I); 4674 } 4675 4676 Result += " = "; 4677 4678 switch (Args[I].getKind()) { 4679 case TemplateArgument::Null: 4680 Result += "<no value>"; 4681 break; 4682 4683 case TemplateArgument::Type: { 4684 std::string TypeStr; 4685 Args[I].getAsType().getAsStringInternal(TypeStr, 4686 Context.PrintingPolicy); 4687 Result += TypeStr; 4688 break; 4689 } 4690 4691 case TemplateArgument::Declaration: { 4692 bool Unnamed = true; 4693 if (NamedDecl *ND = dyn_cast_or_null<NamedDecl>(Args[I].getAsDecl())) { 4694 if (ND->getDeclName()) { 4695 Unnamed = false; 4696 Result += ND->getNameAsString(); 4697 } 4698 } 4699 4700 if (Unnamed) { 4701 Result += "<anonymous>"; 4702 } 4703 break; 4704 } 4705 4706 case TemplateArgument::Template: { 4707 std::string Str; 4708 llvm::raw_string_ostream OS(Str); 4709 Args[I].getAsTemplate().print(OS, Context.PrintingPolicy); 4710 Result += OS.str(); 4711 break; 4712 } 4713 4714 case TemplateArgument::Integral: { 4715 Result += Args[I].getAsIntegral()->toString(10); 4716 break; 4717 } 4718 4719 case TemplateArgument::Expression: { 4720 assert(false && "No expressions in deduced template arguments!"); 4721 Result += "<expression>"; 4722 break; 4723 } 4724 4725 case TemplateArgument::Pack: 4726 // FIXME: Format template argument packs 4727 Result += "<template argument pack>"; 4728 break; 4729 } 4730 } 4731 4732 Result += ']'; 4733 return Result; 4734} 4735