SemaTemplate.cpp revision 3b56c002591b59c6c257951f6613b44de83fa860
1//===------- SemaTemplate.cpp - Semantic Analysis for C++ Templates -------===/ 2 3// 4// The LLVM Compiler Infrastructure 5// 6// This file is distributed under the University of Illinois Open Source 7// License. See LICENSE.TXT for details. 8//===----------------------------------------------------------------------===/ 9 10// 11// This file implements semantic analysis for C++ templates. 12//===----------------------------------------------------------------------===/ 13 14#include "Sema.h" 15#include "clang/AST/ASTContext.h" 16#include "clang/AST/Expr.h" 17#include "clang/AST/ExprCXX.h" 18#include "clang/AST/DeclTemplate.h" 19#include "clang/Parse/DeclSpec.h" 20#include "clang/Basic/LangOptions.h" 21 22using namespace clang; 23 24/// isTemplateName - Determines whether the identifier II is a 25/// template name in the current scope, and returns the template 26/// declaration if II names a template. An optional CXXScope can be 27/// passed to indicate the C++ scope in which the identifier will be 28/// found. 29TemplateNameKind Sema::isTemplateName(const IdentifierInfo &II, Scope *S, 30 TemplateTy &TemplateResult, 31 const CXXScopeSpec *SS) { 32 NamedDecl *IIDecl = LookupParsedName(S, SS, &II, LookupOrdinaryName); 33 34 TemplateNameKind TNK = TNK_Non_template; 35 TemplateDecl *Template = 0; 36 37 if (IIDecl) { 38 if ((Template = dyn_cast<TemplateDecl>(IIDecl))) { 39 if (isa<FunctionTemplateDecl>(IIDecl)) 40 TNK = TNK_Function_template; 41 else if (isa<ClassTemplateDecl>(IIDecl) || 42 isa<TemplateTemplateParmDecl>(IIDecl)) 43 TNK = TNK_Type_template; 44 else 45 assert(false && "Unknown template declaration kind"); 46 } else if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(IIDecl)) { 47 // C++ [temp.local]p1: 48 // Like normal (non-template) classes, class templates have an 49 // injected-class-name (Clause 9). The injected-class-name 50 // can be used with or without a template-argument-list. When 51 // it is used without a template-argument-list, it is 52 // equivalent to the injected-class-name followed by the 53 // template-parameters of the class template enclosed in 54 // <>. When it is used with a template-argument-list, it 55 // refers to the specified class template specialization, 56 // which could be the current specialization or another 57 // specialization. 58 if (Record->isInjectedClassName()) { 59 Record = cast<CXXRecordDecl>(Context.getCanonicalDecl(Record)); 60 if ((Template = Record->getDescribedClassTemplate())) 61 TNK = TNK_Type_template; 62 else if (ClassTemplateSpecializationDecl *Spec 63 = dyn_cast<ClassTemplateSpecializationDecl>(Record)) { 64 Template = Spec->getSpecializedTemplate(); 65 TNK = TNK_Type_template; 66 } 67 } 68 } 69 70 // FIXME: What follows is a gross hack. 71 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(IIDecl)) { 72 if (FD->getType()->isDependentType()) { 73 TemplateResult = TemplateTy::make(FD); 74 return TNK_Function_template; 75 } 76 } else if (OverloadedFunctionDecl *Ovl 77 = dyn_cast<OverloadedFunctionDecl>(IIDecl)) { 78 for (OverloadedFunctionDecl::function_iterator F = Ovl->function_begin(), 79 FEnd = Ovl->function_end(); 80 F != FEnd; ++F) { 81 if ((*F)->getType()->isDependentType()) { 82 TemplateResult = TemplateTy::make(Ovl); 83 return TNK_Function_template; 84 } 85 } 86 } 87 88 if (TNK != TNK_Non_template) { 89 if (SS && SS->isSet() && !SS->isInvalid()) { 90 NestedNameSpecifier *Qualifier 91 = static_cast<NestedNameSpecifier *>(SS->getScopeRep()); 92 TemplateResult 93 = TemplateTy::make(Context.getQualifiedTemplateName(Qualifier, 94 false, 95 Template)); 96 } else 97 TemplateResult = TemplateTy::make(TemplateName(Template)); 98 } 99 } 100 return TNK; 101} 102 103/// DiagnoseTemplateParameterShadow - Produce a diagnostic complaining 104/// that the template parameter 'PrevDecl' is being shadowed by a new 105/// declaration at location Loc. Returns true to indicate that this is 106/// an error, and false otherwise. 107bool Sema::DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl) { 108 assert(PrevDecl->isTemplateParameter() && "Not a template parameter"); 109 110 // Microsoft Visual C++ permits template parameters to be shadowed. 111 if (getLangOptions().Microsoft) 112 return false; 113 114 // C++ [temp.local]p4: 115 // A template-parameter shall not be redeclared within its 116 // scope (including nested scopes). 117 Diag(Loc, diag::err_template_param_shadow) 118 << cast<NamedDecl>(PrevDecl)->getDeclName(); 119 Diag(PrevDecl->getLocation(), diag::note_template_param_here); 120 return true; 121} 122 123/// AdjustDeclIfTemplate - If the given decl happens to be a template, reset 124/// the parameter D to reference the templated declaration and return a pointer 125/// to the template declaration. Otherwise, do nothing to D and return null. 126TemplateDecl *Sema::AdjustDeclIfTemplate(DeclPtrTy &D) { 127 if (TemplateDecl *Temp = dyn_cast<TemplateDecl>(D.getAs<Decl>())) { 128 D = DeclPtrTy::make(Temp->getTemplatedDecl()); 129 return Temp; 130 } 131 return 0; 132} 133 134/// ActOnTypeParameter - Called when a C++ template type parameter 135/// (e.g., "typename T") has been parsed. Typename specifies whether 136/// the keyword "typename" was used to declare the type parameter 137/// (otherwise, "class" was used), and KeyLoc is the location of the 138/// "class" or "typename" keyword. ParamName is the name of the 139/// parameter (NULL indicates an unnamed template parameter) and 140/// ParamName is the location of the parameter name (if any). 141/// If the type parameter has a default argument, it will be added 142/// later via ActOnTypeParameterDefault. 143Sema::DeclPtrTy Sema::ActOnTypeParameter(Scope *S, bool Typename, 144 SourceLocation KeyLoc, 145 IdentifierInfo *ParamName, 146 SourceLocation ParamNameLoc, 147 unsigned Depth, unsigned Position) { 148 assert(S->isTemplateParamScope() && 149 "Template type parameter not in template parameter scope!"); 150 bool Invalid = false; 151 152 if (ParamName) { 153 NamedDecl *PrevDecl = LookupName(S, ParamName, LookupTagName); 154 if (PrevDecl && PrevDecl->isTemplateParameter()) 155 Invalid = Invalid || DiagnoseTemplateParameterShadow(ParamNameLoc, 156 PrevDecl); 157 } 158 159 SourceLocation Loc = ParamNameLoc; 160 if (!ParamName) 161 Loc = KeyLoc; 162 163 TemplateTypeParmDecl *Param 164 = TemplateTypeParmDecl::Create(Context, CurContext, Loc, 165 Depth, Position, ParamName, Typename); 166 if (Invalid) 167 Param->setInvalidDecl(); 168 169 if (ParamName) { 170 // Add the template parameter into the current scope. 171 S->AddDecl(DeclPtrTy::make(Param)); 172 IdResolver.AddDecl(Param); 173 } 174 175 return DeclPtrTy::make(Param); 176} 177 178/// ActOnTypeParameterDefault - Adds a default argument (the type 179/// Default) to the given template type parameter (TypeParam). 180void Sema::ActOnTypeParameterDefault(DeclPtrTy TypeParam, 181 SourceLocation EqualLoc, 182 SourceLocation DefaultLoc, 183 TypeTy *DefaultT) { 184 TemplateTypeParmDecl *Parm 185 = cast<TemplateTypeParmDecl>(TypeParam.getAs<Decl>()); 186 QualType Default = QualType::getFromOpaquePtr(DefaultT); 187 188 // C++ [temp.param]p14: 189 // A template-parameter shall not be used in its own default argument. 190 // FIXME: Implement this check! Needs a recursive walk over the types. 191 192 // Check the template argument itself. 193 if (CheckTemplateArgument(Parm, Default, DefaultLoc)) { 194 Parm->setInvalidDecl(); 195 return; 196 } 197 198 Parm->setDefaultArgument(Default, DefaultLoc, false); 199} 200 201/// \brief Check that the type of a non-type template parameter is 202/// well-formed. 203/// 204/// \returns the (possibly-promoted) parameter type if valid; 205/// otherwise, produces a diagnostic and returns a NULL type. 206QualType 207Sema::CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc) { 208 // C++ [temp.param]p4: 209 // 210 // A non-type template-parameter shall have one of the following 211 // (optionally cv-qualified) types: 212 // 213 // -- integral or enumeration type, 214 if (T->isIntegralType() || T->isEnumeralType() || 215 // -- pointer to object or pointer to function, 216 (T->isPointerType() && 217 (T->getAsPointerType()->getPointeeType()->isObjectType() || 218 T->getAsPointerType()->getPointeeType()->isFunctionType())) || 219 // -- reference to object or reference to function, 220 T->isReferenceType() || 221 // -- pointer to member. 222 T->isMemberPointerType() || 223 // If T is a dependent type, we can't do the check now, so we 224 // assume that it is well-formed. 225 T->isDependentType()) 226 return T; 227 // C++ [temp.param]p8: 228 // 229 // A non-type template-parameter of type "array of T" or 230 // "function returning T" is adjusted to be of type "pointer to 231 // T" or "pointer to function returning T", respectively. 232 else if (T->isArrayType()) 233 // FIXME: Keep the type prior to promotion? 234 return Context.getArrayDecayedType(T); 235 else if (T->isFunctionType()) 236 // FIXME: Keep the type prior to promotion? 237 return Context.getPointerType(T); 238 239 Diag(Loc, diag::err_template_nontype_parm_bad_type) 240 << T; 241 242 return QualType(); 243} 244 245/// ActOnNonTypeTemplateParameter - Called when a C++ non-type 246/// template parameter (e.g., "int Size" in "template<int Size> 247/// class Array") has been parsed. S is the current scope and D is 248/// the parsed declarator. 249Sema::DeclPtrTy Sema::ActOnNonTypeTemplateParameter(Scope *S, Declarator &D, 250 unsigned Depth, 251 unsigned Position) { 252 QualType T = GetTypeForDeclarator(D, S); 253 254 assert(S->isTemplateParamScope() && 255 "Non-type template parameter not in template parameter scope!"); 256 bool Invalid = false; 257 258 IdentifierInfo *ParamName = D.getIdentifier(); 259 if (ParamName) { 260 NamedDecl *PrevDecl = LookupName(S, ParamName, LookupTagName); 261 if (PrevDecl && PrevDecl->isTemplateParameter()) 262 Invalid = Invalid || DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), 263 PrevDecl); 264 } 265 266 T = CheckNonTypeTemplateParameterType(T, D.getIdentifierLoc()); 267 if (T.isNull()) { 268 T = Context.IntTy; // Recover with an 'int' type. 269 Invalid = true; 270 } 271 272 NonTypeTemplateParmDecl *Param 273 = NonTypeTemplateParmDecl::Create(Context, CurContext, D.getIdentifierLoc(), 274 Depth, Position, ParamName, T); 275 if (Invalid) 276 Param->setInvalidDecl(); 277 278 if (D.getIdentifier()) { 279 // Add the template parameter into the current scope. 280 S->AddDecl(DeclPtrTy::make(Param)); 281 IdResolver.AddDecl(Param); 282 } 283 return DeclPtrTy::make(Param); 284} 285 286/// \brief Adds a default argument to the given non-type template 287/// parameter. 288void Sema::ActOnNonTypeTemplateParameterDefault(DeclPtrTy TemplateParamD, 289 SourceLocation EqualLoc, 290 ExprArg DefaultE) { 291 NonTypeTemplateParmDecl *TemplateParm 292 = cast<NonTypeTemplateParmDecl>(TemplateParamD.getAs<Decl>()); 293 Expr *Default = static_cast<Expr *>(DefaultE.get()); 294 295 // C++ [temp.param]p14: 296 // A template-parameter shall not be used in its own default argument. 297 // FIXME: Implement this check! Needs a recursive walk over the types. 298 299 // Check the well-formedness of the default template argument. 300 if (CheckTemplateArgument(TemplateParm, TemplateParm->getType(), Default)) { 301 TemplateParm->setInvalidDecl(); 302 return; 303 } 304 305 TemplateParm->setDefaultArgument(DefaultE.takeAs<Expr>()); 306} 307 308 309/// ActOnTemplateTemplateParameter - Called when a C++ template template 310/// parameter (e.g. T in template <template <typename> class T> class array) 311/// has been parsed. S is the current scope. 312Sema::DeclPtrTy Sema::ActOnTemplateTemplateParameter(Scope* S, 313 SourceLocation TmpLoc, 314 TemplateParamsTy *Params, 315 IdentifierInfo *Name, 316 SourceLocation NameLoc, 317 unsigned Depth, 318 unsigned Position) 319{ 320 assert(S->isTemplateParamScope() && 321 "Template template parameter not in template parameter scope!"); 322 323 // Construct the parameter object. 324 TemplateTemplateParmDecl *Param = 325 TemplateTemplateParmDecl::Create(Context, CurContext, TmpLoc, Depth, 326 Position, Name, 327 (TemplateParameterList*)Params); 328 329 // Make sure the parameter is valid. 330 // FIXME: Decl object is not currently invalidated anywhere so this doesn't 331 // do anything yet. However, if the template parameter list or (eventual) 332 // default value is ever invalidated, that will propagate here. 333 bool Invalid = false; 334 if (Invalid) { 335 Param->setInvalidDecl(); 336 } 337 338 // If the tt-param has a name, then link the identifier into the scope 339 // and lookup mechanisms. 340 if (Name) { 341 S->AddDecl(DeclPtrTy::make(Param)); 342 IdResolver.AddDecl(Param); 343 } 344 345 return DeclPtrTy::make(Param); 346} 347 348/// \brief Adds a default argument to the given template template 349/// parameter. 350void Sema::ActOnTemplateTemplateParameterDefault(DeclPtrTy TemplateParamD, 351 SourceLocation EqualLoc, 352 ExprArg DefaultE) { 353 TemplateTemplateParmDecl *TemplateParm 354 = cast<TemplateTemplateParmDecl>(TemplateParamD.getAs<Decl>()); 355 356 // Since a template-template parameter's default argument is an 357 // id-expression, it must be a DeclRefExpr. 358 DeclRefExpr *Default 359 = cast<DeclRefExpr>(static_cast<Expr *>(DefaultE.get())); 360 361 // C++ [temp.param]p14: 362 // A template-parameter shall not be used in its own default argument. 363 // FIXME: Implement this check! Needs a recursive walk over the types. 364 365 // Check the well-formedness of the template argument. 366 if (!isa<TemplateDecl>(Default->getDecl())) { 367 Diag(Default->getSourceRange().getBegin(), 368 diag::err_template_arg_must_be_template) 369 << Default->getSourceRange(); 370 TemplateParm->setInvalidDecl(); 371 return; 372 } 373 if (CheckTemplateArgument(TemplateParm, Default)) { 374 TemplateParm->setInvalidDecl(); 375 return; 376 } 377 378 DefaultE.release(); 379 TemplateParm->setDefaultArgument(Default); 380} 381 382/// ActOnTemplateParameterList - Builds a TemplateParameterList that 383/// contains the template parameters in Params/NumParams. 384Sema::TemplateParamsTy * 385Sema::ActOnTemplateParameterList(unsigned Depth, 386 SourceLocation ExportLoc, 387 SourceLocation TemplateLoc, 388 SourceLocation LAngleLoc, 389 DeclPtrTy *Params, unsigned NumParams, 390 SourceLocation RAngleLoc) { 391 if (ExportLoc.isValid()) 392 Diag(ExportLoc, diag::note_template_export_unsupported); 393 394 return TemplateParameterList::Create(Context, TemplateLoc, LAngleLoc, 395 (Decl**)Params, NumParams, RAngleLoc); 396} 397 398Sema::DeclResult 399Sema::ActOnClassTemplate(Scope *S, unsigned TagSpec, TagKind TK, 400 SourceLocation KWLoc, const CXXScopeSpec &SS, 401 IdentifierInfo *Name, SourceLocation NameLoc, 402 AttributeList *Attr, 403 MultiTemplateParamsArg TemplateParameterLists, 404 AccessSpecifier AS) { 405 assert(TemplateParameterLists.size() > 0 && "No template parameter lists?"); 406 assert(TK != TK_Reference && "Can only declare or define class templates"); 407 bool Invalid = false; 408 409 // Check that we can declare a template here. 410 if (CheckTemplateDeclScope(S, TemplateParameterLists)) 411 return true; 412 413 TagDecl::TagKind Kind; 414 switch (TagSpec) { 415 default: assert(0 && "Unknown tag type!"); 416 case DeclSpec::TST_struct: Kind = TagDecl::TK_struct; break; 417 case DeclSpec::TST_union: Kind = TagDecl::TK_union; break; 418 case DeclSpec::TST_class: Kind = TagDecl::TK_class; break; 419 } 420 421 // There is no such thing as an unnamed class template. 422 if (!Name) { 423 Diag(KWLoc, diag::err_template_unnamed_class); 424 return true; 425 } 426 427 // Find any previous declaration with this name. 428 LookupResult Previous = LookupParsedName(S, &SS, Name, LookupOrdinaryName, 429 true); 430 assert(!Previous.isAmbiguous() && "Ambiguity in class template redecl?"); 431 NamedDecl *PrevDecl = 0; 432 if (Previous.begin() != Previous.end()) 433 PrevDecl = *Previous.begin(); 434 435 DeclContext *SemanticContext = CurContext; 436 if (SS.isNotEmpty() && !SS.isInvalid()) { 437 SemanticContext = computeDeclContext(SS); 438 439 // FIXME: need to match up several levels of template parameter lists here. 440 } 441 442 // FIXME: member templates! 443 TemplateParameterList *TemplateParams 444 = static_cast<TemplateParameterList *>(*TemplateParameterLists.release()); 445 446 // If there is a previous declaration with the same name, check 447 // whether this is a valid redeclaration. 448 ClassTemplateDecl *PrevClassTemplate 449 = dyn_cast_or_null<ClassTemplateDecl>(PrevDecl); 450 if (PrevClassTemplate) { 451 // Ensure that the template parameter lists are compatible. 452 if (!TemplateParameterListsAreEqual(TemplateParams, 453 PrevClassTemplate->getTemplateParameters(), 454 /*Complain=*/true)) 455 return true; 456 457 // C++ [temp.class]p4: 458 // In a redeclaration, partial specialization, explicit 459 // specialization or explicit instantiation of a class template, 460 // the class-key shall agree in kind with the original class 461 // template declaration (7.1.5.3). 462 RecordDecl *PrevRecordDecl = PrevClassTemplate->getTemplatedDecl(); 463 if (!isAcceptableTagRedeclaration(PrevRecordDecl, Kind, KWLoc, *Name)) { 464 Diag(KWLoc, diag::err_use_with_wrong_tag) 465 << Name 466 << CodeModificationHint::CreateReplacement(KWLoc, 467 PrevRecordDecl->getKindName()); 468 Diag(PrevRecordDecl->getLocation(), diag::note_previous_use); 469 Kind = PrevRecordDecl->getTagKind(); 470 } 471 472 // Check for redefinition of this class template. 473 if (TK == TK_Definition) { 474 if (TagDecl *Def = PrevRecordDecl->getDefinition(Context)) { 475 Diag(NameLoc, diag::err_redefinition) << Name; 476 Diag(Def->getLocation(), diag::note_previous_definition); 477 // FIXME: Would it make sense to try to "forget" the previous 478 // definition, as part of error recovery? 479 return true; 480 } 481 } 482 } else if (PrevDecl && PrevDecl->isTemplateParameter()) { 483 // Maybe we will complain about the shadowed template parameter. 484 DiagnoseTemplateParameterShadow(NameLoc, PrevDecl); 485 // Just pretend that we didn't see the previous declaration. 486 PrevDecl = 0; 487 } else if (PrevDecl) { 488 // C++ [temp]p5: 489 // A class template shall not have the same name as any other 490 // template, class, function, object, enumeration, enumerator, 491 // namespace, or type in the same scope (3.3), except as specified 492 // in (14.5.4). 493 Diag(NameLoc, diag::err_redefinition_different_kind) << Name; 494 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 495 return true; 496 } 497 498 // Check the template parameter list of this declaration, possibly 499 // merging in the template parameter list from the previous class 500 // template declaration. 501 if (CheckTemplateParameterList(TemplateParams, 502 PrevClassTemplate? PrevClassTemplate->getTemplateParameters() : 0)) 503 Invalid = true; 504 505 // FIXME: If we had a scope specifier, we better have a previous template 506 // declaration! 507 508 CXXRecordDecl *NewClass = 509 CXXRecordDecl::Create(Context, Kind, SemanticContext, NameLoc, Name, 510 PrevClassTemplate? 511 PrevClassTemplate->getTemplatedDecl() : 0, 512 /*DelayTypeCreation=*/true); 513 514 ClassTemplateDecl *NewTemplate 515 = ClassTemplateDecl::Create(Context, SemanticContext, NameLoc, 516 DeclarationName(Name), TemplateParams, 517 NewClass, PrevClassTemplate); 518 NewClass->setDescribedClassTemplate(NewTemplate); 519 520 // Build the type for the class template declaration now. 521 QualType T = 522 Context.getTypeDeclType(NewClass, 523 PrevClassTemplate? 524 PrevClassTemplate->getTemplatedDecl() : 0); 525 assert(T->isDependentType() && "Class template type is not dependent?"); 526 (void)T; 527 528 // Set the access specifier. 529 SetMemberAccessSpecifier(NewTemplate, PrevClassTemplate, AS); 530 531 // Set the lexical context of these templates 532 NewClass->setLexicalDeclContext(CurContext); 533 NewTemplate->setLexicalDeclContext(CurContext); 534 535 if (TK == TK_Definition) 536 NewClass->startDefinition(); 537 538 if (Attr) 539 ProcessDeclAttributeList(NewClass, Attr); 540 541 PushOnScopeChains(NewTemplate, S); 542 543 if (Invalid) { 544 NewTemplate->setInvalidDecl(); 545 NewClass->setInvalidDecl(); 546 } 547 return DeclPtrTy::make(NewTemplate); 548} 549 550/// \brief Checks the validity of a template parameter list, possibly 551/// considering the template parameter list from a previous 552/// declaration. 553/// 554/// If an "old" template parameter list is provided, it must be 555/// equivalent (per TemplateParameterListsAreEqual) to the "new" 556/// template parameter list. 557/// 558/// \param NewParams Template parameter list for a new template 559/// declaration. This template parameter list will be updated with any 560/// default arguments that are carried through from the previous 561/// template parameter list. 562/// 563/// \param OldParams If provided, template parameter list from a 564/// previous declaration of the same template. Default template 565/// arguments will be merged from the old template parameter list to 566/// the new template parameter list. 567/// 568/// \returns true if an error occurred, false otherwise. 569bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams, 570 TemplateParameterList *OldParams) { 571 bool Invalid = false; 572 573 // C++ [temp.param]p10: 574 // The set of default template-arguments available for use with a 575 // template declaration or definition is obtained by merging the 576 // default arguments from the definition (if in scope) and all 577 // declarations in scope in the same way default function 578 // arguments are (8.3.6). 579 bool SawDefaultArgument = false; 580 SourceLocation PreviousDefaultArgLoc; 581 582 // Dummy initialization to avoid warnings. 583 TemplateParameterList::iterator OldParam = NewParams->end(); 584 if (OldParams) 585 OldParam = OldParams->begin(); 586 587 for (TemplateParameterList::iterator NewParam = NewParams->begin(), 588 NewParamEnd = NewParams->end(); 589 NewParam != NewParamEnd; ++NewParam) { 590 // Variables used to diagnose redundant default arguments 591 bool RedundantDefaultArg = false; 592 SourceLocation OldDefaultLoc; 593 SourceLocation NewDefaultLoc; 594 595 // Variables used to diagnose missing default arguments 596 bool MissingDefaultArg = false; 597 598 // Merge default arguments for template type parameters. 599 if (TemplateTypeParmDecl *NewTypeParm 600 = dyn_cast<TemplateTypeParmDecl>(*NewParam)) { 601 TemplateTypeParmDecl *OldTypeParm 602 = OldParams? cast<TemplateTypeParmDecl>(*OldParam) : 0; 603 604 if (OldTypeParm && OldTypeParm->hasDefaultArgument() && 605 NewTypeParm->hasDefaultArgument()) { 606 OldDefaultLoc = OldTypeParm->getDefaultArgumentLoc(); 607 NewDefaultLoc = NewTypeParm->getDefaultArgumentLoc(); 608 SawDefaultArgument = true; 609 RedundantDefaultArg = true; 610 PreviousDefaultArgLoc = NewDefaultLoc; 611 } else if (OldTypeParm && OldTypeParm->hasDefaultArgument()) { 612 // Merge the default argument from the old declaration to the 613 // new declaration. 614 SawDefaultArgument = true; 615 NewTypeParm->setDefaultArgument(OldTypeParm->getDefaultArgument(), 616 OldTypeParm->getDefaultArgumentLoc(), 617 true); 618 PreviousDefaultArgLoc = OldTypeParm->getDefaultArgumentLoc(); 619 } else if (NewTypeParm->hasDefaultArgument()) { 620 SawDefaultArgument = true; 621 PreviousDefaultArgLoc = NewTypeParm->getDefaultArgumentLoc(); 622 } else if (SawDefaultArgument) 623 MissingDefaultArg = true; 624 } 625 // Merge default arguments for non-type template parameters 626 else if (NonTypeTemplateParmDecl *NewNonTypeParm 627 = dyn_cast<NonTypeTemplateParmDecl>(*NewParam)) { 628 NonTypeTemplateParmDecl *OldNonTypeParm 629 = OldParams? cast<NonTypeTemplateParmDecl>(*OldParam) : 0; 630 if (OldNonTypeParm && OldNonTypeParm->hasDefaultArgument() && 631 NewNonTypeParm->hasDefaultArgument()) { 632 OldDefaultLoc = OldNonTypeParm->getDefaultArgumentLoc(); 633 NewDefaultLoc = NewNonTypeParm->getDefaultArgumentLoc(); 634 SawDefaultArgument = true; 635 RedundantDefaultArg = true; 636 PreviousDefaultArgLoc = NewDefaultLoc; 637 } else if (OldNonTypeParm && OldNonTypeParm->hasDefaultArgument()) { 638 // Merge the default argument from the old declaration to the 639 // new declaration. 640 SawDefaultArgument = true; 641 // FIXME: We need to create a new kind of "default argument" 642 // expression that points to a previous template template 643 // parameter. 644 NewNonTypeParm->setDefaultArgument( 645 OldNonTypeParm->getDefaultArgument()); 646 PreviousDefaultArgLoc = OldNonTypeParm->getDefaultArgumentLoc(); 647 } else if (NewNonTypeParm->hasDefaultArgument()) { 648 SawDefaultArgument = true; 649 PreviousDefaultArgLoc = NewNonTypeParm->getDefaultArgumentLoc(); 650 } else if (SawDefaultArgument) 651 MissingDefaultArg = true; 652 } 653 // Merge default arguments for template template parameters 654 else { 655 TemplateTemplateParmDecl *NewTemplateParm 656 = cast<TemplateTemplateParmDecl>(*NewParam); 657 TemplateTemplateParmDecl *OldTemplateParm 658 = OldParams? cast<TemplateTemplateParmDecl>(*OldParam) : 0; 659 if (OldTemplateParm && OldTemplateParm->hasDefaultArgument() && 660 NewTemplateParm->hasDefaultArgument()) { 661 OldDefaultLoc = OldTemplateParm->getDefaultArgumentLoc(); 662 NewDefaultLoc = NewTemplateParm->getDefaultArgumentLoc(); 663 SawDefaultArgument = true; 664 RedundantDefaultArg = true; 665 PreviousDefaultArgLoc = NewDefaultLoc; 666 } else if (OldTemplateParm && OldTemplateParm->hasDefaultArgument()) { 667 // Merge the default argument from the old declaration to the 668 // new declaration. 669 SawDefaultArgument = true; 670 // FIXME: We need to create a new kind of "default argument" expression 671 // that points to a previous template template parameter. 672 NewTemplateParm->setDefaultArgument( 673 OldTemplateParm->getDefaultArgument()); 674 PreviousDefaultArgLoc = OldTemplateParm->getDefaultArgumentLoc(); 675 } else if (NewTemplateParm->hasDefaultArgument()) { 676 SawDefaultArgument = true; 677 PreviousDefaultArgLoc = NewTemplateParm->getDefaultArgumentLoc(); 678 } else if (SawDefaultArgument) 679 MissingDefaultArg = true; 680 } 681 682 if (RedundantDefaultArg) { 683 // C++ [temp.param]p12: 684 // A template-parameter shall not be given default arguments 685 // by two different declarations in the same scope. 686 Diag(NewDefaultLoc, diag::err_template_param_default_arg_redefinition); 687 Diag(OldDefaultLoc, diag::note_template_param_prev_default_arg); 688 Invalid = true; 689 } else if (MissingDefaultArg) { 690 // C++ [temp.param]p11: 691 // If a template-parameter has a default template-argument, 692 // all subsequent template-parameters shall have a default 693 // template-argument supplied. 694 Diag((*NewParam)->getLocation(), 695 diag::err_template_param_default_arg_missing); 696 Diag(PreviousDefaultArgLoc, diag::note_template_param_prev_default_arg); 697 Invalid = true; 698 } 699 700 // If we have an old template parameter list that we're merging 701 // in, move on to the next parameter. 702 if (OldParams) 703 ++OldParam; 704 } 705 706 return Invalid; 707} 708 709/// \brief Translates template arguments as provided by the parser 710/// into template arguments used by semantic analysis. 711static void 712translateTemplateArguments(ASTTemplateArgsPtr &TemplateArgsIn, 713 SourceLocation *TemplateArgLocs, 714 llvm::SmallVector<TemplateArgument, 16> &TemplateArgs) { 715 TemplateArgs.reserve(TemplateArgsIn.size()); 716 717 void **Args = TemplateArgsIn.getArgs(); 718 bool *ArgIsType = TemplateArgsIn.getArgIsType(); 719 for (unsigned Arg = 0, Last = TemplateArgsIn.size(); Arg != Last; ++Arg) { 720 TemplateArgs.push_back( 721 ArgIsType[Arg]? TemplateArgument(TemplateArgLocs[Arg], 722 QualType::getFromOpaquePtr(Args[Arg])) 723 : TemplateArgument(reinterpret_cast<Expr *>(Args[Arg]))); 724 } 725} 726 727/// \brief Build a canonical version of a template argument list. 728/// 729/// This function builds a canonical version of the given template 730/// argument list, where each of the template arguments has been 731/// converted into its canonical form. This routine is typically used 732/// to canonicalize a template argument list when the template name 733/// itself is dependent. When the template name refers to an actual 734/// template declaration, Sema::CheckTemplateArgumentList should be 735/// used to check and canonicalize the template arguments. 736/// 737/// \param TemplateArgs The incoming template arguments. 738/// 739/// \param NumTemplateArgs The number of template arguments in \p 740/// TemplateArgs. 741/// 742/// \param Canonical A vector to be filled with the canonical versions 743/// of the template arguments. 744/// 745/// \param Context The ASTContext in which the template arguments live. 746static void CanonicalizeTemplateArguments(const TemplateArgument *TemplateArgs, 747 unsigned NumTemplateArgs, 748 llvm::SmallVectorImpl<TemplateArgument> &Canonical, 749 ASTContext &Context) { 750 Canonical.reserve(NumTemplateArgs); 751 for (unsigned Idx = 0; Idx < NumTemplateArgs; ++Idx) { 752 switch (TemplateArgs[Idx].getKind()) { 753 case TemplateArgument::Null: 754 assert(false && "Should never see a NULL template argument here"); 755 break; 756 757 case TemplateArgument::Expression: 758 // FIXME: Build canonical expression (!) 759 Canonical.push_back(TemplateArgs[Idx]); 760 break; 761 762 case TemplateArgument::Declaration: 763 Canonical.push_back( 764 TemplateArgument(SourceLocation(), 765 Context.getCanonicalDecl(TemplateArgs[Idx].getAsDecl()))); 766 break; 767 768 case TemplateArgument::Integral: 769 Canonical.push_back(TemplateArgument(SourceLocation(), 770 *TemplateArgs[Idx].getAsIntegral(), 771 TemplateArgs[Idx].getIntegralType())); 772 break; 773 774 case TemplateArgument::Type: { 775 QualType CanonType 776 = Context.getCanonicalType(TemplateArgs[Idx].getAsType()); 777 Canonical.push_back(TemplateArgument(SourceLocation(), CanonType)); 778 break; 779 } 780 } 781 } 782} 783 784QualType Sema::CheckTemplateIdType(TemplateName Name, 785 SourceLocation TemplateLoc, 786 SourceLocation LAngleLoc, 787 const TemplateArgument *TemplateArgs, 788 unsigned NumTemplateArgs, 789 SourceLocation RAngleLoc) { 790 TemplateDecl *Template = Name.getAsTemplateDecl(); 791 if (!Template) { 792 // The template name does not resolve to a template, so we just 793 // build a dependent template-id type. 794 795 // Canonicalize the template arguments to build the canonical 796 // template-id type. 797 llvm::SmallVector<TemplateArgument, 16> CanonicalTemplateArgs; 798 CanonicalizeTemplateArguments(TemplateArgs, NumTemplateArgs, 799 CanonicalTemplateArgs, Context); 800 801 TemplateName CanonName = Context.getCanonicalTemplateName(Name); 802 QualType CanonType 803 = Context.getTemplateSpecializationType(CanonName, 804 &CanonicalTemplateArgs[0], 805 CanonicalTemplateArgs.size()); 806 807 // Build the dependent template-id type. 808 return Context.getTemplateSpecializationType(Name, TemplateArgs, 809 NumTemplateArgs, CanonType); 810 } 811 812 // Check that the template argument list is well-formed for this 813 // template. 814 TemplateArgumentListBuilder ConvertedTemplateArgs(Context); 815 if (CheckTemplateArgumentList(Template, TemplateLoc, LAngleLoc, 816 TemplateArgs, NumTemplateArgs, RAngleLoc, 817 ConvertedTemplateArgs)) 818 return QualType(); 819 820 assert((ConvertedTemplateArgs.size() == 821 Template->getTemplateParameters()->size()) && 822 "Converted template argument list is too short!"); 823 824 QualType CanonType; 825 826 if (TemplateSpecializationType::anyDependentTemplateArguments( 827 TemplateArgs, 828 NumTemplateArgs)) { 829 // This class template specialization is a dependent 830 // type. Therefore, its canonical type is another class template 831 // specialization type that contains all of the converted 832 // arguments in canonical form. This ensures that, e.g., A<T> and 833 // A<T, T> have identical types when A is declared as: 834 // 835 // template<typename T, typename U = T> struct A; 836 TemplateName CanonName = Context.getCanonicalTemplateName(Name); 837 CanonType = Context.getTemplateSpecializationType(CanonName, 838 ConvertedTemplateArgs.getFlatArgumentList(), 839 ConvertedTemplateArgs.flatSize()); 840 } else if (ClassTemplateDecl *ClassTemplate 841 = dyn_cast<ClassTemplateDecl>(Template)) { 842 // Find the class template specialization declaration that 843 // corresponds to these arguments. 844 llvm::FoldingSetNodeID ID; 845 ClassTemplateSpecializationDecl::Profile(ID, 846 ConvertedTemplateArgs.getFlatArgumentList(), 847 ConvertedTemplateArgs.flatSize()); 848 void *InsertPos = 0; 849 ClassTemplateSpecializationDecl *Decl 850 = ClassTemplate->getSpecializations().FindNodeOrInsertPos(ID, InsertPos); 851 if (!Decl) { 852 // This is the first time we have referenced this class template 853 // specialization. Create the canonical declaration and add it to 854 // the set of specializations. 855 Decl = ClassTemplateSpecializationDecl::Create(Context, 856 ClassTemplate->getDeclContext(), 857 TemplateLoc, 858 ClassTemplate, 859 ConvertedTemplateArgs, 0); 860 ClassTemplate->getSpecializations().InsertNode(Decl, InsertPos); 861 Decl->setLexicalDeclContext(CurContext); 862 } 863 864 CanonType = Context.getTypeDeclType(Decl); 865 } 866 867 // Build the fully-sugared type for this class template 868 // specialization, which refers back to the class template 869 // specialization we created or found. 870 return Context.getTemplateSpecializationType(Name, TemplateArgs, 871 NumTemplateArgs, CanonType); 872} 873 874Action::TypeResult 875Sema::ActOnTemplateIdType(TemplateTy TemplateD, SourceLocation TemplateLoc, 876 SourceLocation LAngleLoc, 877 ASTTemplateArgsPtr TemplateArgsIn, 878 SourceLocation *TemplateArgLocs, 879 SourceLocation RAngleLoc) { 880 TemplateName Template = TemplateD.getAsVal<TemplateName>(); 881 882 // Translate the parser's template argument list in our AST format. 883 llvm::SmallVector<TemplateArgument, 16> TemplateArgs; 884 translateTemplateArguments(TemplateArgsIn, TemplateArgLocs, TemplateArgs); 885 886 QualType Result = CheckTemplateIdType(Template, TemplateLoc, LAngleLoc, 887 TemplateArgs.data(), 888 TemplateArgs.size(), 889 RAngleLoc); 890 TemplateArgsIn.release(); 891 892 if (Result.isNull()) 893 return true; 894 895 return Result.getAsOpaquePtr(); 896} 897 898/// \brief Form a dependent template name. 899/// 900/// This action forms a dependent template name given the template 901/// name and its (presumably dependent) scope specifier. For 902/// example, given "MetaFun::template apply", the scope specifier \p 903/// SS will be "MetaFun::", \p TemplateKWLoc contains the location 904/// of the "template" keyword, and "apply" is the \p Name. 905Sema::TemplateTy 906Sema::ActOnDependentTemplateName(SourceLocation TemplateKWLoc, 907 const IdentifierInfo &Name, 908 SourceLocation NameLoc, 909 const CXXScopeSpec &SS) { 910 if (!SS.isSet() || SS.isInvalid()) 911 return TemplateTy(); 912 913 NestedNameSpecifier *Qualifier 914 = static_cast<NestedNameSpecifier *>(SS.getScopeRep()); 915 916 // FIXME: member of the current instantiation 917 918 if (!Qualifier->isDependent()) { 919 // C++0x [temp.names]p5: 920 // If a name prefixed by the keyword template is not the name of 921 // a template, the program is ill-formed. [Note: the keyword 922 // template may not be applied to non-template members of class 923 // templates. -end note ] [ Note: as is the case with the 924 // typename prefix, the template prefix is allowed in cases 925 // where it is not strictly necessary; i.e., when the 926 // nested-name-specifier or the expression on the left of the -> 927 // or . is not dependent on a template-parameter, or the use 928 // does not appear in the scope of a template. -end note] 929 // 930 // Note: C++03 was more strict here, because it banned the use of 931 // the "template" keyword prior to a template-name that was not a 932 // dependent name. C++ DR468 relaxed this requirement (the 933 // "template" keyword is now permitted). We follow the C++0x 934 // rules, even in C++03 mode, retroactively applying the DR. 935 TemplateTy Template; 936 TemplateNameKind TNK = isTemplateName(Name, 0, Template, &SS); 937 if (TNK == TNK_Non_template) { 938 Diag(NameLoc, diag::err_template_kw_refers_to_non_template) 939 << &Name; 940 return TemplateTy(); 941 } 942 943 return Template; 944 } 945 946 return TemplateTy::make(Context.getDependentTemplateName(Qualifier, &Name)); 947} 948 949/// \brief Check that the given template argument list is well-formed 950/// for specializing the given template. 951bool Sema::CheckTemplateArgumentList(TemplateDecl *Template, 952 SourceLocation TemplateLoc, 953 SourceLocation LAngleLoc, 954 const TemplateArgument *TemplateArgs, 955 unsigned NumTemplateArgs, 956 SourceLocation RAngleLoc, 957 TemplateArgumentListBuilder &Converted) { 958 TemplateParameterList *Params = Template->getTemplateParameters(); 959 unsigned NumParams = Params->size(); 960 unsigned NumArgs = NumTemplateArgs; 961 bool Invalid = false; 962 963 if (NumArgs > NumParams || 964 NumArgs < Params->getMinRequiredArguments()) { 965 // FIXME: point at either the first arg beyond what we can handle, 966 // or the '>', depending on whether we have too many or too few 967 // arguments. 968 SourceRange Range; 969 if (NumArgs > NumParams) 970 Range = SourceRange(TemplateArgs[NumParams].getLocation(), RAngleLoc); 971 Diag(TemplateLoc, diag::err_template_arg_list_different_arity) 972 << (NumArgs > NumParams) 973 << (isa<ClassTemplateDecl>(Template)? 0 : 974 isa<FunctionTemplateDecl>(Template)? 1 : 975 isa<TemplateTemplateParmDecl>(Template)? 2 : 3) 976 << Template << Range; 977 Diag(Template->getLocation(), diag::note_template_decl_here) 978 << Params->getSourceRange(); 979 Invalid = true; 980 } 981 982 // C++ [temp.arg]p1: 983 // [...] The type and form of each template-argument specified in 984 // a template-id shall match the type and form specified for the 985 // corresponding parameter declared by the template in its 986 // template-parameter-list. 987 unsigned ArgIdx = 0; 988 for (TemplateParameterList::iterator Param = Params->begin(), 989 ParamEnd = Params->end(); 990 Param != ParamEnd; ++Param, ++ArgIdx) { 991 // Decode the template argument 992 TemplateArgument Arg; 993 if (ArgIdx >= NumArgs) { 994 // Retrieve the default template argument from the template 995 // parameter. 996 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*Param)) { 997 if (!TTP->hasDefaultArgument()) 998 break; 999 1000 QualType ArgType = TTP->getDefaultArgument(); 1001 1002 // If the argument type is dependent, instantiate it now based 1003 // on the previously-computed template arguments. 1004 if (ArgType->isDependentType()) { 1005 InstantiatingTemplate Inst(*this, TemplateLoc, 1006 Template, Converted.getFlatArgumentList(), 1007 Converted.flatSize(), 1008 SourceRange(TemplateLoc, RAngleLoc)); 1009 1010 TemplateArgumentList TemplateArgs(Context, Converted, 1011 /*CopyArgs=*/false, 1012 /*FlattenArgs=*/false); 1013 ArgType = InstantiateType(ArgType, TemplateArgs, 1014 TTP->getDefaultArgumentLoc(), 1015 TTP->getDeclName()); 1016 } 1017 1018 if (ArgType.isNull()) 1019 return true; 1020 1021 Arg = TemplateArgument(TTP->getLocation(), ArgType); 1022 } else if (NonTypeTemplateParmDecl *NTTP 1023 = dyn_cast<NonTypeTemplateParmDecl>(*Param)) { 1024 if (!NTTP->hasDefaultArgument()) 1025 break; 1026 1027 InstantiatingTemplate Inst(*this, TemplateLoc, 1028 Template, Converted.getFlatArgumentList(), 1029 Converted.flatSize(), 1030 SourceRange(TemplateLoc, RAngleLoc)); 1031 1032 TemplateArgumentList TemplateArgs(Context, Converted, 1033 /*CopyArgs=*/false, 1034 /*FlattenArgs=*/false); 1035 1036 Sema::OwningExprResult E = InstantiateExpr(NTTP->getDefaultArgument(), 1037 TemplateArgs); 1038 if (E.isInvalid()) 1039 return true; 1040 1041 Arg = TemplateArgument(E.takeAs<Expr>()); 1042 } else { 1043 TemplateTemplateParmDecl *TempParm 1044 = cast<TemplateTemplateParmDecl>(*Param); 1045 1046 if (!TempParm->hasDefaultArgument()) 1047 break; 1048 1049 // FIXME: Instantiate default argument 1050 Arg = TemplateArgument(TempParm->getDefaultArgument()); 1051 } 1052 } else { 1053 // Retrieve the template argument produced by the user. 1054 Arg = TemplateArgs[ArgIdx]; 1055 } 1056 1057 1058 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*Param)) { 1059 // Check template type parameters. 1060 if (Arg.getKind() == TemplateArgument::Type) { 1061 if (CheckTemplateArgument(TTP, Arg.getAsType(), Arg.getLocation())) 1062 Invalid = true; 1063 1064 // Add the converted template type argument. 1065 Converted.push_back( 1066 TemplateArgument(Arg.getLocation(), 1067 Context.getCanonicalType(Arg.getAsType()))); 1068 continue; 1069 } 1070 1071 // C++ [temp.arg.type]p1: 1072 // A template-argument for a template-parameter which is a 1073 // type shall be a type-id. 1074 1075 // We have a template type parameter but the template argument 1076 // is not a type. 1077 Diag(Arg.getLocation(), diag::err_template_arg_must_be_type); 1078 Diag((*Param)->getLocation(), diag::note_template_param_here); 1079 Invalid = true; 1080 } else if (NonTypeTemplateParmDecl *NTTP 1081 = dyn_cast<NonTypeTemplateParmDecl>(*Param)) { 1082 // Check non-type template parameters. 1083 1084 // Instantiate the type of the non-type template parameter with 1085 // the template arguments we've seen thus far. 1086 QualType NTTPType = NTTP->getType(); 1087 if (NTTPType->isDependentType()) { 1088 // Instantiate the type of the non-type template parameter. 1089 InstantiatingTemplate Inst(*this, TemplateLoc, 1090 Template, Converted.getFlatArgumentList(), 1091 Converted.flatSize(), 1092 SourceRange(TemplateLoc, RAngleLoc)); 1093 1094 TemplateArgumentList TemplateArgs(Context, Converted, 1095 /*CopyArgs=*/false, 1096 /*FlattenArgs=*/false); 1097 NTTPType = InstantiateType(NTTPType, TemplateArgs, 1098 NTTP->getLocation(), 1099 NTTP->getDeclName()); 1100 // If that worked, check the non-type template parameter type 1101 // for validity. 1102 if (!NTTPType.isNull()) 1103 NTTPType = CheckNonTypeTemplateParameterType(NTTPType, 1104 NTTP->getLocation()); 1105 1106 if (NTTPType.isNull()) { 1107 Invalid = true; 1108 break; 1109 } 1110 } 1111 1112 switch (Arg.getKind()) { 1113 case TemplateArgument::Null: 1114 assert(false && "Should never see a NULL template argument here"); 1115 break; 1116 1117 case TemplateArgument::Expression: { 1118 Expr *E = Arg.getAsExpr(); 1119 if (CheckTemplateArgument(NTTP, NTTPType, E, &Converted)) 1120 Invalid = true; 1121 break; 1122 } 1123 1124 case TemplateArgument::Declaration: 1125 case TemplateArgument::Integral: 1126 // We've already checked this template argument, so just copy 1127 // it to the list of converted arguments. 1128 Converted.push_back(Arg); 1129 break; 1130 1131 case TemplateArgument::Type: 1132 // We have a non-type template parameter but the template 1133 // argument is a type. 1134 1135 // C++ [temp.arg]p2: 1136 // In a template-argument, an ambiguity between a type-id and 1137 // an expression is resolved to a type-id, regardless of the 1138 // form of the corresponding template-parameter. 1139 // 1140 // We warn specifically about this case, since it can be rather 1141 // confusing for users. 1142 if (Arg.getAsType()->isFunctionType()) 1143 Diag(Arg.getLocation(), diag::err_template_arg_nontype_ambig) 1144 << Arg.getAsType(); 1145 else 1146 Diag(Arg.getLocation(), diag::err_template_arg_must_be_expr); 1147 Diag((*Param)->getLocation(), diag::note_template_param_here); 1148 Invalid = true; 1149 } 1150 } else { 1151 // Check template template parameters. 1152 TemplateTemplateParmDecl *TempParm 1153 = cast<TemplateTemplateParmDecl>(*Param); 1154 1155 switch (Arg.getKind()) { 1156 case TemplateArgument::Null: 1157 assert(false && "Should never see a NULL template argument here"); 1158 break; 1159 1160 case TemplateArgument::Expression: { 1161 Expr *ArgExpr = Arg.getAsExpr(); 1162 if (ArgExpr && isa<DeclRefExpr>(ArgExpr) && 1163 isa<TemplateDecl>(cast<DeclRefExpr>(ArgExpr)->getDecl())) { 1164 if (CheckTemplateArgument(TempParm, cast<DeclRefExpr>(ArgExpr))) 1165 Invalid = true; 1166 1167 // Add the converted template argument. 1168 Decl *D 1169 = Context.getCanonicalDecl(cast<DeclRefExpr>(ArgExpr)->getDecl()); 1170 Converted.push_back(TemplateArgument(Arg.getLocation(), D)); 1171 continue; 1172 } 1173 } 1174 // fall through 1175 1176 case TemplateArgument::Type: { 1177 // We have a template template parameter but the template 1178 // argument does not refer to a template. 1179 Diag(Arg.getLocation(), diag::err_template_arg_must_be_template); 1180 Invalid = true; 1181 break; 1182 } 1183 1184 case TemplateArgument::Declaration: 1185 // We've already checked this template argument, so just copy 1186 // it to the list of converted arguments. 1187 Converted.push_back(Arg); 1188 break; 1189 1190 case TemplateArgument::Integral: 1191 assert(false && "Integral argument with template template parameter"); 1192 break; 1193 } 1194 } 1195 } 1196 1197 return Invalid; 1198} 1199 1200/// \brief Check a template argument against its corresponding 1201/// template type parameter. 1202/// 1203/// This routine implements the semantics of C++ [temp.arg.type]. It 1204/// returns true if an error occurred, and false otherwise. 1205bool Sema::CheckTemplateArgument(TemplateTypeParmDecl *Param, 1206 QualType Arg, SourceLocation ArgLoc) { 1207 // C++ [temp.arg.type]p2: 1208 // A local type, a type with no linkage, an unnamed type or a type 1209 // compounded from any of these types shall not be used as a 1210 // template-argument for a template type-parameter. 1211 // 1212 // FIXME: Perform the recursive and no-linkage type checks. 1213 const TagType *Tag = 0; 1214 if (const EnumType *EnumT = Arg->getAsEnumType()) 1215 Tag = EnumT; 1216 else if (const RecordType *RecordT = Arg->getAsRecordType()) 1217 Tag = RecordT; 1218 if (Tag && Tag->getDecl()->getDeclContext()->isFunctionOrMethod()) 1219 return Diag(ArgLoc, diag::err_template_arg_local_type) 1220 << QualType(Tag, 0); 1221 else if (Tag && !Tag->getDecl()->getDeclName() && 1222 !Tag->getDecl()->getTypedefForAnonDecl()) { 1223 Diag(ArgLoc, diag::err_template_arg_unnamed_type); 1224 Diag(Tag->getDecl()->getLocation(), diag::note_template_unnamed_type_here); 1225 return true; 1226 } 1227 1228 return false; 1229} 1230 1231/// \brief Checks whether the given template argument is the address 1232/// of an object or function according to C++ [temp.arg.nontype]p1. 1233bool Sema::CheckTemplateArgumentAddressOfObjectOrFunction(Expr *Arg, 1234 NamedDecl *&Entity) { 1235 bool Invalid = false; 1236 1237 // See through any implicit casts we added to fix the type. 1238 if (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(Arg)) 1239 Arg = Cast->getSubExpr(); 1240 1241 // C++0x allows nullptr, and there's no further checking to be done for that. 1242 if (Arg->getType()->isNullPtrType()) 1243 return false; 1244 1245 // C++ [temp.arg.nontype]p1: 1246 // 1247 // A template-argument for a non-type, non-template 1248 // template-parameter shall be one of: [...] 1249 // 1250 // -- the address of an object or function with external 1251 // linkage, including function templates and function 1252 // template-ids but excluding non-static class members, 1253 // expressed as & id-expression where the & is optional if 1254 // the name refers to a function or array, or if the 1255 // corresponding template-parameter is a reference; or 1256 DeclRefExpr *DRE = 0; 1257 1258 // Ignore (and complain about) any excess parentheses. 1259 while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) { 1260 if (!Invalid) { 1261 Diag(Arg->getSourceRange().getBegin(), 1262 diag::err_template_arg_extra_parens) 1263 << Arg->getSourceRange(); 1264 Invalid = true; 1265 } 1266 1267 Arg = Parens->getSubExpr(); 1268 } 1269 1270 if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) { 1271 if (UnOp->getOpcode() == UnaryOperator::AddrOf) 1272 DRE = dyn_cast<DeclRefExpr>(UnOp->getSubExpr()); 1273 } else 1274 DRE = dyn_cast<DeclRefExpr>(Arg); 1275 1276 if (!DRE || !isa<ValueDecl>(DRE->getDecl())) 1277 return Diag(Arg->getSourceRange().getBegin(), 1278 diag::err_template_arg_not_object_or_func_form) 1279 << Arg->getSourceRange(); 1280 1281 // Cannot refer to non-static data members 1282 if (FieldDecl *Field = dyn_cast<FieldDecl>(DRE->getDecl())) 1283 return Diag(Arg->getSourceRange().getBegin(), diag::err_template_arg_field) 1284 << Field << Arg->getSourceRange(); 1285 1286 // Cannot refer to non-static member functions 1287 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(DRE->getDecl())) 1288 if (!Method->isStatic()) 1289 return Diag(Arg->getSourceRange().getBegin(), 1290 diag::err_template_arg_method) 1291 << Method << Arg->getSourceRange(); 1292 1293 // Functions must have external linkage. 1294 if (FunctionDecl *Func = dyn_cast<FunctionDecl>(DRE->getDecl())) { 1295 if (Func->getStorageClass() == FunctionDecl::Static) { 1296 Diag(Arg->getSourceRange().getBegin(), 1297 diag::err_template_arg_function_not_extern) 1298 << Func << Arg->getSourceRange(); 1299 Diag(Func->getLocation(), diag::note_template_arg_internal_object) 1300 << true; 1301 return true; 1302 } 1303 1304 // Okay: we've named a function with external linkage. 1305 Entity = Func; 1306 return Invalid; 1307 } 1308 1309 if (VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) { 1310 if (!Var->hasGlobalStorage()) { 1311 Diag(Arg->getSourceRange().getBegin(), 1312 diag::err_template_arg_object_not_extern) 1313 << Var << Arg->getSourceRange(); 1314 Diag(Var->getLocation(), diag::note_template_arg_internal_object) 1315 << true; 1316 return true; 1317 } 1318 1319 // Okay: we've named an object with external linkage 1320 Entity = Var; 1321 return Invalid; 1322 } 1323 1324 // We found something else, but we don't know specifically what it is. 1325 Diag(Arg->getSourceRange().getBegin(), 1326 diag::err_template_arg_not_object_or_func) 1327 << Arg->getSourceRange(); 1328 Diag(DRE->getDecl()->getLocation(), 1329 diag::note_template_arg_refers_here); 1330 return true; 1331} 1332 1333/// \brief Checks whether the given template argument is a pointer to 1334/// member constant according to C++ [temp.arg.nontype]p1. 1335bool 1336Sema::CheckTemplateArgumentPointerToMember(Expr *Arg, NamedDecl *&Member) { 1337 bool Invalid = false; 1338 1339 // See through any implicit casts we added to fix the type. 1340 if (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(Arg)) 1341 Arg = Cast->getSubExpr(); 1342 1343 // C++0x allows nullptr, and there's no further checking to be done for that. 1344 if (Arg->getType()->isNullPtrType()) 1345 return false; 1346 1347 // C++ [temp.arg.nontype]p1: 1348 // 1349 // A template-argument for a non-type, non-template 1350 // template-parameter shall be one of: [...] 1351 // 1352 // -- a pointer to member expressed as described in 5.3.1. 1353 QualifiedDeclRefExpr *DRE = 0; 1354 1355 // Ignore (and complain about) any excess parentheses. 1356 while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) { 1357 if (!Invalid) { 1358 Diag(Arg->getSourceRange().getBegin(), 1359 diag::err_template_arg_extra_parens) 1360 << Arg->getSourceRange(); 1361 Invalid = true; 1362 } 1363 1364 Arg = Parens->getSubExpr(); 1365 } 1366 1367 if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) 1368 if (UnOp->getOpcode() == UnaryOperator::AddrOf) 1369 DRE = dyn_cast<QualifiedDeclRefExpr>(UnOp->getSubExpr()); 1370 1371 if (!DRE) 1372 return Diag(Arg->getSourceRange().getBegin(), 1373 diag::err_template_arg_not_pointer_to_member_form) 1374 << Arg->getSourceRange(); 1375 1376 if (isa<FieldDecl>(DRE->getDecl()) || isa<CXXMethodDecl>(DRE->getDecl())) { 1377 assert((isa<FieldDecl>(DRE->getDecl()) || 1378 !cast<CXXMethodDecl>(DRE->getDecl())->isStatic()) && 1379 "Only non-static member pointers can make it here"); 1380 1381 // Okay: this is the address of a non-static member, and therefore 1382 // a member pointer constant. 1383 Member = DRE->getDecl(); 1384 return Invalid; 1385 } 1386 1387 // We found something else, but we don't know specifically what it is. 1388 Diag(Arg->getSourceRange().getBegin(), 1389 diag::err_template_arg_not_pointer_to_member_form) 1390 << Arg->getSourceRange(); 1391 Diag(DRE->getDecl()->getLocation(), 1392 diag::note_template_arg_refers_here); 1393 return true; 1394} 1395 1396/// \brief Check a template argument against its corresponding 1397/// non-type template parameter. 1398/// 1399/// This routine implements the semantics of C++ [temp.arg.nontype]. 1400/// It returns true if an error occurred, and false otherwise. \p 1401/// InstantiatedParamType is the type of the non-type template 1402/// parameter after it has been instantiated. 1403/// 1404/// If Converted is non-NULL and no errors occur, the value 1405/// of this argument will be added to the end of the Converted vector. 1406bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param, 1407 QualType InstantiatedParamType, Expr *&Arg, 1408 TemplateArgumentListBuilder *Converted) { 1409 SourceLocation StartLoc = Arg->getSourceRange().getBegin(); 1410 1411 // If either the parameter has a dependent type or the argument is 1412 // type-dependent, there's nothing we can check now. 1413 // FIXME: Add template argument to Converted! 1414 if (InstantiatedParamType->isDependentType() || Arg->isTypeDependent()) { 1415 // FIXME: Produce a cloned, canonical expression? 1416 if (Converted) 1417 Converted->push_back(TemplateArgument(Arg)); 1418 return false; 1419 } 1420 1421 // C++ [temp.arg.nontype]p5: 1422 // The following conversions are performed on each expression used 1423 // as a non-type template-argument. If a non-type 1424 // template-argument cannot be converted to the type of the 1425 // corresponding template-parameter then the program is 1426 // ill-formed. 1427 // 1428 // -- for a non-type template-parameter of integral or 1429 // enumeration type, integral promotions (4.5) and integral 1430 // conversions (4.7) are applied. 1431 QualType ParamType = InstantiatedParamType; 1432 QualType ArgType = Arg->getType(); 1433 if (ParamType->isIntegralType() || ParamType->isEnumeralType()) { 1434 // C++ [temp.arg.nontype]p1: 1435 // A template-argument for a non-type, non-template 1436 // template-parameter shall be one of: 1437 // 1438 // -- an integral constant-expression of integral or enumeration 1439 // type; or 1440 // -- the name of a non-type template-parameter; or 1441 SourceLocation NonConstantLoc; 1442 llvm::APSInt Value; 1443 if (!ArgType->isIntegralType() && !ArgType->isEnumeralType()) { 1444 Diag(Arg->getSourceRange().getBegin(), 1445 diag::err_template_arg_not_integral_or_enumeral) 1446 << ArgType << Arg->getSourceRange(); 1447 Diag(Param->getLocation(), diag::note_template_param_here); 1448 return true; 1449 } else if (!Arg->isValueDependent() && 1450 !Arg->isIntegerConstantExpr(Value, Context, &NonConstantLoc)) { 1451 Diag(NonConstantLoc, diag::err_template_arg_not_ice) 1452 << ArgType << Arg->getSourceRange(); 1453 return true; 1454 } 1455 1456 // FIXME: We need some way to more easily get the unqualified form 1457 // of the types without going all the way to the 1458 // canonical type. 1459 if (Context.getCanonicalType(ParamType).getCVRQualifiers()) 1460 ParamType = Context.getCanonicalType(ParamType).getUnqualifiedType(); 1461 if (Context.getCanonicalType(ArgType).getCVRQualifiers()) 1462 ArgType = Context.getCanonicalType(ArgType).getUnqualifiedType(); 1463 1464 // Try to convert the argument to the parameter's type. 1465 if (ParamType == ArgType) { 1466 // Okay: no conversion necessary 1467 } else if (IsIntegralPromotion(Arg, ArgType, ParamType) || 1468 !ParamType->isEnumeralType()) { 1469 // This is an integral promotion or conversion. 1470 ImpCastExprToType(Arg, ParamType); 1471 } else { 1472 // We can't perform this conversion. 1473 Diag(Arg->getSourceRange().getBegin(), 1474 diag::err_template_arg_not_convertible) 1475 << Arg->getType() << InstantiatedParamType << Arg->getSourceRange(); 1476 Diag(Param->getLocation(), diag::note_template_param_here); 1477 return true; 1478 } 1479 1480 QualType IntegerType = Context.getCanonicalType(ParamType); 1481 if (const EnumType *Enum = IntegerType->getAsEnumType()) 1482 IntegerType = Enum->getDecl()->getIntegerType(); 1483 1484 if (!Arg->isValueDependent()) { 1485 // Check that an unsigned parameter does not receive a negative 1486 // value. 1487 if (IntegerType->isUnsignedIntegerType() 1488 && (Value.isSigned() && Value.isNegative())) { 1489 Diag(Arg->getSourceRange().getBegin(), diag::err_template_arg_negative) 1490 << Value.toString(10) << Param->getType() 1491 << Arg->getSourceRange(); 1492 Diag(Param->getLocation(), diag::note_template_param_here); 1493 return true; 1494 } 1495 1496 // Check that we don't overflow the template parameter type. 1497 unsigned AllowedBits = Context.getTypeSize(IntegerType); 1498 if (Value.getActiveBits() > AllowedBits) { 1499 Diag(Arg->getSourceRange().getBegin(), 1500 diag::err_template_arg_too_large) 1501 << Value.toString(10) << Param->getType() 1502 << Arg->getSourceRange(); 1503 Diag(Param->getLocation(), diag::note_template_param_here); 1504 return true; 1505 } 1506 1507 if (Value.getBitWidth() != AllowedBits) 1508 Value.extOrTrunc(AllowedBits); 1509 Value.setIsSigned(IntegerType->isSignedIntegerType()); 1510 } 1511 1512 if (Converted) { 1513 // Add the value of this argument to the list of converted 1514 // arguments. We use the bitwidth and signedness of the template 1515 // parameter. 1516 if (Arg->isValueDependent()) { 1517 // The argument is value-dependent. Create a new 1518 // TemplateArgument with the converted expression. 1519 Converted->push_back(TemplateArgument(Arg)); 1520 return false; 1521 } 1522 1523 Converted->push_back(TemplateArgument(StartLoc, Value, 1524 ParamType->isEnumeralType() ? ParamType : IntegerType)); 1525 } 1526 1527 return false; 1528 } 1529 1530 // Handle pointer-to-function, reference-to-function, and 1531 // pointer-to-member-function all in (roughly) the same way. 1532 if (// -- For a non-type template-parameter of type pointer to 1533 // function, only the function-to-pointer conversion (4.3) is 1534 // applied. If the template-argument represents a set of 1535 // overloaded functions (or a pointer to such), the matching 1536 // function is selected from the set (13.4). 1537 // In C++0x, any std::nullptr_t value can be converted. 1538 (ParamType->isPointerType() && 1539 ParamType->getAsPointerType()->getPointeeType()->isFunctionType()) || 1540 // -- For a non-type template-parameter of type reference to 1541 // function, no conversions apply. If the template-argument 1542 // represents a set of overloaded functions, the matching 1543 // function is selected from the set (13.4). 1544 (ParamType->isReferenceType() && 1545 ParamType->getAsReferenceType()->getPointeeType()->isFunctionType()) || 1546 // -- For a non-type template-parameter of type pointer to 1547 // member function, no conversions apply. If the 1548 // template-argument represents a set of overloaded member 1549 // functions, the matching member function is selected from 1550 // the set (13.4). 1551 // Again, C++0x allows a std::nullptr_t value. 1552 (ParamType->isMemberPointerType() && 1553 ParamType->getAsMemberPointerType()->getPointeeType() 1554 ->isFunctionType())) { 1555 if (Context.hasSameUnqualifiedType(ArgType, 1556 ParamType.getNonReferenceType())) { 1557 // We don't have to do anything: the types already match. 1558 } else if (ArgType->isNullPtrType() && (ParamType->isPointerType() || 1559 ParamType->isMemberPointerType())) { 1560 ArgType = ParamType; 1561 ImpCastExprToType(Arg, ParamType); 1562 } else if (ArgType->isFunctionType() && ParamType->isPointerType()) { 1563 ArgType = Context.getPointerType(ArgType); 1564 ImpCastExprToType(Arg, ArgType); 1565 } else if (FunctionDecl *Fn 1566 = ResolveAddressOfOverloadedFunction(Arg, ParamType, true)) { 1567 if (DiagnoseUseOfDecl(Fn, Arg->getSourceRange().getBegin())) 1568 return true; 1569 1570 FixOverloadedFunctionReference(Arg, Fn); 1571 ArgType = Arg->getType(); 1572 if (ArgType->isFunctionType() && ParamType->isPointerType()) { 1573 ArgType = Context.getPointerType(Arg->getType()); 1574 ImpCastExprToType(Arg, ArgType); 1575 } 1576 } 1577 1578 if (!Context.hasSameUnqualifiedType(ArgType, 1579 ParamType.getNonReferenceType())) { 1580 // We can't perform this conversion. 1581 Diag(Arg->getSourceRange().getBegin(), 1582 diag::err_template_arg_not_convertible) 1583 << Arg->getType() << InstantiatedParamType << Arg->getSourceRange(); 1584 Diag(Param->getLocation(), diag::note_template_param_here); 1585 return true; 1586 } 1587 1588 if (ParamType->isMemberPointerType()) { 1589 NamedDecl *Member = 0; 1590 if (CheckTemplateArgumentPointerToMember(Arg, Member)) 1591 return true; 1592 1593 if (Converted) { 1594 Member = cast_or_null<NamedDecl>(Context.getCanonicalDecl(Member)); 1595 Converted->push_back(TemplateArgument(StartLoc, Member)); 1596 } 1597 1598 return false; 1599 } 1600 1601 NamedDecl *Entity = 0; 1602 if (CheckTemplateArgumentAddressOfObjectOrFunction(Arg, Entity)) 1603 return true; 1604 1605 if (Converted) { 1606 Entity = cast_or_null<NamedDecl>(Context.getCanonicalDecl(Entity)); 1607 Converted->push_back(TemplateArgument(StartLoc, Entity)); 1608 } 1609 return false; 1610 } 1611 1612 if (ParamType->isPointerType()) { 1613 // -- for a non-type template-parameter of type pointer to 1614 // object, qualification conversions (4.4) and the 1615 // array-to-pointer conversion (4.2) are applied. 1616 // C++0x also allows a value of std::nullptr_t. 1617 assert(ParamType->getAsPointerType()->getPointeeType()->isObjectType() && 1618 "Only object pointers allowed here"); 1619 1620 if (ArgType->isNullPtrType()) { 1621 ArgType = ParamType; 1622 ImpCastExprToType(Arg, ParamType); 1623 } else if (ArgType->isArrayType()) { 1624 ArgType = Context.getArrayDecayedType(ArgType); 1625 ImpCastExprToType(Arg, ArgType); 1626 } 1627 1628 if (IsQualificationConversion(ArgType, ParamType)) { 1629 ArgType = ParamType; 1630 ImpCastExprToType(Arg, ParamType); 1631 } 1632 1633 if (!Context.hasSameUnqualifiedType(ArgType, ParamType)) { 1634 // We can't perform this conversion. 1635 Diag(Arg->getSourceRange().getBegin(), 1636 diag::err_template_arg_not_convertible) 1637 << Arg->getType() << InstantiatedParamType << Arg->getSourceRange(); 1638 Diag(Param->getLocation(), diag::note_template_param_here); 1639 return true; 1640 } 1641 1642 NamedDecl *Entity = 0; 1643 if (CheckTemplateArgumentAddressOfObjectOrFunction(Arg, Entity)) 1644 return true; 1645 1646 if (Converted) { 1647 Entity = cast_or_null<NamedDecl>(Context.getCanonicalDecl(Entity)); 1648 Converted->push_back(TemplateArgument(StartLoc, Entity)); 1649 } 1650 1651 return false; 1652 } 1653 1654 if (const ReferenceType *ParamRefType = ParamType->getAsReferenceType()) { 1655 // -- For a non-type template-parameter of type reference to 1656 // object, no conversions apply. The type referred to by the 1657 // reference may be more cv-qualified than the (otherwise 1658 // identical) type of the template-argument. The 1659 // template-parameter is bound directly to the 1660 // template-argument, which must be an lvalue. 1661 assert(ParamRefType->getPointeeType()->isObjectType() && 1662 "Only object references allowed here"); 1663 1664 if (!Context.hasSameUnqualifiedType(ParamRefType->getPointeeType(), ArgType)) { 1665 Diag(Arg->getSourceRange().getBegin(), 1666 diag::err_template_arg_no_ref_bind) 1667 << InstantiatedParamType << Arg->getType() 1668 << Arg->getSourceRange(); 1669 Diag(Param->getLocation(), diag::note_template_param_here); 1670 return true; 1671 } 1672 1673 unsigned ParamQuals 1674 = Context.getCanonicalType(ParamType).getCVRQualifiers(); 1675 unsigned ArgQuals = Context.getCanonicalType(ArgType).getCVRQualifiers(); 1676 1677 if ((ParamQuals | ArgQuals) != ParamQuals) { 1678 Diag(Arg->getSourceRange().getBegin(), 1679 diag::err_template_arg_ref_bind_ignores_quals) 1680 << InstantiatedParamType << Arg->getType() 1681 << Arg->getSourceRange(); 1682 Diag(Param->getLocation(), diag::note_template_param_here); 1683 return true; 1684 } 1685 1686 NamedDecl *Entity = 0; 1687 if (CheckTemplateArgumentAddressOfObjectOrFunction(Arg, Entity)) 1688 return true; 1689 1690 if (Converted) { 1691 Entity = cast<NamedDecl>(Context.getCanonicalDecl(Entity)); 1692 Converted->push_back(TemplateArgument(StartLoc, Entity)); 1693 } 1694 1695 return false; 1696 } 1697 1698 // -- For a non-type template-parameter of type pointer to data 1699 // member, qualification conversions (4.4) are applied. 1700 // C++0x allows std::nullptr_t values. 1701 assert(ParamType->isMemberPointerType() && "Only pointers to members remain"); 1702 1703 if (Context.hasSameUnqualifiedType(ParamType, ArgType)) { 1704 // Types match exactly: nothing more to do here. 1705 } else if (ArgType->isNullPtrType()) { 1706 ImpCastExprToType(Arg, ParamType); 1707 } else if (IsQualificationConversion(ArgType, ParamType)) { 1708 ImpCastExprToType(Arg, ParamType); 1709 } else { 1710 // We can't perform this conversion. 1711 Diag(Arg->getSourceRange().getBegin(), 1712 diag::err_template_arg_not_convertible) 1713 << Arg->getType() << InstantiatedParamType << Arg->getSourceRange(); 1714 Diag(Param->getLocation(), diag::note_template_param_here); 1715 return true; 1716 } 1717 1718 NamedDecl *Member = 0; 1719 if (CheckTemplateArgumentPointerToMember(Arg, Member)) 1720 return true; 1721 1722 if (Converted) { 1723 Member = cast_or_null<NamedDecl>(Context.getCanonicalDecl(Member)); 1724 Converted->push_back(TemplateArgument(StartLoc, Member)); 1725 } 1726 1727 return false; 1728} 1729 1730/// \brief Check a template argument against its corresponding 1731/// template template parameter. 1732/// 1733/// This routine implements the semantics of C++ [temp.arg.template]. 1734/// It returns true if an error occurred, and false otherwise. 1735bool Sema::CheckTemplateArgument(TemplateTemplateParmDecl *Param, 1736 DeclRefExpr *Arg) { 1737 assert(isa<TemplateDecl>(Arg->getDecl()) && "Only template decls allowed"); 1738 TemplateDecl *Template = cast<TemplateDecl>(Arg->getDecl()); 1739 1740 // C++ [temp.arg.template]p1: 1741 // A template-argument for a template template-parameter shall be 1742 // the name of a class template, expressed as id-expression. Only 1743 // primary class templates are considered when matching the 1744 // template template argument with the corresponding parameter; 1745 // partial specializations are not considered even if their 1746 // parameter lists match that of the template template parameter. 1747 if (!isa<ClassTemplateDecl>(Template)) { 1748 assert(isa<FunctionTemplateDecl>(Template) && 1749 "Only function templates are possible here"); 1750 Diag(Arg->getSourceRange().getBegin(), 1751 diag::note_template_arg_refers_here_func) 1752 << Template; 1753 } 1754 1755 return !TemplateParameterListsAreEqual(Template->getTemplateParameters(), 1756 Param->getTemplateParameters(), 1757 true, true, 1758 Arg->getSourceRange().getBegin()); 1759} 1760 1761/// \brief Determine whether the given template parameter lists are 1762/// equivalent. 1763/// 1764/// \param New The new template parameter list, typically written in the 1765/// source code as part of a new template declaration. 1766/// 1767/// \param Old The old template parameter list, typically found via 1768/// name lookup of the template declared with this template parameter 1769/// list. 1770/// 1771/// \param Complain If true, this routine will produce a diagnostic if 1772/// the template parameter lists are not equivalent. 1773/// 1774/// \param IsTemplateTemplateParm If true, this routine is being 1775/// called to compare the template parameter lists of a template 1776/// template parameter. 1777/// 1778/// \param TemplateArgLoc If this source location is valid, then we 1779/// are actually checking the template parameter list of a template 1780/// argument (New) against the template parameter list of its 1781/// corresponding template template parameter (Old). We produce 1782/// slightly different diagnostics in this scenario. 1783/// 1784/// \returns True if the template parameter lists are equal, false 1785/// otherwise. 1786bool 1787Sema::TemplateParameterListsAreEqual(TemplateParameterList *New, 1788 TemplateParameterList *Old, 1789 bool Complain, 1790 bool IsTemplateTemplateParm, 1791 SourceLocation TemplateArgLoc) { 1792 if (Old->size() != New->size()) { 1793 if (Complain) { 1794 unsigned NextDiag = diag::err_template_param_list_different_arity; 1795 if (TemplateArgLoc.isValid()) { 1796 Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch); 1797 NextDiag = diag::note_template_param_list_different_arity; 1798 } 1799 Diag(New->getTemplateLoc(), NextDiag) 1800 << (New->size() > Old->size()) 1801 << IsTemplateTemplateParm 1802 << SourceRange(New->getTemplateLoc(), New->getRAngleLoc()); 1803 Diag(Old->getTemplateLoc(), diag::note_template_prev_declaration) 1804 << IsTemplateTemplateParm 1805 << SourceRange(Old->getTemplateLoc(), Old->getRAngleLoc()); 1806 } 1807 1808 return false; 1809 } 1810 1811 for (TemplateParameterList::iterator OldParm = Old->begin(), 1812 OldParmEnd = Old->end(), NewParm = New->begin(); 1813 OldParm != OldParmEnd; ++OldParm, ++NewParm) { 1814 if ((*OldParm)->getKind() != (*NewParm)->getKind()) { 1815 unsigned NextDiag = diag::err_template_param_different_kind; 1816 if (TemplateArgLoc.isValid()) { 1817 Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch); 1818 NextDiag = diag::note_template_param_different_kind; 1819 } 1820 Diag((*NewParm)->getLocation(), NextDiag) 1821 << IsTemplateTemplateParm; 1822 Diag((*OldParm)->getLocation(), diag::note_template_prev_declaration) 1823 << IsTemplateTemplateParm; 1824 return false; 1825 } 1826 1827 if (isa<TemplateTypeParmDecl>(*OldParm)) { 1828 // Okay; all template type parameters are equivalent (since we 1829 // know we're at the same index). 1830#if 0 1831 // FIXME: Enable this code in debug mode *after* we properly go through 1832 // and "instantiate" the template parameter lists of template template 1833 // parameters. It's only after this instantiation that (1) any dependent 1834 // types within the template parameter list of the template template 1835 // parameter can be checked, and (2) the template type parameter depths 1836 // will match up. 1837 QualType OldParmType 1838 = Context.getTypeDeclType(cast<TemplateTypeParmDecl>(*OldParm)); 1839 QualType NewParmType 1840 = Context.getTypeDeclType(cast<TemplateTypeParmDecl>(*NewParm)); 1841 assert(Context.getCanonicalType(OldParmType) == 1842 Context.getCanonicalType(NewParmType) && 1843 "type parameter mismatch?"); 1844#endif 1845 } else if (NonTypeTemplateParmDecl *OldNTTP 1846 = dyn_cast<NonTypeTemplateParmDecl>(*OldParm)) { 1847 // The types of non-type template parameters must agree. 1848 NonTypeTemplateParmDecl *NewNTTP 1849 = cast<NonTypeTemplateParmDecl>(*NewParm); 1850 if (Context.getCanonicalType(OldNTTP->getType()) != 1851 Context.getCanonicalType(NewNTTP->getType())) { 1852 if (Complain) { 1853 unsigned NextDiag = diag::err_template_nontype_parm_different_type; 1854 if (TemplateArgLoc.isValid()) { 1855 Diag(TemplateArgLoc, 1856 diag::err_template_arg_template_params_mismatch); 1857 NextDiag = diag::note_template_nontype_parm_different_type; 1858 } 1859 Diag(NewNTTP->getLocation(), NextDiag) 1860 << NewNTTP->getType() 1861 << IsTemplateTemplateParm; 1862 Diag(OldNTTP->getLocation(), 1863 diag::note_template_nontype_parm_prev_declaration) 1864 << OldNTTP->getType(); 1865 } 1866 return false; 1867 } 1868 } else { 1869 // The template parameter lists of template template 1870 // parameters must agree. 1871 // FIXME: Could we perform a faster "type" comparison here? 1872 assert(isa<TemplateTemplateParmDecl>(*OldParm) && 1873 "Only template template parameters handled here"); 1874 TemplateTemplateParmDecl *OldTTP 1875 = cast<TemplateTemplateParmDecl>(*OldParm); 1876 TemplateTemplateParmDecl *NewTTP 1877 = cast<TemplateTemplateParmDecl>(*NewParm); 1878 if (!TemplateParameterListsAreEqual(NewTTP->getTemplateParameters(), 1879 OldTTP->getTemplateParameters(), 1880 Complain, 1881 /*IsTemplateTemplateParm=*/true, 1882 TemplateArgLoc)) 1883 return false; 1884 } 1885 } 1886 1887 return true; 1888} 1889 1890/// \brief Check whether a template can be declared within this scope. 1891/// 1892/// If the template declaration is valid in this scope, returns 1893/// false. Otherwise, issues a diagnostic and returns true. 1894bool 1895Sema::CheckTemplateDeclScope(Scope *S, 1896 MultiTemplateParamsArg &TemplateParameterLists) { 1897 assert(TemplateParameterLists.size() > 0 && "Not a template"); 1898 1899 // Find the nearest enclosing declaration scope. 1900 while ((S->getFlags() & Scope::DeclScope) == 0 || 1901 (S->getFlags() & Scope::TemplateParamScope) != 0) 1902 S = S->getParent(); 1903 1904 TemplateParameterList *TemplateParams = 1905 static_cast<TemplateParameterList*>(*TemplateParameterLists.get()); 1906 SourceLocation TemplateLoc = TemplateParams->getTemplateLoc(); 1907 SourceRange TemplateRange 1908 = SourceRange(TemplateLoc, TemplateParams->getRAngleLoc()); 1909 1910 // C++ [temp]p2: 1911 // A template-declaration can appear only as a namespace scope or 1912 // class scope declaration. 1913 DeclContext *Ctx = static_cast<DeclContext *>(S->getEntity()); 1914 while (Ctx && isa<LinkageSpecDecl>(Ctx)) { 1915 if (cast<LinkageSpecDecl>(Ctx)->getLanguage() != LinkageSpecDecl::lang_cxx) 1916 return Diag(TemplateLoc, diag::err_template_linkage) 1917 << TemplateRange; 1918 1919 Ctx = Ctx->getParent(); 1920 } 1921 1922 if (Ctx && (Ctx->isFileContext() || Ctx->isRecord())) 1923 return false; 1924 1925 return Diag(TemplateLoc, diag::err_template_outside_namespace_or_class_scope) 1926 << TemplateRange; 1927} 1928 1929/// \brief Check whether a class template specialization or explicit 1930/// instantiation in the current context is well-formed. 1931/// 1932/// This routine determines whether a class template specialization or 1933/// explicit instantiation can be declared in the current context 1934/// (C++ [temp.expl.spec]p2, C++0x [temp.explicit]p2) and emits 1935/// appropriate diagnostics if there was an error. It returns true if 1936// there was an error that we cannot recover from, and false otherwise. 1937bool 1938Sema::CheckClassTemplateSpecializationScope(ClassTemplateDecl *ClassTemplate, 1939 ClassTemplateSpecializationDecl *PrevDecl, 1940 SourceLocation TemplateNameLoc, 1941 SourceRange ScopeSpecifierRange, 1942 bool ExplicitInstantiation) { 1943 // C++ [temp.expl.spec]p2: 1944 // An explicit specialization shall be declared in the namespace 1945 // of which the template is a member, or, for member templates, in 1946 // the namespace of which the enclosing class or enclosing class 1947 // template is a member. An explicit specialization of a member 1948 // function, member class or static data member of a class 1949 // template shall be declared in the namespace of which the class 1950 // template is a member. Such a declaration may also be a 1951 // definition. If the declaration is not a definition, the 1952 // specialization may be defined later in the name- space in which 1953 // the explicit specialization was declared, or in a namespace 1954 // that encloses the one in which the explicit specialization was 1955 // declared. 1956 if (CurContext->getLookupContext()->isFunctionOrMethod()) { 1957 Diag(TemplateNameLoc, diag::err_template_spec_decl_function_scope) 1958 << ExplicitInstantiation << ClassTemplate; 1959 return true; 1960 } 1961 1962 DeclContext *DC = CurContext->getEnclosingNamespaceContext(); 1963 DeclContext *TemplateContext 1964 = ClassTemplate->getDeclContext()->getEnclosingNamespaceContext(); 1965 if ((!PrevDecl || PrevDecl->getSpecializationKind() == TSK_Undeclared) && 1966 !ExplicitInstantiation) { 1967 // There is no prior declaration of this entity, so this 1968 // specialization must be in the same context as the template 1969 // itself. 1970 if (DC != TemplateContext) { 1971 if (isa<TranslationUnitDecl>(TemplateContext)) 1972 Diag(TemplateNameLoc, diag::err_template_spec_decl_out_of_scope_global) 1973 << ClassTemplate << ScopeSpecifierRange; 1974 else if (isa<NamespaceDecl>(TemplateContext)) 1975 Diag(TemplateNameLoc, diag::err_template_spec_decl_out_of_scope) 1976 << ClassTemplate << cast<NamedDecl>(TemplateContext) 1977 << ScopeSpecifierRange; 1978 1979 Diag(ClassTemplate->getLocation(), diag::note_template_decl_here); 1980 } 1981 1982 return false; 1983 } 1984 1985 // We have a previous declaration of this entity. Make sure that 1986 // this redeclaration (or definition) occurs in an enclosing namespace. 1987 if (!CurContext->Encloses(TemplateContext)) { 1988 // FIXME: In C++98, we would like to turn these errors into warnings, 1989 // dependent on a -Wc++0x flag. 1990 bool SuppressedDiag = false; 1991 if (isa<TranslationUnitDecl>(TemplateContext)) { 1992 if (!ExplicitInstantiation || getLangOptions().CPlusPlus0x) 1993 Diag(TemplateNameLoc, diag::err_template_spec_redecl_global_scope) 1994 << ExplicitInstantiation << ClassTemplate << ScopeSpecifierRange; 1995 else 1996 SuppressedDiag = true; 1997 } else if (isa<NamespaceDecl>(TemplateContext)) { 1998 if (!ExplicitInstantiation || getLangOptions().CPlusPlus0x) 1999 Diag(TemplateNameLoc, diag::err_template_spec_redecl_out_of_scope) 2000 << ExplicitInstantiation << ClassTemplate 2001 << cast<NamedDecl>(TemplateContext) << ScopeSpecifierRange; 2002 else 2003 SuppressedDiag = true; 2004 } 2005 2006 if (!SuppressedDiag) 2007 Diag(ClassTemplate->getLocation(), diag::note_template_decl_here); 2008 } 2009 2010 return false; 2011} 2012 2013Sema::DeclResult 2014Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagKind TK, 2015 SourceLocation KWLoc, 2016 const CXXScopeSpec &SS, 2017 TemplateTy TemplateD, 2018 SourceLocation TemplateNameLoc, 2019 SourceLocation LAngleLoc, 2020 ASTTemplateArgsPtr TemplateArgsIn, 2021 SourceLocation *TemplateArgLocs, 2022 SourceLocation RAngleLoc, 2023 AttributeList *Attr, 2024 MultiTemplateParamsArg TemplateParameterLists) { 2025 // Find the class template we're specializing 2026 TemplateName Name = TemplateD.getAsVal<TemplateName>(); 2027 ClassTemplateDecl *ClassTemplate 2028 = cast<ClassTemplateDecl>(Name.getAsTemplateDecl()); 2029 2030 bool isPartialSpecialization = false; 2031 2032 // Check the validity of the template headers that introduce this 2033 // template. 2034 // FIXME: Once we have member templates, we'll need to check 2035 // C++ [temp.expl.spec]p17-18, where we could have multiple levels of 2036 // template<> headers. 2037 if (TemplateParameterLists.size() == 0) 2038 Diag(KWLoc, diag::err_template_spec_needs_header) 2039 << CodeModificationHint::CreateInsertion(KWLoc, "template<> "); 2040 else { 2041 TemplateParameterList *TemplateParams 2042 = static_cast<TemplateParameterList*>(*TemplateParameterLists.get()); 2043 if (TemplateParameterLists.size() > 1) { 2044 Diag(TemplateParams->getTemplateLoc(), 2045 diag::err_template_spec_extra_headers); 2046 return true; 2047 } 2048 2049 // FIXME: We'll need more checks, here! 2050 if (TemplateParams->size() > 0) 2051 isPartialSpecialization = true; 2052 } 2053 2054 // Check that the specialization uses the same tag kind as the 2055 // original template. 2056 TagDecl::TagKind Kind; 2057 switch (TagSpec) { 2058 default: assert(0 && "Unknown tag type!"); 2059 case DeclSpec::TST_struct: Kind = TagDecl::TK_struct; break; 2060 case DeclSpec::TST_union: Kind = TagDecl::TK_union; break; 2061 case DeclSpec::TST_class: Kind = TagDecl::TK_class; break; 2062 } 2063 if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(), 2064 Kind, KWLoc, 2065 *ClassTemplate->getIdentifier())) { 2066 Diag(KWLoc, diag::err_use_with_wrong_tag) 2067 << ClassTemplate 2068 << CodeModificationHint::CreateReplacement(KWLoc, 2069 ClassTemplate->getTemplatedDecl()->getKindName()); 2070 Diag(ClassTemplate->getTemplatedDecl()->getLocation(), 2071 diag::note_previous_use); 2072 Kind = ClassTemplate->getTemplatedDecl()->getTagKind(); 2073 } 2074 2075 // Translate the parser's template argument list in our AST format. 2076 llvm::SmallVector<TemplateArgument, 16> TemplateArgs; 2077 translateTemplateArguments(TemplateArgsIn, TemplateArgLocs, TemplateArgs); 2078 2079 // Check that the template argument list is well-formed for this 2080 // template. 2081 TemplateArgumentListBuilder ConvertedTemplateArgs(Context); 2082 if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc, LAngleLoc, 2083 &TemplateArgs[0], TemplateArgs.size(), 2084 RAngleLoc, ConvertedTemplateArgs)) 2085 return true; 2086 2087 assert((ConvertedTemplateArgs.size() == 2088 ClassTemplate->getTemplateParameters()->size()) && 2089 "Converted template argument list is too short!"); 2090 2091 // Find the class template (partial) specialization declaration that 2092 // corresponds to these arguments. 2093 llvm::FoldingSetNodeID ID; 2094 if (isPartialSpecialization) 2095 // FIXME: Template parameter list matters, too 2096 ClassTemplatePartialSpecializationDecl::Profile(ID, 2097 ConvertedTemplateArgs.getFlatArgumentList(), 2098 ConvertedTemplateArgs.flatSize()); 2099 else 2100 ClassTemplateSpecializationDecl::Profile(ID, 2101 ConvertedTemplateArgs.getFlatArgumentList(), 2102 ConvertedTemplateArgs.flatSize()); 2103 void *InsertPos = 0; 2104 ClassTemplateSpecializationDecl *PrevDecl = 0; 2105 2106 if (isPartialSpecialization) 2107 PrevDecl 2108 = ClassTemplate->getPartialSpecializations().FindNodeOrInsertPos(ID, 2109 InsertPos); 2110 else 2111 PrevDecl 2112 = ClassTemplate->getSpecializations().FindNodeOrInsertPos(ID, InsertPos); 2113 2114 ClassTemplateSpecializationDecl *Specialization = 0; 2115 2116 // Check whether we can declare a class template specialization in 2117 // the current scope. 2118 if (CheckClassTemplateSpecializationScope(ClassTemplate, PrevDecl, 2119 TemplateNameLoc, 2120 SS.getRange(), 2121 /*ExplicitInstantiation=*/false)) 2122 return true; 2123 2124 if (PrevDecl && PrevDecl->getSpecializationKind() == TSK_Undeclared) { 2125 // Since the only prior class template specialization with these 2126 // arguments was referenced but not declared, reuse that 2127 // declaration node as our own, updating its source location to 2128 // reflect our new declaration. 2129 Specialization = PrevDecl; 2130 Specialization->setLocation(TemplateNameLoc); 2131 PrevDecl = 0; 2132 } else if (isPartialSpecialization) { 2133 // FIXME: extra checking for partial specializations 2134 2135 // Create a new class template partial specialization declaration node. 2136 TemplateParameterList *TemplateParams 2137 = static_cast<TemplateParameterList*>(*TemplateParameterLists.get()); 2138 ClassTemplatePartialSpecializationDecl *PrevPartial 2139 = cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl); 2140 ClassTemplatePartialSpecializationDecl *Partial 2141 = ClassTemplatePartialSpecializationDecl::Create(Context, 2142 ClassTemplate->getDeclContext(), 2143 TemplateNameLoc, 2144 TemplateParams, 2145 ClassTemplate, 2146 ConvertedTemplateArgs, 2147 PrevPartial); 2148 2149 if (PrevPartial) { 2150 ClassTemplate->getPartialSpecializations().RemoveNode(PrevPartial); 2151 ClassTemplate->getPartialSpecializations().GetOrInsertNode(Partial); 2152 } else { 2153 ClassTemplate->getPartialSpecializations().InsertNode(Partial, InsertPos); 2154 } 2155 Specialization = Partial; 2156 } else { 2157 // Create a new class template specialization declaration node for 2158 // this explicit specialization. 2159 Specialization 2160 = ClassTemplateSpecializationDecl::Create(Context, 2161 ClassTemplate->getDeclContext(), 2162 TemplateNameLoc, 2163 ClassTemplate, 2164 ConvertedTemplateArgs, 2165 PrevDecl); 2166 2167 if (PrevDecl) { 2168 ClassTemplate->getSpecializations().RemoveNode(PrevDecl); 2169 ClassTemplate->getSpecializations().GetOrInsertNode(Specialization); 2170 } else { 2171 ClassTemplate->getSpecializations().InsertNode(Specialization, 2172 InsertPos); 2173 } 2174 } 2175 2176 // Note that this is an explicit specialization. 2177 Specialization->setSpecializationKind(TSK_ExplicitSpecialization); 2178 2179 // Check that this isn't a redefinition of this specialization. 2180 if (TK == TK_Definition) { 2181 if (RecordDecl *Def = Specialization->getDefinition(Context)) { 2182 // FIXME: Should also handle explicit specialization after implicit 2183 // instantiation with a special diagnostic. 2184 SourceRange Range(TemplateNameLoc, RAngleLoc); 2185 Diag(TemplateNameLoc, diag::err_redefinition) 2186 << Context.getTypeDeclType(Specialization) << Range; 2187 Diag(Def->getLocation(), diag::note_previous_definition); 2188 Specialization->setInvalidDecl(); 2189 return true; 2190 } 2191 } 2192 2193 // Build the fully-sugared type for this class template 2194 // specialization as the user wrote in the specialization 2195 // itself. This means that we'll pretty-print the type retrieved 2196 // from the specialization's declaration the way that the user 2197 // actually wrote the specialization, rather than formatting the 2198 // name based on the "canonical" representation used to store the 2199 // template arguments in the specialization. 2200 QualType WrittenTy 2201 = Context.getTemplateSpecializationType(Name, 2202 &TemplateArgs[0], 2203 TemplateArgs.size(), 2204 Context.getTypeDeclType(Specialization)); 2205 Specialization->setTypeAsWritten(WrittenTy); 2206 TemplateArgsIn.release(); 2207 2208 // C++ [temp.expl.spec]p9: 2209 // A template explicit specialization is in the scope of the 2210 // namespace in which the template was defined. 2211 // 2212 // We actually implement this paragraph where we set the semantic 2213 // context (in the creation of the ClassTemplateSpecializationDecl), 2214 // but we also maintain the lexical context where the actual 2215 // definition occurs. 2216 Specialization->setLexicalDeclContext(CurContext); 2217 2218 // We may be starting the definition of this specialization. 2219 if (TK == TK_Definition) 2220 Specialization->startDefinition(); 2221 2222 // Add the specialization into its lexical context, so that it can 2223 // be seen when iterating through the list of declarations in that 2224 // context. However, specializations are not found by name lookup. 2225 CurContext->addDecl(Context, Specialization); 2226 return DeclPtrTy::make(Specialization); 2227} 2228 2229// Explicit instantiation of a class template specialization 2230Sema::DeclResult 2231Sema::ActOnExplicitInstantiation(Scope *S, SourceLocation TemplateLoc, 2232 unsigned TagSpec, 2233 SourceLocation KWLoc, 2234 const CXXScopeSpec &SS, 2235 TemplateTy TemplateD, 2236 SourceLocation TemplateNameLoc, 2237 SourceLocation LAngleLoc, 2238 ASTTemplateArgsPtr TemplateArgsIn, 2239 SourceLocation *TemplateArgLocs, 2240 SourceLocation RAngleLoc, 2241 AttributeList *Attr) { 2242 // Find the class template we're specializing 2243 TemplateName Name = TemplateD.getAsVal<TemplateName>(); 2244 ClassTemplateDecl *ClassTemplate 2245 = cast<ClassTemplateDecl>(Name.getAsTemplateDecl()); 2246 2247 // Check that the specialization uses the same tag kind as the 2248 // original template. 2249 TagDecl::TagKind Kind; 2250 switch (TagSpec) { 2251 default: assert(0 && "Unknown tag type!"); 2252 case DeclSpec::TST_struct: Kind = TagDecl::TK_struct; break; 2253 case DeclSpec::TST_union: Kind = TagDecl::TK_union; break; 2254 case DeclSpec::TST_class: Kind = TagDecl::TK_class; break; 2255 } 2256 if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(), 2257 Kind, KWLoc, 2258 *ClassTemplate->getIdentifier())) { 2259 Diag(KWLoc, diag::err_use_with_wrong_tag) 2260 << ClassTemplate 2261 << CodeModificationHint::CreateReplacement(KWLoc, 2262 ClassTemplate->getTemplatedDecl()->getKindName()); 2263 Diag(ClassTemplate->getTemplatedDecl()->getLocation(), 2264 diag::note_previous_use); 2265 Kind = ClassTemplate->getTemplatedDecl()->getTagKind(); 2266 } 2267 2268 // C++0x [temp.explicit]p2: 2269 // [...] An explicit instantiation shall appear in an enclosing 2270 // namespace of its template. [...] 2271 // 2272 // This is C++ DR 275. 2273 if (CheckClassTemplateSpecializationScope(ClassTemplate, 0, 2274 TemplateNameLoc, 2275 SS.getRange(), 2276 /*ExplicitInstantiation=*/true)) 2277 return true; 2278 2279 // Translate the parser's template argument list in our AST format. 2280 llvm::SmallVector<TemplateArgument, 16> TemplateArgs; 2281 translateTemplateArguments(TemplateArgsIn, TemplateArgLocs, TemplateArgs); 2282 2283 // Check that the template argument list is well-formed for this 2284 // template. 2285 TemplateArgumentListBuilder ConvertedTemplateArgs(Context); 2286 if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc, LAngleLoc, 2287 TemplateArgs.data(), TemplateArgs.size(), 2288 RAngleLoc, ConvertedTemplateArgs)) 2289 return true; 2290 2291 assert((ConvertedTemplateArgs.size() == 2292 ClassTemplate->getTemplateParameters()->size()) && 2293 "Converted template argument list is too short!"); 2294 2295 // Find the class template specialization declaration that 2296 // corresponds to these arguments. 2297 llvm::FoldingSetNodeID ID; 2298 ClassTemplateSpecializationDecl::Profile(ID, 2299 ConvertedTemplateArgs.getFlatArgumentList(), 2300 ConvertedTemplateArgs.flatSize()); 2301 void *InsertPos = 0; 2302 ClassTemplateSpecializationDecl *PrevDecl 2303 = ClassTemplate->getSpecializations().FindNodeOrInsertPos(ID, InsertPos); 2304 2305 ClassTemplateSpecializationDecl *Specialization = 0; 2306 2307 bool SpecializationRequiresInstantiation = true; 2308 if (PrevDecl) { 2309 if (PrevDecl->getSpecializationKind() == TSK_ExplicitInstantiation) { 2310 // This particular specialization has already been declared or 2311 // instantiated. We cannot explicitly instantiate it. 2312 Diag(TemplateNameLoc, diag::err_explicit_instantiation_duplicate) 2313 << Context.getTypeDeclType(PrevDecl); 2314 Diag(PrevDecl->getLocation(), 2315 diag::note_previous_explicit_instantiation); 2316 return DeclPtrTy::make(PrevDecl); 2317 } 2318 2319 if (PrevDecl->getSpecializationKind() == TSK_ExplicitSpecialization) { 2320 // C++ DR 259, C++0x [temp.explicit]p4: 2321 // For a given set of template parameters, if an explicit 2322 // instantiation of a template appears after a declaration of 2323 // an explicit specialization for that template, the explicit 2324 // instantiation has no effect. 2325 if (!getLangOptions().CPlusPlus0x) { 2326 Diag(TemplateNameLoc, 2327 diag::ext_explicit_instantiation_after_specialization) 2328 << Context.getTypeDeclType(PrevDecl); 2329 Diag(PrevDecl->getLocation(), 2330 diag::note_previous_template_specialization); 2331 } 2332 2333 // Create a new class template specialization declaration node 2334 // for this explicit specialization. This node is only used to 2335 // record the existence of this explicit instantiation for 2336 // accurate reproduction of the source code; we don't actually 2337 // use it for anything, since it is semantically irrelevant. 2338 Specialization 2339 = ClassTemplateSpecializationDecl::Create(Context, 2340 ClassTemplate->getDeclContext(), 2341 TemplateNameLoc, 2342 ClassTemplate, 2343 ConvertedTemplateArgs, 0); 2344 Specialization->setLexicalDeclContext(CurContext); 2345 CurContext->addDecl(Context, Specialization); 2346 return DeclPtrTy::make(Specialization); 2347 } 2348 2349 // If we have already (implicitly) instantiated this 2350 // specialization, there is less work to do. 2351 if (PrevDecl->getSpecializationKind() == TSK_ImplicitInstantiation) 2352 SpecializationRequiresInstantiation = false; 2353 2354 // Since the only prior class template specialization with these 2355 // arguments was referenced but not declared, reuse that 2356 // declaration node as our own, updating its source location to 2357 // reflect our new declaration. 2358 Specialization = PrevDecl; 2359 Specialization->setLocation(TemplateNameLoc); 2360 PrevDecl = 0; 2361 } else { 2362 // Create a new class template specialization declaration node for 2363 // this explicit specialization. 2364 Specialization 2365 = ClassTemplateSpecializationDecl::Create(Context, 2366 ClassTemplate->getDeclContext(), 2367 TemplateNameLoc, 2368 ClassTemplate, 2369 ConvertedTemplateArgs, 0); 2370 2371 ClassTemplate->getSpecializations().InsertNode(Specialization, 2372 InsertPos); 2373 } 2374 2375 // Build the fully-sugared type for this explicit instantiation as 2376 // the user wrote in the explicit instantiation itself. This means 2377 // that we'll pretty-print the type retrieved from the 2378 // specialization's declaration the way that the user actually wrote 2379 // the explicit instantiation, rather than formatting the name based 2380 // on the "canonical" representation used to store the template 2381 // arguments in the specialization. 2382 QualType WrittenTy 2383 = Context.getTemplateSpecializationType(Name, 2384 TemplateArgs.data(), 2385 TemplateArgs.size(), 2386 Context.getTypeDeclType(Specialization)); 2387 Specialization->setTypeAsWritten(WrittenTy); 2388 TemplateArgsIn.release(); 2389 2390 // Add the explicit instantiation into its lexical context. However, 2391 // since explicit instantiations are never found by name lookup, we 2392 // just put it into the declaration context directly. 2393 Specialization->setLexicalDeclContext(CurContext); 2394 CurContext->addDecl(Context, Specialization); 2395 2396 // C++ [temp.explicit]p3: 2397 // A definition of a class template or class member template 2398 // shall be in scope at the point of the explicit instantiation of 2399 // the class template or class member template. 2400 // 2401 // This check comes when we actually try to perform the 2402 // instantiation. 2403 if (SpecializationRequiresInstantiation) 2404 InstantiateClassTemplateSpecialization(Specialization, true); 2405 else // Instantiate the members of this class template specialization. 2406 InstantiateClassTemplateSpecializationMembers(TemplateLoc, Specialization); 2407 2408 return DeclPtrTy::make(Specialization); 2409} 2410 2411// Explicit instantiation of a member class of a class template. 2412Sema::DeclResult 2413Sema::ActOnExplicitInstantiation(Scope *S, SourceLocation TemplateLoc, 2414 unsigned TagSpec, 2415 SourceLocation KWLoc, 2416 const CXXScopeSpec &SS, 2417 IdentifierInfo *Name, 2418 SourceLocation NameLoc, 2419 AttributeList *Attr) { 2420 2421 bool Owned = false; 2422 DeclPtrTy TagD = ActOnTag(S, TagSpec, Action::TK_Reference, 2423 KWLoc, SS, Name, NameLoc, Attr, AS_none, Owned); 2424 if (!TagD) 2425 return true; 2426 2427 TagDecl *Tag = cast<TagDecl>(TagD.getAs<Decl>()); 2428 if (Tag->isEnum()) { 2429 Diag(TemplateLoc, diag::err_explicit_instantiation_enum) 2430 << Context.getTypeDeclType(Tag); 2431 return true; 2432 } 2433 2434 if (Tag->isInvalidDecl()) 2435 return true; 2436 2437 CXXRecordDecl *Record = cast<CXXRecordDecl>(Tag); 2438 CXXRecordDecl *Pattern = Record->getInstantiatedFromMemberClass(); 2439 if (!Pattern) { 2440 Diag(TemplateLoc, diag::err_explicit_instantiation_nontemplate_type) 2441 << Context.getTypeDeclType(Record); 2442 Diag(Record->getLocation(), diag::note_nontemplate_decl_here); 2443 return true; 2444 } 2445 2446 // C++0x [temp.explicit]p2: 2447 // [...] An explicit instantiation shall appear in an enclosing 2448 // namespace of its template. [...] 2449 // 2450 // This is C++ DR 275. 2451 if (getLangOptions().CPlusPlus0x) { 2452 // FIXME: In C++98, we would like to turn these errors into warnings, 2453 // dependent on a -Wc++0x flag. 2454 DeclContext *PatternContext 2455 = Pattern->getDeclContext()->getEnclosingNamespaceContext(); 2456 if (!CurContext->Encloses(PatternContext)) { 2457 Diag(TemplateLoc, diag::err_explicit_instantiation_out_of_scope) 2458 << Record << cast<NamedDecl>(PatternContext) << SS.getRange(); 2459 Diag(Pattern->getLocation(), diag::note_previous_declaration); 2460 } 2461 } 2462 2463 if (!Record->getDefinition(Context)) { 2464 // If the class has a definition, instantiate it (and all of its 2465 // members, recursively). 2466 Pattern = cast_or_null<CXXRecordDecl>(Pattern->getDefinition(Context)); 2467 if (Pattern && InstantiateClass(TemplateLoc, Record, Pattern, 2468 getTemplateInstantiationArgs(Record), 2469 /*ExplicitInstantiation=*/true)) 2470 return true; 2471 } else // Instantiate all of the members of class. 2472 InstantiateClassMembers(TemplateLoc, Record, 2473 getTemplateInstantiationArgs(Record)); 2474 2475 // FIXME: We don't have any representation for explicit instantiations of 2476 // member classes. Such a representation is not needed for compilation, but it 2477 // should be available for clients that want to see all of the declarations in 2478 // the source code. 2479 return TagD; 2480} 2481 2482Sema::TypeResult 2483Sema::ActOnTypenameType(SourceLocation TypenameLoc, const CXXScopeSpec &SS, 2484 const IdentifierInfo &II, SourceLocation IdLoc) { 2485 NestedNameSpecifier *NNS 2486 = static_cast<NestedNameSpecifier *>(SS.getScopeRep()); 2487 if (!NNS) 2488 return true; 2489 2490 QualType T = CheckTypenameType(NNS, II, SourceRange(TypenameLoc, IdLoc)); 2491 if (T.isNull()) 2492 return true; 2493 return T.getAsOpaquePtr(); 2494} 2495 2496Sema::TypeResult 2497Sema::ActOnTypenameType(SourceLocation TypenameLoc, const CXXScopeSpec &SS, 2498 SourceLocation TemplateLoc, TypeTy *Ty) { 2499 QualType T = QualType::getFromOpaquePtr(Ty); 2500 NestedNameSpecifier *NNS 2501 = static_cast<NestedNameSpecifier *>(SS.getScopeRep()); 2502 const TemplateSpecializationType *TemplateId 2503 = T->getAsTemplateSpecializationType(); 2504 assert(TemplateId && "Expected a template specialization type"); 2505 2506 if (NNS->isDependent()) 2507 return Context.getTypenameType(NNS, TemplateId).getAsOpaquePtr(); 2508 2509 return Context.getQualifiedNameType(NNS, T).getAsOpaquePtr(); 2510} 2511 2512/// \brief Build the type that describes a C++ typename specifier, 2513/// e.g., "typename T::type". 2514QualType 2515Sema::CheckTypenameType(NestedNameSpecifier *NNS, const IdentifierInfo &II, 2516 SourceRange Range) { 2517 CXXRecordDecl *CurrentInstantiation = 0; 2518 if (NNS->isDependent()) { 2519 CurrentInstantiation = getCurrentInstantiationOf(NNS); 2520 2521 // If the nested-name-specifier does not refer to the current 2522 // instantiation, then build a typename type. 2523 if (!CurrentInstantiation) 2524 return Context.getTypenameType(NNS, &II); 2525 } 2526 2527 DeclContext *Ctx = 0; 2528 2529 if (CurrentInstantiation) 2530 Ctx = CurrentInstantiation; 2531 else { 2532 CXXScopeSpec SS; 2533 SS.setScopeRep(NNS); 2534 SS.setRange(Range); 2535 if (RequireCompleteDeclContext(SS)) 2536 return QualType(); 2537 2538 Ctx = computeDeclContext(SS); 2539 } 2540 assert(Ctx && "No declaration context?"); 2541 2542 DeclarationName Name(&II); 2543 LookupResult Result = LookupQualifiedName(Ctx, Name, LookupOrdinaryName, 2544 false); 2545 unsigned DiagID = 0; 2546 Decl *Referenced = 0; 2547 switch (Result.getKind()) { 2548 case LookupResult::NotFound: 2549 if (Ctx->isTranslationUnit()) 2550 DiagID = diag::err_typename_nested_not_found_global; 2551 else 2552 DiagID = diag::err_typename_nested_not_found; 2553 break; 2554 2555 case LookupResult::Found: 2556 if (TypeDecl *Type = dyn_cast<TypeDecl>(Result.getAsDecl())) { 2557 // We found a type. Build a QualifiedNameType, since the 2558 // typename-specifier was just sugar. FIXME: Tell 2559 // QualifiedNameType that it has a "typename" prefix. 2560 return Context.getQualifiedNameType(NNS, Context.getTypeDeclType(Type)); 2561 } 2562 2563 DiagID = diag::err_typename_nested_not_type; 2564 Referenced = Result.getAsDecl(); 2565 break; 2566 2567 case LookupResult::FoundOverloaded: 2568 DiagID = diag::err_typename_nested_not_type; 2569 Referenced = *Result.begin(); 2570 break; 2571 2572 case LookupResult::AmbiguousBaseSubobjectTypes: 2573 case LookupResult::AmbiguousBaseSubobjects: 2574 case LookupResult::AmbiguousReference: 2575 DiagnoseAmbiguousLookup(Result, Name, Range.getEnd(), Range); 2576 return QualType(); 2577 } 2578 2579 // If we get here, it's because name lookup did not find a 2580 // type. Emit an appropriate diagnostic and return an error. 2581 if (NamedDecl *NamedCtx = dyn_cast<NamedDecl>(Ctx)) 2582 Diag(Range.getEnd(), DiagID) << Range << Name << NamedCtx; 2583 else 2584 Diag(Range.getEnd(), DiagID) << Range << Name; 2585 if (Referenced) 2586 Diag(Referenced->getLocation(), diag::note_typename_refers_here) 2587 << Name; 2588 return QualType(); 2589} 2590