SemaTemplate.cpp revision a35faf97e36ffb4974f3f5f3ee6182fbbd9172c7
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; 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.getFlatArgumentList(), 860 ConvertedTemplateArgs.flatSize(), 0); 861 ClassTemplate->getSpecializations().InsertNode(Decl, InsertPos); 862 Decl->setLexicalDeclContext(CurContext); 863 } 864 865 CanonType = Context.getTypeDeclType(Decl); 866 } 867 868 // Build the fully-sugared type for this class template 869 // specialization, which refers back to the class template 870 // specialization we created or found. 871 return Context.getTemplateSpecializationType(Name, TemplateArgs, 872 NumTemplateArgs, CanonType); 873} 874 875Action::TypeResult 876Sema::ActOnTemplateIdType(TemplateTy TemplateD, SourceLocation TemplateLoc, 877 SourceLocation LAngleLoc, 878 ASTTemplateArgsPtr TemplateArgsIn, 879 SourceLocation *TemplateArgLocs, 880 SourceLocation RAngleLoc) { 881 TemplateName Template = TemplateD.getAsVal<TemplateName>(); 882 883 // Translate the parser's template argument list in our AST format. 884 llvm::SmallVector<TemplateArgument, 16> TemplateArgs; 885 translateTemplateArguments(TemplateArgsIn, TemplateArgLocs, TemplateArgs); 886 887 QualType Result = CheckTemplateIdType(Template, TemplateLoc, LAngleLoc, 888 TemplateArgs.data(), 889 TemplateArgs.size(), 890 RAngleLoc); 891 TemplateArgsIn.release(); 892 893 if (Result.isNull()) 894 return true; 895 896 return Result.getAsOpaquePtr(); 897} 898 899/// \brief Form a dependent template name. 900/// 901/// This action forms a dependent template name given the template 902/// name and its (presumably dependent) scope specifier. For 903/// example, given "MetaFun::template apply", the scope specifier \p 904/// SS will be "MetaFun::", \p TemplateKWLoc contains the location 905/// of the "template" keyword, and "apply" is the \p Name. 906Sema::TemplateTy 907Sema::ActOnDependentTemplateName(SourceLocation TemplateKWLoc, 908 const IdentifierInfo &Name, 909 SourceLocation NameLoc, 910 const CXXScopeSpec &SS) { 911 if (!SS.isSet() || SS.isInvalid()) 912 return TemplateTy(); 913 914 NestedNameSpecifier *Qualifier 915 = static_cast<NestedNameSpecifier *>(SS.getScopeRep()); 916 917 // FIXME: member of the current instantiation 918 919 if (!Qualifier->isDependent()) { 920 // C++0x [temp.names]p5: 921 // If a name prefixed by the keyword template is not the name of 922 // a template, the program is ill-formed. [Note: the keyword 923 // template may not be applied to non-template members of class 924 // templates. -end note ] [ Note: as is the case with the 925 // typename prefix, the template prefix is allowed in cases 926 // where it is not strictly necessary; i.e., when the 927 // nested-name-specifier or the expression on the left of the -> 928 // or . is not dependent on a template-parameter, or the use 929 // does not appear in the scope of a template. -end note] 930 // 931 // Note: C++03 was more strict here, because it banned the use of 932 // the "template" keyword prior to a template-name that was not a 933 // dependent name. C++ DR468 relaxed this requirement (the 934 // "template" keyword is now permitted). We follow the C++0x 935 // rules, even in C++03 mode, retroactively applying the DR. 936 TemplateTy Template; 937 TemplateNameKind TNK = isTemplateName(Name, 0, Template, &SS); 938 if (TNK == TNK_Non_template) { 939 Diag(NameLoc, diag::err_template_kw_refers_to_non_template) 940 << &Name; 941 return TemplateTy(); 942 } 943 944 return Template; 945 } 946 947 return TemplateTy::make(Context.getDependentTemplateName(Qualifier, &Name)); 948} 949 950/// \brief Check that the given template argument list is well-formed 951/// for specializing the given template. 952bool Sema::CheckTemplateArgumentList(TemplateDecl *Template, 953 SourceLocation TemplateLoc, 954 SourceLocation LAngleLoc, 955 const TemplateArgument *TemplateArgs, 956 unsigned NumTemplateArgs, 957 SourceLocation RAngleLoc, 958 TemplateArgumentListBuilder &Converted) { 959 TemplateParameterList *Params = Template->getTemplateParameters(); 960 unsigned NumParams = Params->size(); 961 unsigned NumArgs = NumTemplateArgs; 962 bool Invalid = false; 963 964 if (NumArgs > NumParams || 965 NumArgs < Params->getMinRequiredArguments()) { 966 // FIXME: point at either the first arg beyond what we can handle, 967 // or the '>', depending on whether we have too many or too few 968 // arguments. 969 SourceRange Range; 970 if (NumArgs > NumParams) 971 Range = SourceRange(TemplateArgs[NumParams].getLocation(), RAngleLoc); 972 Diag(TemplateLoc, diag::err_template_arg_list_different_arity) 973 << (NumArgs > NumParams) 974 << (isa<ClassTemplateDecl>(Template)? 0 : 975 isa<FunctionTemplateDecl>(Template)? 1 : 976 isa<TemplateTemplateParmDecl>(Template)? 2 : 3) 977 << Template << Range; 978 Diag(Template->getLocation(), diag::note_template_decl_here) 979 << Params->getSourceRange(); 980 Invalid = true; 981 } 982 983 // C++ [temp.arg]p1: 984 // [...] The type and form of each template-argument specified in 985 // a template-id shall match the type and form specified for the 986 // corresponding parameter declared by the template in its 987 // template-parameter-list. 988 unsigned ArgIdx = 0; 989 for (TemplateParameterList::iterator Param = Params->begin(), 990 ParamEnd = Params->end(); 991 Param != ParamEnd; ++Param, ++ArgIdx) { 992 // Decode the template argument 993 TemplateArgument Arg; 994 if (ArgIdx >= NumArgs) { 995 // Retrieve the default template argument from the template 996 // parameter. 997 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*Param)) { 998 if (!TTP->hasDefaultArgument()) 999 break; 1000 1001 QualType ArgType = TTP->getDefaultArgument(); 1002 1003 // If the argument type is dependent, instantiate it now based 1004 // on the previously-computed template arguments. 1005 if (ArgType->isDependentType()) { 1006 InstantiatingTemplate Inst(*this, TemplateLoc, 1007 Template, Converted.getFlatArgumentList(), 1008 Converted.flatSize(), 1009 SourceRange(TemplateLoc, RAngleLoc)); 1010 1011 TemplateArgumentList TemplateArgs(Context, 1012 Converted.getFlatArgumentList(), 1013 Converted.flatSize(), 1014 /*CopyArgs=*/false); 1015 ArgType = InstantiateType(ArgType, TemplateArgs, 1016 TTP->getDefaultArgumentLoc(), 1017 TTP->getDeclName()); 1018 } 1019 1020 if (ArgType.isNull()) 1021 return true; 1022 1023 Arg = TemplateArgument(TTP->getLocation(), ArgType); 1024 } else if (NonTypeTemplateParmDecl *NTTP 1025 = dyn_cast<NonTypeTemplateParmDecl>(*Param)) { 1026 if (!NTTP->hasDefaultArgument()) 1027 break; 1028 1029 // FIXME: Instantiate default argument 1030 Arg = TemplateArgument(NTTP->getDefaultArgument()); 1031 } else { 1032 TemplateTemplateParmDecl *TempParm 1033 = cast<TemplateTemplateParmDecl>(*Param); 1034 1035 if (!TempParm->hasDefaultArgument()) 1036 break; 1037 1038 // FIXME: Instantiate default argument 1039 Arg = TemplateArgument(TempParm->getDefaultArgument()); 1040 } 1041 } else { 1042 // Retrieve the template argument produced by the user. 1043 Arg = TemplateArgs[ArgIdx]; 1044 } 1045 1046 1047 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*Param)) { 1048 // Check template type parameters. 1049 if (Arg.getKind() == TemplateArgument::Type) { 1050 if (CheckTemplateArgument(TTP, Arg.getAsType(), Arg.getLocation())) 1051 Invalid = true; 1052 1053 // Add the converted template type argument. 1054 Converted.push_back( 1055 TemplateArgument(Arg.getLocation(), 1056 Context.getCanonicalType(Arg.getAsType()))); 1057 continue; 1058 } 1059 1060 // C++ [temp.arg.type]p1: 1061 // A template-argument for a template-parameter which is a 1062 // type shall be a type-id. 1063 1064 // We have a template type parameter but the template argument 1065 // is not a type. 1066 Diag(Arg.getLocation(), diag::err_template_arg_must_be_type); 1067 Diag((*Param)->getLocation(), diag::note_template_param_here); 1068 Invalid = true; 1069 } else if (NonTypeTemplateParmDecl *NTTP 1070 = dyn_cast<NonTypeTemplateParmDecl>(*Param)) { 1071 // Check non-type template parameters. 1072 1073 // Instantiate the type of the non-type template parameter with 1074 // the template arguments we've seen thus far. 1075 QualType NTTPType = NTTP->getType(); 1076 if (NTTPType->isDependentType()) { 1077 // Instantiate the type of the non-type template parameter. 1078 InstantiatingTemplate Inst(*this, TemplateLoc, 1079 Template, Converted.getFlatArgumentList(), 1080 Converted.flatSize(), 1081 SourceRange(TemplateLoc, RAngleLoc)); 1082 1083 TemplateArgumentList TemplateArgs(Context, 1084 Converted.getFlatArgumentList(), 1085 Converted.flatSize(), 1086 /*CopyArgs=*/false); 1087 NTTPType = InstantiateType(NTTPType, TemplateArgs, 1088 NTTP->getLocation(), 1089 NTTP->getDeclName()); 1090 // If that worked, check the non-type template parameter type 1091 // for validity. 1092 if (!NTTPType.isNull()) 1093 NTTPType = CheckNonTypeTemplateParameterType(NTTPType, 1094 NTTP->getLocation()); 1095 1096 if (NTTPType.isNull()) { 1097 Invalid = true; 1098 break; 1099 } 1100 } 1101 1102 switch (Arg.getKind()) { 1103 case TemplateArgument::Null: 1104 assert(false && "Should never see a NULL template argument here"); 1105 break; 1106 1107 case TemplateArgument::Expression: { 1108 Expr *E = Arg.getAsExpr(); 1109 if (CheckTemplateArgument(NTTP, NTTPType, E, &Converted)) 1110 Invalid = true; 1111 break; 1112 } 1113 1114 case TemplateArgument::Declaration: 1115 case TemplateArgument::Integral: 1116 // We've already checked this template argument, so just copy 1117 // it to the list of converted arguments. 1118 Converted.push_back(Arg); 1119 break; 1120 1121 case TemplateArgument::Type: 1122 // We have a non-type template parameter but the template 1123 // argument is a type. 1124 1125 // C++ [temp.arg]p2: 1126 // In a template-argument, an ambiguity between a type-id and 1127 // an expression is resolved to a type-id, regardless of the 1128 // form of the corresponding template-parameter. 1129 // 1130 // We warn specifically about this case, since it can be rather 1131 // confusing for users. 1132 if (Arg.getAsType()->isFunctionType()) 1133 Diag(Arg.getLocation(), diag::err_template_arg_nontype_ambig) 1134 << Arg.getAsType(); 1135 else 1136 Diag(Arg.getLocation(), diag::err_template_arg_must_be_expr); 1137 Diag((*Param)->getLocation(), diag::note_template_param_here); 1138 Invalid = true; 1139 } 1140 } else { 1141 // Check template template parameters. 1142 TemplateTemplateParmDecl *TempParm 1143 = cast<TemplateTemplateParmDecl>(*Param); 1144 1145 switch (Arg.getKind()) { 1146 case TemplateArgument::Null: 1147 assert(false && "Should never see a NULL template argument here"); 1148 break; 1149 1150 case TemplateArgument::Expression: { 1151 Expr *ArgExpr = Arg.getAsExpr(); 1152 if (ArgExpr && isa<DeclRefExpr>(ArgExpr) && 1153 isa<TemplateDecl>(cast<DeclRefExpr>(ArgExpr)->getDecl())) { 1154 if (CheckTemplateArgument(TempParm, cast<DeclRefExpr>(ArgExpr))) 1155 Invalid = true; 1156 1157 // Add the converted template argument. 1158 Decl *D 1159 = Context.getCanonicalDecl(cast<DeclRefExpr>(ArgExpr)->getDecl()); 1160 Converted.push_back(TemplateArgument(Arg.getLocation(), D)); 1161 continue; 1162 } 1163 } 1164 // fall through 1165 1166 case TemplateArgument::Type: { 1167 // We have a template template parameter but the template 1168 // argument does not refer to a template. 1169 Diag(Arg.getLocation(), diag::err_template_arg_must_be_template); 1170 Invalid = true; 1171 break; 1172 } 1173 1174 case TemplateArgument::Declaration: 1175 // We've already checked this template argument, so just copy 1176 // it to the list of converted arguments. 1177 Converted.push_back(Arg); 1178 break; 1179 1180 case TemplateArgument::Integral: 1181 assert(false && "Integral argument with template template parameter"); 1182 break; 1183 } 1184 } 1185 } 1186 1187 return Invalid; 1188} 1189 1190/// \brief Check a template argument against its corresponding 1191/// template type parameter. 1192/// 1193/// This routine implements the semantics of C++ [temp.arg.type]. It 1194/// returns true if an error occurred, and false otherwise. 1195bool Sema::CheckTemplateArgument(TemplateTypeParmDecl *Param, 1196 QualType Arg, SourceLocation ArgLoc) { 1197 // C++ [temp.arg.type]p2: 1198 // A local type, a type with no linkage, an unnamed type or a type 1199 // compounded from any of these types shall not be used as a 1200 // template-argument for a template type-parameter. 1201 // 1202 // FIXME: Perform the recursive and no-linkage type checks. 1203 const TagType *Tag = 0; 1204 if (const EnumType *EnumT = Arg->getAsEnumType()) 1205 Tag = EnumT; 1206 else if (const RecordType *RecordT = Arg->getAsRecordType()) 1207 Tag = RecordT; 1208 if (Tag && Tag->getDecl()->getDeclContext()->isFunctionOrMethod()) 1209 return Diag(ArgLoc, diag::err_template_arg_local_type) 1210 << QualType(Tag, 0); 1211 else if (Tag && !Tag->getDecl()->getDeclName() && 1212 !Tag->getDecl()->getTypedefForAnonDecl()) { 1213 Diag(ArgLoc, diag::err_template_arg_unnamed_type); 1214 Diag(Tag->getDecl()->getLocation(), diag::note_template_unnamed_type_here); 1215 return true; 1216 } 1217 1218 return false; 1219} 1220 1221/// \brief Checks whether the given template argument is the address 1222/// of an object or function according to C++ [temp.arg.nontype]p1. 1223bool Sema::CheckTemplateArgumentAddressOfObjectOrFunction(Expr *Arg, 1224 NamedDecl *&Entity) { 1225 bool Invalid = false; 1226 1227 // See through any implicit casts we added to fix the type. 1228 if (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(Arg)) 1229 Arg = Cast->getSubExpr(); 1230 1231 // C++0x allows nullptr, and there's no further checking to be done for that. 1232 if (Arg->getType()->isNullPtrType()) 1233 return false; 1234 1235 // C++ [temp.arg.nontype]p1: 1236 // 1237 // A template-argument for a non-type, non-template 1238 // template-parameter shall be one of: [...] 1239 // 1240 // -- the address of an object or function with external 1241 // linkage, including function templates and function 1242 // template-ids but excluding non-static class members, 1243 // expressed as & id-expression where the & is optional if 1244 // the name refers to a function or array, or if the 1245 // corresponding template-parameter is a reference; or 1246 DeclRefExpr *DRE = 0; 1247 1248 // Ignore (and complain about) any excess parentheses. 1249 while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) { 1250 if (!Invalid) { 1251 Diag(Arg->getSourceRange().getBegin(), 1252 diag::err_template_arg_extra_parens) 1253 << Arg->getSourceRange(); 1254 Invalid = true; 1255 } 1256 1257 Arg = Parens->getSubExpr(); 1258 } 1259 1260 if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) { 1261 if (UnOp->getOpcode() == UnaryOperator::AddrOf) 1262 DRE = dyn_cast<DeclRefExpr>(UnOp->getSubExpr()); 1263 } else 1264 DRE = dyn_cast<DeclRefExpr>(Arg); 1265 1266 if (!DRE || !isa<ValueDecl>(DRE->getDecl())) 1267 return Diag(Arg->getSourceRange().getBegin(), 1268 diag::err_template_arg_not_object_or_func_form) 1269 << Arg->getSourceRange(); 1270 1271 // Cannot refer to non-static data members 1272 if (FieldDecl *Field = dyn_cast<FieldDecl>(DRE->getDecl())) 1273 return Diag(Arg->getSourceRange().getBegin(), diag::err_template_arg_field) 1274 << Field << Arg->getSourceRange(); 1275 1276 // Cannot refer to non-static member functions 1277 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(DRE->getDecl())) 1278 if (!Method->isStatic()) 1279 return Diag(Arg->getSourceRange().getBegin(), 1280 diag::err_template_arg_method) 1281 << Method << Arg->getSourceRange(); 1282 1283 // Functions must have external linkage. 1284 if (FunctionDecl *Func = dyn_cast<FunctionDecl>(DRE->getDecl())) { 1285 if (Func->getStorageClass() == FunctionDecl::Static) { 1286 Diag(Arg->getSourceRange().getBegin(), 1287 diag::err_template_arg_function_not_extern) 1288 << Func << Arg->getSourceRange(); 1289 Diag(Func->getLocation(), diag::note_template_arg_internal_object) 1290 << true; 1291 return true; 1292 } 1293 1294 // Okay: we've named a function with external linkage. 1295 Entity = Func; 1296 return Invalid; 1297 } 1298 1299 if (VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) { 1300 if (!Var->hasGlobalStorage()) { 1301 Diag(Arg->getSourceRange().getBegin(), 1302 diag::err_template_arg_object_not_extern) 1303 << Var << Arg->getSourceRange(); 1304 Diag(Var->getLocation(), diag::note_template_arg_internal_object) 1305 << true; 1306 return true; 1307 } 1308 1309 // Okay: we've named an object with external linkage 1310 Entity = Var; 1311 return Invalid; 1312 } 1313 1314 // We found something else, but we don't know specifically what it is. 1315 Diag(Arg->getSourceRange().getBegin(), 1316 diag::err_template_arg_not_object_or_func) 1317 << Arg->getSourceRange(); 1318 Diag(DRE->getDecl()->getLocation(), 1319 diag::note_template_arg_refers_here); 1320 return true; 1321} 1322 1323/// \brief Checks whether the given template argument is a pointer to 1324/// member constant according to C++ [temp.arg.nontype]p1. 1325bool 1326Sema::CheckTemplateArgumentPointerToMember(Expr *Arg, NamedDecl *&Member) { 1327 bool Invalid = false; 1328 1329 // See through any implicit casts we added to fix the type. 1330 if (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(Arg)) 1331 Arg = Cast->getSubExpr(); 1332 1333 // C++0x allows nullptr, and there's no further checking to be done for that. 1334 if (Arg->getType()->isNullPtrType()) 1335 return false; 1336 1337 // C++ [temp.arg.nontype]p1: 1338 // 1339 // A template-argument for a non-type, non-template 1340 // template-parameter shall be one of: [...] 1341 // 1342 // -- a pointer to member expressed as described in 5.3.1. 1343 QualifiedDeclRefExpr *DRE = 0; 1344 1345 // Ignore (and complain about) any excess parentheses. 1346 while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) { 1347 if (!Invalid) { 1348 Diag(Arg->getSourceRange().getBegin(), 1349 diag::err_template_arg_extra_parens) 1350 << Arg->getSourceRange(); 1351 Invalid = true; 1352 } 1353 1354 Arg = Parens->getSubExpr(); 1355 } 1356 1357 if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) 1358 if (UnOp->getOpcode() == UnaryOperator::AddrOf) 1359 DRE = dyn_cast<QualifiedDeclRefExpr>(UnOp->getSubExpr()); 1360 1361 if (!DRE) 1362 return Diag(Arg->getSourceRange().getBegin(), 1363 diag::err_template_arg_not_pointer_to_member_form) 1364 << Arg->getSourceRange(); 1365 1366 if (isa<FieldDecl>(DRE->getDecl()) || isa<CXXMethodDecl>(DRE->getDecl())) { 1367 assert((isa<FieldDecl>(DRE->getDecl()) || 1368 !cast<CXXMethodDecl>(DRE->getDecl())->isStatic()) && 1369 "Only non-static member pointers can make it here"); 1370 1371 // Okay: this is the address of a non-static member, and therefore 1372 // a member pointer constant. 1373 Member = DRE->getDecl(); 1374 return Invalid; 1375 } 1376 1377 // We found something else, but we don't know specifically what it is. 1378 Diag(Arg->getSourceRange().getBegin(), 1379 diag::err_template_arg_not_pointer_to_member_form) 1380 << Arg->getSourceRange(); 1381 Diag(DRE->getDecl()->getLocation(), 1382 diag::note_template_arg_refers_here); 1383 return true; 1384} 1385 1386/// \brief Check a template argument against its corresponding 1387/// non-type template parameter. 1388/// 1389/// This routine implements the semantics of C++ [temp.arg.nontype]. 1390/// It returns true if an error occurred, and false otherwise. \p 1391/// InstantiatedParamType is the type of the non-type template 1392/// parameter after it has been instantiated. 1393/// 1394/// If Converted is non-NULL and no errors occur, the value 1395/// of this argument will be added to the end of the Converted vector. 1396bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param, 1397 QualType InstantiatedParamType, Expr *&Arg, 1398 TemplateArgumentListBuilder *Converted) { 1399 SourceLocation StartLoc = Arg->getSourceRange().getBegin(); 1400 1401 // If either the parameter has a dependent type or the argument is 1402 // type-dependent, there's nothing we can check now. 1403 // FIXME: Add template argument to Converted! 1404 if (InstantiatedParamType->isDependentType() || Arg->isTypeDependent()) { 1405 // FIXME: Produce a cloned, canonical expression? 1406 Converted->push_back(TemplateArgument(Arg)); 1407 return false; 1408 } 1409 1410 // C++ [temp.arg.nontype]p5: 1411 // The following conversions are performed on each expression used 1412 // as a non-type template-argument. If a non-type 1413 // template-argument cannot be converted to the type of the 1414 // corresponding template-parameter then the program is 1415 // ill-formed. 1416 // 1417 // -- for a non-type template-parameter of integral or 1418 // enumeration type, integral promotions (4.5) and integral 1419 // conversions (4.7) are applied. 1420 QualType ParamType = InstantiatedParamType; 1421 QualType ArgType = Arg->getType(); 1422 if (ParamType->isIntegralType() || ParamType->isEnumeralType()) { 1423 // C++ [temp.arg.nontype]p1: 1424 // A template-argument for a non-type, non-template 1425 // template-parameter shall be one of: 1426 // 1427 // -- an integral constant-expression of integral or enumeration 1428 // type; or 1429 // -- the name of a non-type template-parameter; or 1430 SourceLocation NonConstantLoc; 1431 llvm::APSInt Value; 1432 if (!ArgType->isIntegralType() && !ArgType->isEnumeralType()) { 1433 Diag(Arg->getSourceRange().getBegin(), 1434 diag::err_template_arg_not_integral_or_enumeral) 1435 << ArgType << Arg->getSourceRange(); 1436 Diag(Param->getLocation(), diag::note_template_param_here); 1437 return true; 1438 } else if (!Arg->isValueDependent() && 1439 !Arg->isIntegerConstantExpr(Value, Context, &NonConstantLoc)) { 1440 Diag(NonConstantLoc, diag::err_template_arg_not_ice) 1441 << ArgType << Arg->getSourceRange(); 1442 return true; 1443 } 1444 1445 // FIXME: We need some way to more easily get the unqualified form 1446 // of the types without going all the way to the 1447 // canonical type. 1448 if (Context.getCanonicalType(ParamType).getCVRQualifiers()) 1449 ParamType = Context.getCanonicalType(ParamType).getUnqualifiedType(); 1450 if (Context.getCanonicalType(ArgType).getCVRQualifiers()) 1451 ArgType = Context.getCanonicalType(ArgType).getUnqualifiedType(); 1452 1453 // Try to convert the argument to the parameter's type. 1454 if (ParamType == ArgType) { 1455 // Okay: no conversion necessary 1456 } else if (IsIntegralPromotion(Arg, ArgType, ParamType) || 1457 !ParamType->isEnumeralType()) { 1458 // This is an integral promotion or conversion. 1459 ImpCastExprToType(Arg, ParamType); 1460 } else { 1461 // We can't perform this conversion. 1462 Diag(Arg->getSourceRange().getBegin(), 1463 diag::err_template_arg_not_convertible) 1464 << Arg->getType() << InstantiatedParamType << Arg->getSourceRange(); 1465 Diag(Param->getLocation(), diag::note_template_param_here); 1466 return true; 1467 } 1468 1469 QualType IntegerType = Context.getCanonicalType(ParamType); 1470 if (const EnumType *Enum = IntegerType->getAsEnumType()) 1471 IntegerType = Enum->getDecl()->getIntegerType(); 1472 1473 if (!Arg->isValueDependent()) { 1474 // Check that an unsigned parameter does not receive a negative 1475 // value. 1476 if (IntegerType->isUnsignedIntegerType() 1477 && (Value.isSigned() && Value.isNegative())) { 1478 Diag(Arg->getSourceRange().getBegin(), diag::err_template_arg_negative) 1479 << Value.toString(10) << Param->getType() 1480 << Arg->getSourceRange(); 1481 Diag(Param->getLocation(), diag::note_template_param_here); 1482 return true; 1483 } 1484 1485 // Check that we don't overflow the template parameter type. 1486 unsigned AllowedBits = Context.getTypeSize(IntegerType); 1487 if (Value.getActiveBits() > AllowedBits) { 1488 Diag(Arg->getSourceRange().getBegin(), 1489 diag::err_template_arg_too_large) 1490 << Value.toString(10) << Param->getType() 1491 << Arg->getSourceRange(); 1492 Diag(Param->getLocation(), diag::note_template_param_here); 1493 return true; 1494 } 1495 1496 if (Value.getBitWidth() != AllowedBits) 1497 Value.extOrTrunc(AllowedBits); 1498 Value.setIsSigned(IntegerType->isSignedIntegerType()); 1499 } 1500 1501 if (Converted) { 1502 // Add the value of this argument to the list of converted 1503 // arguments. We use the bitwidth and signedness of the template 1504 // parameter. 1505 if (Arg->isValueDependent()) { 1506 // The argument is value-dependent. Create a new 1507 // TemplateArgument with the converted expression. 1508 Converted->push_back(TemplateArgument(Arg)); 1509 return false; 1510 } 1511 1512 Converted->push_back(TemplateArgument(StartLoc, Value, 1513 ParamType->isEnumeralType() ? ParamType : IntegerType)); 1514 } 1515 1516 return false; 1517 } 1518 1519 // Handle pointer-to-function, reference-to-function, and 1520 // pointer-to-member-function all in (roughly) the same way. 1521 if (// -- For a non-type template-parameter of type pointer to 1522 // function, only the function-to-pointer conversion (4.3) is 1523 // applied. If the template-argument represents a set of 1524 // overloaded functions (or a pointer to such), the matching 1525 // function is selected from the set (13.4). 1526 // In C++0x, any std::nullptr_t value can be converted. 1527 (ParamType->isPointerType() && 1528 ParamType->getAsPointerType()->getPointeeType()->isFunctionType()) || 1529 // -- For a non-type template-parameter of type reference to 1530 // function, no conversions apply. If the template-argument 1531 // represents a set of overloaded functions, the matching 1532 // function is selected from the set (13.4). 1533 (ParamType->isReferenceType() && 1534 ParamType->getAsReferenceType()->getPointeeType()->isFunctionType()) || 1535 // -- For a non-type template-parameter of type pointer to 1536 // member function, no conversions apply. If the 1537 // template-argument represents a set of overloaded member 1538 // functions, the matching member function is selected from 1539 // the set (13.4). 1540 // Again, C++0x allows a std::nullptr_t value. 1541 (ParamType->isMemberPointerType() && 1542 ParamType->getAsMemberPointerType()->getPointeeType() 1543 ->isFunctionType())) { 1544 if (Context.hasSameUnqualifiedType(ArgType, 1545 ParamType.getNonReferenceType())) { 1546 // We don't have to do anything: the types already match. 1547 } else if (ArgType->isNullPtrType() && (ParamType->isPointerType() || 1548 ParamType->isMemberPointerType())) { 1549 ArgType = ParamType; 1550 ImpCastExprToType(Arg, ParamType); 1551 } else if (ArgType->isFunctionType() && ParamType->isPointerType()) { 1552 ArgType = Context.getPointerType(ArgType); 1553 ImpCastExprToType(Arg, ArgType); 1554 } else if (FunctionDecl *Fn 1555 = ResolveAddressOfOverloadedFunction(Arg, ParamType, true)) { 1556 if (DiagnoseUseOfDecl(Fn, Arg->getSourceRange().getBegin())) 1557 return true; 1558 1559 FixOverloadedFunctionReference(Arg, Fn); 1560 ArgType = Arg->getType(); 1561 if (ArgType->isFunctionType() && ParamType->isPointerType()) { 1562 ArgType = Context.getPointerType(Arg->getType()); 1563 ImpCastExprToType(Arg, ArgType); 1564 } 1565 } 1566 1567 if (!Context.hasSameUnqualifiedType(ArgType, 1568 ParamType.getNonReferenceType())) { 1569 // We can't perform this conversion. 1570 Diag(Arg->getSourceRange().getBegin(), 1571 diag::err_template_arg_not_convertible) 1572 << Arg->getType() << InstantiatedParamType << Arg->getSourceRange(); 1573 Diag(Param->getLocation(), diag::note_template_param_here); 1574 return true; 1575 } 1576 1577 if (ParamType->isMemberPointerType()) { 1578 NamedDecl *Member = 0; 1579 if (CheckTemplateArgumentPointerToMember(Arg, Member)) 1580 return true; 1581 1582 if (Converted) { 1583 Member = cast_or_null<NamedDecl>(Context.getCanonicalDecl(Member)); 1584 Converted->push_back(TemplateArgument(StartLoc, Member)); 1585 } 1586 1587 return false; 1588 } 1589 1590 NamedDecl *Entity = 0; 1591 if (CheckTemplateArgumentAddressOfObjectOrFunction(Arg, Entity)) 1592 return true; 1593 1594 if (Converted) { 1595 Entity = cast_or_null<NamedDecl>(Context.getCanonicalDecl(Entity)); 1596 Converted->push_back(TemplateArgument(StartLoc, Entity)); 1597 } 1598 return false; 1599 } 1600 1601 if (ParamType->isPointerType()) { 1602 // -- for a non-type template-parameter of type pointer to 1603 // object, qualification conversions (4.4) and the 1604 // array-to-pointer conversion (4.2) are applied. 1605 // C++0x also allows a value of std::nullptr_t. 1606 assert(ParamType->getAsPointerType()->getPointeeType()->isObjectType() && 1607 "Only object pointers allowed here"); 1608 1609 if (ArgType->isNullPtrType()) { 1610 ArgType = ParamType; 1611 ImpCastExprToType(Arg, ParamType); 1612 } else if (ArgType->isArrayType()) { 1613 ArgType = Context.getArrayDecayedType(ArgType); 1614 ImpCastExprToType(Arg, ArgType); 1615 } 1616 1617 if (IsQualificationConversion(ArgType, ParamType)) { 1618 ArgType = ParamType; 1619 ImpCastExprToType(Arg, ParamType); 1620 } 1621 1622 if (!Context.hasSameUnqualifiedType(ArgType, ParamType)) { 1623 // We can't perform this conversion. 1624 Diag(Arg->getSourceRange().getBegin(), 1625 diag::err_template_arg_not_convertible) 1626 << Arg->getType() << InstantiatedParamType << Arg->getSourceRange(); 1627 Diag(Param->getLocation(), diag::note_template_param_here); 1628 return true; 1629 } 1630 1631 NamedDecl *Entity = 0; 1632 if (CheckTemplateArgumentAddressOfObjectOrFunction(Arg, Entity)) 1633 return true; 1634 1635 if (Converted) { 1636 Entity = cast_or_null<NamedDecl>(Context.getCanonicalDecl(Entity)); 1637 Converted->push_back(TemplateArgument(StartLoc, Entity)); 1638 } 1639 1640 return false; 1641 } 1642 1643 if (const ReferenceType *ParamRefType = ParamType->getAsReferenceType()) { 1644 // -- For a non-type template-parameter of type reference to 1645 // object, no conversions apply. The type referred to by the 1646 // reference may be more cv-qualified than the (otherwise 1647 // identical) type of the template-argument. The 1648 // template-parameter is bound directly to the 1649 // template-argument, which must be an lvalue. 1650 assert(ParamRefType->getPointeeType()->isObjectType() && 1651 "Only object references allowed here"); 1652 1653 if (!Context.hasSameUnqualifiedType(ParamRefType->getPointeeType(), ArgType)) { 1654 Diag(Arg->getSourceRange().getBegin(), 1655 diag::err_template_arg_no_ref_bind) 1656 << InstantiatedParamType << Arg->getType() 1657 << Arg->getSourceRange(); 1658 Diag(Param->getLocation(), diag::note_template_param_here); 1659 return true; 1660 } 1661 1662 unsigned ParamQuals 1663 = Context.getCanonicalType(ParamType).getCVRQualifiers(); 1664 unsigned ArgQuals = Context.getCanonicalType(ArgType).getCVRQualifiers(); 1665 1666 if ((ParamQuals | ArgQuals) != ParamQuals) { 1667 Diag(Arg->getSourceRange().getBegin(), 1668 diag::err_template_arg_ref_bind_ignores_quals) 1669 << InstantiatedParamType << Arg->getType() 1670 << Arg->getSourceRange(); 1671 Diag(Param->getLocation(), diag::note_template_param_here); 1672 return true; 1673 } 1674 1675 NamedDecl *Entity = 0; 1676 if (CheckTemplateArgumentAddressOfObjectOrFunction(Arg, Entity)) 1677 return true; 1678 1679 if (Converted) { 1680 Entity = cast<NamedDecl>(Context.getCanonicalDecl(Entity)); 1681 Converted->push_back(TemplateArgument(StartLoc, Entity)); 1682 } 1683 1684 return false; 1685 } 1686 1687 // -- For a non-type template-parameter of type pointer to data 1688 // member, qualification conversions (4.4) are applied. 1689 // C++0x allows std::nullptr_t values. 1690 assert(ParamType->isMemberPointerType() && "Only pointers to members remain"); 1691 1692 if (Context.hasSameUnqualifiedType(ParamType, ArgType)) { 1693 // Types match exactly: nothing more to do here. 1694 } else if (ArgType->isNullPtrType()) { 1695 ImpCastExprToType(Arg, ParamType); 1696 } else if (IsQualificationConversion(ArgType, ParamType)) { 1697 ImpCastExprToType(Arg, ParamType); 1698 } else { 1699 // We can't perform this conversion. 1700 Diag(Arg->getSourceRange().getBegin(), 1701 diag::err_template_arg_not_convertible) 1702 << Arg->getType() << InstantiatedParamType << Arg->getSourceRange(); 1703 Diag(Param->getLocation(), diag::note_template_param_here); 1704 return true; 1705 } 1706 1707 NamedDecl *Member = 0; 1708 if (CheckTemplateArgumentPointerToMember(Arg, Member)) 1709 return true; 1710 1711 if (Converted) { 1712 Member = cast_or_null<NamedDecl>(Context.getCanonicalDecl(Member)); 1713 Converted->push_back(TemplateArgument(StartLoc, Member)); 1714 } 1715 1716 return false; 1717} 1718 1719/// \brief Check a template argument against its corresponding 1720/// template template parameter. 1721/// 1722/// This routine implements the semantics of C++ [temp.arg.template]. 1723/// It returns true if an error occurred, and false otherwise. 1724bool Sema::CheckTemplateArgument(TemplateTemplateParmDecl *Param, 1725 DeclRefExpr *Arg) { 1726 assert(isa<TemplateDecl>(Arg->getDecl()) && "Only template decls allowed"); 1727 TemplateDecl *Template = cast<TemplateDecl>(Arg->getDecl()); 1728 1729 // C++ [temp.arg.template]p1: 1730 // A template-argument for a template template-parameter shall be 1731 // the name of a class template, expressed as id-expression. Only 1732 // primary class templates are considered when matching the 1733 // template template argument with the corresponding parameter; 1734 // partial specializations are not considered even if their 1735 // parameter lists match that of the template template parameter. 1736 if (!isa<ClassTemplateDecl>(Template)) { 1737 assert(isa<FunctionTemplateDecl>(Template) && 1738 "Only function templates are possible here"); 1739 Diag(Arg->getSourceRange().getBegin(), 1740 diag::note_template_arg_refers_here_func) 1741 << Template; 1742 } 1743 1744 return !TemplateParameterListsAreEqual(Template->getTemplateParameters(), 1745 Param->getTemplateParameters(), 1746 true, true, 1747 Arg->getSourceRange().getBegin()); 1748} 1749 1750/// \brief Determine whether the given template parameter lists are 1751/// equivalent. 1752/// 1753/// \param New The new template parameter list, typically written in the 1754/// source code as part of a new template declaration. 1755/// 1756/// \param Old The old template parameter list, typically found via 1757/// name lookup of the template declared with this template parameter 1758/// list. 1759/// 1760/// \param Complain If true, this routine will produce a diagnostic if 1761/// the template parameter lists are not equivalent. 1762/// 1763/// \param IsTemplateTemplateParm If true, this routine is being 1764/// called to compare the template parameter lists of a template 1765/// template parameter. 1766/// 1767/// \param TemplateArgLoc If this source location is valid, then we 1768/// are actually checking the template parameter list of a template 1769/// argument (New) against the template parameter list of its 1770/// corresponding template template parameter (Old). We produce 1771/// slightly different diagnostics in this scenario. 1772/// 1773/// \returns True if the template parameter lists are equal, false 1774/// otherwise. 1775bool 1776Sema::TemplateParameterListsAreEqual(TemplateParameterList *New, 1777 TemplateParameterList *Old, 1778 bool Complain, 1779 bool IsTemplateTemplateParm, 1780 SourceLocation TemplateArgLoc) { 1781 if (Old->size() != New->size()) { 1782 if (Complain) { 1783 unsigned NextDiag = diag::err_template_param_list_different_arity; 1784 if (TemplateArgLoc.isValid()) { 1785 Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch); 1786 NextDiag = diag::note_template_param_list_different_arity; 1787 } 1788 Diag(New->getTemplateLoc(), NextDiag) 1789 << (New->size() > Old->size()) 1790 << IsTemplateTemplateParm 1791 << SourceRange(New->getTemplateLoc(), New->getRAngleLoc()); 1792 Diag(Old->getTemplateLoc(), diag::note_template_prev_declaration) 1793 << IsTemplateTemplateParm 1794 << SourceRange(Old->getTemplateLoc(), Old->getRAngleLoc()); 1795 } 1796 1797 return false; 1798 } 1799 1800 for (TemplateParameterList::iterator OldParm = Old->begin(), 1801 OldParmEnd = Old->end(), NewParm = New->begin(); 1802 OldParm != OldParmEnd; ++OldParm, ++NewParm) { 1803 if ((*OldParm)->getKind() != (*NewParm)->getKind()) { 1804 unsigned NextDiag = diag::err_template_param_different_kind; 1805 if (TemplateArgLoc.isValid()) { 1806 Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch); 1807 NextDiag = diag::note_template_param_different_kind; 1808 } 1809 Diag((*NewParm)->getLocation(), NextDiag) 1810 << IsTemplateTemplateParm; 1811 Diag((*OldParm)->getLocation(), diag::note_template_prev_declaration) 1812 << IsTemplateTemplateParm; 1813 return false; 1814 } 1815 1816 if (isa<TemplateTypeParmDecl>(*OldParm)) { 1817 // Okay; all template type parameters are equivalent (since we 1818 // know we're at the same index). 1819#if 0 1820 // FIXME: Enable this code in debug mode *after* we properly go through 1821 // and "instantiate" the template parameter lists of template template 1822 // parameters. It's only after this instantiation that (1) any dependent 1823 // types within the template parameter list of the template template 1824 // parameter can be checked, and (2) the template type parameter depths 1825 // will match up. 1826 QualType OldParmType 1827 = Context.getTypeDeclType(cast<TemplateTypeParmDecl>(*OldParm)); 1828 QualType NewParmType 1829 = Context.getTypeDeclType(cast<TemplateTypeParmDecl>(*NewParm)); 1830 assert(Context.getCanonicalType(OldParmType) == 1831 Context.getCanonicalType(NewParmType) && 1832 "type parameter mismatch?"); 1833#endif 1834 } else if (NonTypeTemplateParmDecl *OldNTTP 1835 = dyn_cast<NonTypeTemplateParmDecl>(*OldParm)) { 1836 // The types of non-type template parameters must agree. 1837 NonTypeTemplateParmDecl *NewNTTP 1838 = cast<NonTypeTemplateParmDecl>(*NewParm); 1839 if (Context.getCanonicalType(OldNTTP->getType()) != 1840 Context.getCanonicalType(NewNTTP->getType())) { 1841 if (Complain) { 1842 unsigned NextDiag = diag::err_template_nontype_parm_different_type; 1843 if (TemplateArgLoc.isValid()) { 1844 Diag(TemplateArgLoc, 1845 diag::err_template_arg_template_params_mismatch); 1846 NextDiag = diag::note_template_nontype_parm_different_type; 1847 } 1848 Diag(NewNTTP->getLocation(), NextDiag) 1849 << NewNTTP->getType() 1850 << IsTemplateTemplateParm; 1851 Diag(OldNTTP->getLocation(), 1852 diag::note_template_nontype_parm_prev_declaration) 1853 << OldNTTP->getType(); 1854 } 1855 return false; 1856 } 1857 } else { 1858 // The template parameter lists of template template 1859 // parameters must agree. 1860 // FIXME: Could we perform a faster "type" comparison here? 1861 assert(isa<TemplateTemplateParmDecl>(*OldParm) && 1862 "Only template template parameters handled here"); 1863 TemplateTemplateParmDecl *OldTTP 1864 = cast<TemplateTemplateParmDecl>(*OldParm); 1865 TemplateTemplateParmDecl *NewTTP 1866 = cast<TemplateTemplateParmDecl>(*NewParm); 1867 if (!TemplateParameterListsAreEqual(NewTTP->getTemplateParameters(), 1868 OldTTP->getTemplateParameters(), 1869 Complain, 1870 /*IsTemplateTemplateParm=*/true, 1871 TemplateArgLoc)) 1872 return false; 1873 } 1874 } 1875 1876 return true; 1877} 1878 1879/// \brief Check whether a template can be declared within this scope. 1880/// 1881/// If the template declaration is valid in this scope, returns 1882/// false. Otherwise, issues a diagnostic and returns true. 1883bool 1884Sema::CheckTemplateDeclScope(Scope *S, 1885 MultiTemplateParamsArg &TemplateParameterLists) { 1886 assert(TemplateParameterLists.size() > 0 && "Not a template"); 1887 1888 // Find the nearest enclosing declaration scope. 1889 while ((S->getFlags() & Scope::DeclScope) == 0 || 1890 (S->getFlags() & Scope::TemplateParamScope) != 0) 1891 S = S->getParent(); 1892 1893 TemplateParameterList *TemplateParams = 1894 static_cast<TemplateParameterList*>(*TemplateParameterLists.get()); 1895 SourceLocation TemplateLoc = TemplateParams->getTemplateLoc(); 1896 SourceRange TemplateRange 1897 = SourceRange(TemplateLoc, TemplateParams->getRAngleLoc()); 1898 1899 // C++ [temp]p2: 1900 // A template-declaration can appear only as a namespace scope or 1901 // class scope declaration. 1902 DeclContext *Ctx = static_cast<DeclContext *>(S->getEntity()); 1903 while (Ctx && isa<LinkageSpecDecl>(Ctx)) { 1904 if (cast<LinkageSpecDecl>(Ctx)->getLanguage() != LinkageSpecDecl::lang_cxx) 1905 return Diag(TemplateLoc, diag::err_template_linkage) 1906 << TemplateRange; 1907 1908 Ctx = Ctx->getParent(); 1909 } 1910 1911 if (Ctx && (Ctx->isFileContext() || Ctx->isRecord())) 1912 return false; 1913 1914 return Diag(TemplateLoc, diag::err_template_outside_namespace_or_class_scope) 1915 << TemplateRange; 1916} 1917 1918/// \brief Check whether a class template specialization or explicit 1919/// instantiation in the current context is well-formed. 1920/// 1921/// This routine determines whether a class template specialization or 1922/// explicit instantiation can be declared in the current context 1923/// (C++ [temp.expl.spec]p2, C++0x [temp.explicit]p2) and emits 1924/// appropriate diagnostics if there was an error. It returns true if 1925// there was an error that we cannot recover from, and false otherwise. 1926bool 1927Sema::CheckClassTemplateSpecializationScope(ClassTemplateDecl *ClassTemplate, 1928 ClassTemplateSpecializationDecl *PrevDecl, 1929 SourceLocation TemplateNameLoc, 1930 SourceRange ScopeSpecifierRange, 1931 bool ExplicitInstantiation) { 1932 // C++ [temp.expl.spec]p2: 1933 // An explicit specialization shall be declared in the namespace 1934 // of which the template is a member, or, for member templates, in 1935 // the namespace of which the enclosing class or enclosing class 1936 // template is a member. An explicit specialization of a member 1937 // function, member class or static data member of a class 1938 // template shall be declared in the namespace of which the class 1939 // template is a member. Such a declaration may also be a 1940 // definition. If the declaration is not a definition, the 1941 // specialization may be defined later in the name- space in which 1942 // the explicit specialization was declared, or in a namespace 1943 // that encloses the one in which the explicit specialization was 1944 // declared. 1945 if (CurContext->getLookupContext()->isFunctionOrMethod()) { 1946 Diag(TemplateNameLoc, diag::err_template_spec_decl_function_scope) 1947 << ExplicitInstantiation << ClassTemplate; 1948 return true; 1949 } 1950 1951 DeclContext *DC = CurContext->getEnclosingNamespaceContext(); 1952 DeclContext *TemplateContext 1953 = ClassTemplate->getDeclContext()->getEnclosingNamespaceContext(); 1954 if ((!PrevDecl || PrevDecl->getSpecializationKind() == TSK_Undeclared) && 1955 !ExplicitInstantiation) { 1956 // There is no prior declaration of this entity, so this 1957 // specialization must be in the same context as the template 1958 // itself. 1959 if (DC != TemplateContext) { 1960 if (isa<TranslationUnitDecl>(TemplateContext)) 1961 Diag(TemplateNameLoc, diag::err_template_spec_decl_out_of_scope_global) 1962 << ClassTemplate << ScopeSpecifierRange; 1963 else if (isa<NamespaceDecl>(TemplateContext)) 1964 Diag(TemplateNameLoc, diag::err_template_spec_decl_out_of_scope) 1965 << ClassTemplate << cast<NamedDecl>(TemplateContext) 1966 << ScopeSpecifierRange; 1967 1968 Diag(ClassTemplate->getLocation(), diag::note_template_decl_here); 1969 } 1970 1971 return false; 1972 } 1973 1974 // We have a previous declaration of this entity. Make sure that 1975 // this redeclaration (or definition) occurs in an enclosing namespace. 1976 if (!CurContext->Encloses(TemplateContext)) { 1977 // FIXME: In C++98, we would like to turn these errors into warnings, 1978 // dependent on a -Wc++0x flag. 1979 bool SuppressedDiag = false; 1980 if (isa<TranslationUnitDecl>(TemplateContext)) { 1981 if (!ExplicitInstantiation || getLangOptions().CPlusPlus0x) 1982 Diag(TemplateNameLoc, diag::err_template_spec_redecl_global_scope) 1983 << ExplicitInstantiation << ClassTemplate << ScopeSpecifierRange; 1984 else 1985 SuppressedDiag = true; 1986 } else if (isa<NamespaceDecl>(TemplateContext)) { 1987 if (!ExplicitInstantiation || getLangOptions().CPlusPlus0x) 1988 Diag(TemplateNameLoc, diag::err_template_spec_redecl_out_of_scope) 1989 << ExplicitInstantiation << ClassTemplate 1990 << cast<NamedDecl>(TemplateContext) << ScopeSpecifierRange; 1991 else 1992 SuppressedDiag = true; 1993 } 1994 1995 if (!SuppressedDiag) 1996 Diag(ClassTemplate->getLocation(), diag::note_template_decl_here); 1997 } 1998 1999 return false; 2000} 2001 2002Sema::DeclResult 2003Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagKind TK, 2004 SourceLocation KWLoc, 2005 const CXXScopeSpec &SS, 2006 TemplateTy TemplateD, 2007 SourceLocation TemplateNameLoc, 2008 SourceLocation LAngleLoc, 2009 ASTTemplateArgsPtr TemplateArgsIn, 2010 SourceLocation *TemplateArgLocs, 2011 SourceLocation RAngleLoc, 2012 AttributeList *Attr, 2013 MultiTemplateParamsArg TemplateParameterLists) { 2014 // Find the class template we're specializing 2015 TemplateName Name = TemplateD.getAsVal<TemplateName>(); 2016 ClassTemplateDecl *ClassTemplate 2017 = cast<ClassTemplateDecl>(Name.getAsTemplateDecl()); 2018 2019 bool isPartialSpecialization = false; 2020 2021 // Check the validity of the template headers that introduce this 2022 // template. 2023 // FIXME: Once we have member templates, we'll need to check 2024 // C++ [temp.expl.spec]p17-18, where we could have multiple levels of 2025 // template<> headers. 2026 if (TemplateParameterLists.size() == 0) 2027 Diag(KWLoc, diag::err_template_spec_needs_header) 2028 << CodeModificationHint::CreateInsertion(KWLoc, "template<> "); 2029 else { 2030 TemplateParameterList *TemplateParams 2031 = static_cast<TemplateParameterList*>(*TemplateParameterLists.get()); 2032 if (TemplateParameterLists.size() > 1) { 2033 Diag(TemplateParams->getTemplateLoc(), 2034 diag::err_template_spec_extra_headers); 2035 return true; 2036 } 2037 2038 // FIXME: We'll need more checks, here! 2039 if (TemplateParams->size() > 0) 2040 isPartialSpecialization = true; 2041 } 2042 2043 // Check that the specialization uses the same tag kind as the 2044 // original template. 2045 TagDecl::TagKind Kind; 2046 switch (TagSpec) { 2047 default: assert(0 && "Unknown tag type!"); 2048 case DeclSpec::TST_struct: Kind = TagDecl::TK_struct; break; 2049 case DeclSpec::TST_union: Kind = TagDecl::TK_union; break; 2050 case DeclSpec::TST_class: Kind = TagDecl::TK_class; break; 2051 } 2052 if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(), 2053 Kind, KWLoc, 2054 *ClassTemplate->getIdentifier())) { 2055 Diag(KWLoc, diag::err_use_with_wrong_tag) 2056 << ClassTemplate 2057 << CodeModificationHint::CreateReplacement(KWLoc, 2058 ClassTemplate->getTemplatedDecl()->getKindName()); 2059 Diag(ClassTemplate->getTemplatedDecl()->getLocation(), 2060 diag::note_previous_use); 2061 Kind = ClassTemplate->getTemplatedDecl()->getTagKind(); 2062 } 2063 2064 // Translate the parser's template argument list in our AST format. 2065 llvm::SmallVector<TemplateArgument, 16> TemplateArgs; 2066 translateTemplateArguments(TemplateArgsIn, TemplateArgLocs, TemplateArgs); 2067 2068 // Check that the template argument list is well-formed for this 2069 // template. 2070 TemplateArgumentListBuilder ConvertedTemplateArgs; 2071 if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc, LAngleLoc, 2072 &TemplateArgs[0], TemplateArgs.size(), 2073 RAngleLoc, ConvertedTemplateArgs)) 2074 return true; 2075 2076 assert((ConvertedTemplateArgs.size() == 2077 ClassTemplate->getTemplateParameters()->size()) && 2078 "Converted template argument list is too short!"); 2079 2080 // Find the class template (partial) specialization declaration that 2081 // corresponds to these arguments. 2082 llvm::FoldingSetNodeID ID; 2083 if (isPartialSpecialization) 2084 // FIXME: Template parameter list matters, too 2085 ClassTemplatePartialSpecializationDecl::Profile(ID, 2086 ConvertedTemplateArgs.getFlatArgumentList(), 2087 ConvertedTemplateArgs.flatSize()); 2088 else 2089 ClassTemplateSpecializationDecl::Profile(ID, 2090 ConvertedTemplateArgs.getFlatArgumentList(), 2091 ConvertedTemplateArgs.flatSize()); 2092 void *InsertPos = 0; 2093 ClassTemplateSpecializationDecl *PrevDecl = 0; 2094 2095 if (isPartialSpecialization) 2096 PrevDecl 2097 = ClassTemplate->getPartialSpecializations().FindNodeOrInsertPos(ID, 2098 InsertPos); 2099 else 2100 PrevDecl 2101 = ClassTemplate->getSpecializations().FindNodeOrInsertPos(ID, InsertPos); 2102 2103 ClassTemplateSpecializationDecl *Specialization = 0; 2104 2105 // Check whether we can declare a class template specialization in 2106 // the current scope. 2107 if (CheckClassTemplateSpecializationScope(ClassTemplate, PrevDecl, 2108 TemplateNameLoc, 2109 SS.getRange(), 2110 /*ExplicitInstantiation=*/false)) 2111 return true; 2112 2113 if (PrevDecl && PrevDecl->getSpecializationKind() == TSK_Undeclared) { 2114 // Since the only prior class template specialization with these 2115 // arguments was referenced but not declared, reuse that 2116 // declaration node as our own, updating its source location to 2117 // reflect our new declaration. 2118 Specialization = PrevDecl; 2119 Specialization->setLocation(TemplateNameLoc); 2120 PrevDecl = 0; 2121 } else if (isPartialSpecialization) { 2122 // FIXME: extra checking for partial specializations 2123 2124 // Create a new class template partial specialization declaration node. 2125 TemplateParameterList *TemplateParams 2126 = static_cast<TemplateParameterList*>(*TemplateParameterLists.get()); 2127 ClassTemplatePartialSpecializationDecl *PrevPartial 2128 = cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl); 2129 ClassTemplatePartialSpecializationDecl *Partial 2130 = ClassTemplatePartialSpecializationDecl::Create(Context, 2131 ClassTemplate->getDeclContext(), 2132 TemplateNameLoc, 2133 TemplateParams, 2134 ClassTemplate, 2135 ConvertedTemplateArgs.getFlatArgumentList(), 2136 ConvertedTemplateArgs.flatSize(), 2137 PrevPartial); 2138 2139 if (PrevPartial) { 2140 ClassTemplate->getPartialSpecializations().RemoveNode(PrevPartial); 2141 ClassTemplate->getPartialSpecializations().GetOrInsertNode(Partial); 2142 } else { 2143 ClassTemplate->getPartialSpecializations().InsertNode(Partial, InsertPos); 2144 } 2145 Specialization = Partial; 2146 } else { 2147 // Create a new class template specialization declaration node for 2148 // this explicit specialization. 2149 Specialization 2150 = ClassTemplateSpecializationDecl::Create(Context, 2151 ClassTemplate->getDeclContext(), 2152 TemplateNameLoc, 2153 ClassTemplate, 2154 ConvertedTemplateArgs.getFlatArgumentList(), 2155 ConvertedTemplateArgs.flatSize(), 2156 PrevDecl); 2157 2158 if (PrevDecl) { 2159 ClassTemplate->getSpecializations().RemoveNode(PrevDecl); 2160 ClassTemplate->getSpecializations().GetOrInsertNode(Specialization); 2161 } else { 2162 ClassTemplate->getSpecializations().InsertNode(Specialization, 2163 InsertPos); 2164 } 2165 } 2166 2167 // Note that this is an explicit specialization. 2168 Specialization->setSpecializationKind(TSK_ExplicitSpecialization); 2169 2170 // Check that this isn't a redefinition of this specialization. 2171 if (TK == TK_Definition) { 2172 if (RecordDecl *Def = Specialization->getDefinition(Context)) { 2173 // FIXME: Should also handle explicit specialization after implicit 2174 // instantiation with a special diagnostic. 2175 SourceRange Range(TemplateNameLoc, RAngleLoc); 2176 Diag(TemplateNameLoc, diag::err_redefinition) 2177 << Context.getTypeDeclType(Specialization) << Range; 2178 Diag(Def->getLocation(), diag::note_previous_definition); 2179 Specialization->setInvalidDecl(); 2180 return true; 2181 } 2182 } 2183 2184 // Build the fully-sugared type for this class template 2185 // specialization as the user wrote in the specialization 2186 // itself. This means that we'll pretty-print the type retrieved 2187 // from the specialization's declaration the way that the user 2188 // actually wrote the specialization, rather than formatting the 2189 // name based on the "canonical" representation used to store the 2190 // template arguments in the specialization. 2191 QualType WrittenTy 2192 = Context.getTemplateSpecializationType(Name, 2193 &TemplateArgs[0], 2194 TemplateArgs.size(), 2195 Context.getTypeDeclType(Specialization)); 2196 Specialization->setTypeAsWritten(WrittenTy); 2197 TemplateArgsIn.release(); 2198 2199 // C++ [temp.expl.spec]p9: 2200 // A template explicit specialization is in the scope of the 2201 // namespace in which the template was defined. 2202 // 2203 // We actually implement this paragraph where we set the semantic 2204 // context (in the creation of the ClassTemplateSpecializationDecl), 2205 // but we also maintain the lexical context where the actual 2206 // definition occurs. 2207 Specialization->setLexicalDeclContext(CurContext); 2208 2209 // We may be starting the definition of this specialization. 2210 if (TK == TK_Definition) 2211 Specialization->startDefinition(); 2212 2213 // Add the specialization into its lexical context, so that it can 2214 // be seen when iterating through the list of declarations in that 2215 // context. However, specializations are not found by name lookup. 2216 CurContext->addDecl(Context, Specialization); 2217 return DeclPtrTy::make(Specialization); 2218} 2219 2220// Explicit instantiation of a class template specialization 2221Sema::DeclResult 2222Sema::ActOnExplicitInstantiation(Scope *S, SourceLocation TemplateLoc, 2223 unsigned TagSpec, 2224 SourceLocation KWLoc, 2225 const CXXScopeSpec &SS, 2226 TemplateTy TemplateD, 2227 SourceLocation TemplateNameLoc, 2228 SourceLocation LAngleLoc, 2229 ASTTemplateArgsPtr TemplateArgsIn, 2230 SourceLocation *TemplateArgLocs, 2231 SourceLocation RAngleLoc, 2232 AttributeList *Attr) { 2233 // Find the class template we're specializing 2234 TemplateName Name = TemplateD.getAsVal<TemplateName>(); 2235 ClassTemplateDecl *ClassTemplate 2236 = cast<ClassTemplateDecl>(Name.getAsTemplateDecl()); 2237 2238 // Check that the specialization uses the same tag kind as the 2239 // original template. 2240 TagDecl::TagKind Kind; 2241 switch (TagSpec) { 2242 default: assert(0 && "Unknown tag type!"); 2243 case DeclSpec::TST_struct: Kind = TagDecl::TK_struct; break; 2244 case DeclSpec::TST_union: Kind = TagDecl::TK_union; break; 2245 case DeclSpec::TST_class: Kind = TagDecl::TK_class; break; 2246 } 2247 if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(), 2248 Kind, KWLoc, 2249 *ClassTemplate->getIdentifier())) { 2250 Diag(KWLoc, diag::err_use_with_wrong_tag) 2251 << ClassTemplate 2252 << CodeModificationHint::CreateReplacement(KWLoc, 2253 ClassTemplate->getTemplatedDecl()->getKindName()); 2254 Diag(ClassTemplate->getTemplatedDecl()->getLocation(), 2255 diag::note_previous_use); 2256 Kind = ClassTemplate->getTemplatedDecl()->getTagKind(); 2257 } 2258 2259 // C++0x [temp.explicit]p2: 2260 // [...] An explicit instantiation shall appear in an enclosing 2261 // namespace of its template. [...] 2262 // 2263 // This is C++ DR 275. 2264 if (CheckClassTemplateSpecializationScope(ClassTemplate, 0, 2265 TemplateNameLoc, 2266 SS.getRange(), 2267 /*ExplicitInstantiation=*/true)) 2268 return true; 2269 2270 // Translate the parser's template argument list in our AST format. 2271 llvm::SmallVector<TemplateArgument, 16> TemplateArgs; 2272 translateTemplateArguments(TemplateArgsIn, TemplateArgLocs, TemplateArgs); 2273 2274 // Check that the template argument list is well-formed for this 2275 // template. 2276 TemplateArgumentListBuilder ConvertedTemplateArgs; 2277 if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc, LAngleLoc, 2278 TemplateArgs.data(), TemplateArgs.size(), 2279 RAngleLoc, ConvertedTemplateArgs)) 2280 return true; 2281 2282 assert((ConvertedTemplateArgs.size() == 2283 ClassTemplate->getTemplateParameters()->size()) && 2284 "Converted template argument list is too short!"); 2285 2286 // Find the class template specialization declaration that 2287 // corresponds to these arguments. 2288 llvm::FoldingSetNodeID ID; 2289 ClassTemplateSpecializationDecl::Profile(ID, 2290 ConvertedTemplateArgs.getFlatArgumentList(), 2291 ConvertedTemplateArgs.flatSize()); 2292 void *InsertPos = 0; 2293 ClassTemplateSpecializationDecl *PrevDecl 2294 = ClassTemplate->getSpecializations().FindNodeOrInsertPos(ID, InsertPos); 2295 2296 ClassTemplateSpecializationDecl *Specialization = 0; 2297 2298 bool SpecializationRequiresInstantiation = true; 2299 if (PrevDecl) { 2300 if (PrevDecl->getSpecializationKind() == TSK_ExplicitInstantiation) { 2301 // This particular specialization has already been declared or 2302 // instantiated. We cannot explicitly instantiate it. 2303 Diag(TemplateNameLoc, diag::err_explicit_instantiation_duplicate) 2304 << Context.getTypeDeclType(PrevDecl); 2305 Diag(PrevDecl->getLocation(), 2306 diag::note_previous_explicit_instantiation); 2307 return DeclPtrTy::make(PrevDecl); 2308 } 2309 2310 if (PrevDecl->getSpecializationKind() == TSK_ExplicitSpecialization) { 2311 // C++ DR 259, C++0x [temp.explicit]p4: 2312 // For a given set of template parameters, if an explicit 2313 // instantiation of a template appears after a declaration of 2314 // an explicit specialization for that template, the explicit 2315 // instantiation has no effect. 2316 if (!getLangOptions().CPlusPlus0x) { 2317 Diag(TemplateNameLoc, 2318 diag::ext_explicit_instantiation_after_specialization) 2319 << Context.getTypeDeclType(PrevDecl); 2320 Diag(PrevDecl->getLocation(), 2321 diag::note_previous_template_specialization); 2322 } 2323 2324 // Create a new class template specialization declaration node 2325 // for this explicit specialization. This node is only used to 2326 // record the existence of this explicit instantiation for 2327 // accurate reproduction of the source code; we don't actually 2328 // use it for anything, since it is semantically irrelevant. 2329 Specialization 2330 = ClassTemplateSpecializationDecl::Create(Context, 2331 ClassTemplate->getDeclContext(), 2332 TemplateNameLoc, 2333 ClassTemplate, 2334 ConvertedTemplateArgs.getFlatArgumentList(), 2335 ConvertedTemplateArgs.flatSize(), 2336 0); 2337 Specialization->setLexicalDeclContext(CurContext); 2338 CurContext->addDecl(Context, Specialization); 2339 return DeclPtrTy::make(Specialization); 2340 } 2341 2342 // If we have already (implicitly) instantiated this 2343 // specialization, there is less work to do. 2344 if (PrevDecl->getSpecializationKind() == TSK_ImplicitInstantiation) 2345 SpecializationRequiresInstantiation = false; 2346 2347 // Since the only prior class template specialization with these 2348 // arguments was referenced but not declared, reuse that 2349 // declaration node as our own, updating its source location to 2350 // reflect our new declaration. 2351 Specialization = PrevDecl; 2352 Specialization->setLocation(TemplateNameLoc); 2353 PrevDecl = 0; 2354 } else { 2355 // Create a new class template specialization declaration node for 2356 // this explicit specialization. 2357 Specialization 2358 = ClassTemplateSpecializationDecl::Create(Context, 2359 ClassTemplate->getDeclContext(), 2360 TemplateNameLoc, 2361 ClassTemplate, 2362 ConvertedTemplateArgs.getFlatArgumentList(), 2363 ConvertedTemplateArgs.flatSize(), 2364 0); 2365 2366 ClassTemplate->getSpecializations().InsertNode(Specialization, 2367 InsertPos); 2368 } 2369 2370 // Build the fully-sugared type for this explicit instantiation as 2371 // the user wrote in the explicit instantiation itself. This means 2372 // that we'll pretty-print the type retrieved from the 2373 // specialization's declaration the way that the user actually wrote 2374 // the explicit instantiation, rather than formatting the name based 2375 // on the "canonical" representation used to store the template 2376 // arguments in the specialization. 2377 QualType WrittenTy 2378 = Context.getTemplateSpecializationType(Name, 2379 TemplateArgs.data(), 2380 TemplateArgs.size(), 2381 Context.getTypeDeclType(Specialization)); 2382 Specialization->setTypeAsWritten(WrittenTy); 2383 TemplateArgsIn.release(); 2384 2385 // Add the explicit instantiation into its lexical context. However, 2386 // since explicit instantiations are never found by name lookup, we 2387 // just put it into the declaration context directly. 2388 Specialization->setLexicalDeclContext(CurContext); 2389 CurContext->addDecl(Context, Specialization); 2390 2391 // C++ [temp.explicit]p3: 2392 // A definition of a class template or class member template 2393 // shall be in scope at the point of the explicit instantiation of 2394 // the class template or class member template. 2395 // 2396 // This check comes when we actually try to perform the 2397 // instantiation. 2398 if (SpecializationRequiresInstantiation) 2399 InstantiateClassTemplateSpecialization(Specialization, true); 2400 else // Instantiate the members of this class template specialization. 2401 InstantiateClassTemplateSpecializationMembers(TemplateLoc, Specialization); 2402 2403 return DeclPtrTy::make(Specialization); 2404} 2405 2406// Explicit instantiation of a member class of a class template. 2407Sema::DeclResult 2408Sema::ActOnExplicitInstantiation(Scope *S, SourceLocation TemplateLoc, 2409 unsigned TagSpec, 2410 SourceLocation KWLoc, 2411 const CXXScopeSpec &SS, 2412 IdentifierInfo *Name, 2413 SourceLocation NameLoc, 2414 AttributeList *Attr) { 2415 2416 bool Owned = false; 2417 DeclPtrTy TagD = ActOnTag(S, TagSpec, Action::TK_Reference, 2418 KWLoc, SS, Name, NameLoc, Attr, AS_none, Owned); 2419 if (!TagD) 2420 return true; 2421 2422 TagDecl *Tag = cast<TagDecl>(TagD.getAs<Decl>()); 2423 if (Tag->isEnum()) { 2424 Diag(TemplateLoc, diag::err_explicit_instantiation_enum) 2425 << Context.getTypeDeclType(Tag); 2426 return true; 2427 } 2428 2429 if (Tag->isInvalidDecl()) 2430 return true; 2431 2432 CXXRecordDecl *Record = cast<CXXRecordDecl>(Tag); 2433 CXXRecordDecl *Pattern = Record->getInstantiatedFromMemberClass(); 2434 if (!Pattern) { 2435 Diag(TemplateLoc, diag::err_explicit_instantiation_nontemplate_type) 2436 << Context.getTypeDeclType(Record); 2437 Diag(Record->getLocation(), diag::note_nontemplate_decl_here); 2438 return true; 2439 } 2440 2441 // C++0x [temp.explicit]p2: 2442 // [...] An explicit instantiation shall appear in an enclosing 2443 // namespace of its template. [...] 2444 // 2445 // This is C++ DR 275. 2446 if (getLangOptions().CPlusPlus0x) { 2447 // FIXME: In C++98, we would like to turn these errors into warnings, 2448 // dependent on a -Wc++0x flag. 2449 DeclContext *PatternContext 2450 = Pattern->getDeclContext()->getEnclosingNamespaceContext(); 2451 if (!CurContext->Encloses(PatternContext)) { 2452 Diag(TemplateLoc, diag::err_explicit_instantiation_out_of_scope) 2453 << Record << cast<NamedDecl>(PatternContext) << SS.getRange(); 2454 Diag(Pattern->getLocation(), diag::note_previous_declaration); 2455 } 2456 } 2457 2458 if (!Record->getDefinition(Context)) { 2459 // If the class has a definition, instantiate it (and all of its 2460 // members, recursively). 2461 Pattern = cast_or_null<CXXRecordDecl>(Pattern->getDefinition(Context)); 2462 if (Pattern && InstantiateClass(TemplateLoc, Record, Pattern, 2463 getTemplateInstantiationArgs(Record), 2464 /*ExplicitInstantiation=*/true)) 2465 return true; 2466 } else // Instantiate all of the members of class. 2467 InstantiateClassMembers(TemplateLoc, Record, 2468 getTemplateInstantiationArgs(Record)); 2469 2470 // FIXME: We don't have any representation for explicit instantiations of 2471 // member classes. Such a representation is not needed for compilation, but it 2472 // should be available for clients that want to see all of the declarations in 2473 // the source code. 2474 return TagD; 2475} 2476 2477Sema::TypeResult 2478Sema::ActOnTypenameType(SourceLocation TypenameLoc, const CXXScopeSpec &SS, 2479 const IdentifierInfo &II, SourceLocation IdLoc) { 2480 NestedNameSpecifier *NNS 2481 = static_cast<NestedNameSpecifier *>(SS.getScopeRep()); 2482 if (!NNS) 2483 return true; 2484 2485 QualType T = CheckTypenameType(NNS, II, SourceRange(TypenameLoc, IdLoc)); 2486 if (T.isNull()) 2487 return true; 2488 return T.getAsOpaquePtr(); 2489} 2490 2491Sema::TypeResult 2492Sema::ActOnTypenameType(SourceLocation TypenameLoc, const CXXScopeSpec &SS, 2493 SourceLocation TemplateLoc, TypeTy *Ty) { 2494 QualType T = QualType::getFromOpaquePtr(Ty); 2495 NestedNameSpecifier *NNS 2496 = static_cast<NestedNameSpecifier *>(SS.getScopeRep()); 2497 const TemplateSpecializationType *TemplateId 2498 = T->getAsTemplateSpecializationType(); 2499 assert(TemplateId && "Expected a template specialization type"); 2500 2501 if (NNS->isDependent()) 2502 return Context.getTypenameType(NNS, TemplateId).getAsOpaquePtr(); 2503 2504 return Context.getQualifiedNameType(NNS, T).getAsOpaquePtr(); 2505} 2506 2507/// \brief Build the type that describes a C++ typename specifier, 2508/// e.g., "typename T::type". 2509QualType 2510Sema::CheckTypenameType(NestedNameSpecifier *NNS, const IdentifierInfo &II, 2511 SourceRange Range) { 2512 CXXRecordDecl *CurrentInstantiation = 0; 2513 if (NNS->isDependent()) { 2514 CurrentInstantiation = getCurrentInstantiationOf(NNS); 2515 2516 // If the nested-name-specifier does not refer to the current 2517 // instantiation, then build a typename type. 2518 if (!CurrentInstantiation) 2519 return Context.getTypenameType(NNS, &II); 2520 } 2521 2522 DeclContext *Ctx = 0; 2523 2524 if (CurrentInstantiation) 2525 Ctx = CurrentInstantiation; 2526 else { 2527 CXXScopeSpec SS; 2528 SS.setScopeRep(NNS); 2529 SS.setRange(Range); 2530 if (RequireCompleteDeclContext(SS)) 2531 return QualType(); 2532 2533 Ctx = computeDeclContext(SS); 2534 } 2535 assert(Ctx && "No declaration context?"); 2536 2537 DeclarationName Name(&II); 2538 LookupResult Result = LookupQualifiedName(Ctx, Name, LookupOrdinaryName, 2539 false); 2540 unsigned DiagID = 0; 2541 Decl *Referenced = 0; 2542 switch (Result.getKind()) { 2543 case LookupResult::NotFound: 2544 if (Ctx->isTranslationUnit()) 2545 DiagID = diag::err_typename_nested_not_found_global; 2546 else 2547 DiagID = diag::err_typename_nested_not_found; 2548 break; 2549 2550 case LookupResult::Found: 2551 if (TypeDecl *Type = dyn_cast<TypeDecl>(Result.getAsDecl())) { 2552 // We found a type. Build a QualifiedNameType, since the 2553 // typename-specifier was just sugar. FIXME: Tell 2554 // QualifiedNameType that it has a "typename" prefix. 2555 return Context.getQualifiedNameType(NNS, Context.getTypeDeclType(Type)); 2556 } 2557 2558 DiagID = diag::err_typename_nested_not_type; 2559 Referenced = Result.getAsDecl(); 2560 break; 2561 2562 case LookupResult::FoundOverloaded: 2563 DiagID = diag::err_typename_nested_not_type; 2564 Referenced = *Result.begin(); 2565 break; 2566 2567 case LookupResult::AmbiguousBaseSubobjectTypes: 2568 case LookupResult::AmbiguousBaseSubobjects: 2569 case LookupResult::AmbiguousReference: 2570 DiagnoseAmbiguousLookup(Result, Name, Range.getEnd(), Range); 2571 return QualType(); 2572 } 2573 2574 // If we get here, it's because name lookup did not find a 2575 // type. Emit an appropriate diagnostic and return an error. 2576 if (NamedDecl *NamedCtx = dyn_cast<NamedDecl>(Ctx)) 2577 Diag(Range.getEnd(), DiagID) << Range << Name << NamedCtx; 2578 else 2579 Diag(Range.getEnd(), DiagID) << Range << Name; 2580 if (Referenced) 2581 Diag(Referenced->getLocation(), diag::note_typename_refers_here) 2582 << Name; 2583 return QualType(); 2584} 2585