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