SemaTemplate.cpp revision 42963612a4187b55685b7f75489c11abd3fa100e
1//===------- SemaTemplate.cpp - Semantic Analysis for C++ Templates -------===/ 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7//===----------------------------------------------------------------------===/ 8// 9// This file implements semantic analysis for C++ templates. 10//===----------------------------------------------------------------------===/ 11 12#include "clang/Sema/SemaInternal.h" 13#include "clang/Sema/Lookup.h" 14#include "clang/Sema/Scope.h" 15#include "clang/Sema/Template.h" 16#include "clang/Sema/TemplateDeduction.h" 17#include "TreeTransform.h" 18#include "clang/AST/ASTContext.h" 19#include "clang/AST/Expr.h" 20#include "clang/AST/ExprCXX.h" 21#include "clang/AST/DeclFriend.h" 22#include "clang/AST/DeclTemplate.h" 23#include "clang/AST/RecursiveASTVisitor.h" 24#include "clang/AST/TypeVisitor.h" 25#include "clang/Sema/DeclSpec.h" 26#include "clang/Sema/ParsedTemplate.h" 27#include "clang/Basic/LangOptions.h" 28#include "clang/Basic/PartialDiagnostic.h" 29#include "llvm/ADT/SmallBitVector.h" 30#include "llvm/ADT/SmallString.h" 31#include "llvm/ADT/StringExtras.h" 32using namespace clang; 33using namespace sema; 34 35// Exported for use by Parser. 36SourceRange 37clang::getTemplateParamsRange(TemplateParameterList const * const *Ps, 38 unsigned N) { 39 if (!N) return SourceRange(); 40 return SourceRange(Ps[0]->getTemplateLoc(), Ps[N-1]->getRAngleLoc()); 41} 42 43/// \brief Determine whether the declaration found is acceptable as the name 44/// of a template and, if so, return that template declaration. Otherwise, 45/// returns NULL. 46static NamedDecl *isAcceptableTemplateName(ASTContext &Context, 47 NamedDecl *Orig, 48 bool AllowFunctionTemplates) { 49 NamedDecl *D = Orig->getUnderlyingDecl(); 50 51 if (isa<TemplateDecl>(D)) { 52 if (!AllowFunctionTemplates && isa<FunctionTemplateDecl>(D)) 53 return 0; 54 55 return Orig; 56 } 57 58 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) { 59 // C++ [temp.local]p1: 60 // Like normal (non-template) classes, class templates have an 61 // injected-class-name (Clause 9). The injected-class-name 62 // can be used with or without a template-argument-list. When 63 // it is used without a template-argument-list, it is 64 // equivalent to the injected-class-name followed by the 65 // template-parameters of the class template enclosed in 66 // <>. When it is used with a template-argument-list, it 67 // refers to the specified class template specialization, 68 // which could be the current specialization or another 69 // specialization. 70 if (Record->isInjectedClassName()) { 71 Record = cast<CXXRecordDecl>(Record->getDeclContext()); 72 if (Record->getDescribedClassTemplate()) 73 return Record->getDescribedClassTemplate(); 74 75 if (ClassTemplateSpecializationDecl *Spec 76 = dyn_cast<ClassTemplateSpecializationDecl>(Record)) 77 return Spec->getSpecializedTemplate(); 78 } 79 80 return 0; 81 } 82 83 return 0; 84} 85 86void Sema::FilterAcceptableTemplateNames(LookupResult &R, 87 bool AllowFunctionTemplates) { 88 // The set of class templates we've already seen. 89 llvm::SmallPtrSet<ClassTemplateDecl *, 8> ClassTemplates; 90 LookupResult::Filter filter = R.makeFilter(); 91 while (filter.hasNext()) { 92 NamedDecl *Orig = filter.next(); 93 NamedDecl *Repl = isAcceptableTemplateName(Context, Orig, 94 AllowFunctionTemplates); 95 if (!Repl) 96 filter.erase(); 97 else if (Repl != Orig) { 98 99 // C++ [temp.local]p3: 100 // A lookup that finds an injected-class-name (10.2) can result in an 101 // ambiguity in certain cases (for example, if it is found in more than 102 // one base class). If all of the injected-class-names that are found 103 // refer to specializations of the same class template, and if the name 104 // is used as a template-name, the reference refers to the class 105 // template itself and not a specialization thereof, and is not 106 // ambiguous. 107 if (ClassTemplateDecl *ClassTmpl = dyn_cast<ClassTemplateDecl>(Repl)) 108 if (!ClassTemplates.insert(ClassTmpl)) { 109 filter.erase(); 110 continue; 111 } 112 113 // FIXME: we promote access to public here as a workaround to 114 // the fact that LookupResult doesn't let us remember that we 115 // found this template through a particular injected class name, 116 // which means we end up doing nasty things to the invariants. 117 // Pretending that access is public is *much* safer. 118 filter.replace(Repl, AS_public); 119 } 120 } 121 filter.done(); 122} 123 124bool Sema::hasAnyAcceptableTemplateNames(LookupResult &R, 125 bool AllowFunctionTemplates) { 126 for (LookupResult::iterator I = R.begin(), IEnd = R.end(); I != IEnd; ++I) 127 if (isAcceptableTemplateName(Context, *I, AllowFunctionTemplates)) 128 return true; 129 130 return false; 131} 132 133TemplateNameKind Sema::isTemplateName(Scope *S, 134 CXXScopeSpec &SS, 135 bool hasTemplateKeyword, 136 UnqualifiedId &Name, 137 ParsedType ObjectTypePtr, 138 bool EnteringContext, 139 TemplateTy &TemplateResult, 140 bool &MemberOfUnknownSpecialization) { 141 assert(getLangOpts().CPlusPlus && "No template names in C!"); 142 143 DeclarationName TName; 144 MemberOfUnknownSpecialization = false; 145 146 switch (Name.getKind()) { 147 case UnqualifiedId::IK_Identifier: 148 TName = DeclarationName(Name.Identifier); 149 break; 150 151 case UnqualifiedId::IK_OperatorFunctionId: 152 TName = Context.DeclarationNames.getCXXOperatorName( 153 Name.OperatorFunctionId.Operator); 154 break; 155 156 case UnqualifiedId::IK_LiteralOperatorId: 157 TName = Context.DeclarationNames.getCXXLiteralOperatorName(Name.Identifier); 158 break; 159 160 default: 161 return TNK_Non_template; 162 } 163 164 QualType ObjectType = ObjectTypePtr.get(); 165 166 LookupResult R(*this, TName, Name.getLocStart(), LookupOrdinaryName); 167 LookupTemplateName(R, S, SS, ObjectType, EnteringContext, 168 MemberOfUnknownSpecialization); 169 if (R.empty()) return TNK_Non_template; 170 if (R.isAmbiguous()) { 171 // Suppress diagnostics; we'll redo this lookup later. 172 R.suppressDiagnostics(); 173 174 // FIXME: we might have ambiguous templates, in which case we 175 // should at least parse them properly! 176 return TNK_Non_template; 177 } 178 179 TemplateName Template; 180 TemplateNameKind TemplateKind; 181 182 unsigned ResultCount = R.end() - R.begin(); 183 if (ResultCount > 1) { 184 // We assume that we'll preserve the qualifier from a function 185 // template name in other ways. 186 Template = Context.getOverloadedTemplateName(R.begin(), R.end()); 187 TemplateKind = TNK_Function_template; 188 189 // We'll do this lookup again later. 190 R.suppressDiagnostics(); 191 } else { 192 TemplateDecl *TD = cast<TemplateDecl>((*R.begin())->getUnderlyingDecl()); 193 194 if (SS.isSet() && !SS.isInvalid()) { 195 NestedNameSpecifier *Qualifier 196 = static_cast<NestedNameSpecifier *>(SS.getScopeRep()); 197 Template = Context.getQualifiedTemplateName(Qualifier, 198 hasTemplateKeyword, TD); 199 } else { 200 Template = TemplateName(TD); 201 } 202 203 if (isa<FunctionTemplateDecl>(TD)) { 204 TemplateKind = TNK_Function_template; 205 206 // We'll do this lookup again later. 207 R.suppressDiagnostics(); 208 } else { 209 assert(isa<ClassTemplateDecl>(TD) || isa<TemplateTemplateParmDecl>(TD) || 210 isa<TypeAliasTemplateDecl>(TD)); 211 TemplateKind = TNK_Type_template; 212 } 213 } 214 215 TemplateResult = TemplateTy::make(Template); 216 return TemplateKind; 217} 218 219bool Sema::DiagnoseUnknownTemplateName(const IdentifierInfo &II, 220 SourceLocation IILoc, 221 Scope *S, 222 const CXXScopeSpec *SS, 223 TemplateTy &SuggestedTemplate, 224 TemplateNameKind &SuggestedKind) { 225 // We can't recover unless there's a dependent scope specifier preceding the 226 // template name. 227 // FIXME: Typo correction? 228 if (!SS || !SS->isSet() || !isDependentScopeSpecifier(*SS) || 229 computeDeclContext(*SS)) 230 return false; 231 232 // The code is missing a 'template' keyword prior to the dependent template 233 // name. 234 NestedNameSpecifier *Qualifier = (NestedNameSpecifier*)SS->getScopeRep(); 235 Diag(IILoc, diag::err_template_kw_missing) 236 << Qualifier << II.getName() 237 << FixItHint::CreateInsertion(IILoc, "template "); 238 SuggestedTemplate 239 = TemplateTy::make(Context.getDependentTemplateName(Qualifier, &II)); 240 SuggestedKind = TNK_Dependent_template_name; 241 return true; 242} 243 244void Sema::LookupTemplateName(LookupResult &Found, 245 Scope *S, CXXScopeSpec &SS, 246 QualType ObjectType, 247 bool EnteringContext, 248 bool &MemberOfUnknownSpecialization) { 249 // Determine where to perform name lookup 250 MemberOfUnknownSpecialization = false; 251 DeclContext *LookupCtx = 0; 252 bool isDependent = false; 253 if (!ObjectType.isNull()) { 254 // This nested-name-specifier occurs in a member access expression, e.g., 255 // x->B::f, and we are looking into the type of the object. 256 assert(!SS.isSet() && "ObjectType and scope specifier cannot coexist"); 257 LookupCtx = computeDeclContext(ObjectType); 258 isDependent = ObjectType->isDependentType(); 259 assert((isDependent || !ObjectType->isIncompleteType()) && 260 "Caller should have completed object type"); 261 262 // Template names cannot appear inside an Objective-C class or object type. 263 if (ObjectType->isObjCObjectOrInterfaceType()) { 264 Found.clear(); 265 return; 266 } 267 } else if (SS.isSet()) { 268 // This nested-name-specifier occurs after another nested-name-specifier, 269 // so long into the context associated with the prior nested-name-specifier. 270 LookupCtx = computeDeclContext(SS, EnteringContext); 271 isDependent = isDependentScopeSpecifier(SS); 272 273 // The declaration context must be complete. 274 if (LookupCtx && RequireCompleteDeclContext(SS, LookupCtx)) 275 return; 276 } 277 278 bool ObjectTypeSearchedInScope = false; 279 bool AllowFunctionTemplatesInLookup = true; 280 if (LookupCtx) { 281 // Perform "qualified" name lookup into the declaration context we 282 // computed, which is either the type of the base of a member access 283 // expression or the declaration context associated with a prior 284 // nested-name-specifier. 285 LookupQualifiedName(Found, LookupCtx); 286 if (!ObjectType.isNull() && Found.empty()) { 287 // C++ [basic.lookup.classref]p1: 288 // In a class member access expression (5.2.5), if the . or -> token is 289 // immediately followed by an identifier followed by a <, the 290 // identifier must be looked up to determine whether the < is the 291 // beginning of a template argument list (14.2) or a less-than operator. 292 // The identifier is first looked up in the class of the object 293 // expression. If the identifier is not found, it is then looked up in 294 // the context of the entire postfix-expression and shall name a class 295 // or function template. 296 if (S) LookupName(Found, S); 297 ObjectTypeSearchedInScope = true; 298 AllowFunctionTemplatesInLookup = false; 299 } 300 } else if (isDependent && (!S || ObjectType.isNull())) { 301 // We cannot look into a dependent object type or nested nme 302 // specifier. 303 MemberOfUnknownSpecialization = true; 304 return; 305 } else { 306 // Perform unqualified name lookup in the current scope. 307 LookupName(Found, S); 308 309 if (!ObjectType.isNull()) 310 AllowFunctionTemplatesInLookup = false; 311 } 312 313 if (Found.empty() && !isDependent) { 314 // If we did not find any names, attempt to correct any typos. 315 DeclarationName Name = Found.getLookupName(); 316 Found.clear(); 317 // Simple filter callback that, for keywords, only accepts the C++ *_cast 318 CorrectionCandidateCallback FilterCCC; 319 FilterCCC.WantTypeSpecifiers = false; 320 FilterCCC.WantExpressionKeywords = false; 321 FilterCCC.WantRemainingKeywords = false; 322 FilterCCC.WantCXXNamedCasts = true; 323 if (TypoCorrection Corrected = CorrectTypo(Found.getLookupNameInfo(), 324 Found.getLookupKind(), S, &SS, 325 FilterCCC, LookupCtx)) { 326 Found.setLookupName(Corrected.getCorrection()); 327 if (Corrected.getCorrectionDecl()) 328 Found.addDecl(Corrected.getCorrectionDecl()); 329 FilterAcceptableTemplateNames(Found); 330 if (!Found.empty()) { 331 std::string CorrectedStr(Corrected.getAsString(getLangOpts())); 332 std::string CorrectedQuotedStr(Corrected.getQuoted(getLangOpts())); 333 if (LookupCtx) 334 Diag(Found.getNameLoc(), diag::err_no_member_template_suggest) 335 << Name << LookupCtx << CorrectedQuotedStr << SS.getRange() 336 << FixItHint::CreateReplacement(Found.getNameLoc(), CorrectedStr); 337 else 338 Diag(Found.getNameLoc(), diag::err_no_template_suggest) 339 << Name << CorrectedQuotedStr 340 << FixItHint::CreateReplacement(Found.getNameLoc(), CorrectedStr); 341 if (TemplateDecl *Template = Found.getAsSingle<TemplateDecl>()) 342 Diag(Template->getLocation(), diag::note_previous_decl) 343 << CorrectedQuotedStr; 344 } 345 } else { 346 Found.setLookupName(Name); 347 } 348 } 349 350 FilterAcceptableTemplateNames(Found, AllowFunctionTemplatesInLookup); 351 if (Found.empty()) { 352 if (isDependent) 353 MemberOfUnknownSpecialization = true; 354 return; 355 } 356 357 if (S && !ObjectType.isNull() && !ObjectTypeSearchedInScope) { 358 // C++ [basic.lookup.classref]p1: 359 // [...] If the lookup in the class of the object expression finds a 360 // template, the name is also looked up in the context of the entire 361 // postfix-expression and [...] 362 // 363 LookupResult FoundOuter(*this, Found.getLookupName(), Found.getNameLoc(), 364 LookupOrdinaryName); 365 LookupName(FoundOuter, S); 366 FilterAcceptableTemplateNames(FoundOuter, /*AllowFunctionTemplates=*/false); 367 368 if (FoundOuter.empty()) { 369 // - if the name is not found, the name found in the class of the 370 // object expression is used, otherwise 371 } else if (!FoundOuter.getAsSingle<ClassTemplateDecl>() || 372 FoundOuter.isAmbiguous()) { 373 // - if the name is found in the context of the entire 374 // postfix-expression and does not name a class template, the name 375 // found in the class of the object expression is used, otherwise 376 FoundOuter.clear(); 377 } else if (!Found.isSuppressingDiagnostics()) { 378 // - if the name found is a class template, it must refer to the same 379 // entity as the one found in the class of the object expression, 380 // otherwise the program is ill-formed. 381 if (!Found.isSingleResult() || 382 Found.getFoundDecl()->getCanonicalDecl() 383 != FoundOuter.getFoundDecl()->getCanonicalDecl()) { 384 Diag(Found.getNameLoc(), 385 diag::ext_nested_name_member_ref_lookup_ambiguous) 386 << Found.getLookupName() 387 << ObjectType; 388 Diag(Found.getRepresentativeDecl()->getLocation(), 389 diag::note_ambig_member_ref_object_type) 390 << ObjectType; 391 Diag(FoundOuter.getFoundDecl()->getLocation(), 392 diag::note_ambig_member_ref_scope); 393 394 // Recover by taking the template that we found in the object 395 // expression's type. 396 } 397 } 398 } 399} 400 401/// ActOnDependentIdExpression - Handle a dependent id-expression that 402/// was just parsed. This is only possible with an explicit scope 403/// specifier naming a dependent type. 404ExprResult 405Sema::ActOnDependentIdExpression(const CXXScopeSpec &SS, 406 SourceLocation TemplateKWLoc, 407 const DeclarationNameInfo &NameInfo, 408 bool isAddressOfOperand, 409 const TemplateArgumentListInfo *TemplateArgs) { 410 DeclContext *DC = getFunctionLevelDeclContext(); 411 412 if (!isAddressOfOperand && 413 isa<CXXMethodDecl>(DC) && 414 cast<CXXMethodDecl>(DC)->isInstance()) { 415 QualType ThisType = cast<CXXMethodDecl>(DC)->getThisType(Context); 416 417 // Since the 'this' expression is synthesized, we don't need to 418 // perform the double-lookup check. 419 NamedDecl *FirstQualifierInScope = 0; 420 421 return Owned(CXXDependentScopeMemberExpr::Create(Context, 422 /*This*/ 0, ThisType, 423 /*IsArrow*/ true, 424 /*Op*/ SourceLocation(), 425 SS.getWithLocInContext(Context), 426 TemplateKWLoc, 427 FirstQualifierInScope, 428 NameInfo, 429 TemplateArgs)); 430 } 431 432 return BuildDependentDeclRefExpr(SS, TemplateKWLoc, NameInfo, TemplateArgs); 433} 434 435ExprResult 436Sema::BuildDependentDeclRefExpr(const CXXScopeSpec &SS, 437 SourceLocation TemplateKWLoc, 438 const DeclarationNameInfo &NameInfo, 439 const TemplateArgumentListInfo *TemplateArgs) { 440 return Owned(DependentScopeDeclRefExpr::Create(Context, 441 SS.getWithLocInContext(Context), 442 TemplateKWLoc, 443 NameInfo, 444 TemplateArgs)); 445} 446 447/// DiagnoseTemplateParameterShadow - Produce a diagnostic complaining 448/// that the template parameter 'PrevDecl' is being shadowed by a new 449/// declaration at location Loc. Returns true to indicate that this is 450/// an error, and false otherwise. 451void Sema::DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl) { 452 assert(PrevDecl->isTemplateParameter() && "Not a template parameter"); 453 454 // Microsoft Visual C++ permits template parameters to be shadowed. 455 if (getLangOpts().MicrosoftExt) 456 return; 457 458 // C++ [temp.local]p4: 459 // A template-parameter shall not be redeclared within its 460 // scope (including nested scopes). 461 Diag(Loc, diag::err_template_param_shadow) 462 << cast<NamedDecl>(PrevDecl)->getDeclName(); 463 Diag(PrevDecl->getLocation(), diag::note_template_param_here); 464 return; 465} 466 467/// AdjustDeclIfTemplate - If the given decl happens to be a template, reset 468/// the parameter D to reference the templated declaration and return a pointer 469/// to the template declaration. Otherwise, do nothing to D and return null. 470TemplateDecl *Sema::AdjustDeclIfTemplate(Decl *&D) { 471 if (TemplateDecl *Temp = dyn_cast_or_null<TemplateDecl>(D)) { 472 D = Temp->getTemplatedDecl(); 473 return Temp; 474 } 475 return 0; 476} 477 478ParsedTemplateArgument ParsedTemplateArgument::getTemplatePackExpansion( 479 SourceLocation EllipsisLoc) const { 480 assert(Kind == Template && 481 "Only template template arguments can be pack expansions here"); 482 assert(getAsTemplate().get().containsUnexpandedParameterPack() && 483 "Template template argument pack expansion without packs"); 484 ParsedTemplateArgument Result(*this); 485 Result.EllipsisLoc = EllipsisLoc; 486 return Result; 487} 488 489static TemplateArgumentLoc translateTemplateArgument(Sema &SemaRef, 490 const ParsedTemplateArgument &Arg) { 491 492 switch (Arg.getKind()) { 493 case ParsedTemplateArgument::Type: { 494 TypeSourceInfo *DI; 495 QualType T = SemaRef.GetTypeFromParser(Arg.getAsType(), &DI); 496 if (!DI) 497 DI = SemaRef.Context.getTrivialTypeSourceInfo(T, Arg.getLocation()); 498 return TemplateArgumentLoc(TemplateArgument(T), DI); 499 } 500 501 case ParsedTemplateArgument::NonType: { 502 Expr *E = static_cast<Expr *>(Arg.getAsExpr()); 503 return TemplateArgumentLoc(TemplateArgument(E), E); 504 } 505 506 case ParsedTemplateArgument::Template: { 507 TemplateName Template = Arg.getAsTemplate().get(); 508 TemplateArgument TArg; 509 if (Arg.getEllipsisLoc().isValid()) 510 TArg = TemplateArgument(Template, llvm::Optional<unsigned int>()); 511 else 512 TArg = Template; 513 return TemplateArgumentLoc(TArg, 514 Arg.getScopeSpec().getWithLocInContext( 515 SemaRef.Context), 516 Arg.getLocation(), 517 Arg.getEllipsisLoc()); 518 } 519 } 520 521 llvm_unreachable("Unhandled parsed template argument"); 522} 523 524/// \brief Translates template arguments as provided by the parser 525/// into template arguments used by semantic analysis. 526void Sema::translateTemplateArguments(const ASTTemplateArgsPtr &TemplateArgsIn, 527 TemplateArgumentListInfo &TemplateArgs) { 528 for (unsigned I = 0, Last = TemplateArgsIn.size(); I != Last; ++I) 529 TemplateArgs.addArgument(translateTemplateArgument(*this, 530 TemplateArgsIn[I])); 531} 532 533/// ActOnTypeParameter - Called when a C++ template type parameter 534/// (e.g., "typename T") has been parsed. Typename specifies whether 535/// the keyword "typename" was used to declare the type parameter 536/// (otherwise, "class" was used), and KeyLoc is the location of the 537/// "class" or "typename" keyword. ParamName is the name of the 538/// parameter (NULL indicates an unnamed template parameter) and 539/// ParamNameLoc is the location of the parameter name (if any). 540/// If the type parameter has a default argument, it will be added 541/// later via ActOnTypeParameterDefault. 542Decl *Sema::ActOnTypeParameter(Scope *S, bool Typename, bool Ellipsis, 543 SourceLocation EllipsisLoc, 544 SourceLocation KeyLoc, 545 IdentifierInfo *ParamName, 546 SourceLocation ParamNameLoc, 547 unsigned Depth, unsigned Position, 548 SourceLocation EqualLoc, 549 ParsedType DefaultArg) { 550 assert(S->isTemplateParamScope() && 551 "Template type parameter not in template parameter scope!"); 552 bool Invalid = false; 553 554 if (ParamName) { 555 NamedDecl *PrevDecl = LookupSingleName(S, ParamName, ParamNameLoc, 556 LookupOrdinaryName, 557 ForRedeclaration); 558 if (PrevDecl && PrevDecl->isTemplateParameter()) { 559 DiagnoseTemplateParameterShadow(ParamNameLoc, PrevDecl); 560 PrevDecl = 0; 561 } 562 } 563 564 SourceLocation Loc = ParamNameLoc; 565 if (!ParamName) 566 Loc = KeyLoc; 567 568 TemplateTypeParmDecl *Param 569 = TemplateTypeParmDecl::Create(Context, Context.getTranslationUnitDecl(), 570 KeyLoc, Loc, Depth, Position, ParamName, 571 Typename, Ellipsis); 572 Param->setAccess(AS_public); 573 if (Invalid) 574 Param->setInvalidDecl(); 575 576 if (ParamName) { 577 // Add the template parameter into the current scope. 578 S->AddDecl(Param); 579 IdResolver.AddDecl(Param); 580 } 581 582 // C++0x [temp.param]p9: 583 // A default template-argument may be specified for any kind of 584 // template-parameter that is not a template parameter pack. 585 if (DefaultArg && Ellipsis) { 586 Diag(EqualLoc, diag::err_template_param_pack_default_arg); 587 DefaultArg = ParsedType(); 588 } 589 590 // Handle the default argument, if provided. 591 if (DefaultArg) { 592 TypeSourceInfo *DefaultTInfo; 593 GetTypeFromParser(DefaultArg, &DefaultTInfo); 594 595 assert(DefaultTInfo && "expected source information for type"); 596 597 // Check for unexpanded parameter packs. 598 if (DiagnoseUnexpandedParameterPack(Loc, DefaultTInfo, 599 UPPC_DefaultArgument)) 600 return Param; 601 602 // Check the template argument itself. 603 if (CheckTemplateArgument(Param, DefaultTInfo)) { 604 Param->setInvalidDecl(); 605 return Param; 606 } 607 608 Param->setDefaultArgument(DefaultTInfo, false); 609 } 610 611 return Param; 612} 613 614/// \brief Check that the type of a non-type template parameter is 615/// well-formed. 616/// 617/// \returns the (possibly-promoted) parameter type if valid; 618/// otherwise, produces a diagnostic and returns a NULL type. 619QualType 620Sema::CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc) { 621 // We don't allow variably-modified types as the type of non-type template 622 // parameters. 623 if (T->isVariablyModifiedType()) { 624 Diag(Loc, diag::err_variably_modified_nontype_template_param) 625 << T; 626 return QualType(); 627 } 628 629 // C++ [temp.param]p4: 630 // 631 // A non-type template-parameter shall have one of the following 632 // (optionally cv-qualified) types: 633 // 634 // -- integral or enumeration type, 635 if (T->isIntegralOrEnumerationType() || 636 // -- pointer to object or pointer to function, 637 T->isPointerType() || 638 // -- reference to object or reference to function, 639 T->isReferenceType() || 640 // -- pointer to member, 641 T->isMemberPointerType() || 642 // -- std::nullptr_t. 643 T->isNullPtrType() || 644 // If T is a dependent type, we can't do the check now, so we 645 // assume that it is well-formed. 646 T->isDependentType()) { 647 // C++ [temp.param]p5: The top-level cv-qualifiers on the template-parameter 648 // are ignored when determining its type. 649 return T.getUnqualifiedType(); 650 } 651 652 // C++ [temp.param]p8: 653 // 654 // A non-type template-parameter of type "array of T" or 655 // "function returning T" is adjusted to be of type "pointer to 656 // T" or "pointer to function returning T", respectively. 657 else if (T->isArrayType()) 658 // FIXME: Keep the type prior to promotion? 659 return Context.getArrayDecayedType(T); 660 else if (T->isFunctionType()) 661 // FIXME: Keep the type prior to promotion? 662 return Context.getPointerType(T); 663 664 Diag(Loc, diag::err_template_nontype_parm_bad_type) 665 << T; 666 667 return QualType(); 668} 669 670Decl *Sema::ActOnNonTypeTemplateParameter(Scope *S, Declarator &D, 671 unsigned Depth, 672 unsigned Position, 673 SourceLocation EqualLoc, 674 Expr *Default) { 675 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 676 QualType T = TInfo->getType(); 677 678 assert(S->isTemplateParamScope() && 679 "Non-type template parameter not in template parameter scope!"); 680 bool Invalid = false; 681 682 IdentifierInfo *ParamName = D.getIdentifier(); 683 if (ParamName) { 684 NamedDecl *PrevDecl = LookupSingleName(S, ParamName, D.getIdentifierLoc(), 685 LookupOrdinaryName, 686 ForRedeclaration); 687 if (PrevDecl && PrevDecl->isTemplateParameter()) { 688 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl); 689 PrevDecl = 0; 690 } 691 } 692 693 T = CheckNonTypeTemplateParameterType(T, D.getIdentifierLoc()); 694 if (T.isNull()) { 695 T = Context.IntTy; // Recover with an 'int' type. 696 Invalid = true; 697 } 698 699 bool IsParameterPack = D.hasEllipsis(); 700 NonTypeTemplateParmDecl *Param 701 = NonTypeTemplateParmDecl::Create(Context, Context.getTranslationUnitDecl(), 702 D.getLocStart(), 703 D.getIdentifierLoc(), 704 Depth, Position, ParamName, T, 705 IsParameterPack, TInfo); 706 Param->setAccess(AS_public); 707 708 if (Invalid) 709 Param->setInvalidDecl(); 710 711 if (D.getIdentifier()) { 712 // Add the template parameter into the current scope. 713 S->AddDecl(Param); 714 IdResolver.AddDecl(Param); 715 } 716 717 // C++0x [temp.param]p9: 718 // A default template-argument may be specified for any kind of 719 // template-parameter that is not a template parameter pack. 720 if (Default && IsParameterPack) { 721 Diag(EqualLoc, diag::err_template_param_pack_default_arg); 722 Default = 0; 723 } 724 725 // Check the well-formedness of the default template argument, if provided. 726 if (Default) { 727 // Check for unexpanded parameter packs. 728 if (DiagnoseUnexpandedParameterPack(Default, UPPC_DefaultArgument)) 729 return Param; 730 731 TemplateArgument Converted; 732 ExprResult DefaultRes = CheckTemplateArgument(Param, Param->getType(), Default, Converted); 733 if (DefaultRes.isInvalid()) { 734 Param->setInvalidDecl(); 735 return Param; 736 } 737 Default = DefaultRes.take(); 738 739 Param->setDefaultArgument(Default, false); 740 } 741 742 return Param; 743} 744 745/// ActOnTemplateTemplateParameter - Called when a C++ template template 746/// parameter (e.g. T in template <template <typename> class T> class array) 747/// has been parsed. S is the current scope. 748Decl *Sema::ActOnTemplateTemplateParameter(Scope* S, 749 SourceLocation TmpLoc, 750 TemplateParameterList *Params, 751 SourceLocation EllipsisLoc, 752 IdentifierInfo *Name, 753 SourceLocation NameLoc, 754 unsigned Depth, 755 unsigned Position, 756 SourceLocation EqualLoc, 757 ParsedTemplateArgument Default) { 758 assert(S->isTemplateParamScope() && 759 "Template template parameter not in template parameter scope!"); 760 761 // Construct the parameter object. 762 bool IsParameterPack = EllipsisLoc.isValid(); 763 TemplateTemplateParmDecl *Param = 764 TemplateTemplateParmDecl::Create(Context, Context.getTranslationUnitDecl(), 765 NameLoc.isInvalid()? TmpLoc : NameLoc, 766 Depth, Position, IsParameterPack, 767 Name, Params); 768 Param->setAccess(AS_public); 769 770 // If the template template parameter has a name, then link the identifier 771 // into the scope and lookup mechanisms. 772 if (Name) { 773 S->AddDecl(Param); 774 IdResolver.AddDecl(Param); 775 } 776 777 if (Params->size() == 0) { 778 Diag(Param->getLocation(), diag::err_template_template_parm_no_parms) 779 << SourceRange(Params->getLAngleLoc(), Params->getRAngleLoc()); 780 Param->setInvalidDecl(); 781 } 782 783 // C++0x [temp.param]p9: 784 // A default template-argument may be specified for any kind of 785 // template-parameter that is not a template parameter pack. 786 if (IsParameterPack && !Default.isInvalid()) { 787 Diag(EqualLoc, diag::err_template_param_pack_default_arg); 788 Default = ParsedTemplateArgument(); 789 } 790 791 if (!Default.isInvalid()) { 792 // Check only that we have a template template argument. We don't want to 793 // try to check well-formedness now, because our template template parameter 794 // might have dependent types in its template parameters, which we wouldn't 795 // be able to match now. 796 // 797 // If none of the template template parameter's template arguments mention 798 // other template parameters, we could actually perform more checking here. 799 // However, it isn't worth doing. 800 TemplateArgumentLoc DefaultArg = translateTemplateArgument(*this, Default); 801 if (DefaultArg.getArgument().getAsTemplate().isNull()) { 802 Diag(DefaultArg.getLocation(), diag::err_template_arg_not_class_template) 803 << DefaultArg.getSourceRange(); 804 return Param; 805 } 806 807 // Check for unexpanded parameter packs. 808 if (DiagnoseUnexpandedParameterPack(DefaultArg.getLocation(), 809 DefaultArg.getArgument().getAsTemplate(), 810 UPPC_DefaultArgument)) 811 return Param; 812 813 Param->setDefaultArgument(DefaultArg, false); 814 } 815 816 return Param; 817} 818 819/// ActOnTemplateParameterList - Builds a TemplateParameterList that 820/// contains the template parameters in Params/NumParams. 821TemplateParameterList * 822Sema::ActOnTemplateParameterList(unsigned Depth, 823 SourceLocation ExportLoc, 824 SourceLocation TemplateLoc, 825 SourceLocation LAngleLoc, 826 Decl **Params, unsigned NumParams, 827 SourceLocation RAngleLoc) { 828 if (ExportLoc.isValid()) 829 Diag(ExportLoc, diag::warn_template_export_unsupported); 830 831 return TemplateParameterList::Create(Context, TemplateLoc, LAngleLoc, 832 (NamedDecl**)Params, NumParams, 833 RAngleLoc); 834} 835 836static void SetNestedNameSpecifier(TagDecl *T, const CXXScopeSpec &SS) { 837 if (SS.isSet()) 838 T->setQualifierInfo(SS.getWithLocInContext(T->getASTContext())); 839} 840 841DeclResult 842Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK, 843 SourceLocation KWLoc, CXXScopeSpec &SS, 844 IdentifierInfo *Name, SourceLocation NameLoc, 845 AttributeList *Attr, 846 TemplateParameterList *TemplateParams, 847 AccessSpecifier AS, SourceLocation ModulePrivateLoc, 848 unsigned NumOuterTemplateParamLists, 849 TemplateParameterList** OuterTemplateParamLists) { 850 assert(TemplateParams && TemplateParams->size() > 0 && 851 "No template parameters"); 852 assert(TUK != TUK_Reference && "Can only declare or define class templates"); 853 bool Invalid = false; 854 855 // Check that we can declare a template here. 856 if (CheckTemplateDeclScope(S, TemplateParams)) 857 return true; 858 859 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec); 860 assert(Kind != TTK_Enum && "can't build template of enumerated type"); 861 862 // There is no such thing as an unnamed class template. 863 if (!Name) { 864 Diag(KWLoc, diag::err_template_unnamed_class); 865 return true; 866 } 867 868 // Find any previous declaration with this name. 869 DeclContext *SemanticContext; 870 LookupResult Previous(*this, Name, NameLoc, LookupOrdinaryName, 871 ForRedeclaration); 872 if (SS.isNotEmpty() && !SS.isInvalid()) { 873 SemanticContext = computeDeclContext(SS, true); 874 if (!SemanticContext) { 875 // FIXME: Horrible, horrible hack! We can't currently represent this 876 // in the AST, and historically we have just ignored such friend 877 // class templates, so don't complain here. 878 if (TUK != TUK_Friend) 879 Diag(NameLoc, diag::err_template_qualified_declarator_no_match) 880 << SS.getScopeRep() << SS.getRange(); 881 return true; 882 } 883 884 if (RequireCompleteDeclContext(SS, SemanticContext)) 885 return true; 886 887 // If we're adding a template to a dependent context, we may need to 888 // rebuilding some of the types used within the template parameter list, 889 // now that we know what the current instantiation is. 890 if (SemanticContext->isDependentContext()) { 891 ContextRAII SavedContext(*this, SemanticContext); 892 if (RebuildTemplateParamsInCurrentInstantiation(TemplateParams)) 893 Invalid = true; 894 } else if (TUK != TUK_Friend && TUK != TUK_Reference) 895 diagnoseQualifiedDeclaration(SS, SemanticContext, Name, NameLoc); 896 897 LookupQualifiedName(Previous, SemanticContext); 898 } else { 899 SemanticContext = CurContext; 900 LookupName(Previous, S); 901 } 902 903 if (Previous.isAmbiguous()) 904 return true; 905 906 NamedDecl *PrevDecl = 0; 907 if (Previous.begin() != Previous.end()) 908 PrevDecl = (*Previous.begin())->getUnderlyingDecl(); 909 910 // If there is a previous declaration with the same name, check 911 // whether this is a valid redeclaration. 912 ClassTemplateDecl *PrevClassTemplate 913 = dyn_cast_or_null<ClassTemplateDecl>(PrevDecl); 914 915 // We may have found the injected-class-name of a class template, 916 // class template partial specialization, or class template specialization. 917 // In these cases, grab the template that is being defined or specialized. 918 if (!PrevClassTemplate && PrevDecl && isa<CXXRecordDecl>(PrevDecl) && 919 cast<CXXRecordDecl>(PrevDecl)->isInjectedClassName()) { 920 PrevDecl = cast<CXXRecordDecl>(PrevDecl->getDeclContext()); 921 PrevClassTemplate 922 = cast<CXXRecordDecl>(PrevDecl)->getDescribedClassTemplate(); 923 if (!PrevClassTemplate && isa<ClassTemplateSpecializationDecl>(PrevDecl)) { 924 PrevClassTemplate 925 = cast<ClassTemplateSpecializationDecl>(PrevDecl) 926 ->getSpecializedTemplate(); 927 } 928 } 929 930 if (TUK == TUK_Friend) { 931 // C++ [namespace.memdef]p3: 932 // [...] When looking for a prior declaration of a class or a function 933 // declared as a friend, and when the name of the friend class or 934 // function is neither a qualified name nor a template-id, scopes outside 935 // the innermost enclosing namespace scope are not considered. 936 if (!SS.isSet()) { 937 DeclContext *OutermostContext = CurContext; 938 while (!OutermostContext->isFileContext()) 939 OutermostContext = OutermostContext->getLookupParent(); 940 941 if (PrevDecl && 942 (OutermostContext->Equals(PrevDecl->getDeclContext()) || 943 OutermostContext->Encloses(PrevDecl->getDeclContext()))) { 944 SemanticContext = PrevDecl->getDeclContext(); 945 } else { 946 // Declarations in outer scopes don't matter. However, the outermost 947 // context we computed is the semantic context for our new 948 // declaration. 949 PrevDecl = PrevClassTemplate = 0; 950 SemanticContext = OutermostContext; 951 } 952 } 953 954 if (CurContext->isDependentContext()) { 955 // If this is a dependent context, we don't want to link the friend 956 // class template to the template in scope, because that would perform 957 // checking of the template parameter lists that can't be performed 958 // until the outer context is instantiated. 959 PrevDecl = PrevClassTemplate = 0; 960 } 961 } else if (PrevDecl && !isDeclInScope(PrevDecl, SemanticContext, S)) 962 PrevDecl = PrevClassTemplate = 0; 963 964 if (PrevClassTemplate) { 965 // Ensure that the template parameter lists are compatible. 966 if (!TemplateParameterListsAreEqual(TemplateParams, 967 PrevClassTemplate->getTemplateParameters(), 968 /*Complain=*/true, 969 TPL_TemplateMatch)) 970 return true; 971 972 // C++ [temp.class]p4: 973 // In a redeclaration, partial specialization, explicit 974 // specialization or explicit instantiation of a class template, 975 // the class-key shall agree in kind with the original class 976 // template declaration (7.1.5.3). 977 RecordDecl *PrevRecordDecl = PrevClassTemplate->getTemplatedDecl(); 978 if (!isAcceptableTagRedeclaration(PrevRecordDecl, Kind, 979 TUK == TUK_Definition, KWLoc, *Name)) { 980 Diag(KWLoc, diag::err_use_with_wrong_tag) 981 << Name 982 << FixItHint::CreateReplacement(KWLoc, PrevRecordDecl->getKindName()); 983 Diag(PrevRecordDecl->getLocation(), diag::note_previous_use); 984 Kind = PrevRecordDecl->getTagKind(); 985 } 986 987 // Check for redefinition of this class template. 988 if (TUK == TUK_Definition) { 989 if (TagDecl *Def = PrevRecordDecl->getDefinition()) { 990 Diag(NameLoc, diag::err_redefinition) << Name; 991 Diag(Def->getLocation(), diag::note_previous_definition); 992 // FIXME: Would it make sense to try to "forget" the previous 993 // definition, as part of error recovery? 994 return true; 995 } 996 } 997 } else if (PrevDecl && PrevDecl->isTemplateParameter()) { 998 // Maybe we will complain about the shadowed template parameter. 999 DiagnoseTemplateParameterShadow(NameLoc, PrevDecl); 1000 // Just pretend that we didn't see the previous declaration. 1001 PrevDecl = 0; 1002 } else if (PrevDecl) { 1003 // C++ [temp]p5: 1004 // A class template shall not have the same name as any other 1005 // template, class, function, object, enumeration, enumerator, 1006 // namespace, or type in the same scope (3.3), except as specified 1007 // in (14.5.4). 1008 Diag(NameLoc, diag::err_redefinition_different_kind) << Name; 1009 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 1010 return true; 1011 } 1012 1013 // Check the template parameter list of this declaration, possibly 1014 // merging in the template parameter list from the previous class 1015 // template declaration. 1016 if (CheckTemplateParameterList(TemplateParams, 1017 PrevClassTemplate? PrevClassTemplate->getTemplateParameters() : 0, 1018 (SS.isSet() && SemanticContext && 1019 SemanticContext->isRecord() && 1020 SemanticContext->isDependentContext()) 1021 ? TPC_ClassTemplateMember 1022 : TPC_ClassTemplate)) 1023 Invalid = true; 1024 1025 if (SS.isSet()) { 1026 // If the name of the template was qualified, we must be defining the 1027 // template out-of-line. 1028 if (!SS.isInvalid() && !Invalid && !PrevClassTemplate && 1029 !(TUK == TUK_Friend && CurContext->isDependentContext())) { 1030 Diag(NameLoc, diag::err_member_def_does_not_match) 1031 << Name << SemanticContext << SS.getRange(); 1032 Invalid = true; 1033 } 1034 } 1035 1036 CXXRecordDecl *NewClass = 1037 CXXRecordDecl::Create(Context, Kind, SemanticContext, KWLoc, NameLoc, Name, 1038 PrevClassTemplate? 1039 PrevClassTemplate->getTemplatedDecl() : 0, 1040 /*DelayTypeCreation=*/true); 1041 SetNestedNameSpecifier(NewClass, SS); 1042 if (NumOuterTemplateParamLists > 0) 1043 NewClass->setTemplateParameterListsInfo(Context, 1044 NumOuterTemplateParamLists, 1045 OuterTemplateParamLists); 1046 1047 // Add alignment attributes if necessary; these attributes are checked when 1048 // the ASTContext lays out the structure. 1049 AddAlignmentAttributesForRecord(NewClass); 1050 AddMsStructLayoutForRecord(NewClass); 1051 1052 ClassTemplateDecl *NewTemplate 1053 = ClassTemplateDecl::Create(Context, SemanticContext, NameLoc, 1054 DeclarationName(Name), TemplateParams, 1055 NewClass, PrevClassTemplate); 1056 NewClass->setDescribedClassTemplate(NewTemplate); 1057 1058 if (ModulePrivateLoc.isValid()) 1059 NewTemplate->setModulePrivate(); 1060 1061 // Build the type for the class template declaration now. 1062 QualType T = NewTemplate->getInjectedClassNameSpecialization(); 1063 T = Context.getInjectedClassNameType(NewClass, T); 1064 assert(T->isDependentType() && "Class template type is not dependent?"); 1065 (void)T; 1066 1067 // If we are providing an explicit specialization of a member that is a 1068 // class template, make a note of that. 1069 if (PrevClassTemplate && 1070 PrevClassTemplate->getInstantiatedFromMemberTemplate()) 1071 PrevClassTemplate->setMemberSpecialization(); 1072 1073 // Set the access specifier. 1074 if (!Invalid && TUK != TUK_Friend && NewTemplate->getDeclContext()->isRecord()) 1075 SetMemberAccessSpecifier(NewTemplate, PrevClassTemplate, AS); 1076 1077 // Set the lexical context of these templates 1078 NewClass->setLexicalDeclContext(CurContext); 1079 NewTemplate->setLexicalDeclContext(CurContext); 1080 1081 if (TUK == TUK_Definition) 1082 NewClass->startDefinition(); 1083 1084 if (Attr) 1085 ProcessDeclAttributeList(S, NewClass, Attr); 1086 1087 if (TUK != TUK_Friend) 1088 PushOnScopeChains(NewTemplate, S); 1089 else { 1090 if (PrevClassTemplate && PrevClassTemplate->getAccess() != AS_none) { 1091 NewTemplate->setAccess(PrevClassTemplate->getAccess()); 1092 NewClass->setAccess(PrevClassTemplate->getAccess()); 1093 } 1094 1095 NewTemplate->setObjectOfFriendDecl(/* PreviouslyDeclared = */ 1096 PrevClassTemplate != NULL); 1097 1098 // Friend templates are visible in fairly strange ways. 1099 if (!CurContext->isDependentContext()) { 1100 DeclContext *DC = SemanticContext->getRedeclContext(); 1101 DC->makeDeclVisibleInContext(NewTemplate); 1102 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC)) 1103 PushOnScopeChains(NewTemplate, EnclosingScope, 1104 /* AddToContext = */ false); 1105 } 1106 1107 FriendDecl *Friend = FriendDecl::Create(Context, CurContext, 1108 NewClass->getLocation(), 1109 NewTemplate, 1110 /*FIXME:*/NewClass->getLocation()); 1111 Friend->setAccess(AS_public); 1112 CurContext->addDecl(Friend); 1113 } 1114 1115 if (Invalid) { 1116 NewTemplate->setInvalidDecl(); 1117 NewClass->setInvalidDecl(); 1118 } 1119 return NewTemplate; 1120} 1121 1122/// \brief Diagnose the presence of a default template argument on a 1123/// template parameter, which is ill-formed in certain contexts. 1124/// 1125/// \returns true if the default template argument should be dropped. 1126static bool DiagnoseDefaultTemplateArgument(Sema &S, 1127 Sema::TemplateParamListContext TPC, 1128 SourceLocation ParamLoc, 1129 SourceRange DefArgRange) { 1130 switch (TPC) { 1131 case Sema::TPC_ClassTemplate: 1132 case Sema::TPC_TypeAliasTemplate: 1133 return false; 1134 1135 case Sema::TPC_FunctionTemplate: 1136 case Sema::TPC_FriendFunctionTemplateDefinition: 1137 // C++ [temp.param]p9: 1138 // A default template-argument shall not be specified in a 1139 // function template declaration or a function template 1140 // definition [...] 1141 // If a friend function template declaration specifies a default 1142 // template-argument, that declaration shall be a definition and shall be 1143 // the only declaration of the function template in the translation unit. 1144 // (C++98/03 doesn't have this wording; see DR226). 1145 S.Diag(ParamLoc, S.getLangOpts().CPlusPlus0x ? 1146 diag::warn_cxx98_compat_template_parameter_default_in_function_template 1147 : diag::ext_template_parameter_default_in_function_template) 1148 << DefArgRange; 1149 return false; 1150 1151 case Sema::TPC_ClassTemplateMember: 1152 // C++0x [temp.param]p9: 1153 // A default template-argument shall not be specified in the 1154 // template-parameter-lists of the definition of a member of a 1155 // class template that appears outside of the member's class. 1156 S.Diag(ParamLoc, diag::err_template_parameter_default_template_member) 1157 << DefArgRange; 1158 return true; 1159 1160 case Sema::TPC_FriendFunctionTemplate: 1161 // C++ [temp.param]p9: 1162 // A default template-argument shall not be specified in a 1163 // friend template declaration. 1164 S.Diag(ParamLoc, diag::err_template_parameter_default_friend_template) 1165 << DefArgRange; 1166 return true; 1167 1168 // FIXME: C++0x [temp.param]p9 allows default template-arguments 1169 // for friend function templates if there is only a single 1170 // declaration (and it is a definition). Strange! 1171 } 1172 1173 llvm_unreachable("Invalid TemplateParamListContext!"); 1174} 1175 1176/// \brief Check for unexpanded parameter packs within the template parameters 1177/// of a template template parameter, recursively. 1178static bool DiagnoseUnexpandedParameterPacks(Sema &S, 1179 TemplateTemplateParmDecl *TTP) { 1180 TemplateParameterList *Params = TTP->getTemplateParameters(); 1181 for (unsigned I = 0, N = Params->size(); I != N; ++I) { 1182 NamedDecl *P = Params->getParam(I); 1183 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) { 1184 if (S.DiagnoseUnexpandedParameterPack(NTTP->getLocation(), 1185 NTTP->getTypeSourceInfo(), 1186 Sema::UPPC_NonTypeTemplateParameterType)) 1187 return true; 1188 1189 continue; 1190 } 1191 1192 if (TemplateTemplateParmDecl *InnerTTP 1193 = dyn_cast<TemplateTemplateParmDecl>(P)) 1194 if (DiagnoseUnexpandedParameterPacks(S, InnerTTP)) 1195 return true; 1196 } 1197 1198 return false; 1199} 1200 1201/// \brief Checks the validity of a template parameter list, possibly 1202/// considering the template parameter list from a previous 1203/// declaration. 1204/// 1205/// If an "old" template parameter list is provided, it must be 1206/// equivalent (per TemplateParameterListsAreEqual) to the "new" 1207/// template parameter list. 1208/// 1209/// \param NewParams Template parameter list for a new template 1210/// declaration. This template parameter list will be updated with any 1211/// default arguments that are carried through from the previous 1212/// template parameter list. 1213/// 1214/// \param OldParams If provided, template parameter list from a 1215/// previous declaration of the same template. Default template 1216/// arguments will be merged from the old template parameter list to 1217/// the new template parameter list. 1218/// 1219/// \param TPC Describes the context in which we are checking the given 1220/// template parameter list. 1221/// 1222/// \returns true if an error occurred, false otherwise. 1223bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams, 1224 TemplateParameterList *OldParams, 1225 TemplateParamListContext TPC) { 1226 bool Invalid = false; 1227 1228 // C++ [temp.param]p10: 1229 // The set of default template-arguments available for use with a 1230 // template declaration or definition is obtained by merging the 1231 // default arguments from the definition (if in scope) and all 1232 // declarations in scope in the same way default function 1233 // arguments are (8.3.6). 1234 bool SawDefaultArgument = false; 1235 SourceLocation PreviousDefaultArgLoc; 1236 1237 // Dummy initialization to avoid warnings. 1238 TemplateParameterList::iterator OldParam = NewParams->end(); 1239 if (OldParams) 1240 OldParam = OldParams->begin(); 1241 1242 bool RemoveDefaultArguments = false; 1243 for (TemplateParameterList::iterator NewParam = NewParams->begin(), 1244 NewParamEnd = NewParams->end(); 1245 NewParam != NewParamEnd; ++NewParam) { 1246 // Variables used to diagnose redundant default arguments 1247 bool RedundantDefaultArg = false; 1248 SourceLocation OldDefaultLoc; 1249 SourceLocation NewDefaultLoc; 1250 1251 // Variable used to diagnose missing default arguments 1252 bool MissingDefaultArg = false; 1253 1254 // Variable used to diagnose non-final parameter packs 1255 bool SawParameterPack = false; 1256 1257 if (TemplateTypeParmDecl *NewTypeParm 1258 = dyn_cast<TemplateTypeParmDecl>(*NewParam)) { 1259 // Check the presence of a default argument here. 1260 if (NewTypeParm->hasDefaultArgument() && 1261 DiagnoseDefaultTemplateArgument(*this, TPC, 1262 NewTypeParm->getLocation(), 1263 NewTypeParm->getDefaultArgumentInfo()->getTypeLoc() 1264 .getSourceRange())) 1265 NewTypeParm->removeDefaultArgument(); 1266 1267 // Merge default arguments for template type parameters. 1268 TemplateTypeParmDecl *OldTypeParm 1269 = OldParams? cast<TemplateTypeParmDecl>(*OldParam) : 0; 1270 1271 if (NewTypeParm->isParameterPack()) { 1272 assert(!NewTypeParm->hasDefaultArgument() && 1273 "Parameter packs can't have a default argument!"); 1274 SawParameterPack = true; 1275 } else if (OldTypeParm && OldTypeParm->hasDefaultArgument() && 1276 NewTypeParm->hasDefaultArgument()) { 1277 OldDefaultLoc = OldTypeParm->getDefaultArgumentLoc(); 1278 NewDefaultLoc = NewTypeParm->getDefaultArgumentLoc(); 1279 SawDefaultArgument = true; 1280 RedundantDefaultArg = true; 1281 PreviousDefaultArgLoc = NewDefaultLoc; 1282 } else if (OldTypeParm && OldTypeParm->hasDefaultArgument()) { 1283 // Merge the default argument from the old declaration to the 1284 // new declaration. 1285 SawDefaultArgument = true; 1286 NewTypeParm->setDefaultArgument(OldTypeParm->getDefaultArgumentInfo(), 1287 true); 1288 PreviousDefaultArgLoc = OldTypeParm->getDefaultArgumentLoc(); 1289 } else if (NewTypeParm->hasDefaultArgument()) { 1290 SawDefaultArgument = true; 1291 PreviousDefaultArgLoc = NewTypeParm->getDefaultArgumentLoc(); 1292 } else if (SawDefaultArgument) 1293 MissingDefaultArg = true; 1294 } else if (NonTypeTemplateParmDecl *NewNonTypeParm 1295 = dyn_cast<NonTypeTemplateParmDecl>(*NewParam)) { 1296 // Check for unexpanded parameter packs. 1297 if (DiagnoseUnexpandedParameterPack(NewNonTypeParm->getLocation(), 1298 NewNonTypeParm->getTypeSourceInfo(), 1299 UPPC_NonTypeTemplateParameterType)) { 1300 Invalid = true; 1301 continue; 1302 } 1303 1304 // Check the presence of a default argument here. 1305 if (NewNonTypeParm->hasDefaultArgument() && 1306 DiagnoseDefaultTemplateArgument(*this, TPC, 1307 NewNonTypeParm->getLocation(), 1308 NewNonTypeParm->getDefaultArgument()->getSourceRange())) { 1309 NewNonTypeParm->removeDefaultArgument(); 1310 } 1311 1312 // Merge default arguments for non-type template parameters 1313 NonTypeTemplateParmDecl *OldNonTypeParm 1314 = OldParams? cast<NonTypeTemplateParmDecl>(*OldParam) : 0; 1315 if (NewNonTypeParm->isParameterPack()) { 1316 assert(!NewNonTypeParm->hasDefaultArgument() && 1317 "Parameter packs can't have a default argument!"); 1318 SawParameterPack = true; 1319 } else if (OldNonTypeParm && OldNonTypeParm->hasDefaultArgument() && 1320 NewNonTypeParm->hasDefaultArgument()) { 1321 OldDefaultLoc = OldNonTypeParm->getDefaultArgumentLoc(); 1322 NewDefaultLoc = NewNonTypeParm->getDefaultArgumentLoc(); 1323 SawDefaultArgument = true; 1324 RedundantDefaultArg = true; 1325 PreviousDefaultArgLoc = NewDefaultLoc; 1326 } else if (OldNonTypeParm && OldNonTypeParm->hasDefaultArgument()) { 1327 // Merge the default argument from the old declaration to the 1328 // new declaration. 1329 SawDefaultArgument = true; 1330 // FIXME: We need to create a new kind of "default argument" 1331 // expression that points to a previous non-type template 1332 // parameter. 1333 NewNonTypeParm->setDefaultArgument( 1334 OldNonTypeParm->getDefaultArgument(), 1335 /*Inherited=*/ true); 1336 PreviousDefaultArgLoc = OldNonTypeParm->getDefaultArgumentLoc(); 1337 } else if (NewNonTypeParm->hasDefaultArgument()) { 1338 SawDefaultArgument = true; 1339 PreviousDefaultArgLoc = NewNonTypeParm->getDefaultArgumentLoc(); 1340 } else if (SawDefaultArgument) 1341 MissingDefaultArg = true; 1342 } else { 1343 TemplateTemplateParmDecl *NewTemplateParm 1344 = cast<TemplateTemplateParmDecl>(*NewParam); 1345 1346 // Check for unexpanded parameter packs, recursively. 1347 if (::DiagnoseUnexpandedParameterPacks(*this, NewTemplateParm)) { 1348 Invalid = true; 1349 continue; 1350 } 1351 1352 // Check the presence of a default argument here. 1353 if (NewTemplateParm->hasDefaultArgument() && 1354 DiagnoseDefaultTemplateArgument(*this, TPC, 1355 NewTemplateParm->getLocation(), 1356 NewTemplateParm->getDefaultArgument().getSourceRange())) 1357 NewTemplateParm->removeDefaultArgument(); 1358 1359 // Merge default arguments for template template parameters 1360 TemplateTemplateParmDecl *OldTemplateParm 1361 = OldParams? cast<TemplateTemplateParmDecl>(*OldParam) : 0; 1362 if (NewTemplateParm->isParameterPack()) { 1363 assert(!NewTemplateParm->hasDefaultArgument() && 1364 "Parameter packs can't have a default argument!"); 1365 SawParameterPack = true; 1366 } else if (OldTemplateParm && OldTemplateParm->hasDefaultArgument() && 1367 NewTemplateParm->hasDefaultArgument()) { 1368 OldDefaultLoc = OldTemplateParm->getDefaultArgument().getLocation(); 1369 NewDefaultLoc = NewTemplateParm->getDefaultArgument().getLocation(); 1370 SawDefaultArgument = true; 1371 RedundantDefaultArg = true; 1372 PreviousDefaultArgLoc = NewDefaultLoc; 1373 } else if (OldTemplateParm && OldTemplateParm->hasDefaultArgument()) { 1374 // Merge the default argument from the old declaration to the 1375 // new declaration. 1376 SawDefaultArgument = true; 1377 // FIXME: We need to create a new kind of "default argument" expression 1378 // that points to a previous template template parameter. 1379 NewTemplateParm->setDefaultArgument( 1380 OldTemplateParm->getDefaultArgument(), 1381 /*Inherited=*/ true); 1382 PreviousDefaultArgLoc 1383 = OldTemplateParm->getDefaultArgument().getLocation(); 1384 } else if (NewTemplateParm->hasDefaultArgument()) { 1385 SawDefaultArgument = true; 1386 PreviousDefaultArgLoc 1387 = NewTemplateParm->getDefaultArgument().getLocation(); 1388 } else if (SawDefaultArgument) 1389 MissingDefaultArg = true; 1390 } 1391 1392 // C++0x [temp.param]p11: 1393 // If a template parameter of a primary class template or alias template 1394 // is a template parameter pack, it shall be the last template parameter. 1395 if (SawParameterPack && (NewParam + 1) != NewParamEnd && 1396 (TPC == TPC_ClassTemplate || TPC == TPC_TypeAliasTemplate)) { 1397 Diag((*NewParam)->getLocation(), 1398 diag::err_template_param_pack_must_be_last_template_parameter); 1399 Invalid = true; 1400 } 1401 1402 if (RedundantDefaultArg) { 1403 // C++ [temp.param]p12: 1404 // A template-parameter shall not be given default arguments 1405 // by two different declarations in the same scope. 1406 Diag(NewDefaultLoc, diag::err_template_param_default_arg_redefinition); 1407 Diag(OldDefaultLoc, diag::note_template_param_prev_default_arg); 1408 Invalid = true; 1409 } else if (MissingDefaultArg && TPC != TPC_FunctionTemplate) { 1410 // C++ [temp.param]p11: 1411 // If a template-parameter of a class template has a default 1412 // template-argument, each subsequent template-parameter shall either 1413 // have a default template-argument supplied or be a template parameter 1414 // pack. 1415 Diag((*NewParam)->getLocation(), 1416 diag::err_template_param_default_arg_missing); 1417 Diag(PreviousDefaultArgLoc, diag::note_template_param_prev_default_arg); 1418 Invalid = true; 1419 RemoveDefaultArguments = true; 1420 } 1421 1422 // If we have an old template parameter list that we're merging 1423 // in, move on to the next parameter. 1424 if (OldParams) 1425 ++OldParam; 1426 } 1427 1428 // We were missing some default arguments at the end of the list, so remove 1429 // all of the default arguments. 1430 if (RemoveDefaultArguments) { 1431 for (TemplateParameterList::iterator NewParam = NewParams->begin(), 1432 NewParamEnd = NewParams->end(); 1433 NewParam != NewParamEnd; ++NewParam) { 1434 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*NewParam)) 1435 TTP->removeDefaultArgument(); 1436 else if (NonTypeTemplateParmDecl *NTTP 1437 = dyn_cast<NonTypeTemplateParmDecl>(*NewParam)) 1438 NTTP->removeDefaultArgument(); 1439 else 1440 cast<TemplateTemplateParmDecl>(*NewParam)->removeDefaultArgument(); 1441 } 1442 } 1443 1444 return Invalid; 1445} 1446 1447namespace { 1448 1449/// A class which looks for a use of a certain level of template 1450/// parameter. 1451struct DependencyChecker : RecursiveASTVisitor<DependencyChecker> { 1452 typedef RecursiveASTVisitor<DependencyChecker> super; 1453 1454 unsigned Depth; 1455 bool Match; 1456 1457 DependencyChecker(TemplateParameterList *Params) : Match(false) { 1458 NamedDecl *ND = Params->getParam(0); 1459 if (TemplateTypeParmDecl *PD = dyn_cast<TemplateTypeParmDecl>(ND)) { 1460 Depth = PD->getDepth(); 1461 } else if (NonTypeTemplateParmDecl *PD = 1462 dyn_cast<NonTypeTemplateParmDecl>(ND)) { 1463 Depth = PD->getDepth(); 1464 } else { 1465 Depth = cast<TemplateTemplateParmDecl>(ND)->getDepth(); 1466 } 1467 } 1468 1469 bool Matches(unsigned ParmDepth) { 1470 if (ParmDepth >= Depth) { 1471 Match = true; 1472 return true; 1473 } 1474 return false; 1475 } 1476 1477 bool VisitTemplateTypeParmType(const TemplateTypeParmType *T) { 1478 return !Matches(T->getDepth()); 1479 } 1480 1481 bool TraverseTemplateName(TemplateName N) { 1482 if (TemplateTemplateParmDecl *PD = 1483 dyn_cast_or_null<TemplateTemplateParmDecl>(N.getAsTemplateDecl())) 1484 if (Matches(PD->getDepth())) return false; 1485 return super::TraverseTemplateName(N); 1486 } 1487 1488 bool VisitDeclRefExpr(DeclRefExpr *E) { 1489 if (NonTypeTemplateParmDecl *PD = 1490 dyn_cast<NonTypeTemplateParmDecl>(E->getDecl())) { 1491 if (PD->getDepth() == Depth) { 1492 Match = true; 1493 return false; 1494 } 1495 } 1496 return super::VisitDeclRefExpr(E); 1497 } 1498 1499 bool TraverseInjectedClassNameType(const InjectedClassNameType *T) { 1500 return TraverseType(T->getInjectedSpecializationType()); 1501 } 1502}; 1503} 1504 1505/// Determines whether a given type depends on the given parameter 1506/// list. 1507static bool 1508DependsOnTemplateParameters(QualType T, TemplateParameterList *Params) { 1509 DependencyChecker Checker(Params); 1510 Checker.TraverseType(T); 1511 return Checker.Match; 1512} 1513 1514// Find the source range corresponding to the named type in the given 1515// nested-name-specifier, if any. 1516static SourceRange getRangeOfTypeInNestedNameSpecifier(ASTContext &Context, 1517 QualType T, 1518 const CXXScopeSpec &SS) { 1519 NestedNameSpecifierLoc NNSLoc(SS.getScopeRep(), SS.location_data()); 1520 while (NestedNameSpecifier *NNS = NNSLoc.getNestedNameSpecifier()) { 1521 if (const Type *CurType = NNS->getAsType()) { 1522 if (Context.hasSameUnqualifiedType(T, QualType(CurType, 0))) 1523 return NNSLoc.getTypeLoc().getSourceRange(); 1524 } else 1525 break; 1526 1527 NNSLoc = NNSLoc.getPrefix(); 1528 } 1529 1530 return SourceRange(); 1531} 1532 1533/// \brief Match the given template parameter lists to the given scope 1534/// specifier, returning the template parameter list that applies to the 1535/// name. 1536/// 1537/// \param DeclStartLoc the start of the declaration that has a scope 1538/// specifier or a template parameter list. 1539/// 1540/// \param DeclLoc The location of the declaration itself. 1541/// 1542/// \param SS the scope specifier that will be matched to the given template 1543/// parameter lists. This scope specifier precedes a qualified name that is 1544/// being declared. 1545/// 1546/// \param ParamLists the template parameter lists, from the outermost to the 1547/// innermost template parameter lists. 1548/// 1549/// \param NumParamLists the number of template parameter lists in ParamLists. 1550/// 1551/// \param IsFriend Whether to apply the slightly different rules for 1552/// matching template parameters to scope specifiers in friend 1553/// declarations. 1554/// 1555/// \param IsExplicitSpecialization will be set true if the entity being 1556/// declared is an explicit specialization, false otherwise. 1557/// 1558/// \returns the template parameter list, if any, that corresponds to the 1559/// name that is preceded by the scope specifier @p SS. This template 1560/// parameter list may have template parameters (if we're declaring a 1561/// template) or may have no template parameters (if we're declaring a 1562/// template specialization), or may be NULL (if what we're declaring isn't 1563/// itself a template). 1564TemplateParameterList * 1565Sema::MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc, 1566 SourceLocation DeclLoc, 1567 const CXXScopeSpec &SS, 1568 TemplateParameterList **ParamLists, 1569 unsigned NumParamLists, 1570 bool IsFriend, 1571 bool &IsExplicitSpecialization, 1572 bool &Invalid) { 1573 IsExplicitSpecialization = false; 1574 Invalid = false; 1575 1576 // The sequence of nested types to which we will match up the template 1577 // parameter lists. We first build this list by starting with the type named 1578 // by the nested-name-specifier and walking out until we run out of types. 1579 SmallVector<QualType, 4> NestedTypes; 1580 QualType T; 1581 if (SS.getScopeRep()) { 1582 if (CXXRecordDecl *Record 1583 = dyn_cast_or_null<CXXRecordDecl>(computeDeclContext(SS, true))) 1584 T = Context.getTypeDeclType(Record); 1585 else 1586 T = QualType(SS.getScopeRep()->getAsType(), 0); 1587 } 1588 1589 // If we found an explicit specialization that prevents us from needing 1590 // 'template<>' headers, this will be set to the location of that 1591 // explicit specialization. 1592 SourceLocation ExplicitSpecLoc; 1593 1594 while (!T.isNull()) { 1595 NestedTypes.push_back(T); 1596 1597 // Retrieve the parent of a record type. 1598 if (CXXRecordDecl *Record = T->getAsCXXRecordDecl()) { 1599 // If this type is an explicit specialization, we're done. 1600 if (ClassTemplateSpecializationDecl *Spec 1601 = dyn_cast<ClassTemplateSpecializationDecl>(Record)) { 1602 if (!isa<ClassTemplatePartialSpecializationDecl>(Spec) && 1603 Spec->getSpecializationKind() == TSK_ExplicitSpecialization) { 1604 ExplicitSpecLoc = Spec->getLocation(); 1605 break; 1606 } 1607 } else if (Record->getTemplateSpecializationKind() 1608 == TSK_ExplicitSpecialization) { 1609 ExplicitSpecLoc = Record->getLocation(); 1610 break; 1611 } 1612 1613 if (TypeDecl *Parent = dyn_cast<TypeDecl>(Record->getParent())) 1614 T = Context.getTypeDeclType(Parent); 1615 else 1616 T = QualType(); 1617 continue; 1618 } 1619 1620 if (const TemplateSpecializationType *TST 1621 = T->getAs<TemplateSpecializationType>()) { 1622 if (TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) { 1623 if (TypeDecl *Parent = dyn_cast<TypeDecl>(Template->getDeclContext())) 1624 T = Context.getTypeDeclType(Parent); 1625 else 1626 T = QualType(); 1627 continue; 1628 } 1629 } 1630 1631 // Look one step prior in a dependent template specialization type. 1632 if (const DependentTemplateSpecializationType *DependentTST 1633 = T->getAs<DependentTemplateSpecializationType>()) { 1634 if (NestedNameSpecifier *NNS = DependentTST->getQualifier()) 1635 T = QualType(NNS->getAsType(), 0); 1636 else 1637 T = QualType(); 1638 continue; 1639 } 1640 1641 // Look one step prior in a dependent name type. 1642 if (const DependentNameType *DependentName = T->getAs<DependentNameType>()){ 1643 if (NestedNameSpecifier *NNS = DependentName->getQualifier()) 1644 T = QualType(NNS->getAsType(), 0); 1645 else 1646 T = QualType(); 1647 continue; 1648 } 1649 1650 // Retrieve the parent of an enumeration type. 1651 if (const EnumType *EnumT = T->getAs<EnumType>()) { 1652 // FIXME: Forward-declared enums require a TSK_ExplicitSpecialization 1653 // check here. 1654 EnumDecl *Enum = EnumT->getDecl(); 1655 1656 // Get to the parent type. 1657 if (TypeDecl *Parent = dyn_cast<TypeDecl>(Enum->getParent())) 1658 T = Context.getTypeDeclType(Parent); 1659 else 1660 T = QualType(); 1661 continue; 1662 } 1663 1664 T = QualType(); 1665 } 1666 // Reverse the nested types list, since we want to traverse from the outermost 1667 // to the innermost while checking template-parameter-lists. 1668 std::reverse(NestedTypes.begin(), NestedTypes.end()); 1669 1670 // C++0x [temp.expl.spec]p17: 1671 // A member or a member template may be nested within many 1672 // enclosing class templates. In an explicit specialization for 1673 // such a member, the member declaration shall be preceded by a 1674 // template<> for each enclosing class template that is 1675 // explicitly specialized. 1676 bool SawNonEmptyTemplateParameterList = false; 1677 unsigned ParamIdx = 0; 1678 for (unsigned TypeIdx = 0, NumTypes = NestedTypes.size(); TypeIdx != NumTypes; 1679 ++TypeIdx) { 1680 T = NestedTypes[TypeIdx]; 1681 1682 // Whether we expect a 'template<>' header. 1683 bool NeedEmptyTemplateHeader = false; 1684 1685 // Whether we expect a template header with parameters. 1686 bool NeedNonemptyTemplateHeader = false; 1687 1688 // For a dependent type, the set of template parameters that we 1689 // expect to see. 1690 TemplateParameterList *ExpectedTemplateParams = 0; 1691 1692 // C++0x [temp.expl.spec]p15: 1693 // A member or a member template may be nested within many enclosing 1694 // class templates. In an explicit specialization for such a member, the 1695 // member declaration shall be preceded by a template<> for each 1696 // enclosing class template that is explicitly specialized. 1697 if (CXXRecordDecl *Record = T->getAsCXXRecordDecl()) { 1698 if (ClassTemplatePartialSpecializationDecl *Partial 1699 = dyn_cast<ClassTemplatePartialSpecializationDecl>(Record)) { 1700 ExpectedTemplateParams = Partial->getTemplateParameters(); 1701 NeedNonemptyTemplateHeader = true; 1702 } else if (Record->isDependentType()) { 1703 if (Record->getDescribedClassTemplate()) { 1704 ExpectedTemplateParams = Record->getDescribedClassTemplate() 1705 ->getTemplateParameters(); 1706 NeedNonemptyTemplateHeader = true; 1707 } 1708 } else if (ClassTemplateSpecializationDecl *Spec 1709 = dyn_cast<ClassTemplateSpecializationDecl>(Record)) { 1710 // C++0x [temp.expl.spec]p4: 1711 // Members of an explicitly specialized class template are defined 1712 // in the same manner as members of normal classes, and not using 1713 // the template<> syntax. 1714 if (Spec->getSpecializationKind() != TSK_ExplicitSpecialization) 1715 NeedEmptyTemplateHeader = true; 1716 else 1717 continue; 1718 } else if (Record->getTemplateSpecializationKind()) { 1719 if (Record->getTemplateSpecializationKind() 1720 != TSK_ExplicitSpecialization && 1721 TypeIdx == NumTypes - 1) 1722 IsExplicitSpecialization = true; 1723 1724 continue; 1725 } 1726 } else if (const TemplateSpecializationType *TST 1727 = T->getAs<TemplateSpecializationType>()) { 1728 if (TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) { 1729 ExpectedTemplateParams = Template->getTemplateParameters(); 1730 NeedNonemptyTemplateHeader = true; 1731 } 1732 } else if (T->getAs<DependentTemplateSpecializationType>()) { 1733 // FIXME: We actually could/should check the template arguments here 1734 // against the corresponding template parameter list. 1735 NeedNonemptyTemplateHeader = false; 1736 } 1737 1738 // C++ [temp.expl.spec]p16: 1739 // In an explicit specialization declaration for a member of a class 1740 // template or a member template that ap- pears in namespace scope, the 1741 // member template and some of its enclosing class templates may remain 1742 // unspecialized, except that the declaration shall not explicitly 1743 // specialize a class member template if its en- closing class templates 1744 // are not explicitly specialized as well. 1745 if (ParamIdx < NumParamLists) { 1746 if (ParamLists[ParamIdx]->size() == 0) { 1747 if (SawNonEmptyTemplateParameterList) { 1748 Diag(DeclLoc, diag::err_specialize_member_of_template) 1749 << ParamLists[ParamIdx]->getSourceRange(); 1750 Invalid = true; 1751 IsExplicitSpecialization = false; 1752 return 0; 1753 } 1754 } else 1755 SawNonEmptyTemplateParameterList = true; 1756 } 1757 1758 if (NeedEmptyTemplateHeader) { 1759 // If we're on the last of the types, and we need a 'template<>' header 1760 // here, then it's an explicit specialization. 1761 if (TypeIdx == NumTypes - 1) 1762 IsExplicitSpecialization = true; 1763 1764 if (ParamIdx < NumParamLists) { 1765 if (ParamLists[ParamIdx]->size() > 0) { 1766 // The header has template parameters when it shouldn't. Complain. 1767 Diag(ParamLists[ParamIdx]->getTemplateLoc(), 1768 diag::err_template_param_list_matches_nontemplate) 1769 << T 1770 << SourceRange(ParamLists[ParamIdx]->getLAngleLoc(), 1771 ParamLists[ParamIdx]->getRAngleLoc()) 1772 << getRangeOfTypeInNestedNameSpecifier(Context, T, SS); 1773 Invalid = true; 1774 return 0; 1775 } 1776 1777 // Consume this template header. 1778 ++ParamIdx; 1779 continue; 1780 } 1781 1782 if (!IsFriend) { 1783 // We don't have a template header, but we should. 1784 SourceLocation ExpectedTemplateLoc; 1785 if (NumParamLists > 0) 1786 ExpectedTemplateLoc = ParamLists[0]->getTemplateLoc(); 1787 else 1788 ExpectedTemplateLoc = DeclStartLoc; 1789 1790 Diag(DeclLoc, diag::err_template_spec_needs_header) 1791 << getRangeOfTypeInNestedNameSpecifier(Context, T, SS) 1792 << FixItHint::CreateInsertion(ExpectedTemplateLoc, "template<> "); 1793 } 1794 1795 continue; 1796 } 1797 1798 if (NeedNonemptyTemplateHeader) { 1799 // In friend declarations we can have template-ids which don't 1800 // depend on the corresponding template parameter lists. But 1801 // assume that empty parameter lists are supposed to match this 1802 // template-id. 1803 if (IsFriend && T->isDependentType()) { 1804 if (ParamIdx < NumParamLists && 1805 DependsOnTemplateParameters(T, ParamLists[ParamIdx])) 1806 ExpectedTemplateParams = 0; 1807 else 1808 continue; 1809 } 1810 1811 if (ParamIdx < NumParamLists) { 1812 // Check the template parameter list, if we can. 1813 if (ExpectedTemplateParams && 1814 !TemplateParameterListsAreEqual(ParamLists[ParamIdx], 1815 ExpectedTemplateParams, 1816 true, TPL_TemplateMatch)) 1817 Invalid = true; 1818 1819 if (!Invalid && 1820 CheckTemplateParameterList(ParamLists[ParamIdx], 0, 1821 TPC_ClassTemplateMember)) 1822 Invalid = true; 1823 1824 ++ParamIdx; 1825 continue; 1826 } 1827 1828 Diag(DeclLoc, diag::err_template_spec_needs_template_parameters) 1829 << T 1830 << getRangeOfTypeInNestedNameSpecifier(Context, T, SS); 1831 Invalid = true; 1832 continue; 1833 } 1834 } 1835 1836 // If there were at least as many template-ids as there were template 1837 // parameter lists, then there are no template parameter lists remaining for 1838 // the declaration itself. 1839 if (ParamIdx >= NumParamLists) 1840 return 0; 1841 1842 // If there were too many template parameter lists, complain about that now. 1843 if (ParamIdx < NumParamLists - 1) { 1844 bool HasAnyExplicitSpecHeader = false; 1845 bool AllExplicitSpecHeaders = true; 1846 for (unsigned I = ParamIdx; I != NumParamLists - 1; ++I) { 1847 if (ParamLists[I]->size() == 0) 1848 HasAnyExplicitSpecHeader = true; 1849 else 1850 AllExplicitSpecHeaders = false; 1851 } 1852 1853 Diag(ParamLists[ParamIdx]->getTemplateLoc(), 1854 AllExplicitSpecHeaders? diag::warn_template_spec_extra_headers 1855 : diag::err_template_spec_extra_headers) 1856 << SourceRange(ParamLists[ParamIdx]->getTemplateLoc(), 1857 ParamLists[NumParamLists - 2]->getRAngleLoc()); 1858 1859 // If there was a specialization somewhere, such that 'template<>' is 1860 // not required, and there were any 'template<>' headers, note where the 1861 // specialization occurred. 1862 if (ExplicitSpecLoc.isValid() && HasAnyExplicitSpecHeader) 1863 Diag(ExplicitSpecLoc, 1864 diag::note_explicit_template_spec_does_not_need_header) 1865 << NestedTypes.back(); 1866 1867 // We have a template parameter list with no corresponding scope, which 1868 // means that the resulting template declaration can't be instantiated 1869 // properly (we'll end up with dependent nodes when we shouldn't). 1870 if (!AllExplicitSpecHeaders) 1871 Invalid = true; 1872 } 1873 1874 // C++ [temp.expl.spec]p16: 1875 // In an explicit specialization declaration for a member of a class 1876 // template or a member template that ap- pears in namespace scope, the 1877 // member template and some of its enclosing class templates may remain 1878 // unspecialized, except that the declaration shall not explicitly 1879 // specialize a class member template if its en- closing class templates 1880 // are not explicitly specialized as well. 1881 if (ParamLists[NumParamLists - 1]->size() == 0 && 1882 SawNonEmptyTemplateParameterList) { 1883 Diag(DeclLoc, diag::err_specialize_member_of_template) 1884 << ParamLists[ParamIdx]->getSourceRange(); 1885 Invalid = true; 1886 IsExplicitSpecialization = false; 1887 return 0; 1888 } 1889 1890 // Return the last template parameter list, which corresponds to the 1891 // entity being declared. 1892 return ParamLists[NumParamLists - 1]; 1893} 1894 1895void Sema::NoteAllFoundTemplates(TemplateName Name) { 1896 if (TemplateDecl *Template = Name.getAsTemplateDecl()) { 1897 Diag(Template->getLocation(), diag::note_template_declared_here) 1898 << (isa<FunctionTemplateDecl>(Template)? 0 1899 : isa<ClassTemplateDecl>(Template)? 1 1900 : isa<TypeAliasTemplateDecl>(Template)? 2 1901 : 3) 1902 << Template->getDeclName(); 1903 return; 1904 } 1905 1906 if (OverloadedTemplateStorage *OST = Name.getAsOverloadedTemplate()) { 1907 for (OverloadedTemplateStorage::iterator I = OST->begin(), 1908 IEnd = OST->end(); 1909 I != IEnd; ++I) 1910 Diag((*I)->getLocation(), diag::note_template_declared_here) 1911 << 0 << (*I)->getDeclName(); 1912 1913 return; 1914 } 1915} 1916 1917QualType Sema::CheckTemplateIdType(TemplateName Name, 1918 SourceLocation TemplateLoc, 1919 TemplateArgumentListInfo &TemplateArgs) { 1920 DependentTemplateName *DTN 1921 = Name.getUnderlying().getAsDependentTemplateName(); 1922 if (DTN && DTN->isIdentifier()) 1923 // When building a template-id where the template-name is dependent, 1924 // assume the template is a type template. Either our assumption is 1925 // correct, or the code is ill-formed and will be diagnosed when the 1926 // dependent name is substituted. 1927 return Context.getDependentTemplateSpecializationType(ETK_None, 1928 DTN->getQualifier(), 1929 DTN->getIdentifier(), 1930 TemplateArgs); 1931 1932 TemplateDecl *Template = Name.getAsTemplateDecl(); 1933 if (!Template || isa<FunctionTemplateDecl>(Template)) { 1934 // We might have a substituted template template parameter pack. If so, 1935 // build a template specialization type for it. 1936 if (Name.getAsSubstTemplateTemplateParmPack()) 1937 return Context.getTemplateSpecializationType(Name, TemplateArgs); 1938 1939 Diag(TemplateLoc, diag::err_template_id_not_a_type) 1940 << Name; 1941 NoteAllFoundTemplates(Name); 1942 return QualType(); 1943 } 1944 1945 // Check that the template argument list is well-formed for this 1946 // template. 1947 SmallVector<TemplateArgument, 4> Converted; 1948 bool ExpansionIntoFixedList = false; 1949 if (CheckTemplateArgumentList(Template, TemplateLoc, TemplateArgs, 1950 false, Converted, &ExpansionIntoFixedList)) 1951 return QualType(); 1952 1953 QualType CanonType; 1954 1955 bool InstantiationDependent = false; 1956 TypeAliasTemplateDecl *AliasTemplate = 0; 1957 if (!ExpansionIntoFixedList && 1958 (AliasTemplate = dyn_cast<TypeAliasTemplateDecl>(Template))) { 1959 // Find the canonical type for this type alias template specialization. 1960 TypeAliasDecl *Pattern = AliasTemplate->getTemplatedDecl(); 1961 if (Pattern->isInvalidDecl()) 1962 return QualType(); 1963 1964 TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, 1965 Converted.data(), Converted.size()); 1966 1967 // Only substitute for the innermost template argument list. 1968 MultiLevelTemplateArgumentList TemplateArgLists; 1969 TemplateArgLists.addOuterTemplateArguments(&TemplateArgs); 1970 unsigned Depth = AliasTemplate->getTemplateParameters()->getDepth(); 1971 for (unsigned I = 0; I < Depth; ++I) 1972 TemplateArgLists.addOuterTemplateArguments(0, 0); 1973 1974 InstantiatingTemplate Inst(*this, TemplateLoc, Template); 1975 CanonType = SubstType(Pattern->getUnderlyingType(), 1976 TemplateArgLists, AliasTemplate->getLocation(), 1977 AliasTemplate->getDeclName()); 1978 if (CanonType.isNull()) 1979 return QualType(); 1980 } else if (Name.isDependent() || 1981 TemplateSpecializationType::anyDependentTemplateArguments( 1982 TemplateArgs, InstantiationDependent)) { 1983 // This class template specialization is a dependent 1984 // type. Therefore, its canonical type is another class template 1985 // specialization type that contains all of the converted 1986 // arguments in canonical form. This ensures that, e.g., A<T> and 1987 // A<T, T> have identical types when A is declared as: 1988 // 1989 // template<typename T, typename U = T> struct A; 1990 TemplateName CanonName = Context.getCanonicalTemplateName(Name); 1991 CanonType = Context.getTemplateSpecializationType(CanonName, 1992 Converted.data(), 1993 Converted.size()); 1994 1995 // FIXME: CanonType is not actually the canonical type, and unfortunately 1996 // it is a TemplateSpecializationType that we will never use again. 1997 // In the future, we need to teach getTemplateSpecializationType to only 1998 // build the canonical type and return that to us. 1999 CanonType = Context.getCanonicalType(CanonType); 2000 2001 // This might work out to be a current instantiation, in which 2002 // case the canonical type needs to be the InjectedClassNameType. 2003 // 2004 // TODO: in theory this could be a simple hashtable lookup; most 2005 // changes to CurContext don't change the set of current 2006 // instantiations. 2007 if (isa<ClassTemplateDecl>(Template)) { 2008 for (DeclContext *Ctx = CurContext; Ctx; Ctx = Ctx->getLookupParent()) { 2009 // If we get out to a namespace, we're done. 2010 if (Ctx->isFileContext()) break; 2011 2012 // If this isn't a record, keep looking. 2013 CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Ctx); 2014 if (!Record) continue; 2015 2016 // Look for one of the two cases with InjectedClassNameTypes 2017 // and check whether it's the same template. 2018 if (!isa<ClassTemplatePartialSpecializationDecl>(Record) && 2019 !Record->getDescribedClassTemplate()) 2020 continue; 2021 2022 // Fetch the injected class name type and check whether its 2023 // injected type is equal to the type we just built. 2024 QualType ICNT = Context.getTypeDeclType(Record); 2025 QualType Injected = cast<InjectedClassNameType>(ICNT) 2026 ->getInjectedSpecializationType(); 2027 2028 if (CanonType != Injected->getCanonicalTypeInternal()) 2029 continue; 2030 2031 // If so, the canonical type of this TST is the injected 2032 // class name type of the record we just found. 2033 assert(ICNT.isCanonical()); 2034 CanonType = ICNT; 2035 break; 2036 } 2037 } 2038 } else if (ClassTemplateDecl *ClassTemplate 2039 = dyn_cast<ClassTemplateDecl>(Template)) { 2040 // Find the class template specialization declaration that 2041 // corresponds to these arguments. 2042 void *InsertPos = 0; 2043 ClassTemplateSpecializationDecl *Decl 2044 = ClassTemplate->findSpecialization(Converted.data(), Converted.size(), 2045 InsertPos); 2046 if (!Decl) { 2047 // This is the first time we have referenced this class template 2048 // specialization. Create the canonical declaration and add it to 2049 // the set of specializations. 2050 Decl = ClassTemplateSpecializationDecl::Create(Context, 2051 ClassTemplate->getTemplatedDecl()->getTagKind(), 2052 ClassTemplate->getDeclContext(), 2053 ClassTemplate->getTemplatedDecl()->getLocStart(), 2054 ClassTemplate->getLocation(), 2055 ClassTemplate, 2056 Converted.data(), 2057 Converted.size(), 0); 2058 ClassTemplate->AddSpecialization(Decl, InsertPos); 2059 Decl->setLexicalDeclContext(CurContext); 2060 } 2061 2062 CanonType = Context.getTypeDeclType(Decl); 2063 assert(isa<RecordType>(CanonType) && 2064 "type of non-dependent specialization is not a RecordType"); 2065 } 2066 2067 // Build the fully-sugared type for this class template 2068 // specialization, which refers back to the class template 2069 // specialization we created or found. 2070 return Context.getTemplateSpecializationType(Name, TemplateArgs, CanonType); 2071} 2072 2073TypeResult 2074Sema::ActOnTemplateIdType(CXXScopeSpec &SS, SourceLocation TemplateKWLoc, 2075 TemplateTy TemplateD, SourceLocation TemplateLoc, 2076 SourceLocation LAngleLoc, 2077 ASTTemplateArgsPtr TemplateArgsIn, 2078 SourceLocation RAngleLoc, 2079 bool IsCtorOrDtorName) { 2080 if (SS.isInvalid()) 2081 return true; 2082 2083 TemplateName Template = TemplateD.getAsVal<TemplateName>(); 2084 2085 // Translate the parser's template argument list in our AST format. 2086 TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc); 2087 translateTemplateArguments(TemplateArgsIn, TemplateArgs); 2088 2089 if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) { 2090 QualType T 2091 = Context.getDependentTemplateSpecializationType(ETK_None, 2092 DTN->getQualifier(), 2093 DTN->getIdentifier(), 2094 TemplateArgs); 2095 // Build type-source information. 2096 TypeLocBuilder TLB; 2097 DependentTemplateSpecializationTypeLoc SpecTL 2098 = TLB.push<DependentTemplateSpecializationTypeLoc>(T); 2099 SpecTL.setElaboratedKeywordLoc(SourceLocation()); 2100 SpecTL.setQualifierLoc(SS.getWithLocInContext(Context)); 2101 SpecTL.setTemplateKeywordLoc(TemplateKWLoc); 2102 SpecTL.setTemplateNameLoc(TemplateLoc); 2103 SpecTL.setLAngleLoc(LAngleLoc); 2104 SpecTL.setRAngleLoc(RAngleLoc); 2105 for (unsigned I = 0, N = SpecTL.getNumArgs(); I != N; ++I) 2106 SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo()); 2107 return CreateParsedType(T, TLB.getTypeSourceInfo(Context, T)); 2108 } 2109 2110 QualType Result = CheckTemplateIdType(Template, TemplateLoc, TemplateArgs); 2111 TemplateArgsIn.release(); 2112 2113 if (Result.isNull()) 2114 return true; 2115 2116 // Build type-source information. 2117 TypeLocBuilder TLB; 2118 TemplateSpecializationTypeLoc SpecTL 2119 = TLB.push<TemplateSpecializationTypeLoc>(Result); 2120 SpecTL.setTemplateKeywordLoc(TemplateKWLoc); 2121 SpecTL.setTemplateNameLoc(TemplateLoc); 2122 SpecTL.setLAngleLoc(LAngleLoc); 2123 SpecTL.setRAngleLoc(RAngleLoc); 2124 for (unsigned i = 0, e = SpecTL.getNumArgs(); i != e; ++i) 2125 SpecTL.setArgLocInfo(i, TemplateArgs[i].getLocInfo()); 2126 2127 // NOTE: avoid constructing an ElaboratedTypeLoc if this is a 2128 // constructor or destructor name (in such a case, the scope specifier 2129 // will be attached to the enclosing Decl or Expr node). 2130 if (SS.isNotEmpty() && !IsCtorOrDtorName) { 2131 // Create an elaborated-type-specifier containing the nested-name-specifier. 2132 Result = Context.getElaboratedType(ETK_None, SS.getScopeRep(), Result); 2133 ElaboratedTypeLoc ElabTL = TLB.push<ElaboratedTypeLoc>(Result); 2134 ElabTL.setElaboratedKeywordLoc(SourceLocation()); 2135 ElabTL.setQualifierLoc(SS.getWithLocInContext(Context)); 2136 } 2137 2138 return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result)); 2139} 2140 2141TypeResult Sema::ActOnTagTemplateIdType(TagUseKind TUK, 2142 TypeSpecifierType TagSpec, 2143 SourceLocation TagLoc, 2144 CXXScopeSpec &SS, 2145 SourceLocation TemplateKWLoc, 2146 TemplateTy TemplateD, 2147 SourceLocation TemplateLoc, 2148 SourceLocation LAngleLoc, 2149 ASTTemplateArgsPtr TemplateArgsIn, 2150 SourceLocation RAngleLoc) { 2151 TemplateName Template = TemplateD.getAsVal<TemplateName>(); 2152 2153 // Translate the parser's template argument list in our AST format. 2154 TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc); 2155 translateTemplateArguments(TemplateArgsIn, TemplateArgs); 2156 2157 // Determine the tag kind 2158 TagTypeKind TagKind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec); 2159 ElaboratedTypeKeyword Keyword 2160 = TypeWithKeyword::getKeywordForTagTypeKind(TagKind); 2161 2162 if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) { 2163 QualType T = Context.getDependentTemplateSpecializationType(Keyword, 2164 DTN->getQualifier(), 2165 DTN->getIdentifier(), 2166 TemplateArgs); 2167 2168 // Build type-source information. 2169 TypeLocBuilder TLB; 2170 DependentTemplateSpecializationTypeLoc SpecTL 2171 = TLB.push<DependentTemplateSpecializationTypeLoc>(T); 2172 SpecTL.setElaboratedKeywordLoc(TagLoc); 2173 SpecTL.setQualifierLoc(SS.getWithLocInContext(Context)); 2174 SpecTL.setTemplateKeywordLoc(TemplateKWLoc); 2175 SpecTL.setTemplateNameLoc(TemplateLoc); 2176 SpecTL.setLAngleLoc(LAngleLoc); 2177 SpecTL.setRAngleLoc(RAngleLoc); 2178 for (unsigned I = 0, N = SpecTL.getNumArgs(); I != N; ++I) 2179 SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo()); 2180 return CreateParsedType(T, TLB.getTypeSourceInfo(Context, T)); 2181 } 2182 2183 if (TypeAliasTemplateDecl *TAT = 2184 dyn_cast_or_null<TypeAliasTemplateDecl>(Template.getAsTemplateDecl())) { 2185 // C++0x [dcl.type.elab]p2: 2186 // If the identifier resolves to a typedef-name or the simple-template-id 2187 // resolves to an alias template specialization, the 2188 // elaborated-type-specifier is ill-formed. 2189 Diag(TemplateLoc, diag::err_tag_reference_non_tag) << 4; 2190 Diag(TAT->getLocation(), diag::note_declared_at); 2191 } 2192 2193 QualType Result = CheckTemplateIdType(Template, TemplateLoc, TemplateArgs); 2194 if (Result.isNull()) 2195 return TypeResult(true); 2196 2197 // Check the tag kind 2198 if (const RecordType *RT = Result->getAs<RecordType>()) { 2199 RecordDecl *D = RT->getDecl(); 2200 2201 IdentifierInfo *Id = D->getIdentifier(); 2202 assert(Id && "templated class must have an identifier"); 2203 2204 if (!isAcceptableTagRedeclaration(D, TagKind, TUK == TUK_Definition, 2205 TagLoc, *Id)) { 2206 Diag(TagLoc, diag::err_use_with_wrong_tag) 2207 << Result 2208 << FixItHint::CreateReplacement(SourceRange(TagLoc), D->getKindName()); 2209 Diag(D->getLocation(), diag::note_previous_use); 2210 } 2211 } 2212 2213 // Provide source-location information for the template specialization. 2214 TypeLocBuilder TLB; 2215 TemplateSpecializationTypeLoc SpecTL 2216 = TLB.push<TemplateSpecializationTypeLoc>(Result); 2217 SpecTL.setTemplateKeywordLoc(TemplateKWLoc); 2218 SpecTL.setTemplateNameLoc(TemplateLoc); 2219 SpecTL.setLAngleLoc(LAngleLoc); 2220 SpecTL.setRAngleLoc(RAngleLoc); 2221 for (unsigned i = 0, e = SpecTL.getNumArgs(); i != e; ++i) 2222 SpecTL.setArgLocInfo(i, TemplateArgs[i].getLocInfo()); 2223 2224 // Construct an elaborated type containing the nested-name-specifier (if any) 2225 // and tag keyword. 2226 Result = Context.getElaboratedType(Keyword, SS.getScopeRep(), Result); 2227 ElaboratedTypeLoc ElabTL = TLB.push<ElaboratedTypeLoc>(Result); 2228 ElabTL.setElaboratedKeywordLoc(TagLoc); 2229 ElabTL.setQualifierLoc(SS.getWithLocInContext(Context)); 2230 return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result)); 2231} 2232 2233ExprResult Sema::BuildTemplateIdExpr(const CXXScopeSpec &SS, 2234 SourceLocation TemplateKWLoc, 2235 LookupResult &R, 2236 bool RequiresADL, 2237 const TemplateArgumentListInfo *TemplateArgs) { 2238 // FIXME: Can we do any checking at this point? I guess we could check the 2239 // template arguments that we have against the template name, if the template 2240 // name refers to a single template. That's not a terribly common case, 2241 // though. 2242 // foo<int> could identify a single function unambiguously 2243 // This approach does NOT work, since f<int>(1); 2244 // gets resolved prior to resorting to overload resolution 2245 // i.e., template<class T> void f(double); 2246 // vs template<class T, class U> void f(U); 2247 2248 // These should be filtered out by our callers. 2249 assert(!R.empty() && "empty lookup results when building templateid"); 2250 assert(!R.isAmbiguous() && "ambiguous lookup when building templateid"); 2251 2252 // We don't want lookup warnings at this point. 2253 R.suppressDiagnostics(); 2254 2255 UnresolvedLookupExpr *ULE 2256 = UnresolvedLookupExpr::Create(Context, R.getNamingClass(), 2257 SS.getWithLocInContext(Context), 2258 TemplateKWLoc, 2259 R.getLookupNameInfo(), 2260 RequiresADL, TemplateArgs, 2261 R.begin(), R.end()); 2262 2263 return Owned(ULE); 2264} 2265 2266// We actually only call this from template instantiation. 2267ExprResult 2268Sema::BuildQualifiedTemplateIdExpr(CXXScopeSpec &SS, 2269 SourceLocation TemplateKWLoc, 2270 const DeclarationNameInfo &NameInfo, 2271 const TemplateArgumentListInfo *TemplateArgs) { 2272 assert(TemplateArgs || TemplateKWLoc.isValid()); 2273 DeclContext *DC; 2274 if (!(DC = computeDeclContext(SS, false)) || 2275 DC->isDependentContext() || 2276 RequireCompleteDeclContext(SS, DC)) 2277 return BuildDependentDeclRefExpr(SS, TemplateKWLoc, NameInfo, TemplateArgs); 2278 2279 bool MemberOfUnknownSpecialization; 2280 LookupResult R(*this, NameInfo, LookupOrdinaryName); 2281 LookupTemplateName(R, (Scope*) 0, SS, QualType(), /*Entering*/ false, 2282 MemberOfUnknownSpecialization); 2283 2284 if (R.isAmbiguous()) 2285 return ExprError(); 2286 2287 if (R.empty()) { 2288 Diag(NameInfo.getLoc(), diag::err_template_kw_refers_to_non_template) 2289 << NameInfo.getName() << SS.getRange(); 2290 return ExprError(); 2291 } 2292 2293 if (ClassTemplateDecl *Temp = R.getAsSingle<ClassTemplateDecl>()) { 2294 Diag(NameInfo.getLoc(), diag::err_template_kw_refers_to_class_template) 2295 << (NestedNameSpecifier*) SS.getScopeRep() 2296 << NameInfo.getName() << SS.getRange(); 2297 Diag(Temp->getLocation(), diag::note_referenced_class_template); 2298 return ExprError(); 2299 } 2300 2301 return BuildTemplateIdExpr(SS, TemplateKWLoc, R, /*ADL*/ false, TemplateArgs); 2302} 2303 2304/// \brief Form a dependent template name. 2305/// 2306/// This action forms a dependent template name given the template 2307/// name and its (presumably dependent) scope specifier. For 2308/// example, given "MetaFun::template apply", the scope specifier \p 2309/// SS will be "MetaFun::", \p TemplateKWLoc contains the location 2310/// of the "template" keyword, and "apply" is the \p Name. 2311TemplateNameKind Sema::ActOnDependentTemplateName(Scope *S, 2312 CXXScopeSpec &SS, 2313 SourceLocation TemplateKWLoc, 2314 UnqualifiedId &Name, 2315 ParsedType ObjectType, 2316 bool EnteringContext, 2317 TemplateTy &Result) { 2318 if (TemplateKWLoc.isValid() && S && !S->getTemplateParamParent()) 2319 Diag(TemplateKWLoc, 2320 getLangOpts().CPlusPlus0x ? 2321 diag::warn_cxx98_compat_template_outside_of_template : 2322 diag::ext_template_outside_of_template) 2323 << FixItHint::CreateRemoval(TemplateKWLoc); 2324 2325 DeclContext *LookupCtx = 0; 2326 if (SS.isSet()) 2327 LookupCtx = computeDeclContext(SS, EnteringContext); 2328 if (!LookupCtx && ObjectType) 2329 LookupCtx = computeDeclContext(ObjectType.get()); 2330 if (LookupCtx) { 2331 // C++0x [temp.names]p5: 2332 // If a name prefixed by the keyword template is not the name of 2333 // a template, the program is ill-formed. [Note: the keyword 2334 // template may not be applied to non-template members of class 2335 // templates. -end note ] [ Note: as is the case with the 2336 // typename prefix, the template prefix is allowed in cases 2337 // where it is not strictly necessary; i.e., when the 2338 // nested-name-specifier or the expression on the left of the -> 2339 // or . is not dependent on a template-parameter, or the use 2340 // does not appear in the scope of a template. -end note] 2341 // 2342 // Note: C++03 was more strict here, because it banned the use of 2343 // the "template" keyword prior to a template-name that was not a 2344 // dependent name. C++ DR468 relaxed this requirement (the 2345 // "template" keyword is now permitted). We follow the C++0x 2346 // rules, even in C++03 mode with a warning, retroactively applying the DR. 2347 bool MemberOfUnknownSpecialization; 2348 TemplateNameKind TNK = isTemplateName(0, SS, TemplateKWLoc.isValid(), Name, 2349 ObjectType, EnteringContext, Result, 2350 MemberOfUnknownSpecialization); 2351 if (TNK == TNK_Non_template && LookupCtx->isDependentContext() && 2352 isa<CXXRecordDecl>(LookupCtx) && 2353 (!cast<CXXRecordDecl>(LookupCtx)->hasDefinition() || 2354 cast<CXXRecordDecl>(LookupCtx)->hasAnyDependentBases())) { 2355 // This is a dependent template. Handle it below. 2356 } else if (TNK == TNK_Non_template) { 2357 Diag(Name.getLocStart(), 2358 diag::err_template_kw_refers_to_non_template) 2359 << GetNameFromUnqualifiedId(Name).getName() 2360 << Name.getSourceRange() 2361 << TemplateKWLoc; 2362 return TNK_Non_template; 2363 } else { 2364 // We found something; return it. 2365 return TNK; 2366 } 2367 } 2368 2369 NestedNameSpecifier *Qualifier 2370 = static_cast<NestedNameSpecifier *>(SS.getScopeRep()); 2371 2372 switch (Name.getKind()) { 2373 case UnqualifiedId::IK_Identifier: 2374 Result = TemplateTy::make(Context.getDependentTemplateName(Qualifier, 2375 Name.Identifier)); 2376 return TNK_Dependent_template_name; 2377 2378 case UnqualifiedId::IK_OperatorFunctionId: 2379 Result = TemplateTy::make(Context.getDependentTemplateName(Qualifier, 2380 Name.OperatorFunctionId.Operator)); 2381 return TNK_Dependent_template_name; 2382 2383 case UnqualifiedId::IK_LiteralOperatorId: 2384 llvm_unreachable( 2385 "We don't support these; Parse shouldn't have allowed propagation"); 2386 2387 default: 2388 break; 2389 } 2390 2391 Diag(Name.getLocStart(), 2392 diag::err_template_kw_refers_to_non_template) 2393 << GetNameFromUnqualifiedId(Name).getName() 2394 << Name.getSourceRange() 2395 << TemplateKWLoc; 2396 return TNK_Non_template; 2397} 2398 2399bool Sema::CheckTemplateTypeArgument(TemplateTypeParmDecl *Param, 2400 const TemplateArgumentLoc &AL, 2401 SmallVectorImpl<TemplateArgument> &Converted) { 2402 const TemplateArgument &Arg = AL.getArgument(); 2403 2404 // Check template type parameter. 2405 switch(Arg.getKind()) { 2406 case TemplateArgument::Type: 2407 // C++ [temp.arg.type]p1: 2408 // A template-argument for a template-parameter which is a 2409 // type shall be a type-id. 2410 break; 2411 case TemplateArgument::Template: { 2412 // We have a template type parameter but the template argument 2413 // is a template without any arguments. 2414 SourceRange SR = AL.getSourceRange(); 2415 TemplateName Name = Arg.getAsTemplate(); 2416 Diag(SR.getBegin(), diag::err_template_missing_args) 2417 << Name << SR; 2418 if (TemplateDecl *Decl = Name.getAsTemplateDecl()) 2419 Diag(Decl->getLocation(), diag::note_template_decl_here); 2420 2421 return true; 2422 } 2423 default: { 2424 // We have a template type parameter but the template argument 2425 // is not a type. 2426 SourceRange SR = AL.getSourceRange(); 2427 Diag(SR.getBegin(), diag::err_template_arg_must_be_type) << SR; 2428 Diag(Param->getLocation(), diag::note_template_param_here); 2429 2430 return true; 2431 } 2432 } 2433 2434 if (CheckTemplateArgument(Param, AL.getTypeSourceInfo())) 2435 return true; 2436 2437 // Add the converted template type argument. 2438 QualType ArgType = Context.getCanonicalType(Arg.getAsType()); 2439 2440 // Objective-C ARC: 2441 // If an explicitly-specified template argument type is a lifetime type 2442 // with no lifetime qualifier, the __strong lifetime qualifier is inferred. 2443 if (getLangOpts().ObjCAutoRefCount && 2444 ArgType->isObjCLifetimeType() && 2445 !ArgType.getObjCLifetime()) { 2446 Qualifiers Qs; 2447 Qs.setObjCLifetime(Qualifiers::OCL_Strong); 2448 ArgType = Context.getQualifiedType(ArgType, Qs); 2449 } 2450 2451 Converted.push_back(TemplateArgument(ArgType)); 2452 return false; 2453} 2454 2455/// \brief Substitute template arguments into the default template argument for 2456/// the given template type parameter. 2457/// 2458/// \param SemaRef the semantic analysis object for which we are performing 2459/// the substitution. 2460/// 2461/// \param Template the template that we are synthesizing template arguments 2462/// for. 2463/// 2464/// \param TemplateLoc the location of the template name that started the 2465/// template-id we are checking. 2466/// 2467/// \param RAngleLoc the location of the right angle bracket ('>') that 2468/// terminates the template-id. 2469/// 2470/// \param Param the template template parameter whose default we are 2471/// substituting into. 2472/// 2473/// \param Converted the list of template arguments provided for template 2474/// parameters that precede \p Param in the template parameter list. 2475/// \returns the substituted template argument, or NULL if an error occurred. 2476static TypeSourceInfo * 2477SubstDefaultTemplateArgument(Sema &SemaRef, 2478 TemplateDecl *Template, 2479 SourceLocation TemplateLoc, 2480 SourceLocation RAngleLoc, 2481 TemplateTypeParmDecl *Param, 2482 SmallVectorImpl<TemplateArgument> &Converted) { 2483 TypeSourceInfo *ArgType = Param->getDefaultArgumentInfo(); 2484 2485 // If the argument type is dependent, instantiate it now based 2486 // on the previously-computed template arguments. 2487 if (ArgType->getType()->isDependentType()) { 2488 TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, 2489 Converted.data(), Converted.size()); 2490 2491 MultiLevelTemplateArgumentList AllTemplateArgs 2492 = SemaRef.getTemplateInstantiationArgs(Template, &TemplateArgs); 2493 2494 Sema::InstantiatingTemplate Inst(SemaRef, TemplateLoc, 2495 Template, Converted.data(), 2496 Converted.size(), 2497 SourceRange(TemplateLoc, RAngleLoc)); 2498 2499 ArgType = SemaRef.SubstType(ArgType, AllTemplateArgs, 2500 Param->getDefaultArgumentLoc(), 2501 Param->getDeclName()); 2502 } 2503 2504 return ArgType; 2505} 2506 2507/// \brief Substitute template arguments into the default template argument for 2508/// the given non-type template parameter. 2509/// 2510/// \param SemaRef the semantic analysis object for which we are performing 2511/// the substitution. 2512/// 2513/// \param Template the template that we are synthesizing template arguments 2514/// for. 2515/// 2516/// \param TemplateLoc the location of the template name that started the 2517/// template-id we are checking. 2518/// 2519/// \param RAngleLoc the location of the right angle bracket ('>') that 2520/// terminates the template-id. 2521/// 2522/// \param Param the non-type template parameter whose default we are 2523/// substituting into. 2524/// 2525/// \param Converted the list of template arguments provided for template 2526/// parameters that precede \p Param in the template parameter list. 2527/// 2528/// \returns the substituted template argument, or NULL if an error occurred. 2529static ExprResult 2530SubstDefaultTemplateArgument(Sema &SemaRef, 2531 TemplateDecl *Template, 2532 SourceLocation TemplateLoc, 2533 SourceLocation RAngleLoc, 2534 NonTypeTemplateParmDecl *Param, 2535 SmallVectorImpl<TemplateArgument> &Converted) { 2536 TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, 2537 Converted.data(), Converted.size()); 2538 2539 MultiLevelTemplateArgumentList AllTemplateArgs 2540 = SemaRef.getTemplateInstantiationArgs(Template, &TemplateArgs); 2541 2542 Sema::InstantiatingTemplate Inst(SemaRef, TemplateLoc, 2543 Template, Converted.data(), 2544 Converted.size(), 2545 SourceRange(TemplateLoc, RAngleLoc)); 2546 2547 return SemaRef.SubstExpr(Param->getDefaultArgument(), AllTemplateArgs); 2548} 2549 2550/// \brief Substitute template arguments into the default template argument for 2551/// the given template template parameter. 2552/// 2553/// \param SemaRef the semantic analysis object for which we are performing 2554/// the substitution. 2555/// 2556/// \param Template the template that we are synthesizing template arguments 2557/// for. 2558/// 2559/// \param TemplateLoc the location of the template name that started the 2560/// template-id we are checking. 2561/// 2562/// \param RAngleLoc the location of the right angle bracket ('>') that 2563/// terminates the template-id. 2564/// 2565/// \param Param the template template parameter whose default we are 2566/// substituting into. 2567/// 2568/// \param Converted the list of template arguments provided for template 2569/// parameters that precede \p Param in the template parameter list. 2570/// 2571/// \param QualifierLoc Will be set to the nested-name-specifier (with 2572/// source-location information) that precedes the template name. 2573/// 2574/// \returns the substituted template argument, or NULL if an error occurred. 2575static TemplateName 2576SubstDefaultTemplateArgument(Sema &SemaRef, 2577 TemplateDecl *Template, 2578 SourceLocation TemplateLoc, 2579 SourceLocation RAngleLoc, 2580 TemplateTemplateParmDecl *Param, 2581 SmallVectorImpl<TemplateArgument> &Converted, 2582 NestedNameSpecifierLoc &QualifierLoc) { 2583 TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, 2584 Converted.data(), Converted.size()); 2585 2586 MultiLevelTemplateArgumentList AllTemplateArgs 2587 = SemaRef.getTemplateInstantiationArgs(Template, &TemplateArgs); 2588 2589 Sema::InstantiatingTemplate Inst(SemaRef, TemplateLoc, 2590 Template, Converted.data(), 2591 Converted.size(), 2592 SourceRange(TemplateLoc, RAngleLoc)); 2593 2594 // Substitute into the nested-name-specifier first, 2595 QualifierLoc = Param->getDefaultArgument().getTemplateQualifierLoc(); 2596 if (QualifierLoc) { 2597 QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, 2598 AllTemplateArgs); 2599 if (!QualifierLoc) 2600 return TemplateName(); 2601 } 2602 2603 return SemaRef.SubstTemplateName(QualifierLoc, 2604 Param->getDefaultArgument().getArgument().getAsTemplate(), 2605 Param->getDefaultArgument().getTemplateNameLoc(), 2606 AllTemplateArgs); 2607} 2608 2609/// \brief If the given template parameter has a default template 2610/// argument, substitute into that default template argument and 2611/// return the corresponding template argument. 2612TemplateArgumentLoc 2613Sema::SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template, 2614 SourceLocation TemplateLoc, 2615 SourceLocation RAngleLoc, 2616 Decl *Param, 2617 SmallVectorImpl<TemplateArgument> &Converted) { 2618 if (TemplateTypeParmDecl *TypeParm = dyn_cast<TemplateTypeParmDecl>(Param)) { 2619 if (!TypeParm->hasDefaultArgument()) 2620 return TemplateArgumentLoc(); 2621 2622 TypeSourceInfo *DI = SubstDefaultTemplateArgument(*this, Template, 2623 TemplateLoc, 2624 RAngleLoc, 2625 TypeParm, 2626 Converted); 2627 if (DI) 2628 return TemplateArgumentLoc(TemplateArgument(DI->getType()), DI); 2629 2630 return TemplateArgumentLoc(); 2631 } 2632 2633 if (NonTypeTemplateParmDecl *NonTypeParm 2634 = dyn_cast<NonTypeTemplateParmDecl>(Param)) { 2635 if (!NonTypeParm->hasDefaultArgument()) 2636 return TemplateArgumentLoc(); 2637 2638 ExprResult Arg = SubstDefaultTemplateArgument(*this, Template, 2639 TemplateLoc, 2640 RAngleLoc, 2641 NonTypeParm, 2642 Converted); 2643 if (Arg.isInvalid()) 2644 return TemplateArgumentLoc(); 2645 2646 Expr *ArgE = Arg.takeAs<Expr>(); 2647 return TemplateArgumentLoc(TemplateArgument(ArgE), ArgE); 2648 } 2649 2650 TemplateTemplateParmDecl *TempTempParm 2651 = cast<TemplateTemplateParmDecl>(Param); 2652 if (!TempTempParm->hasDefaultArgument()) 2653 return TemplateArgumentLoc(); 2654 2655 2656 NestedNameSpecifierLoc QualifierLoc; 2657 TemplateName TName = SubstDefaultTemplateArgument(*this, Template, 2658 TemplateLoc, 2659 RAngleLoc, 2660 TempTempParm, 2661 Converted, 2662 QualifierLoc); 2663 if (TName.isNull()) 2664 return TemplateArgumentLoc(); 2665 2666 return TemplateArgumentLoc(TemplateArgument(TName), 2667 TempTempParm->getDefaultArgument().getTemplateQualifierLoc(), 2668 TempTempParm->getDefaultArgument().getTemplateNameLoc()); 2669} 2670 2671/// \brief Check that the given template argument corresponds to the given 2672/// template parameter. 2673/// 2674/// \param Param The template parameter against which the argument will be 2675/// checked. 2676/// 2677/// \param Arg The template argument. 2678/// 2679/// \param Template The template in which the template argument resides. 2680/// 2681/// \param TemplateLoc The location of the template name for the template 2682/// whose argument list we're matching. 2683/// 2684/// \param RAngleLoc The location of the right angle bracket ('>') that closes 2685/// the template argument list. 2686/// 2687/// \param ArgumentPackIndex The index into the argument pack where this 2688/// argument will be placed. Only valid if the parameter is a parameter pack. 2689/// 2690/// \param Converted The checked, converted argument will be added to the 2691/// end of this small vector. 2692/// 2693/// \param CTAK Describes how we arrived at this particular template argument: 2694/// explicitly written, deduced, etc. 2695/// 2696/// \returns true on error, false otherwise. 2697bool Sema::CheckTemplateArgument(NamedDecl *Param, 2698 const TemplateArgumentLoc &Arg, 2699 NamedDecl *Template, 2700 SourceLocation TemplateLoc, 2701 SourceLocation RAngleLoc, 2702 unsigned ArgumentPackIndex, 2703 SmallVectorImpl<TemplateArgument> &Converted, 2704 CheckTemplateArgumentKind CTAK) { 2705 // Check template type parameters. 2706 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) 2707 return CheckTemplateTypeArgument(TTP, Arg, Converted); 2708 2709 // Check non-type template parameters. 2710 if (NonTypeTemplateParmDecl *NTTP =dyn_cast<NonTypeTemplateParmDecl>(Param)) { 2711 // Do substitution on the type of the non-type template parameter 2712 // with the template arguments we've seen thus far. But if the 2713 // template has a dependent context then we cannot substitute yet. 2714 QualType NTTPType = NTTP->getType(); 2715 if (NTTP->isParameterPack() && NTTP->isExpandedParameterPack()) 2716 NTTPType = NTTP->getExpansionType(ArgumentPackIndex); 2717 2718 if (NTTPType->isDependentType() && 2719 !isa<TemplateTemplateParmDecl>(Template) && 2720 !Template->getDeclContext()->isDependentContext()) { 2721 // Do substitution on the type of the non-type template parameter. 2722 InstantiatingTemplate Inst(*this, TemplateLoc, Template, 2723 NTTP, Converted.data(), Converted.size(), 2724 SourceRange(TemplateLoc, RAngleLoc)); 2725 2726 TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, 2727 Converted.data(), Converted.size()); 2728 NTTPType = SubstType(NTTPType, 2729 MultiLevelTemplateArgumentList(TemplateArgs), 2730 NTTP->getLocation(), 2731 NTTP->getDeclName()); 2732 // If that worked, check the non-type template parameter type 2733 // for validity. 2734 if (!NTTPType.isNull()) 2735 NTTPType = CheckNonTypeTemplateParameterType(NTTPType, 2736 NTTP->getLocation()); 2737 if (NTTPType.isNull()) 2738 return true; 2739 } 2740 2741 switch (Arg.getArgument().getKind()) { 2742 case TemplateArgument::Null: 2743 llvm_unreachable("Should never see a NULL template argument here"); 2744 2745 case TemplateArgument::Expression: { 2746 TemplateArgument Result; 2747 ExprResult Res = 2748 CheckTemplateArgument(NTTP, NTTPType, Arg.getArgument().getAsExpr(), 2749 Result, CTAK); 2750 if (Res.isInvalid()) 2751 return true; 2752 2753 Converted.push_back(Result); 2754 break; 2755 } 2756 2757 case TemplateArgument::Declaration: 2758 case TemplateArgument::Integral: 2759 // We've already checked this template argument, so just copy 2760 // it to the list of converted arguments. 2761 Converted.push_back(Arg.getArgument()); 2762 break; 2763 2764 case TemplateArgument::Template: 2765 case TemplateArgument::TemplateExpansion: 2766 // We were given a template template argument. It may not be ill-formed; 2767 // see below. 2768 if (DependentTemplateName *DTN 2769 = Arg.getArgument().getAsTemplateOrTemplatePattern() 2770 .getAsDependentTemplateName()) { 2771 // We have a template argument such as \c T::template X, which we 2772 // parsed as a template template argument. However, since we now 2773 // know that we need a non-type template argument, convert this 2774 // template name into an expression. 2775 2776 DeclarationNameInfo NameInfo(DTN->getIdentifier(), 2777 Arg.getTemplateNameLoc()); 2778 2779 CXXScopeSpec SS; 2780 SS.Adopt(Arg.getTemplateQualifierLoc()); 2781 // FIXME: the template-template arg was a DependentTemplateName, 2782 // so it was provided with a template keyword. However, its source 2783 // location is not stored in the template argument structure. 2784 SourceLocation TemplateKWLoc; 2785 ExprResult E = Owned(DependentScopeDeclRefExpr::Create(Context, 2786 SS.getWithLocInContext(Context), 2787 TemplateKWLoc, 2788 NameInfo, 0)); 2789 2790 // If we parsed the template argument as a pack expansion, create a 2791 // pack expansion expression. 2792 if (Arg.getArgument().getKind() == TemplateArgument::TemplateExpansion){ 2793 E = ActOnPackExpansion(E.take(), Arg.getTemplateEllipsisLoc()); 2794 if (E.isInvalid()) 2795 return true; 2796 } 2797 2798 TemplateArgument Result; 2799 E = CheckTemplateArgument(NTTP, NTTPType, E.take(), Result); 2800 if (E.isInvalid()) 2801 return true; 2802 2803 Converted.push_back(Result); 2804 break; 2805 } 2806 2807 // We have a template argument that actually does refer to a class 2808 // template, alias template, or template template parameter, and 2809 // therefore cannot be a non-type template argument. 2810 Diag(Arg.getLocation(), diag::err_template_arg_must_be_expr) 2811 << Arg.getSourceRange(); 2812 2813 Diag(Param->getLocation(), diag::note_template_param_here); 2814 return true; 2815 2816 case TemplateArgument::Type: { 2817 // We have a non-type template parameter but the template 2818 // argument is a type. 2819 2820 // C++ [temp.arg]p2: 2821 // In a template-argument, an ambiguity between a type-id and 2822 // an expression is resolved to a type-id, regardless of the 2823 // form of the corresponding template-parameter. 2824 // 2825 // We warn specifically about this case, since it can be rather 2826 // confusing for users. 2827 QualType T = Arg.getArgument().getAsType(); 2828 SourceRange SR = Arg.getSourceRange(); 2829 if (T->isFunctionType()) 2830 Diag(SR.getBegin(), diag::err_template_arg_nontype_ambig) << SR << T; 2831 else 2832 Diag(SR.getBegin(), diag::err_template_arg_must_be_expr) << SR; 2833 Diag(Param->getLocation(), diag::note_template_param_here); 2834 return true; 2835 } 2836 2837 case TemplateArgument::Pack: 2838 llvm_unreachable("Caller must expand template argument packs"); 2839 } 2840 2841 return false; 2842 } 2843 2844 2845 // Check template template parameters. 2846 TemplateTemplateParmDecl *TempParm = cast<TemplateTemplateParmDecl>(Param); 2847 2848 // Substitute into the template parameter list of the template 2849 // template parameter, since previously-supplied template arguments 2850 // may appear within the template template parameter. 2851 { 2852 // Set up a template instantiation context. 2853 LocalInstantiationScope Scope(*this); 2854 InstantiatingTemplate Inst(*this, TemplateLoc, Template, 2855 TempParm, Converted.data(), Converted.size(), 2856 SourceRange(TemplateLoc, RAngleLoc)); 2857 2858 TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, 2859 Converted.data(), Converted.size()); 2860 TempParm = cast_or_null<TemplateTemplateParmDecl>( 2861 SubstDecl(TempParm, CurContext, 2862 MultiLevelTemplateArgumentList(TemplateArgs))); 2863 if (!TempParm) 2864 return true; 2865 } 2866 2867 switch (Arg.getArgument().getKind()) { 2868 case TemplateArgument::Null: 2869 llvm_unreachable("Should never see a NULL template argument here"); 2870 2871 case TemplateArgument::Template: 2872 case TemplateArgument::TemplateExpansion: 2873 if (CheckTemplateArgument(TempParm, Arg)) 2874 return true; 2875 2876 Converted.push_back(Arg.getArgument()); 2877 break; 2878 2879 case TemplateArgument::Expression: 2880 case TemplateArgument::Type: 2881 // We have a template template parameter but the template 2882 // argument does not refer to a template. 2883 Diag(Arg.getLocation(), diag::err_template_arg_must_be_template) 2884 << getLangOpts().CPlusPlus0x; 2885 return true; 2886 2887 case TemplateArgument::Declaration: 2888 llvm_unreachable("Declaration argument with template template parameter"); 2889 case TemplateArgument::Integral: 2890 llvm_unreachable("Integral argument with template template parameter"); 2891 2892 case TemplateArgument::Pack: 2893 llvm_unreachable("Caller must expand template argument packs"); 2894 } 2895 2896 return false; 2897} 2898 2899/// \brief Diagnose an arity mismatch in the 2900static bool diagnoseArityMismatch(Sema &S, TemplateDecl *Template, 2901 SourceLocation TemplateLoc, 2902 TemplateArgumentListInfo &TemplateArgs) { 2903 TemplateParameterList *Params = Template->getTemplateParameters(); 2904 unsigned NumParams = Params->size(); 2905 unsigned NumArgs = TemplateArgs.size(); 2906 2907 SourceRange Range; 2908 if (NumArgs > NumParams) 2909 Range = SourceRange(TemplateArgs[NumParams].getLocation(), 2910 TemplateArgs.getRAngleLoc()); 2911 S.Diag(TemplateLoc, diag::err_template_arg_list_different_arity) 2912 << (NumArgs > NumParams) 2913 << (isa<ClassTemplateDecl>(Template)? 0 : 2914 isa<FunctionTemplateDecl>(Template)? 1 : 2915 isa<TemplateTemplateParmDecl>(Template)? 2 : 3) 2916 << Template << Range; 2917 S.Diag(Template->getLocation(), diag::note_template_decl_here) 2918 << Params->getSourceRange(); 2919 return true; 2920} 2921 2922/// \brief Check that the given template argument list is well-formed 2923/// for specializing the given template. 2924bool Sema::CheckTemplateArgumentList(TemplateDecl *Template, 2925 SourceLocation TemplateLoc, 2926 TemplateArgumentListInfo &TemplateArgs, 2927 bool PartialTemplateArgs, 2928 SmallVectorImpl<TemplateArgument> &Converted, 2929 bool *ExpansionIntoFixedList) { 2930 if (ExpansionIntoFixedList) 2931 *ExpansionIntoFixedList = false; 2932 2933 TemplateParameterList *Params = Template->getTemplateParameters(); 2934 unsigned NumParams = Params->size(); 2935 unsigned NumArgs = TemplateArgs.size(); 2936 bool Invalid = false; 2937 2938 SourceLocation RAngleLoc = TemplateArgs.getRAngleLoc(); 2939 2940 bool HasParameterPack = 2941 NumParams > 0 && Params->getParam(NumParams - 1)->isTemplateParameterPack(); 2942 2943 // C++ [temp.arg]p1: 2944 // [...] The type and form of each template-argument specified in 2945 // a template-id shall match the type and form specified for the 2946 // corresponding parameter declared by the template in its 2947 // template-parameter-list. 2948 bool isTemplateTemplateParameter = isa<TemplateTemplateParmDecl>(Template); 2949 SmallVector<TemplateArgument, 2> ArgumentPack; 2950 TemplateParameterList::iterator Param = Params->begin(), 2951 ParamEnd = Params->end(); 2952 unsigned ArgIdx = 0; 2953 LocalInstantiationScope InstScope(*this, true); 2954 bool SawPackExpansion = false; 2955 while (Param != ParamEnd) { 2956 if (ArgIdx < NumArgs) { 2957 // If we have an expanded parameter pack, make sure we don't have too 2958 // many arguments. 2959 // FIXME: This really should fall out from the normal arity checking. 2960 if (NonTypeTemplateParmDecl *NTTP 2961 = dyn_cast<NonTypeTemplateParmDecl>(*Param)) { 2962 if (NTTP->isExpandedParameterPack() && 2963 ArgumentPack.size() >= NTTP->getNumExpansionTypes()) { 2964 Diag(TemplateLoc, diag::err_template_arg_list_different_arity) 2965 << true 2966 << (isa<ClassTemplateDecl>(Template)? 0 : 2967 isa<FunctionTemplateDecl>(Template)? 1 : 2968 isa<TemplateTemplateParmDecl>(Template)? 2 : 3) 2969 << Template; 2970 Diag(Template->getLocation(), diag::note_template_decl_here) 2971 << Params->getSourceRange(); 2972 return true; 2973 } 2974 } 2975 2976 // Check the template argument we were given. 2977 if (CheckTemplateArgument(*Param, TemplateArgs[ArgIdx], Template, 2978 TemplateLoc, RAngleLoc, 2979 ArgumentPack.size(), Converted)) 2980 return true; 2981 2982 if ((*Param)->isTemplateParameterPack()) { 2983 // The template parameter was a template parameter pack, so take the 2984 // deduced argument and place it on the argument pack. Note that we 2985 // stay on the same template parameter so that we can deduce more 2986 // arguments. 2987 ArgumentPack.push_back(Converted.back()); 2988 Converted.pop_back(); 2989 } else { 2990 // Move to the next template parameter. 2991 ++Param; 2992 } 2993 2994 // If this template argument is a pack expansion, record that fact 2995 // and break out; we can't actually check any more. 2996 if (TemplateArgs[ArgIdx].getArgument().isPackExpansion()) { 2997 SawPackExpansion = true; 2998 ++ArgIdx; 2999 break; 3000 } 3001 3002 ++ArgIdx; 3003 continue; 3004 } 3005 3006 // If we're checking a partial template argument list, we're done. 3007 if (PartialTemplateArgs) { 3008 if ((*Param)->isTemplateParameterPack() && !ArgumentPack.empty()) 3009 Converted.push_back(TemplateArgument::CreatePackCopy(Context, 3010 ArgumentPack.data(), 3011 ArgumentPack.size())); 3012 3013 return Invalid; 3014 } 3015 3016 // If we have a template parameter pack with no more corresponding 3017 // arguments, just break out now and we'll fill in the argument pack below. 3018 if ((*Param)->isTemplateParameterPack()) 3019 break; 3020 3021 // Check whether we have a default argument. 3022 TemplateArgumentLoc Arg; 3023 3024 // Retrieve the default template argument from the template 3025 // parameter. For each kind of template parameter, we substitute the 3026 // template arguments provided thus far and any "outer" template arguments 3027 // (when the template parameter was part of a nested template) into 3028 // the default argument. 3029 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*Param)) { 3030 if (!TTP->hasDefaultArgument()) 3031 return diagnoseArityMismatch(*this, Template, TemplateLoc, 3032 TemplateArgs); 3033 3034 TypeSourceInfo *ArgType = SubstDefaultTemplateArgument(*this, 3035 Template, 3036 TemplateLoc, 3037 RAngleLoc, 3038 TTP, 3039 Converted); 3040 if (!ArgType) 3041 return true; 3042 3043 Arg = TemplateArgumentLoc(TemplateArgument(ArgType->getType()), 3044 ArgType); 3045 } else if (NonTypeTemplateParmDecl *NTTP 3046 = dyn_cast<NonTypeTemplateParmDecl>(*Param)) { 3047 if (!NTTP->hasDefaultArgument()) 3048 return diagnoseArityMismatch(*this, Template, TemplateLoc, 3049 TemplateArgs); 3050 3051 ExprResult E = SubstDefaultTemplateArgument(*this, Template, 3052 TemplateLoc, 3053 RAngleLoc, 3054 NTTP, 3055 Converted); 3056 if (E.isInvalid()) 3057 return true; 3058 3059 Expr *Ex = E.takeAs<Expr>(); 3060 Arg = TemplateArgumentLoc(TemplateArgument(Ex), Ex); 3061 } else { 3062 TemplateTemplateParmDecl *TempParm 3063 = cast<TemplateTemplateParmDecl>(*Param); 3064 3065 if (!TempParm->hasDefaultArgument()) 3066 return diagnoseArityMismatch(*this, Template, TemplateLoc, 3067 TemplateArgs); 3068 3069 NestedNameSpecifierLoc QualifierLoc; 3070 TemplateName Name = SubstDefaultTemplateArgument(*this, Template, 3071 TemplateLoc, 3072 RAngleLoc, 3073 TempParm, 3074 Converted, 3075 QualifierLoc); 3076 if (Name.isNull()) 3077 return true; 3078 3079 Arg = TemplateArgumentLoc(TemplateArgument(Name), QualifierLoc, 3080 TempParm->getDefaultArgument().getTemplateNameLoc()); 3081 } 3082 3083 // Introduce an instantiation record that describes where we are using 3084 // the default template argument. 3085 InstantiatingTemplate Instantiating(*this, RAngleLoc, Template, *Param, 3086 Converted.data(), Converted.size(), 3087 SourceRange(TemplateLoc, RAngleLoc)); 3088 3089 // Check the default template argument. 3090 if (CheckTemplateArgument(*Param, Arg, Template, TemplateLoc, 3091 RAngleLoc, 0, Converted)) 3092 return true; 3093 3094 // Core issue 150 (assumed resolution): if this is a template template 3095 // parameter, keep track of the default template arguments from the 3096 // template definition. 3097 if (isTemplateTemplateParameter) 3098 TemplateArgs.addArgument(Arg); 3099 3100 // Move to the next template parameter and argument. 3101 ++Param; 3102 ++ArgIdx; 3103 } 3104 3105 // If we saw a pack expansion, then directly convert the remaining arguments, 3106 // because we don't know what parameters they'll match up with. 3107 if (SawPackExpansion) { 3108 bool AddToArgumentPack 3109 = Param != ParamEnd && (*Param)->isTemplateParameterPack(); 3110 while (ArgIdx < NumArgs) { 3111 if (AddToArgumentPack) 3112 ArgumentPack.push_back(TemplateArgs[ArgIdx].getArgument()); 3113 else 3114 Converted.push_back(TemplateArgs[ArgIdx].getArgument()); 3115 ++ArgIdx; 3116 } 3117 3118 // Push the argument pack onto the list of converted arguments. 3119 if (AddToArgumentPack) { 3120 if (ArgumentPack.empty()) 3121 Converted.push_back(TemplateArgument(0, 0)); 3122 else { 3123 Converted.push_back( 3124 TemplateArgument::CreatePackCopy(Context, 3125 ArgumentPack.data(), 3126 ArgumentPack.size())); 3127 ArgumentPack.clear(); 3128 } 3129 } else if (ExpansionIntoFixedList) { 3130 // We have expanded a pack into a fixed list. 3131 *ExpansionIntoFixedList = true; 3132 } 3133 3134 return Invalid; 3135 } 3136 3137 // If we have any leftover arguments, then there were too many arguments. 3138 // Complain and fail. 3139 if (ArgIdx < NumArgs) 3140 return diagnoseArityMismatch(*this, Template, TemplateLoc, TemplateArgs); 3141 3142 // If we have an expanded parameter pack, make sure we don't have too 3143 // many arguments. 3144 // FIXME: This really should fall out from the normal arity checking. 3145 if (Param != ParamEnd) { 3146 if (NonTypeTemplateParmDecl *NTTP 3147 = dyn_cast<NonTypeTemplateParmDecl>(*Param)) { 3148 if (NTTP->isExpandedParameterPack() && 3149 ArgumentPack.size() < NTTP->getNumExpansionTypes()) { 3150 Diag(TemplateLoc, diag::err_template_arg_list_different_arity) 3151 << false 3152 << (isa<ClassTemplateDecl>(Template)? 0 : 3153 isa<FunctionTemplateDecl>(Template)? 1 : 3154 isa<TemplateTemplateParmDecl>(Template)? 2 : 3) 3155 << Template; 3156 Diag(Template->getLocation(), diag::note_template_decl_here) 3157 << Params->getSourceRange(); 3158 return true; 3159 } 3160 } 3161 } 3162 3163 // Form argument packs for each of the parameter packs remaining. 3164 while (Param != ParamEnd) { 3165 // If we're checking a partial list of template arguments, don't fill 3166 // in arguments for non-template parameter packs. 3167 if ((*Param)->isTemplateParameterPack()) { 3168 if (!HasParameterPack) 3169 return true; 3170 if (ArgumentPack.empty()) 3171 Converted.push_back(TemplateArgument(0, 0)); 3172 else { 3173 Converted.push_back(TemplateArgument::CreatePackCopy(Context, 3174 ArgumentPack.data(), 3175 ArgumentPack.size())); 3176 ArgumentPack.clear(); 3177 } 3178 } else if (!PartialTemplateArgs) 3179 return diagnoseArityMismatch(*this, Template, TemplateLoc, TemplateArgs); 3180 3181 ++Param; 3182 } 3183 3184 return Invalid; 3185} 3186 3187namespace { 3188 class UnnamedLocalNoLinkageFinder 3189 : public TypeVisitor<UnnamedLocalNoLinkageFinder, bool> 3190 { 3191 Sema &S; 3192 SourceRange SR; 3193 3194 typedef TypeVisitor<UnnamedLocalNoLinkageFinder, bool> inherited; 3195 3196 public: 3197 UnnamedLocalNoLinkageFinder(Sema &S, SourceRange SR) : S(S), SR(SR) { } 3198 3199 bool Visit(QualType T) { 3200 return inherited::Visit(T.getTypePtr()); 3201 } 3202 3203#define TYPE(Class, Parent) \ 3204 bool Visit##Class##Type(const Class##Type *); 3205#define ABSTRACT_TYPE(Class, Parent) \ 3206 bool Visit##Class##Type(const Class##Type *) { return false; } 3207#define NON_CANONICAL_TYPE(Class, Parent) \ 3208 bool Visit##Class##Type(const Class##Type *) { return false; } 3209#include "clang/AST/TypeNodes.def" 3210 3211 bool VisitTagDecl(const TagDecl *Tag); 3212 bool VisitNestedNameSpecifier(NestedNameSpecifier *NNS); 3213 }; 3214} 3215 3216bool UnnamedLocalNoLinkageFinder::VisitBuiltinType(const BuiltinType*) { 3217 return false; 3218} 3219 3220bool UnnamedLocalNoLinkageFinder::VisitComplexType(const ComplexType* T) { 3221 return Visit(T->getElementType()); 3222} 3223 3224bool UnnamedLocalNoLinkageFinder::VisitPointerType(const PointerType* T) { 3225 return Visit(T->getPointeeType()); 3226} 3227 3228bool UnnamedLocalNoLinkageFinder::VisitBlockPointerType( 3229 const BlockPointerType* T) { 3230 return Visit(T->getPointeeType()); 3231} 3232 3233bool UnnamedLocalNoLinkageFinder::VisitLValueReferenceType( 3234 const LValueReferenceType* T) { 3235 return Visit(T->getPointeeType()); 3236} 3237 3238bool UnnamedLocalNoLinkageFinder::VisitRValueReferenceType( 3239 const RValueReferenceType* T) { 3240 return Visit(T->getPointeeType()); 3241} 3242 3243bool UnnamedLocalNoLinkageFinder::VisitMemberPointerType( 3244 const MemberPointerType* T) { 3245 return Visit(T->getPointeeType()) || Visit(QualType(T->getClass(), 0)); 3246} 3247 3248bool UnnamedLocalNoLinkageFinder::VisitConstantArrayType( 3249 const ConstantArrayType* T) { 3250 return Visit(T->getElementType()); 3251} 3252 3253bool UnnamedLocalNoLinkageFinder::VisitIncompleteArrayType( 3254 const IncompleteArrayType* T) { 3255 return Visit(T->getElementType()); 3256} 3257 3258bool UnnamedLocalNoLinkageFinder::VisitVariableArrayType( 3259 const VariableArrayType* T) { 3260 return Visit(T->getElementType()); 3261} 3262 3263bool UnnamedLocalNoLinkageFinder::VisitDependentSizedArrayType( 3264 const DependentSizedArrayType* T) { 3265 return Visit(T->getElementType()); 3266} 3267 3268bool UnnamedLocalNoLinkageFinder::VisitDependentSizedExtVectorType( 3269 const DependentSizedExtVectorType* T) { 3270 return Visit(T->getElementType()); 3271} 3272 3273bool UnnamedLocalNoLinkageFinder::VisitVectorType(const VectorType* T) { 3274 return Visit(T->getElementType()); 3275} 3276 3277bool UnnamedLocalNoLinkageFinder::VisitExtVectorType(const ExtVectorType* T) { 3278 return Visit(T->getElementType()); 3279} 3280 3281bool UnnamedLocalNoLinkageFinder::VisitFunctionProtoType( 3282 const FunctionProtoType* T) { 3283 for (FunctionProtoType::arg_type_iterator A = T->arg_type_begin(), 3284 AEnd = T->arg_type_end(); 3285 A != AEnd; ++A) { 3286 if (Visit(*A)) 3287 return true; 3288 } 3289 3290 return Visit(T->getResultType()); 3291} 3292 3293bool UnnamedLocalNoLinkageFinder::VisitFunctionNoProtoType( 3294 const FunctionNoProtoType* T) { 3295 return Visit(T->getResultType()); 3296} 3297 3298bool UnnamedLocalNoLinkageFinder::VisitUnresolvedUsingType( 3299 const UnresolvedUsingType*) { 3300 return false; 3301} 3302 3303bool UnnamedLocalNoLinkageFinder::VisitTypeOfExprType(const TypeOfExprType*) { 3304 return false; 3305} 3306 3307bool UnnamedLocalNoLinkageFinder::VisitTypeOfType(const TypeOfType* T) { 3308 return Visit(T->getUnderlyingType()); 3309} 3310 3311bool UnnamedLocalNoLinkageFinder::VisitDecltypeType(const DecltypeType*) { 3312 return false; 3313} 3314 3315bool UnnamedLocalNoLinkageFinder::VisitUnaryTransformType( 3316 const UnaryTransformType*) { 3317 return false; 3318} 3319 3320bool UnnamedLocalNoLinkageFinder::VisitAutoType(const AutoType *T) { 3321 return Visit(T->getDeducedType()); 3322} 3323 3324bool UnnamedLocalNoLinkageFinder::VisitRecordType(const RecordType* T) { 3325 return VisitTagDecl(T->getDecl()); 3326} 3327 3328bool UnnamedLocalNoLinkageFinder::VisitEnumType(const EnumType* T) { 3329 return VisitTagDecl(T->getDecl()); 3330} 3331 3332bool UnnamedLocalNoLinkageFinder::VisitTemplateTypeParmType( 3333 const TemplateTypeParmType*) { 3334 return false; 3335} 3336 3337bool UnnamedLocalNoLinkageFinder::VisitSubstTemplateTypeParmPackType( 3338 const SubstTemplateTypeParmPackType *) { 3339 return false; 3340} 3341 3342bool UnnamedLocalNoLinkageFinder::VisitTemplateSpecializationType( 3343 const TemplateSpecializationType*) { 3344 return false; 3345} 3346 3347bool UnnamedLocalNoLinkageFinder::VisitInjectedClassNameType( 3348 const InjectedClassNameType* T) { 3349 return VisitTagDecl(T->getDecl()); 3350} 3351 3352bool UnnamedLocalNoLinkageFinder::VisitDependentNameType( 3353 const DependentNameType* T) { 3354 return VisitNestedNameSpecifier(T->getQualifier()); 3355} 3356 3357bool UnnamedLocalNoLinkageFinder::VisitDependentTemplateSpecializationType( 3358 const DependentTemplateSpecializationType* T) { 3359 return VisitNestedNameSpecifier(T->getQualifier()); 3360} 3361 3362bool UnnamedLocalNoLinkageFinder::VisitPackExpansionType( 3363 const PackExpansionType* T) { 3364 return Visit(T->getPattern()); 3365} 3366 3367bool UnnamedLocalNoLinkageFinder::VisitObjCObjectType(const ObjCObjectType *) { 3368 return false; 3369} 3370 3371bool UnnamedLocalNoLinkageFinder::VisitObjCInterfaceType( 3372 const ObjCInterfaceType *) { 3373 return false; 3374} 3375 3376bool UnnamedLocalNoLinkageFinder::VisitObjCObjectPointerType( 3377 const ObjCObjectPointerType *) { 3378 return false; 3379} 3380 3381bool UnnamedLocalNoLinkageFinder::VisitAtomicType(const AtomicType* T) { 3382 return Visit(T->getValueType()); 3383} 3384 3385bool UnnamedLocalNoLinkageFinder::VisitTagDecl(const TagDecl *Tag) { 3386 if (Tag->getDeclContext()->isFunctionOrMethod()) { 3387 S.Diag(SR.getBegin(), 3388 S.getLangOpts().CPlusPlus0x ? 3389 diag::warn_cxx98_compat_template_arg_local_type : 3390 diag::ext_template_arg_local_type) 3391 << S.Context.getTypeDeclType(Tag) << SR; 3392 return true; 3393 } 3394 3395 if (!Tag->getDeclName() && !Tag->getTypedefNameForAnonDecl()) { 3396 S.Diag(SR.getBegin(), 3397 S.getLangOpts().CPlusPlus0x ? 3398 diag::warn_cxx98_compat_template_arg_unnamed_type : 3399 diag::ext_template_arg_unnamed_type) << SR; 3400 S.Diag(Tag->getLocation(), diag::note_template_unnamed_type_here); 3401 return true; 3402 } 3403 3404 return false; 3405} 3406 3407bool UnnamedLocalNoLinkageFinder::VisitNestedNameSpecifier( 3408 NestedNameSpecifier *NNS) { 3409 if (NNS->getPrefix() && VisitNestedNameSpecifier(NNS->getPrefix())) 3410 return true; 3411 3412 switch (NNS->getKind()) { 3413 case NestedNameSpecifier::Identifier: 3414 case NestedNameSpecifier::Namespace: 3415 case NestedNameSpecifier::NamespaceAlias: 3416 case NestedNameSpecifier::Global: 3417 return false; 3418 3419 case NestedNameSpecifier::TypeSpec: 3420 case NestedNameSpecifier::TypeSpecWithTemplate: 3421 return Visit(QualType(NNS->getAsType(), 0)); 3422 } 3423 llvm_unreachable("Invalid NestedNameSpecifier::Kind!"); 3424} 3425 3426 3427/// \brief Check a template argument against its corresponding 3428/// template type parameter. 3429/// 3430/// This routine implements the semantics of C++ [temp.arg.type]. It 3431/// returns true if an error occurred, and false otherwise. 3432bool Sema::CheckTemplateArgument(TemplateTypeParmDecl *Param, 3433 TypeSourceInfo *ArgInfo) { 3434 assert(ArgInfo && "invalid TypeSourceInfo"); 3435 QualType Arg = ArgInfo->getType(); 3436 SourceRange SR = ArgInfo->getTypeLoc().getSourceRange(); 3437 3438 if (Arg->isVariablyModifiedType()) { 3439 return Diag(SR.getBegin(), diag::err_variably_modified_template_arg) << Arg; 3440 } else if (Context.hasSameUnqualifiedType(Arg, Context.OverloadTy)) { 3441 return Diag(SR.getBegin(), diag::err_template_arg_overload_type) << SR; 3442 } 3443 3444 // C++03 [temp.arg.type]p2: 3445 // A local type, a type with no linkage, an unnamed type or a type 3446 // compounded from any of these types shall not be used as a 3447 // template-argument for a template type-parameter. 3448 // 3449 // C++11 allows these, and even in C++03 we allow them as an extension with 3450 // a warning. 3451 if (LangOpts.CPlusPlus0x ? 3452 Diags.getDiagnosticLevel(diag::warn_cxx98_compat_template_arg_unnamed_type, 3453 SR.getBegin()) != DiagnosticsEngine::Ignored || 3454 Diags.getDiagnosticLevel(diag::warn_cxx98_compat_template_arg_local_type, 3455 SR.getBegin()) != DiagnosticsEngine::Ignored : 3456 Arg->hasUnnamedOrLocalType()) { 3457 UnnamedLocalNoLinkageFinder Finder(*this, SR); 3458 (void)Finder.Visit(Context.getCanonicalType(Arg)); 3459 } 3460 3461 return false; 3462} 3463 3464enum NullPointerValueKind { 3465 NPV_NotNullPointer, 3466 NPV_NullPointer, 3467 NPV_Error 3468}; 3469 3470/// \brief Determine whether the given template argument is a null pointer 3471/// value of the appropriate type. 3472static NullPointerValueKind 3473isNullPointerValueTemplateArgument(Sema &S, NonTypeTemplateParmDecl *Param, 3474 QualType ParamType, Expr *Arg) { 3475 if (Arg->isValueDependent() || Arg->isTypeDependent()) 3476 return NPV_NotNullPointer; 3477 3478 if (!S.getLangOpts().CPlusPlus0x) 3479 return NPV_NotNullPointer; 3480 3481 // Determine whether we have a constant expression. 3482 Expr::EvalResult EvalResult; 3483 if (!Arg->EvaluateAsRValue(EvalResult, S.Context) || 3484 EvalResult.HasSideEffects) 3485 return NPV_NotNullPointer; 3486 3487 // C++11 [temp.arg.nontype]p1: 3488 // - an address constant expression of type std::nullptr_t 3489 if (Arg->getType()->isNullPtrType()) 3490 return NPV_NullPointer; 3491 3492 // - a constant expression that evaluates to a null pointer value (4.10); or 3493 // - a constant expression that evaluates to a null member pointer value 3494 // (4.11); or 3495 if ((EvalResult.Val.isLValue() && !EvalResult.Val.getLValueBase()) || 3496 (EvalResult.Val.isMemberPointer() && 3497 !EvalResult.Val.getMemberPointerDecl())) { 3498 // If our expression has an appropriate type, we've succeeded. 3499 bool ObjCLifetimeConversion; 3500 if (S.Context.hasSameUnqualifiedType(Arg->getType(), ParamType) || 3501 S.IsQualificationConversion(Arg->getType(), ParamType, false, 3502 ObjCLifetimeConversion)) 3503 return NPV_NullPointer; 3504 3505 // The types didn't match, but we know we got a null pointer; complain, 3506 // then recover as if the types were correct. 3507 S.Diag(Arg->getExprLoc(), diag::err_template_arg_wrongtype_null_constant) 3508 << Arg->getType() << ParamType << Arg->getSourceRange(); 3509 S.Diag(Param->getLocation(), diag::note_template_param_here); 3510 return NPV_NullPointer; 3511 } 3512 3513 // If we don't have a null pointer value, but we do have a NULL pointer 3514 // constant, suggest a cast to the appropriate type. 3515 if (Arg->isNullPointerConstant(S.Context, Expr::NPC_NeverValueDependent)) { 3516 std::string Code = "static_cast<" + ParamType.getAsString() + ">("; 3517 S.Diag(Arg->getExprLoc(), diag::err_template_arg_untyped_null_constant) 3518 << ParamType 3519 << FixItHint::CreateInsertion(Arg->getLocStart(), Code) 3520 << FixItHint::CreateInsertion(S.PP.getLocForEndOfToken(Arg->getLocEnd()), 3521 ")"); 3522 S.Diag(Param->getLocation(), diag::note_template_param_here); 3523 return NPV_NullPointer; 3524 } 3525 3526 // FIXME: If we ever want to support general, address-constant expressions 3527 // as non-type template arguments, we should return the ExprResult here to 3528 // be interpreted by the caller. 3529 return NPV_NotNullPointer; 3530} 3531 3532/// \brief Checks whether the given template argument is the address 3533/// of an object or function according to C++ [temp.arg.nontype]p1. 3534static bool 3535CheckTemplateArgumentAddressOfObjectOrFunction(Sema &S, 3536 NonTypeTemplateParmDecl *Param, 3537 QualType ParamType, 3538 Expr *ArgIn, 3539 TemplateArgument &Converted) { 3540 bool Invalid = false; 3541 Expr *Arg = ArgIn; 3542 QualType ArgType = Arg->getType(); 3543 3544 // If our parameter has pointer type, check for a null template value. 3545 if (ParamType->isPointerType() || ParamType->isNullPtrType()) { 3546 switch (isNullPointerValueTemplateArgument(S, Param, ParamType, Arg)) { 3547 case NPV_NullPointer: 3548 Converted = TemplateArgument((Decl *)0); 3549 return false; 3550 3551 case NPV_Error: 3552 return true; 3553 3554 case NPV_NotNullPointer: 3555 break; 3556 } 3557 } 3558 3559 // See through any implicit casts we added to fix the type. 3560 Arg = Arg->IgnoreImpCasts(); 3561 3562 // C++ [temp.arg.nontype]p1: 3563 // 3564 // A template-argument for a non-type, non-template 3565 // template-parameter shall be one of: [...] 3566 // 3567 // -- the address of an object or function with external 3568 // linkage, including function templates and function 3569 // template-ids but excluding non-static class members, 3570 // expressed as & id-expression where the & is optional if 3571 // the name refers to a function or array, or if the 3572 // corresponding template-parameter is a reference; or 3573 3574 // In C++98/03 mode, give an extension warning on any extra parentheses. 3575 // See http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#773 3576 bool ExtraParens = false; 3577 while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) { 3578 if (!Invalid && !ExtraParens) { 3579 S.Diag(Arg->getLocStart(), 3580 S.getLangOpts().CPlusPlus0x ? 3581 diag::warn_cxx98_compat_template_arg_extra_parens : 3582 diag::ext_template_arg_extra_parens) 3583 << Arg->getSourceRange(); 3584 ExtraParens = true; 3585 } 3586 3587 Arg = Parens->getSubExpr(); 3588 } 3589 3590 while (SubstNonTypeTemplateParmExpr *subst = 3591 dyn_cast<SubstNonTypeTemplateParmExpr>(Arg)) 3592 Arg = subst->getReplacement()->IgnoreImpCasts(); 3593 3594 bool AddressTaken = false; 3595 SourceLocation AddrOpLoc; 3596 if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) { 3597 if (UnOp->getOpcode() == UO_AddrOf) { 3598 Arg = UnOp->getSubExpr(); 3599 AddressTaken = true; 3600 AddrOpLoc = UnOp->getOperatorLoc(); 3601 } 3602 } 3603 3604 if (S.getLangOpts().MicrosoftExt && isa<CXXUuidofExpr>(Arg)) { 3605 Converted = TemplateArgument(ArgIn); 3606 return false; 3607 } 3608 3609 while (SubstNonTypeTemplateParmExpr *subst = 3610 dyn_cast<SubstNonTypeTemplateParmExpr>(Arg)) 3611 Arg = subst->getReplacement()->IgnoreImpCasts(); 3612 3613 // Stop checking the precise nature of the argument if it is value dependent, 3614 // it should be checked when instantiated. 3615 if (Arg->isValueDependent()) { 3616 Converted = TemplateArgument(ArgIn); 3617 return false; 3618 } 3619 3620 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arg); 3621 if (!DRE) { 3622 S.Diag(Arg->getLocStart(), diag::err_template_arg_not_decl_ref) 3623 << Arg->getSourceRange(); 3624 S.Diag(Param->getLocation(), diag::note_template_param_here); 3625 return true; 3626 } 3627 3628 if (!isa<ValueDecl>(DRE->getDecl())) { 3629 S.Diag(Arg->getLocStart(), 3630 diag::err_template_arg_not_object_or_func_form) 3631 << Arg->getSourceRange(); 3632 S.Diag(Param->getLocation(), diag::note_template_param_here); 3633 return true; 3634 } 3635 3636 NamedDecl *Entity = DRE->getDecl(); 3637 3638 // Cannot refer to non-static data members 3639 if (FieldDecl *Field = dyn_cast<FieldDecl>(Entity)) { 3640 S.Diag(Arg->getLocStart(), diag::err_template_arg_field) 3641 << Field << Arg->getSourceRange(); 3642 S.Diag(Param->getLocation(), diag::note_template_param_here); 3643 return true; 3644 } 3645 3646 // Cannot refer to non-static member functions 3647 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Entity)) { 3648 if (!Method->isStatic()) { 3649 S.Diag(Arg->getLocStart(), diag::err_template_arg_method) 3650 << Method << Arg->getSourceRange(); 3651 S.Diag(Param->getLocation(), diag::note_template_param_here); 3652 return true; 3653 } 3654 } 3655 3656 FunctionDecl *Func = dyn_cast<FunctionDecl>(Entity); 3657 VarDecl *Var = dyn_cast<VarDecl>(Entity); 3658 3659 // A non-type template argument must refer to an object or function. 3660 if (!Func && !Var) { 3661 // We found something, but we don't know specifically what it is. 3662 S.Diag(Arg->getLocStart(), diag::err_template_arg_not_object_or_func) 3663 << Arg->getSourceRange(); 3664 S.Diag(DRE->getDecl()->getLocation(), diag::note_template_arg_refers_here); 3665 return true; 3666 } 3667 3668 // Address / reference template args must have external linkage in C++98. 3669 if (Entity->getLinkage() == InternalLinkage) { 3670 S.Diag(Arg->getLocStart(), S.getLangOpts().CPlusPlus0x ? 3671 diag::warn_cxx98_compat_template_arg_object_internal : 3672 diag::ext_template_arg_object_internal) 3673 << !Func << Entity << Arg->getSourceRange(); 3674 S.Diag(Entity->getLocation(), diag::note_template_arg_internal_object) 3675 << !Func; 3676 } else if (Entity->getLinkage() == NoLinkage) { 3677 S.Diag(Arg->getLocStart(), diag::err_template_arg_object_no_linkage) 3678 << !Func << Entity << Arg->getSourceRange(); 3679 S.Diag(Entity->getLocation(), diag::note_template_arg_internal_object) 3680 << !Func; 3681 return true; 3682 } 3683 3684 if (Func) { 3685 // If the template parameter has pointer type, the function decays. 3686 if (ParamType->isPointerType() && !AddressTaken) 3687 ArgType = S.Context.getPointerType(Func->getType()); 3688 else if (AddressTaken && ParamType->isReferenceType()) { 3689 // If we originally had an address-of operator, but the 3690 // parameter has reference type, complain and (if things look 3691 // like they will work) drop the address-of operator. 3692 if (!S.Context.hasSameUnqualifiedType(Func->getType(), 3693 ParamType.getNonReferenceType())) { 3694 S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer) 3695 << ParamType; 3696 S.Diag(Param->getLocation(), diag::note_template_param_here); 3697 return true; 3698 } 3699 3700 S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer) 3701 << ParamType 3702 << FixItHint::CreateRemoval(AddrOpLoc); 3703 S.Diag(Param->getLocation(), diag::note_template_param_here); 3704 3705 ArgType = Func->getType(); 3706 } 3707 } else { 3708 // A value of reference type is not an object. 3709 if (Var->getType()->isReferenceType()) { 3710 S.Diag(Arg->getLocStart(), 3711 diag::err_template_arg_reference_var) 3712 << Var->getType() << Arg->getSourceRange(); 3713 S.Diag(Param->getLocation(), diag::note_template_param_here); 3714 return true; 3715 } 3716 3717 // A template argument must have static storage duration. 3718 // FIXME: Ensure this works for thread_local as well as __thread. 3719 if (Var->isThreadSpecified()) { 3720 S.Diag(Arg->getLocStart(), diag::err_template_arg_thread_local) 3721 << Arg->getSourceRange(); 3722 S.Diag(Var->getLocation(), diag::note_template_arg_refers_here); 3723 return true; 3724 } 3725 3726 // If the template parameter has pointer type, we must have taken 3727 // the address of this object. 3728 if (ParamType->isReferenceType()) { 3729 if (AddressTaken) { 3730 // If we originally had an address-of operator, but the 3731 // parameter has reference type, complain and (if things look 3732 // like they will work) drop the address-of operator. 3733 if (!S.Context.hasSameUnqualifiedType(Var->getType(), 3734 ParamType.getNonReferenceType())) { 3735 S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer) 3736 << ParamType; 3737 S.Diag(Param->getLocation(), diag::note_template_param_here); 3738 return true; 3739 } 3740 3741 S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer) 3742 << ParamType 3743 << FixItHint::CreateRemoval(AddrOpLoc); 3744 S.Diag(Param->getLocation(), diag::note_template_param_here); 3745 3746 ArgType = Var->getType(); 3747 } 3748 } else if (!AddressTaken && ParamType->isPointerType()) { 3749 if (Var->getType()->isArrayType()) { 3750 // Array-to-pointer decay. 3751 ArgType = S.Context.getArrayDecayedType(Var->getType()); 3752 } else { 3753 // If the template parameter has pointer type but the address of 3754 // this object was not taken, complain and (possibly) recover by 3755 // taking the address of the entity. 3756 ArgType = S.Context.getPointerType(Var->getType()); 3757 if (!S.Context.hasSameUnqualifiedType(ArgType, ParamType)) { 3758 S.Diag(Arg->getLocStart(), diag::err_template_arg_not_address_of) 3759 << ParamType; 3760 S.Diag(Param->getLocation(), diag::note_template_param_here); 3761 return true; 3762 } 3763 3764 S.Diag(Arg->getLocStart(), diag::err_template_arg_not_address_of) 3765 << ParamType 3766 << FixItHint::CreateInsertion(Arg->getLocStart(), "&"); 3767 3768 S.Diag(Param->getLocation(), diag::note_template_param_here); 3769 } 3770 } 3771 } 3772 3773 bool ObjCLifetimeConversion; 3774 if (ParamType->isPointerType() && 3775 !ParamType->getAs<PointerType>()->getPointeeType()->isFunctionType() && 3776 S.IsQualificationConversion(ArgType, ParamType, false, 3777 ObjCLifetimeConversion)) { 3778 // For pointer-to-object types, qualification conversions are 3779 // permitted. 3780 } else { 3781 if (const ReferenceType *ParamRef = ParamType->getAs<ReferenceType>()) { 3782 if (!ParamRef->getPointeeType()->isFunctionType()) { 3783 // C++ [temp.arg.nontype]p5b3: 3784 // For a non-type template-parameter of type reference to 3785 // object, no conversions apply. The type referred to by the 3786 // reference may be more cv-qualified than the (otherwise 3787 // identical) type of the template- argument. The 3788 // template-parameter is bound directly to the 3789 // template-argument, which shall be an lvalue. 3790 3791 // FIXME: Other qualifiers? 3792 unsigned ParamQuals = ParamRef->getPointeeType().getCVRQualifiers(); 3793 unsigned ArgQuals = ArgType.getCVRQualifiers(); 3794 3795 if ((ParamQuals | ArgQuals) != ParamQuals) { 3796 S.Diag(Arg->getLocStart(), 3797 diag::err_template_arg_ref_bind_ignores_quals) 3798 << ParamType << Arg->getType() 3799 << Arg->getSourceRange(); 3800 S.Diag(Param->getLocation(), diag::note_template_param_here); 3801 return true; 3802 } 3803 } 3804 } 3805 3806 // At this point, the template argument refers to an object or 3807 // function with external linkage. We now need to check whether the 3808 // argument and parameter types are compatible. 3809 if (!S.Context.hasSameUnqualifiedType(ArgType, 3810 ParamType.getNonReferenceType())) { 3811 // We can't perform this conversion or binding. 3812 if (ParamType->isReferenceType()) 3813 S.Diag(Arg->getLocStart(), diag::err_template_arg_no_ref_bind) 3814 << ParamType << ArgIn->getType() << Arg->getSourceRange(); 3815 else 3816 S.Diag(Arg->getLocStart(), diag::err_template_arg_not_convertible) 3817 << ArgIn->getType() << ParamType << Arg->getSourceRange(); 3818 S.Diag(Param->getLocation(), diag::note_template_param_here); 3819 return true; 3820 } 3821 } 3822 3823 // Create the template argument. 3824 Converted = TemplateArgument(Entity->getCanonicalDecl()); 3825 S.MarkAnyDeclReferenced(Arg->getLocStart(), Entity); 3826 return false; 3827} 3828 3829/// \brief Checks whether the given template argument is a pointer to 3830/// member constant according to C++ [temp.arg.nontype]p1. 3831static bool CheckTemplateArgumentPointerToMember(Sema &S, 3832 NonTypeTemplateParmDecl *Param, 3833 QualType ParamType, 3834 Expr *&ResultArg, 3835 TemplateArgument &Converted) { 3836 bool Invalid = false; 3837 3838 // Check for a null pointer value. 3839 Expr *Arg = ResultArg; 3840 switch (isNullPointerValueTemplateArgument(S, Param, ParamType, Arg)) { 3841 case NPV_Error: 3842 return true; 3843 case NPV_NullPointer: 3844 Converted = TemplateArgument((Decl *)0); 3845 return false; 3846 case NPV_NotNullPointer: 3847 break; 3848 } 3849 3850 bool ObjCLifetimeConversion; 3851 if (S.IsQualificationConversion(Arg->getType(), 3852 ParamType.getNonReferenceType(), 3853 false, ObjCLifetimeConversion)) { 3854 Arg = S.ImpCastExprToType(Arg, ParamType, CK_NoOp, 3855 Arg->getValueKind()).take(); 3856 ResultArg = Arg; 3857 } else if (!S.Context.hasSameUnqualifiedType(Arg->getType(), 3858 ParamType.getNonReferenceType())) { 3859 // We can't perform this conversion. 3860 S.Diag(Arg->getLocStart(), diag::err_template_arg_not_convertible) 3861 << Arg->getType() << ParamType << Arg->getSourceRange(); 3862 S.Diag(Param->getLocation(), diag::note_template_param_here); 3863 return true; 3864 } 3865 3866 // See through any implicit casts we added to fix the type. 3867 while (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(Arg)) 3868 Arg = Cast->getSubExpr(); 3869 3870 // C++ [temp.arg.nontype]p1: 3871 // 3872 // A template-argument for a non-type, non-template 3873 // template-parameter shall be one of: [...] 3874 // 3875 // -- a pointer to member expressed as described in 5.3.1. 3876 DeclRefExpr *DRE = 0; 3877 3878 // In C++98/03 mode, give an extension warning on any extra parentheses. 3879 // See http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#773 3880 bool ExtraParens = false; 3881 while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) { 3882 if (!Invalid && !ExtraParens) { 3883 S.Diag(Arg->getLocStart(), 3884 S.getLangOpts().CPlusPlus0x ? 3885 diag::warn_cxx98_compat_template_arg_extra_parens : 3886 diag::ext_template_arg_extra_parens) 3887 << Arg->getSourceRange(); 3888 ExtraParens = true; 3889 } 3890 3891 Arg = Parens->getSubExpr(); 3892 } 3893 3894 while (SubstNonTypeTemplateParmExpr *subst = 3895 dyn_cast<SubstNonTypeTemplateParmExpr>(Arg)) 3896 Arg = subst->getReplacement()->IgnoreImpCasts(); 3897 3898 // A pointer-to-member constant written &Class::member. 3899 if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) { 3900 if (UnOp->getOpcode() == UO_AddrOf) { 3901 DRE = dyn_cast<DeclRefExpr>(UnOp->getSubExpr()); 3902 if (DRE && !DRE->getQualifier()) 3903 DRE = 0; 3904 } 3905 } 3906 // A constant of pointer-to-member type. 3907 else if ((DRE = dyn_cast<DeclRefExpr>(Arg))) { 3908 if (ValueDecl *VD = dyn_cast<ValueDecl>(DRE->getDecl())) { 3909 if (VD->getType()->isMemberPointerType()) { 3910 if (isa<NonTypeTemplateParmDecl>(VD) || 3911 (isa<VarDecl>(VD) && 3912 S.Context.getCanonicalType(VD->getType()).isConstQualified())) { 3913 if (Arg->isTypeDependent() || Arg->isValueDependent()) 3914 Converted = TemplateArgument(Arg); 3915 else 3916 Converted = TemplateArgument(VD->getCanonicalDecl()); 3917 return Invalid; 3918 } 3919 } 3920 } 3921 3922 DRE = 0; 3923 } 3924 3925 if (!DRE) 3926 return S.Diag(Arg->getLocStart(), 3927 diag::err_template_arg_not_pointer_to_member_form) 3928 << Arg->getSourceRange(); 3929 3930 if (isa<FieldDecl>(DRE->getDecl()) || isa<CXXMethodDecl>(DRE->getDecl())) { 3931 assert((isa<FieldDecl>(DRE->getDecl()) || 3932 !cast<CXXMethodDecl>(DRE->getDecl())->isStatic()) && 3933 "Only non-static member pointers can make it here"); 3934 3935 // Okay: this is the address of a non-static member, and therefore 3936 // a member pointer constant. 3937 if (Arg->isTypeDependent() || Arg->isValueDependent()) 3938 Converted = TemplateArgument(Arg); 3939 else 3940 Converted = TemplateArgument(DRE->getDecl()->getCanonicalDecl()); 3941 return Invalid; 3942 } 3943 3944 // We found something else, but we don't know specifically what it is. 3945 S.Diag(Arg->getLocStart(), 3946 diag::err_template_arg_not_pointer_to_member_form) 3947 << Arg->getSourceRange(); 3948 S.Diag(DRE->getDecl()->getLocation(), diag::note_template_arg_refers_here); 3949 return true; 3950} 3951 3952/// \brief Check a template argument against its corresponding 3953/// non-type template parameter. 3954/// 3955/// This routine implements the semantics of C++ [temp.arg.nontype]. 3956/// If an error occurred, it returns ExprError(); otherwise, it 3957/// returns the converted template argument. \p 3958/// InstantiatedParamType is the type of the non-type template 3959/// parameter after it has been instantiated. 3960ExprResult Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param, 3961 QualType InstantiatedParamType, Expr *Arg, 3962 TemplateArgument &Converted, 3963 CheckTemplateArgumentKind CTAK) { 3964 SourceLocation StartLoc = Arg->getLocStart(); 3965 3966 // If either the parameter has a dependent type or the argument is 3967 // type-dependent, there's nothing we can check now. 3968 if (InstantiatedParamType->isDependentType() || Arg->isTypeDependent()) { 3969 // FIXME: Produce a cloned, canonical expression? 3970 Converted = TemplateArgument(Arg); 3971 return Owned(Arg); 3972 } 3973 3974 // C++ [temp.arg.nontype]p5: 3975 // The following conversions are performed on each expression used 3976 // as a non-type template-argument. If a non-type 3977 // template-argument cannot be converted to the type of the 3978 // corresponding template-parameter then the program is 3979 // ill-formed. 3980 QualType ParamType = InstantiatedParamType; 3981 if (ParamType->isIntegralOrEnumerationType()) { 3982 // C++11: 3983 // -- for a non-type template-parameter of integral or 3984 // enumeration type, conversions permitted in a converted 3985 // constant expression are applied. 3986 // 3987 // C++98: 3988 // -- for a non-type template-parameter of integral or 3989 // enumeration type, integral promotions (4.5) and integral 3990 // conversions (4.7) are applied. 3991 3992 if (CTAK == CTAK_Deduced && 3993 !Context.hasSameUnqualifiedType(ParamType, Arg->getType())) { 3994 // C++ [temp.deduct.type]p17: 3995 // If, in the declaration of a function template with a non-type 3996 // template-parameter, the non-type template-parameter is used 3997 // in an expression in the function parameter-list and, if the 3998 // corresponding template-argument is deduced, the 3999 // template-argument type shall match the type of the 4000 // template-parameter exactly, except that a template-argument 4001 // deduced from an array bound may be of any integral type. 4002 Diag(StartLoc, diag::err_deduced_non_type_template_arg_type_mismatch) 4003 << Arg->getType().getUnqualifiedType() 4004 << ParamType.getUnqualifiedType(); 4005 Diag(Param->getLocation(), diag::note_template_param_here); 4006 return ExprError(); 4007 } 4008 4009 if (getLangOpts().CPlusPlus0x) { 4010 // We can't check arbitrary value-dependent arguments. 4011 // FIXME: If there's no viable conversion to the template parameter type, 4012 // we should be able to diagnose that prior to instantiation. 4013 if (Arg->isValueDependent()) { 4014 Converted = TemplateArgument(Arg); 4015 return Owned(Arg); 4016 } 4017 4018 // C++ [temp.arg.nontype]p1: 4019 // A template-argument for a non-type, non-template template-parameter 4020 // shall be one of: 4021 // 4022 // -- for a non-type template-parameter of integral or enumeration 4023 // type, a converted constant expression of the type of the 4024 // template-parameter; or 4025 llvm::APSInt Value; 4026 ExprResult ArgResult = 4027 CheckConvertedConstantExpression(Arg, ParamType, Value, 4028 CCEK_TemplateArg); 4029 if (ArgResult.isInvalid()) 4030 return ExprError(); 4031 4032 // Widen the argument value to sizeof(parameter type). This is almost 4033 // always a no-op, except when the parameter type is bool. In 4034 // that case, this may extend the argument from 1 bit to 8 bits. 4035 QualType IntegerType = ParamType; 4036 if (const EnumType *Enum = IntegerType->getAs<EnumType>()) 4037 IntegerType = Enum->getDecl()->getIntegerType(); 4038 Value = Value.extOrTrunc(Context.getTypeSize(IntegerType)); 4039 4040 Converted = TemplateArgument(Value, Context.getCanonicalType(ParamType)); 4041 return ArgResult; 4042 } 4043 4044 ExprResult ArgResult = DefaultLvalueConversion(Arg); 4045 if (ArgResult.isInvalid()) 4046 return ExprError(); 4047 Arg = ArgResult.take(); 4048 4049 QualType ArgType = Arg->getType(); 4050 4051 // C++ [temp.arg.nontype]p1: 4052 // A template-argument for a non-type, non-template 4053 // template-parameter shall be one of: 4054 // 4055 // -- an integral constant-expression of integral or enumeration 4056 // type; or 4057 // -- the name of a non-type template-parameter; or 4058 SourceLocation NonConstantLoc; 4059 llvm::APSInt Value; 4060 if (!ArgType->isIntegralOrEnumerationType()) { 4061 Diag(Arg->getLocStart(), 4062 diag::err_template_arg_not_integral_or_enumeral) 4063 << ArgType << Arg->getSourceRange(); 4064 Diag(Param->getLocation(), diag::note_template_param_here); 4065 return ExprError(); 4066 } else if (!Arg->isValueDependent()) { 4067 Arg = VerifyIntegerConstantExpression(Arg, &Value, 4068 PDiag(diag::err_template_arg_not_ice) << ArgType, false).take(); 4069 if (!Arg) 4070 return ExprError(); 4071 } 4072 4073 // From here on out, all we care about are the unqualified forms 4074 // of the parameter and argument types. 4075 ParamType = ParamType.getUnqualifiedType(); 4076 ArgType = ArgType.getUnqualifiedType(); 4077 4078 // Try to convert the argument to the parameter's type. 4079 if (Context.hasSameType(ParamType, ArgType)) { 4080 // Okay: no conversion necessary 4081 } else if (ParamType->isBooleanType()) { 4082 // This is an integral-to-boolean conversion. 4083 Arg = ImpCastExprToType(Arg, ParamType, CK_IntegralToBoolean).take(); 4084 } else if (IsIntegralPromotion(Arg, ArgType, ParamType) || 4085 !ParamType->isEnumeralType()) { 4086 // This is an integral promotion or conversion. 4087 Arg = ImpCastExprToType(Arg, ParamType, CK_IntegralCast).take(); 4088 } else { 4089 // We can't perform this conversion. 4090 Diag(Arg->getLocStart(), 4091 diag::err_template_arg_not_convertible) 4092 << Arg->getType() << InstantiatedParamType << Arg->getSourceRange(); 4093 Diag(Param->getLocation(), diag::note_template_param_here); 4094 return ExprError(); 4095 } 4096 4097 // Add the value of this argument to the list of converted 4098 // arguments. We use the bitwidth and signedness of the template 4099 // parameter. 4100 if (Arg->isValueDependent()) { 4101 // The argument is value-dependent. Create a new 4102 // TemplateArgument with the converted expression. 4103 Converted = TemplateArgument(Arg); 4104 return Owned(Arg); 4105 } 4106 4107 QualType IntegerType = Context.getCanonicalType(ParamType); 4108 if (const EnumType *Enum = IntegerType->getAs<EnumType>()) 4109 IntegerType = Context.getCanonicalType(Enum->getDecl()->getIntegerType()); 4110 4111 if (ParamType->isBooleanType()) { 4112 // Value must be zero or one. 4113 Value = Value != 0; 4114 unsigned AllowedBits = Context.getTypeSize(IntegerType); 4115 if (Value.getBitWidth() != AllowedBits) 4116 Value = Value.extOrTrunc(AllowedBits); 4117 Value.setIsSigned(IntegerType->isSignedIntegerOrEnumerationType()); 4118 } else { 4119 llvm::APSInt OldValue = Value; 4120 4121 // Coerce the template argument's value to the value it will have 4122 // based on the template parameter's type. 4123 unsigned AllowedBits = Context.getTypeSize(IntegerType); 4124 if (Value.getBitWidth() != AllowedBits) 4125 Value = Value.extOrTrunc(AllowedBits); 4126 Value.setIsSigned(IntegerType->isSignedIntegerOrEnumerationType()); 4127 4128 // Complain if an unsigned parameter received a negative value. 4129 if (IntegerType->isUnsignedIntegerOrEnumerationType() 4130 && (OldValue.isSigned() && OldValue.isNegative())) { 4131 Diag(Arg->getLocStart(), diag::warn_template_arg_negative) 4132 << OldValue.toString(10) << Value.toString(10) << Param->getType() 4133 << Arg->getSourceRange(); 4134 Diag(Param->getLocation(), diag::note_template_param_here); 4135 } 4136 4137 // Complain if we overflowed the template parameter's type. 4138 unsigned RequiredBits; 4139 if (IntegerType->isUnsignedIntegerOrEnumerationType()) 4140 RequiredBits = OldValue.getActiveBits(); 4141 else if (OldValue.isUnsigned()) 4142 RequiredBits = OldValue.getActiveBits() + 1; 4143 else 4144 RequiredBits = OldValue.getMinSignedBits(); 4145 if (RequiredBits > AllowedBits) { 4146 Diag(Arg->getLocStart(), 4147 diag::warn_template_arg_too_large) 4148 << OldValue.toString(10) << Value.toString(10) << Param->getType() 4149 << Arg->getSourceRange(); 4150 Diag(Param->getLocation(), diag::note_template_param_here); 4151 } 4152 } 4153 4154 Converted = TemplateArgument(Value, 4155 ParamType->isEnumeralType() 4156 ? Context.getCanonicalType(ParamType) 4157 : IntegerType); 4158 return Owned(Arg); 4159 } 4160 4161 QualType ArgType = Arg->getType(); 4162 DeclAccessPair FoundResult; // temporary for ResolveOverloadedFunction 4163 4164 // Handle pointer-to-function, reference-to-function, and 4165 // pointer-to-member-function all in (roughly) the same way. 4166 if (// -- For a non-type template-parameter of type pointer to 4167 // function, only the function-to-pointer conversion (4.3) is 4168 // applied. If the template-argument represents a set of 4169 // overloaded functions (or a pointer to such), the matching 4170 // function is selected from the set (13.4). 4171 (ParamType->isPointerType() && 4172 ParamType->getAs<PointerType>()->getPointeeType()->isFunctionType()) || 4173 // -- For a non-type template-parameter of type reference to 4174 // function, no conversions apply. If the template-argument 4175 // represents a set of overloaded functions, the matching 4176 // function is selected from the set (13.4). 4177 (ParamType->isReferenceType() && 4178 ParamType->getAs<ReferenceType>()->getPointeeType()->isFunctionType()) || 4179 // -- For a non-type template-parameter of type pointer to 4180 // member function, no conversions apply. If the 4181 // template-argument represents a set of overloaded member 4182 // functions, the matching member function is selected from 4183 // the set (13.4). 4184 (ParamType->isMemberPointerType() && 4185 ParamType->getAs<MemberPointerType>()->getPointeeType() 4186 ->isFunctionType())) { 4187 4188 if (Arg->getType() == Context.OverloadTy) { 4189 if (FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Arg, ParamType, 4190 true, 4191 FoundResult)) { 4192 if (DiagnoseUseOfDecl(Fn, Arg->getLocStart())) 4193 return ExprError(); 4194 4195 Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn); 4196 ArgType = Arg->getType(); 4197 } else 4198 return ExprError(); 4199 } 4200 4201 if (!ParamType->isMemberPointerType()) { 4202 if (CheckTemplateArgumentAddressOfObjectOrFunction(*this, Param, 4203 ParamType, 4204 Arg, Converted)) 4205 return ExprError(); 4206 return Owned(Arg); 4207 } 4208 4209 if (CheckTemplateArgumentPointerToMember(*this, Param, ParamType, Arg, 4210 Converted)) 4211 return ExprError(); 4212 return Owned(Arg); 4213 } 4214 4215 if (ParamType->isPointerType()) { 4216 // -- for a non-type template-parameter of type pointer to 4217 // object, qualification conversions (4.4) and the 4218 // array-to-pointer conversion (4.2) are applied. 4219 // C++0x also allows a value of std::nullptr_t. 4220 assert(ParamType->getPointeeType()->isIncompleteOrObjectType() && 4221 "Only object pointers allowed here"); 4222 4223 if (CheckTemplateArgumentAddressOfObjectOrFunction(*this, Param, 4224 ParamType, 4225 Arg, Converted)) 4226 return ExprError(); 4227 return Owned(Arg); 4228 } 4229 4230 if (const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>()) { 4231 // -- For a non-type template-parameter of type reference to 4232 // object, no conversions apply. The type referred to by the 4233 // reference may be more cv-qualified than the (otherwise 4234 // identical) type of the template-argument. The 4235 // template-parameter is bound directly to the 4236 // template-argument, which must be an lvalue. 4237 assert(ParamRefType->getPointeeType()->isIncompleteOrObjectType() && 4238 "Only object references allowed here"); 4239 4240 if (Arg->getType() == Context.OverloadTy) { 4241 if (FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Arg, 4242 ParamRefType->getPointeeType(), 4243 true, 4244 FoundResult)) { 4245 if (DiagnoseUseOfDecl(Fn, Arg->getLocStart())) 4246 return ExprError(); 4247 4248 Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn); 4249 ArgType = Arg->getType(); 4250 } else 4251 return ExprError(); 4252 } 4253 4254 if (CheckTemplateArgumentAddressOfObjectOrFunction(*this, Param, 4255 ParamType, 4256 Arg, Converted)) 4257 return ExprError(); 4258 return Owned(Arg); 4259 } 4260 4261 // Deal with parameters of type std::nullptr_t. 4262 if (ParamType->isNullPtrType()) { 4263 if (Arg->isTypeDependent() || Arg->isValueDependent()) { 4264 Converted = TemplateArgument(Arg); 4265 return Owned(Arg); 4266 } 4267 4268 switch (isNullPointerValueTemplateArgument(*this, Param, ParamType, Arg)) { 4269 case NPV_NotNullPointer: 4270 Diag(Arg->getExprLoc(), diag::err_template_arg_not_convertible) 4271 << Arg->getType() << ParamType; 4272 Diag(Param->getLocation(), diag::note_template_param_here); 4273 return ExprError(); 4274 4275 case NPV_Error: 4276 return ExprError(); 4277 4278 case NPV_NullPointer: 4279 Converted = TemplateArgument((Decl *)0); 4280 return Owned(Arg);; 4281 } 4282 } 4283 4284 // -- For a non-type template-parameter of type pointer to data 4285 // member, qualification conversions (4.4) are applied. 4286 assert(ParamType->isMemberPointerType() && "Only pointers to members remain"); 4287 4288 if (CheckTemplateArgumentPointerToMember(*this, Param, ParamType, Arg, 4289 Converted)) 4290 return ExprError(); 4291 return Owned(Arg); 4292} 4293 4294/// \brief Check a template argument against its corresponding 4295/// template template parameter. 4296/// 4297/// This routine implements the semantics of C++ [temp.arg.template]. 4298/// It returns true if an error occurred, and false otherwise. 4299bool Sema::CheckTemplateArgument(TemplateTemplateParmDecl *Param, 4300 const TemplateArgumentLoc &Arg) { 4301 TemplateName Name = Arg.getArgument().getAsTemplate(); 4302 TemplateDecl *Template = Name.getAsTemplateDecl(); 4303 if (!Template) { 4304 // Any dependent template name is fine. 4305 assert(Name.isDependent() && "Non-dependent template isn't a declaration?"); 4306 return false; 4307 } 4308 4309 // C++0x [temp.arg.template]p1: 4310 // A template-argument for a template template-parameter shall be 4311 // the name of a class template or an alias template, expressed as an 4312 // id-expression. When the template-argument names a class template, only 4313 // primary class templates are considered when matching the 4314 // template template argument with the corresponding parameter; 4315 // partial specializations are not considered even if their 4316 // parameter lists match that of the template template parameter. 4317 // 4318 // Note that we also allow template template parameters here, which 4319 // will happen when we are dealing with, e.g., class template 4320 // partial specializations. 4321 if (!isa<ClassTemplateDecl>(Template) && 4322 !isa<TemplateTemplateParmDecl>(Template) && 4323 !isa<TypeAliasTemplateDecl>(Template)) { 4324 assert(isa<FunctionTemplateDecl>(Template) && 4325 "Only function templates are possible here"); 4326 Diag(Arg.getLocation(), diag::err_template_arg_not_class_template); 4327 Diag(Template->getLocation(), diag::note_template_arg_refers_here_func) 4328 << Template; 4329 } 4330 4331 return !TemplateParameterListsAreEqual(Template->getTemplateParameters(), 4332 Param->getTemplateParameters(), 4333 true, 4334 TPL_TemplateTemplateArgumentMatch, 4335 Arg.getLocation()); 4336} 4337 4338/// \brief Given a non-type template argument that refers to a 4339/// declaration and the type of its corresponding non-type template 4340/// parameter, produce an expression that properly refers to that 4341/// declaration. 4342ExprResult 4343Sema::BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg, 4344 QualType ParamType, 4345 SourceLocation Loc) { 4346 assert(Arg.getKind() == TemplateArgument::Declaration && 4347 "Only declaration template arguments permitted here"); 4348 4349 // For a NULL non-type template argument, return nullptr casted to the 4350 // parameter's type. 4351 if (!Arg.getAsDecl()) { 4352 return ImpCastExprToType( 4353 new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc), 4354 ParamType, 4355 ParamType->getAs<MemberPointerType>() 4356 ? CK_NullToMemberPointer 4357 : CK_NullToPointer); 4358 } 4359 4360 ValueDecl *VD = cast<ValueDecl>(Arg.getAsDecl()); 4361 4362 if (VD->getDeclContext()->isRecord() && 4363 (isa<CXXMethodDecl>(VD) || isa<FieldDecl>(VD))) { 4364 // If the value is a class member, we might have a pointer-to-member. 4365 // Determine whether the non-type template template parameter is of 4366 // pointer-to-member type. If so, we need to build an appropriate 4367 // expression for a pointer-to-member, since a "normal" DeclRefExpr 4368 // would refer to the member itself. 4369 if (ParamType->isMemberPointerType()) { 4370 QualType ClassType 4371 = Context.getTypeDeclType(cast<RecordDecl>(VD->getDeclContext())); 4372 NestedNameSpecifier *Qualifier 4373 = NestedNameSpecifier::Create(Context, 0, false, 4374 ClassType.getTypePtr()); 4375 CXXScopeSpec SS; 4376 SS.MakeTrivial(Context, Qualifier, Loc); 4377 4378 // The actual value-ness of this is unimportant, but for 4379 // internal consistency's sake, references to instance methods 4380 // are r-values. 4381 ExprValueKind VK = VK_LValue; 4382 if (isa<CXXMethodDecl>(VD) && cast<CXXMethodDecl>(VD)->isInstance()) 4383 VK = VK_RValue; 4384 4385 ExprResult RefExpr = BuildDeclRefExpr(VD, 4386 VD->getType().getNonReferenceType(), 4387 VK, 4388 Loc, 4389 &SS); 4390 if (RefExpr.isInvalid()) 4391 return ExprError(); 4392 4393 RefExpr = CreateBuiltinUnaryOp(Loc, UO_AddrOf, RefExpr.get()); 4394 4395 // We might need to perform a trailing qualification conversion, since 4396 // the element type on the parameter could be more qualified than the 4397 // element type in the expression we constructed. 4398 bool ObjCLifetimeConversion; 4399 if (IsQualificationConversion(((Expr*) RefExpr.get())->getType(), 4400 ParamType.getUnqualifiedType(), false, 4401 ObjCLifetimeConversion)) 4402 RefExpr = ImpCastExprToType(RefExpr.take(), ParamType.getUnqualifiedType(), CK_NoOp); 4403 4404 assert(!RefExpr.isInvalid() && 4405 Context.hasSameType(((Expr*) RefExpr.get())->getType(), 4406 ParamType.getUnqualifiedType())); 4407 return move(RefExpr); 4408 } 4409 } 4410 4411 QualType T = VD->getType().getNonReferenceType(); 4412 if (ParamType->isPointerType()) { 4413 // When the non-type template parameter is a pointer, take the 4414 // address of the declaration. 4415 ExprResult RefExpr = BuildDeclRefExpr(VD, T, VK_LValue, Loc); 4416 if (RefExpr.isInvalid()) 4417 return ExprError(); 4418 4419 if (T->isFunctionType() || T->isArrayType()) { 4420 // Decay functions and arrays. 4421 RefExpr = DefaultFunctionArrayConversion(RefExpr.take()); 4422 if (RefExpr.isInvalid()) 4423 return ExprError(); 4424 4425 return move(RefExpr); 4426 } 4427 4428 // Take the address of everything else 4429 return CreateBuiltinUnaryOp(Loc, UO_AddrOf, RefExpr.get()); 4430 } 4431 4432 ExprValueKind VK = VK_RValue; 4433 4434 // If the non-type template parameter has reference type, qualify the 4435 // resulting declaration reference with the extra qualifiers on the 4436 // type that the reference refers to. 4437 if (const ReferenceType *TargetRef = ParamType->getAs<ReferenceType>()) { 4438 VK = VK_LValue; 4439 T = Context.getQualifiedType(T, 4440 TargetRef->getPointeeType().getQualifiers()); 4441 } 4442 4443 return BuildDeclRefExpr(VD, T, VK, Loc); 4444} 4445 4446/// \brief Construct a new expression that refers to the given 4447/// integral template argument with the given source-location 4448/// information. 4449/// 4450/// This routine takes care of the mapping from an integral template 4451/// argument (which may have any integral type) to the appropriate 4452/// literal value. 4453ExprResult 4454Sema::BuildExpressionFromIntegralTemplateArgument(const TemplateArgument &Arg, 4455 SourceLocation Loc) { 4456 assert(Arg.getKind() == TemplateArgument::Integral && 4457 "Operation is only valid for integral template arguments"); 4458 QualType T = Arg.getIntegralType(); 4459 if (T->isAnyCharacterType()) { 4460 CharacterLiteral::CharacterKind Kind; 4461 if (T->isWideCharType()) 4462 Kind = CharacterLiteral::Wide; 4463 else if (T->isChar16Type()) 4464 Kind = CharacterLiteral::UTF16; 4465 else if (T->isChar32Type()) 4466 Kind = CharacterLiteral::UTF32; 4467 else 4468 Kind = CharacterLiteral::Ascii; 4469 4470 return Owned(new (Context) CharacterLiteral( 4471 Arg.getAsIntegral()->getZExtValue(), 4472 Kind, T, Loc)); 4473 } 4474 4475 if (T->isBooleanType()) 4476 return Owned(new (Context) CXXBoolLiteralExpr( 4477 Arg.getAsIntegral()->getBoolValue(), 4478 T, Loc)); 4479 4480 if (T->isNullPtrType()) 4481 return Owned(new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc)); 4482 4483 // If this is an enum type that we're instantiating, we need to use an integer 4484 // type the same size as the enumerator. We don't want to build an 4485 // IntegerLiteral with enum type. 4486 QualType BT; 4487 if (const EnumType *ET = T->getAs<EnumType>()) 4488 BT = ET->getDecl()->getIntegerType(); 4489 else 4490 BT = T; 4491 4492 Expr *E = IntegerLiteral::Create(Context, *Arg.getAsIntegral(), BT, Loc); 4493 if (T->isEnumeralType()) { 4494 // FIXME: This is a hack. We need a better way to handle substituted 4495 // non-type template parameters. 4496 E = CStyleCastExpr::Create(Context, T, VK_RValue, CK_IntegralCast, E, 0, 4497 Context.getTrivialTypeSourceInfo(T, Loc), 4498 Loc, Loc); 4499 } 4500 4501 return Owned(E); 4502} 4503 4504/// \brief Match two template parameters within template parameter lists. 4505static bool MatchTemplateParameterKind(Sema &S, NamedDecl *New, NamedDecl *Old, 4506 bool Complain, 4507 Sema::TemplateParameterListEqualKind Kind, 4508 SourceLocation TemplateArgLoc) { 4509 // Check the actual kind (type, non-type, template). 4510 if (Old->getKind() != New->getKind()) { 4511 if (Complain) { 4512 unsigned NextDiag = diag::err_template_param_different_kind; 4513 if (TemplateArgLoc.isValid()) { 4514 S.Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch); 4515 NextDiag = diag::note_template_param_different_kind; 4516 } 4517 S.Diag(New->getLocation(), NextDiag) 4518 << (Kind != Sema::TPL_TemplateMatch); 4519 S.Diag(Old->getLocation(), diag::note_template_prev_declaration) 4520 << (Kind != Sema::TPL_TemplateMatch); 4521 } 4522 4523 return false; 4524 } 4525 4526 // Check that both are parameter packs are neither are parameter packs. 4527 // However, if we are matching a template template argument to a 4528 // template template parameter, the template template parameter can have 4529 // a parameter pack where the template template argument does not. 4530 if (Old->isTemplateParameterPack() != New->isTemplateParameterPack() && 4531 !(Kind == Sema::TPL_TemplateTemplateArgumentMatch && 4532 Old->isTemplateParameterPack())) { 4533 if (Complain) { 4534 unsigned NextDiag = diag::err_template_parameter_pack_non_pack; 4535 if (TemplateArgLoc.isValid()) { 4536 S.Diag(TemplateArgLoc, 4537 diag::err_template_arg_template_params_mismatch); 4538 NextDiag = diag::note_template_parameter_pack_non_pack; 4539 } 4540 4541 unsigned ParamKind = isa<TemplateTypeParmDecl>(New)? 0 4542 : isa<NonTypeTemplateParmDecl>(New)? 1 4543 : 2; 4544 S.Diag(New->getLocation(), NextDiag) 4545 << ParamKind << New->isParameterPack(); 4546 S.Diag(Old->getLocation(), diag::note_template_parameter_pack_here) 4547 << ParamKind << Old->isParameterPack(); 4548 } 4549 4550 return false; 4551 } 4552 4553 // For non-type template parameters, check the type of the parameter. 4554 if (NonTypeTemplateParmDecl *OldNTTP 4555 = dyn_cast<NonTypeTemplateParmDecl>(Old)) { 4556 NonTypeTemplateParmDecl *NewNTTP = cast<NonTypeTemplateParmDecl>(New); 4557 4558 // If we are matching a template template argument to a template 4559 // template parameter and one of the non-type template parameter types 4560 // is dependent, then we must wait until template instantiation time 4561 // to actually compare the arguments. 4562 if (Kind == Sema::TPL_TemplateTemplateArgumentMatch && 4563 (OldNTTP->getType()->isDependentType() || 4564 NewNTTP->getType()->isDependentType())) 4565 return true; 4566 4567 if (!S.Context.hasSameType(OldNTTP->getType(), NewNTTP->getType())) { 4568 if (Complain) { 4569 unsigned NextDiag = diag::err_template_nontype_parm_different_type; 4570 if (TemplateArgLoc.isValid()) { 4571 S.Diag(TemplateArgLoc, 4572 diag::err_template_arg_template_params_mismatch); 4573 NextDiag = diag::note_template_nontype_parm_different_type; 4574 } 4575 S.Diag(NewNTTP->getLocation(), NextDiag) 4576 << NewNTTP->getType() 4577 << (Kind != Sema::TPL_TemplateMatch); 4578 S.Diag(OldNTTP->getLocation(), 4579 diag::note_template_nontype_parm_prev_declaration) 4580 << OldNTTP->getType(); 4581 } 4582 4583 return false; 4584 } 4585 4586 return true; 4587 } 4588 4589 // For template template parameters, check the template parameter types. 4590 // The template parameter lists of template template 4591 // parameters must agree. 4592 if (TemplateTemplateParmDecl *OldTTP 4593 = dyn_cast<TemplateTemplateParmDecl>(Old)) { 4594 TemplateTemplateParmDecl *NewTTP = cast<TemplateTemplateParmDecl>(New); 4595 return S.TemplateParameterListsAreEqual(NewTTP->getTemplateParameters(), 4596 OldTTP->getTemplateParameters(), 4597 Complain, 4598 (Kind == Sema::TPL_TemplateMatch 4599 ? Sema::TPL_TemplateTemplateParmMatch 4600 : Kind), 4601 TemplateArgLoc); 4602 } 4603 4604 return true; 4605} 4606 4607/// \brief Diagnose a known arity mismatch when comparing template argument 4608/// lists. 4609static 4610void DiagnoseTemplateParameterListArityMismatch(Sema &S, 4611 TemplateParameterList *New, 4612 TemplateParameterList *Old, 4613 Sema::TemplateParameterListEqualKind Kind, 4614 SourceLocation TemplateArgLoc) { 4615 unsigned NextDiag = diag::err_template_param_list_different_arity; 4616 if (TemplateArgLoc.isValid()) { 4617 S.Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch); 4618 NextDiag = diag::note_template_param_list_different_arity; 4619 } 4620 S.Diag(New->getTemplateLoc(), NextDiag) 4621 << (New->size() > Old->size()) 4622 << (Kind != Sema::TPL_TemplateMatch) 4623 << SourceRange(New->getTemplateLoc(), New->getRAngleLoc()); 4624 S.Diag(Old->getTemplateLoc(), diag::note_template_prev_declaration) 4625 << (Kind != Sema::TPL_TemplateMatch) 4626 << SourceRange(Old->getTemplateLoc(), Old->getRAngleLoc()); 4627} 4628 4629/// \brief Determine whether the given template parameter lists are 4630/// equivalent. 4631/// 4632/// \param New The new template parameter list, typically written in the 4633/// source code as part of a new template declaration. 4634/// 4635/// \param Old The old template parameter list, typically found via 4636/// name lookup of the template declared with this template parameter 4637/// list. 4638/// 4639/// \param Complain If true, this routine will produce a diagnostic if 4640/// the template parameter lists are not equivalent. 4641/// 4642/// \param Kind describes how we are to match the template parameter lists. 4643/// 4644/// \param TemplateArgLoc If this source location is valid, then we 4645/// are actually checking the template parameter list of a template 4646/// argument (New) against the template parameter list of its 4647/// corresponding template template parameter (Old). We produce 4648/// slightly different diagnostics in this scenario. 4649/// 4650/// \returns True if the template parameter lists are equal, false 4651/// otherwise. 4652bool 4653Sema::TemplateParameterListsAreEqual(TemplateParameterList *New, 4654 TemplateParameterList *Old, 4655 bool Complain, 4656 TemplateParameterListEqualKind Kind, 4657 SourceLocation TemplateArgLoc) { 4658 if (Old->size() != New->size() && Kind != TPL_TemplateTemplateArgumentMatch) { 4659 if (Complain) 4660 DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind, 4661 TemplateArgLoc); 4662 4663 return false; 4664 } 4665 4666 // C++0x [temp.arg.template]p3: 4667 // A template-argument matches a template template-parameter (call it P) 4668 // when each of the template parameters in the template-parameter-list of 4669 // the template-argument's corresponding class template or alias template 4670 // (call it A) matches the corresponding template parameter in the 4671 // template-parameter-list of P. [...] 4672 TemplateParameterList::iterator NewParm = New->begin(); 4673 TemplateParameterList::iterator NewParmEnd = New->end(); 4674 for (TemplateParameterList::iterator OldParm = Old->begin(), 4675 OldParmEnd = Old->end(); 4676 OldParm != OldParmEnd; ++OldParm) { 4677 if (Kind != TPL_TemplateTemplateArgumentMatch || 4678 !(*OldParm)->isTemplateParameterPack()) { 4679 if (NewParm == NewParmEnd) { 4680 if (Complain) 4681 DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind, 4682 TemplateArgLoc); 4683 4684 return false; 4685 } 4686 4687 if (!MatchTemplateParameterKind(*this, *NewParm, *OldParm, Complain, 4688 Kind, TemplateArgLoc)) 4689 return false; 4690 4691 ++NewParm; 4692 continue; 4693 } 4694 4695 // C++0x [temp.arg.template]p3: 4696 // [...] When P's template- parameter-list contains a template parameter 4697 // pack (14.5.3), the template parameter pack will match zero or more 4698 // template parameters or template parameter packs in the 4699 // template-parameter-list of A with the same type and form as the 4700 // template parameter pack in P (ignoring whether those template 4701 // parameters are template parameter packs). 4702 for (; NewParm != NewParmEnd; ++NewParm) { 4703 if (!MatchTemplateParameterKind(*this, *NewParm, *OldParm, Complain, 4704 Kind, TemplateArgLoc)) 4705 return false; 4706 } 4707 } 4708 4709 // Make sure we exhausted all of the arguments. 4710 if (NewParm != NewParmEnd) { 4711 if (Complain) 4712 DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind, 4713 TemplateArgLoc); 4714 4715 return false; 4716 } 4717 4718 return true; 4719} 4720 4721/// \brief Check whether a template can be declared within this scope. 4722/// 4723/// If the template declaration is valid in this scope, returns 4724/// false. Otherwise, issues a diagnostic and returns true. 4725bool 4726Sema::CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams) { 4727 if (!S) 4728 return false; 4729 4730 // Find the nearest enclosing declaration scope. 4731 while ((S->getFlags() & Scope::DeclScope) == 0 || 4732 (S->getFlags() & Scope::TemplateParamScope) != 0) 4733 S = S->getParent(); 4734 4735 // C++ [temp]p2: 4736 // A template-declaration can appear only as a namespace scope or 4737 // class scope declaration. 4738 DeclContext *Ctx = static_cast<DeclContext *>(S->getEntity()); 4739 if (Ctx && isa<LinkageSpecDecl>(Ctx) && 4740 cast<LinkageSpecDecl>(Ctx)->getLanguage() != LinkageSpecDecl::lang_cxx) 4741 return Diag(TemplateParams->getTemplateLoc(), diag::err_template_linkage) 4742 << TemplateParams->getSourceRange(); 4743 4744 while (Ctx && isa<LinkageSpecDecl>(Ctx)) 4745 Ctx = Ctx->getParent(); 4746 4747 if (Ctx && (Ctx->isFileContext() || Ctx->isRecord())) 4748 return false; 4749 4750 return Diag(TemplateParams->getTemplateLoc(), 4751 diag::err_template_outside_namespace_or_class_scope) 4752 << TemplateParams->getSourceRange(); 4753} 4754 4755/// \brief Determine what kind of template specialization the given declaration 4756/// is. 4757static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D) { 4758 if (!D) 4759 return TSK_Undeclared; 4760 4761 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) 4762 return Record->getTemplateSpecializationKind(); 4763 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) 4764 return Function->getTemplateSpecializationKind(); 4765 if (VarDecl *Var = dyn_cast<VarDecl>(D)) 4766 return Var->getTemplateSpecializationKind(); 4767 4768 return TSK_Undeclared; 4769} 4770 4771/// \brief Check whether a specialization is well-formed in the current 4772/// context. 4773/// 4774/// This routine determines whether a template specialization can be declared 4775/// in the current context (C++ [temp.expl.spec]p2). 4776/// 4777/// \param S the semantic analysis object for which this check is being 4778/// performed. 4779/// 4780/// \param Specialized the entity being specialized or instantiated, which 4781/// may be a kind of template (class template, function template, etc.) or 4782/// a member of a class template (member function, static data member, 4783/// member class). 4784/// 4785/// \param PrevDecl the previous declaration of this entity, if any. 4786/// 4787/// \param Loc the location of the explicit specialization or instantiation of 4788/// this entity. 4789/// 4790/// \param IsPartialSpecialization whether this is a partial specialization of 4791/// a class template. 4792/// 4793/// \returns true if there was an error that we cannot recover from, false 4794/// otherwise. 4795static bool CheckTemplateSpecializationScope(Sema &S, 4796 NamedDecl *Specialized, 4797 NamedDecl *PrevDecl, 4798 SourceLocation Loc, 4799 bool IsPartialSpecialization) { 4800 // Keep these "kind" numbers in sync with the %select statements in the 4801 // various diagnostics emitted by this routine. 4802 int EntityKind = 0; 4803 if (isa<ClassTemplateDecl>(Specialized)) 4804 EntityKind = IsPartialSpecialization? 1 : 0; 4805 else if (isa<FunctionTemplateDecl>(Specialized)) 4806 EntityKind = 2; 4807 else if (isa<CXXMethodDecl>(Specialized)) 4808 EntityKind = 3; 4809 else if (isa<VarDecl>(Specialized)) 4810 EntityKind = 4; 4811 else if (isa<RecordDecl>(Specialized)) 4812 EntityKind = 5; 4813 else if (isa<EnumDecl>(Specialized) && S.getLangOpts().CPlusPlus0x) 4814 EntityKind = 6; 4815 else { 4816 S.Diag(Loc, diag::err_template_spec_unknown_kind) 4817 << S.getLangOpts().CPlusPlus0x; 4818 S.Diag(Specialized->getLocation(), diag::note_specialized_entity); 4819 return true; 4820 } 4821 4822 // C++ [temp.expl.spec]p2: 4823 // An explicit specialization shall be declared in the namespace 4824 // of which the template is a member, or, for member templates, in 4825 // the namespace of which the enclosing class or enclosing class 4826 // template is a member. An explicit specialization of a member 4827 // function, member class or static data member of a class 4828 // template shall be declared in the namespace of which the class 4829 // template is a member. Such a declaration may also be a 4830 // definition. If the declaration is not a definition, the 4831 // specialization may be defined later in the name- space in which 4832 // the explicit specialization was declared, or in a namespace 4833 // that encloses the one in which the explicit specialization was 4834 // declared. 4835 if (S.CurContext->getRedeclContext()->isFunctionOrMethod()) { 4836 S.Diag(Loc, diag::err_template_spec_decl_function_scope) 4837 << Specialized; 4838 return true; 4839 } 4840 4841 if (S.CurContext->isRecord() && !IsPartialSpecialization) { 4842 if (S.getLangOpts().MicrosoftExt) { 4843 // Do not warn for class scope explicit specialization during 4844 // instantiation, warning was already emitted during pattern 4845 // semantic analysis. 4846 if (!S.ActiveTemplateInstantiations.size()) 4847 S.Diag(Loc, diag::ext_function_specialization_in_class) 4848 << Specialized; 4849 } else { 4850 S.Diag(Loc, diag::err_template_spec_decl_class_scope) 4851 << Specialized; 4852 return true; 4853 } 4854 } 4855 4856 if (S.CurContext->isRecord() && 4857 !S.CurContext->Equals(Specialized->getDeclContext())) { 4858 // Make sure that we're specializing in the right record context. 4859 // Otherwise, things can go horribly wrong. 4860 S.Diag(Loc, diag::err_template_spec_decl_class_scope) 4861 << Specialized; 4862 return true; 4863 } 4864 4865 // C++ [temp.class.spec]p6: 4866 // A class template partial specialization may be declared or redeclared 4867 // in any namespace scope in which its definition may be defined (14.5.1 4868 // and 14.5.2). 4869 bool ComplainedAboutScope = false; 4870 DeclContext *SpecializedContext 4871 = Specialized->getDeclContext()->getEnclosingNamespaceContext(); 4872 DeclContext *DC = S.CurContext->getEnclosingNamespaceContext(); 4873 if ((!PrevDecl || 4874 getTemplateSpecializationKind(PrevDecl) == TSK_Undeclared || 4875 getTemplateSpecializationKind(PrevDecl) == TSK_ImplicitInstantiation)){ 4876 // C++ [temp.exp.spec]p2: 4877 // An explicit specialization shall be declared in the namespace of which 4878 // the template is a member, or, for member templates, in the namespace 4879 // of which the enclosing class or enclosing class template is a member. 4880 // An explicit specialization of a member function, member class or 4881 // static data member of a class template shall be declared in the 4882 // namespace of which the class template is a member. 4883 // 4884 // C++0x [temp.expl.spec]p2: 4885 // An explicit specialization shall be declared in a namespace enclosing 4886 // the specialized template. 4887 if (!DC->InEnclosingNamespaceSetOf(SpecializedContext)) { 4888 bool IsCPlusPlus0xExtension = DC->Encloses(SpecializedContext); 4889 if (isa<TranslationUnitDecl>(SpecializedContext)) { 4890 assert(!IsCPlusPlus0xExtension && 4891 "DC encloses TU but isn't in enclosing namespace set"); 4892 S.Diag(Loc, diag::err_template_spec_decl_out_of_scope_global) 4893 << EntityKind << Specialized; 4894 } else if (isa<NamespaceDecl>(SpecializedContext)) { 4895 int Diag; 4896 if (!IsCPlusPlus0xExtension) 4897 Diag = diag::err_template_spec_decl_out_of_scope; 4898 else if (!S.getLangOpts().CPlusPlus0x) 4899 Diag = diag::ext_template_spec_decl_out_of_scope; 4900 else 4901 Diag = diag::warn_cxx98_compat_template_spec_decl_out_of_scope; 4902 S.Diag(Loc, Diag) 4903 << EntityKind << Specialized << cast<NamedDecl>(SpecializedContext); 4904 } 4905 4906 S.Diag(Specialized->getLocation(), diag::note_specialized_entity); 4907 ComplainedAboutScope = 4908 !(IsCPlusPlus0xExtension && S.getLangOpts().CPlusPlus0x); 4909 } 4910 } 4911 4912 // Make sure that this redeclaration (or definition) occurs in an enclosing 4913 // namespace. 4914 // Note that HandleDeclarator() performs this check for explicit 4915 // specializations of function templates, static data members, and member 4916 // functions, so we skip the check here for those kinds of entities. 4917 // FIXME: HandleDeclarator's diagnostics aren't quite as good, though. 4918 // Should we refactor that check, so that it occurs later? 4919 if (!ComplainedAboutScope && !DC->Encloses(SpecializedContext) && 4920 !(isa<FunctionTemplateDecl>(Specialized) || isa<VarDecl>(Specialized) || 4921 isa<FunctionDecl>(Specialized))) { 4922 if (isa<TranslationUnitDecl>(SpecializedContext)) 4923 S.Diag(Loc, diag::err_template_spec_redecl_global_scope) 4924 << EntityKind << Specialized; 4925 else if (isa<NamespaceDecl>(SpecializedContext)) 4926 S.Diag(Loc, diag::err_template_spec_redecl_out_of_scope) 4927 << EntityKind << Specialized 4928 << cast<NamedDecl>(SpecializedContext); 4929 4930 S.Diag(Specialized->getLocation(), diag::note_specialized_entity); 4931 } 4932 4933 // FIXME: check for specialization-after-instantiation errors and such. 4934 4935 return false; 4936} 4937 4938/// \brief Subroutine of Sema::CheckClassTemplatePartialSpecializationArgs 4939/// that checks non-type template partial specialization arguments. 4940static bool CheckNonTypeClassTemplatePartialSpecializationArgs(Sema &S, 4941 NonTypeTemplateParmDecl *Param, 4942 const TemplateArgument *Args, 4943 unsigned NumArgs) { 4944 for (unsigned I = 0; I != NumArgs; ++I) { 4945 if (Args[I].getKind() == TemplateArgument::Pack) { 4946 if (CheckNonTypeClassTemplatePartialSpecializationArgs(S, Param, 4947 Args[I].pack_begin(), 4948 Args[I].pack_size())) 4949 return true; 4950 4951 continue; 4952 } 4953 4954 Expr *ArgExpr = Args[I].getAsExpr(); 4955 if (!ArgExpr) { 4956 continue; 4957 } 4958 4959 // We can have a pack expansion of any of the bullets below. 4960 if (PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(ArgExpr)) 4961 ArgExpr = Expansion->getPattern(); 4962 4963 // Strip off any implicit casts we added as part of type checking. 4964 while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr)) 4965 ArgExpr = ICE->getSubExpr(); 4966 4967 // C++ [temp.class.spec]p8: 4968 // A non-type argument is non-specialized if it is the name of a 4969 // non-type parameter. All other non-type arguments are 4970 // specialized. 4971 // 4972 // Below, we check the two conditions that only apply to 4973 // specialized non-type arguments, so skip any non-specialized 4974 // arguments. 4975 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ArgExpr)) 4976 if (isa<NonTypeTemplateParmDecl>(DRE->getDecl())) 4977 continue; 4978 4979 // C++ [temp.class.spec]p9: 4980 // Within the argument list of a class template partial 4981 // specialization, the following restrictions apply: 4982 // -- A partially specialized non-type argument expression 4983 // shall not involve a template parameter of the partial 4984 // specialization except when the argument expression is a 4985 // simple identifier. 4986 if (ArgExpr->isTypeDependent() || ArgExpr->isValueDependent()) { 4987 S.Diag(ArgExpr->getLocStart(), 4988 diag::err_dependent_non_type_arg_in_partial_spec) 4989 << ArgExpr->getSourceRange(); 4990 return true; 4991 } 4992 4993 // -- The type of a template parameter corresponding to a 4994 // specialized non-type argument shall not be dependent on a 4995 // parameter of the specialization. 4996 if (Param->getType()->isDependentType()) { 4997 S.Diag(ArgExpr->getLocStart(), 4998 diag::err_dependent_typed_non_type_arg_in_partial_spec) 4999 << Param->getType() 5000 << ArgExpr->getSourceRange(); 5001 S.Diag(Param->getLocation(), diag::note_template_param_here); 5002 return true; 5003 } 5004 } 5005 5006 return false; 5007} 5008 5009/// \brief Check the non-type template arguments of a class template 5010/// partial specialization according to C++ [temp.class.spec]p9. 5011/// 5012/// \param TemplateParams the template parameters of the primary class 5013/// template. 5014/// 5015/// \param TemplateArg the template arguments of the class template 5016/// partial specialization. 5017/// 5018/// \returns true if there was an error, false otherwise. 5019static bool CheckClassTemplatePartialSpecializationArgs(Sema &S, 5020 TemplateParameterList *TemplateParams, 5021 SmallVectorImpl<TemplateArgument> &TemplateArgs) { 5022 const TemplateArgument *ArgList = TemplateArgs.data(); 5023 5024 for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) { 5025 NonTypeTemplateParmDecl *Param 5026 = dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->getParam(I)); 5027 if (!Param) 5028 continue; 5029 5030 if (CheckNonTypeClassTemplatePartialSpecializationArgs(S, Param, 5031 &ArgList[I], 1)) 5032 return true; 5033 } 5034 5035 return false; 5036} 5037 5038DeclResult 5039Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, 5040 TagUseKind TUK, 5041 SourceLocation KWLoc, 5042 SourceLocation ModulePrivateLoc, 5043 CXXScopeSpec &SS, 5044 TemplateTy TemplateD, 5045 SourceLocation TemplateNameLoc, 5046 SourceLocation LAngleLoc, 5047 ASTTemplateArgsPtr TemplateArgsIn, 5048 SourceLocation RAngleLoc, 5049 AttributeList *Attr, 5050 MultiTemplateParamsArg TemplateParameterLists) { 5051 assert(TUK != TUK_Reference && "References are not specializations"); 5052 5053 // NOTE: KWLoc is the location of the tag keyword. This will instead 5054 // store the location of the outermost template keyword in the declaration. 5055 SourceLocation TemplateKWLoc = TemplateParameterLists.size() > 0 5056 ? TemplateParameterLists.get()[0]->getTemplateLoc() : SourceLocation(); 5057 5058 // Find the class template we're specializing 5059 TemplateName Name = TemplateD.getAsVal<TemplateName>(); 5060 ClassTemplateDecl *ClassTemplate 5061 = dyn_cast_or_null<ClassTemplateDecl>(Name.getAsTemplateDecl()); 5062 5063 if (!ClassTemplate) { 5064 Diag(TemplateNameLoc, diag::err_not_class_template_specialization) 5065 << (Name.getAsTemplateDecl() && 5066 isa<TemplateTemplateParmDecl>(Name.getAsTemplateDecl())); 5067 return true; 5068 } 5069 5070 bool isExplicitSpecialization = false; 5071 bool isPartialSpecialization = false; 5072 5073 // Check the validity of the template headers that introduce this 5074 // template. 5075 // FIXME: We probably shouldn't complain about these headers for 5076 // friend declarations. 5077 bool Invalid = false; 5078 TemplateParameterList *TemplateParams 5079 = MatchTemplateParametersToScopeSpecifier(TemplateNameLoc, 5080 TemplateNameLoc, 5081 SS, 5082 (TemplateParameterList**)TemplateParameterLists.get(), 5083 TemplateParameterLists.size(), 5084 TUK == TUK_Friend, 5085 isExplicitSpecialization, 5086 Invalid); 5087 if (Invalid) 5088 return true; 5089 5090 if (TemplateParams && TemplateParams->size() > 0) { 5091 isPartialSpecialization = true; 5092 5093 if (TUK == TUK_Friend) { 5094 Diag(KWLoc, diag::err_partial_specialization_friend) 5095 << SourceRange(LAngleLoc, RAngleLoc); 5096 return true; 5097 } 5098 5099 // C++ [temp.class.spec]p10: 5100 // The template parameter list of a specialization shall not 5101 // contain default template argument values. 5102 for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) { 5103 Decl *Param = TemplateParams->getParam(I); 5104 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) { 5105 if (TTP->hasDefaultArgument()) { 5106 Diag(TTP->getDefaultArgumentLoc(), 5107 diag::err_default_arg_in_partial_spec); 5108 TTP->removeDefaultArgument(); 5109 } 5110 } else if (NonTypeTemplateParmDecl *NTTP 5111 = dyn_cast<NonTypeTemplateParmDecl>(Param)) { 5112 if (Expr *DefArg = NTTP->getDefaultArgument()) { 5113 Diag(NTTP->getDefaultArgumentLoc(), 5114 diag::err_default_arg_in_partial_spec) 5115 << DefArg->getSourceRange(); 5116 NTTP->removeDefaultArgument(); 5117 } 5118 } else { 5119 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(Param); 5120 if (TTP->hasDefaultArgument()) { 5121 Diag(TTP->getDefaultArgument().getLocation(), 5122 diag::err_default_arg_in_partial_spec) 5123 << TTP->getDefaultArgument().getSourceRange(); 5124 TTP->removeDefaultArgument(); 5125 } 5126 } 5127 } 5128 } else if (TemplateParams) { 5129 if (TUK == TUK_Friend) 5130 Diag(KWLoc, diag::err_template_spec_friend) 5131 << FixItHint::CreateRemoval( 5132 SourceRange(TemplateParams->getTemplateLoc(), 5133 TemplateParams->getRAngleLoc())) 5134 << SourceRange(LAngleLoc, RAngleLoc); 5135 else 5136 isExplicitSpecialization = true; 5137 } else if (TUK != TUK_Friend) { 5138 Diag(KWLoc, diag::err_template_spec_needs_header) 5139 << FixItHint::CreateInsertion(KWLoc, "template<> "); 5140 isExplicitSpecialization = true; 5141 } 5142 5143 // Check that the specialization uses the same tag kind as the 5144 // original template. 5145 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec); 5146 assert(Kind != TTK_Enum && "Invalid enum tag in class template spec!"); 5147 if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(), 5148 Kind, TUK == TUK_Definition, KWLoc, 5149 *ClassTemplate->getIdentifier())) { 5150 Diag(KWLoc, diag::err_use_with_wrong_tag) 5151 << ClassTemplate 5152 << FixItHint::CreateReplacement(KWLoc, 5153 ClassTemplate->getTemplatedDecl()->getKindName()); 5154 Diag(ClassTemplate->getTemplatedDecl()->getLocation(), 5155 diag::note_previous_use); 5156 Kind = ClassTemplate->getTemplatedDecl()->getTagKind(); 5157 } 5158 5159 // Translate the parser's template argument list in our AST format. 5160 TemplateArgumentListInfo TemplateArgs; 5161 TemplateArgs.setLAngleLoc(LAngleLoc); 5162 TemplateArgs.setRAngleLoc(RAngleLoc); 5163 translateTemplateArguments(TemplateArgsIn, TemplateArgs); 5164 5165 // Check for unexpanded parameter packs in any of the template arguments. 5166 for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I) 5167 if (DiagnoseUnexpandedParameterPack(TemplateArgs[I], 5168 UPPC_PartialSpecialization)) 5169 return true; 5170 5171 // Check that the template argument list is well-formed for this 5172 // template. 5173 SmallVector<TemplateArgument, 4> Converted; 5174 if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc, 5175 TemplateArgs, false, Converted)) 5176 return true; 5177 5178 // Find the class template (partial) specialization declaration that 5179 // corresponds to these arguments. 5180 if (isPartialSpecialization) { 5181 if (CheckClassTemplatePartialSpecializationArgs(*this, 5182 ClassTemplate->getTemplateParameters(), 5183 Converted)) 5184 return true; 5185 5186 bool InstantiationDependent; 5187 if (!Name.isDependent() && 5188 !TemplateSpecializationType::anyDependentTemplateArguments( 5189 TemplateArgs.getArgumentArray(), 5190 TemplateArgs.size(), 5191 InstantiationDependent)) { 5192 Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized) 5193 << ClassTemplate->getDeclName(); 5194 isPartialSpecialization = false; 5195 } 5196 } 5197 5198 void *InsertPos = 0; 5199 ClassTemplateSpecializationDecl *PrevDecl = 0; 5200 5201 if (isPartialSpecialization) 5202 // FIXME: Template parameter list matters, too 5203 PrevDecl 5204 = ClassTemplate->findPartialSpecialization(Converted.data(), 5205 Converted.size(), 5206 InsertPos); 5207 else 5208 PrevDecl 5209 = ClassTemplate->findSpecialization(Converted.data(), 5210 Converted.size(), InsertPos); 5211 5212 ClassTemplateSpecializationDecl *Specialization = 0; 5213 5214 // Check whether we can declare a class template specialization in 5215 // the current scope. 5216 if (TUK != TUK_Friend && 5217 CheckTemplateSpecializationScope(*this, ClassTemplate, PrevDecl, 5218 TemplateNameLoc, 5219 isPartialSpecialization)) 5220 return true; 5221 5222 // The canonical type 5223 QualType CanonType; 5224 if (PrevDecl && 5225 (PrevDecl->getSpecializationKind() == TSK_Undeclared || 5226 TUK == TUK_Friend)) { 5227 // Since the only prior class template specialization with these 5228 // arguments was referenced but not declared, or we're only 5229 // referencing this specialization as a friend, reuse that 5230 // declaration node as our own, updating its source location and 5231 // the list of outer template parameters to reflect our new declaration. 5232 Specialization = PrevDecl; 5233 Specialization->setLocation(TemplateNameLoc); 5234 if (TemplateParameterLists.size() > 0) { 5235 Specialization->setTemplateParameterListsInfo(Context, 5236 TemplateParameterLists.size(), 5237 (TemplateParameterList**) TemplateParameterLists.release()); 5238 } 5239 PrevDecl = 0; 5240 CanonType = Context.getTypeDeclType(Specialization); 5241 } else if (isPartialSpecialization) { 5242 // Build the canonical type that describes the converted template 5243 // arguments of the class template partial specialization. 5244 TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name); 5245 CanonType = Context.getTemplateSpecializationType(CanonTemplate, 5246 Converted.data(), 5247 Converted.size()); 5248 5249 if (Context.hasSameType(CanonType, 5250 ClassTemplate->getInjectedClassNameSpecialization())) { 5251 // C++ [temp.class.spec]p9b3: 5252 // 5253 // -- The argument list of the specialization shall not be identical 5254 // to the implicit argument list of the primary template. 5255 Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template) 5256 << (TUK == TUK_Definition) 5257 << FixItHint::CreateRemoval(SourceRange(LAngleLoc, RAngleLoc)); 5258 return CheckClassTemplate(S, TagSpec, TUK, KWLoc, SS, 5259 ClassTemplate->getIdentifier(), 5260 TemplateNameLoc, 5261 Attr, 5262 TemplateParams, 5263 AS_none, /*ModulePrivateLoc=*/SourceLocation(), 5264 TemplateParameterLists.size() - 1, 5265 (TemplateParameterList**) TemplateParameterLists.release()); 5266 } 5267 5268 // Create a new class template partial specialization declaration node. 5269 ClassTemplatePartialSpecializationDecl *PrevPartial 5270 = cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl); 5271 unsigned SequenceNumber = PrevPartial? PrevPartial->getSequenceNumber() 5272 : ClassTemplate->getNextPartialSpecSequenceNumber(); 5273 ClassTemplatePartialSpecializationDecl *Partial 5274 = ClassTemplatePartialSpecializationDecl::Create(Context, Kind, 5275 ClassTemplate->getDeclContext(), 5276 KWLoc, TemplateNameLoc, 5277 TemplateParams, 5278 ClassTemplate, 5279 Converted.data(), 5280 Converted.size(), 5281 TemplateArgs, 5282 CanonType, 5283 PrevPartial, 5284 SequenceNumber); 5285 SetNestedNameSpecifier(Partial, SS); 5286 if (TemplateParameterLists.size() > 1 && SS.isSet()) { 5287 Partial->setTemplateParameterListsInfo(Context, 5288 TemplateParameterLists.size() - 1, 5289 (TemplateParameterList**) TemplateParameterLists.release()); 5290 } 5291 5292 if (!PrevPartial) 5293 ClassTemplate->AddPartialSpecialization(Partial, InsertPos); 5294 Specialization = Partial; 5295 5296 // If we are providing an explicit specialization of a member class 5297 // template specialization, make a note of that. 5298 if (PrevPartial && PrevPartial->getInstantiatedFromMember()) 5299 PrevPartial->setMemberSpecialization(); 5300 5301 // Check that all of the template parameters of the class template 5302 // partial specialization are deducible from the template 5303 // arguments. If not, this class template partial specialization 5304 // will never be used. 5305 llvm::SmallBitVector DeducibleParams(TemplateParams->size()); 5306 MarkUsedTemplateParameters(Partial->getTemplateArgs(), true, 5307 TemplateParams->getDepth(), 5308 DeducibleParams); 5309 5310 if (!DeducibleParams.all()) { 5311 unsigned NumNonDeducible = DeducibleParams.size()-DeducibleParams.count(); 5312 Diag(TemplateNameLoc, diag::warn_partial_specs_not_deducible) 5313 << (NumNonDeducible > 1) 5314 << SourceRange(TemplateNameLoc, RAngleLoc); 5315 for (unsigned I = 0, N = DeducibleParams.size(); I != N; ++I) { 5316 if (!DeducibleParams[I]) { 5317 NamedDecl *Param = cast<NamedDecl>(TemplateParams->getParam(I)); 5318 if (Param->getDeclName()) 5319 Diag(Param->getLocation(), 5320 diag::note_partial_spec_unused_parameter) 5321 << Param->getDeclName(); 5322 else 5323 Diag(Param->getLocation(), 5324 diag::note_partial_spec_unused_parameter) 5325 << "<anonymous>"; 5326 } 5327 } 5328 } 5329 } else { 5330 // Create a new class template specialization declaration node for 5331 // this explicit specialization or friend declaration. 5332 Specialization 5333 = ClassTemplateSpecializationDecl::Create(Context, Kind, 5334 ClassTemplate->getDeclContext(), 5335 KWLoc, TemplateNameLoc, 5336 ClassTemplate, 5337 Converted.data(), 5338 Converted.size(), 5339 PrevDecl); 5340 SetNestedNameSpecifier(Specialization, SS); 5341 if (TemplateParameterLists.size() > 0) { 5342 Specialization->setTemplateParameterListsInfo(Context, 5343 TemplateParameterLists.size(), 5344 (TemplateParameterList**) TemplateParameterLists.release()); 5345 } 5346 5347 if (!PrevDecl) 5348 ClassTemplate->AddSpecialization(Specialization, InsertPos); 5349 5350 CanonType = Context.getTypeDeclType(Specialization); 5351 } 5352 5353 // C++ [temp.expl.spec]p6: 5354 // If a template, a member template or the member of a class template is 5355 // explicitly specialized then that specialization shall be declared 5356 // before the first use of that specialization that would cause an implicit 5357 // instantiation to take place, in every translation unit in which such a 5358 // use occurs; no diagnostic is required. 5359 if (PrevDecl && PrevDecl->getPointOfInstantiation().isValid()) { 5360 bool Okay = false; 5361 for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) { 5362 // Is there any previous explicit specialization declaration? 5363 if (getTemplateSpecializationKind(Prev) == TSK_ExplicitSpecialization) { 5364 Okay = true; 5365 break; 5366 } 5367 } 5368 5369 if (!Okay) { 5370 SourceRange Range(TemplateNameLoc, RAngleLoc); 5371 Diag(TemplateNameLoc, diag::err_specialization_after_instantiation) 5372 << Context.getTypeDeclType(Specialization) << Range; 5373 5374 Diag(PrevDecl->getPointOfInstantiation(), 5375 diag::note_instantiation_required_here) 5376 << (PrevDecl->getTemplateSpecializationKind() 5377 != TSK_ImplicitInstantiation); 5378 return true; 5379 } 5380 } 5381 5382 // If this is not a friend, note that this is an explicit specialization. 5383 if (TUK != TUK_Friend) 5384 Specialization->setSpecializationKind(TSK_ExplicitSpecialization); 5385 5386 // Check that this isn't a redefinition of this specialization. 5387 if (TUK == TUK_Definition) { 5388 if (RecordDecl *Def = Specialization->getDefinition()) { 5389 SourceRange Range(TemplateNameLoc, RAngleLoc); 5390 Diag(TemplateNameLoc, diag::err_redefinition) 5391 << Context.getTypeDeclType(Specialization) << Range; 5392 Diag(Def->getLocation(), diag::note_previous_definition); 5393 Specialization->setInvalidDecl(); 5394 return true; 5395 } 5396 } 5397 5398 if (Attr) 5399 ProcessDeclAttributeList(S, Specialization, Attr); 5400 5401 if (ModulePrivateLoc.isValid()) 5402 Diag(Specialization->getLocation(), diag::err_module_private_specialization) 5403 << (isPartialSpecialization? 1 : 0) 5404 << FixItHint::CreateRemoval(ModulePrivateLoc); 5405 5406 // Build the fully-sugared type for this class template 5407 // specialization as the user wrote in the specialization 5408 // itself. This means that we'll pretty-print the type retrieved 5409 // from the specialization's declaration the way that the user 5410 // actually wrote the specialization, rather than formatting the 5411 // name based on the "canonical" representation used to store the 5412 // template arguments in the specialization. 5413 TypeSourceInfo *WrittenTy 5414 = Context.getTemplateSpecializationTypeInfo(Name, TemplateNameLoc, 5415 TemplateArgs, CanonType); 5416 if (TUK != TUK_Friend) { 5417 Specialization->setTypeAsWritten(WrittenTy); 5418 Specialization->setTemplateKeywordLoc(TemplateKWLoc); 5419 } 5420 TemplateArgsIn.release(); 5421 5422 // C++ [temp.expl.spec]p9: 5423 // A template explicit specialization is in the scope of the 5424 // namespace in which the template was defined. 5425 // 5426 // We actually implement this paragraph where we set the semantic 5427 // context (in the creation of the ClassTemplateSpecializationDecl), 5428 // but we also maintain the lexical context where the actual 5429 // definition occurs. 5430 Specialization->setLexicalDeclContext(CurContext); 5431 5432 // We may be starting the definition of this specialization. 5433 if (TUK == TUK_Definition) 5434 Specialization->startDefinition(); 5435 5436 if (TUK == TUK_Friend) { 5437 FriendDecl *Friend = FriendDecl::Create(Context, CurContext, 5438 TemplateNameLoc, 5439 WrittenTy, 5440 /*FIXME:*/KWLoc); 5441 Friend->setAccess(AS_public); 5442 CurContext->addDecl(Friend); 5443 } else { 5444 // Add the specialization into its lexical context, so that it can 5445 // be seen when iterating through the list of declarations in that 5446 // context. However, specializations are not found by name lookup. 5447 CurContext->addDecl(Specialization); 5448 } 5449 return Specialization; 5450} 5451 5452Decl *Sema::ActOnTemplateDeclarator(Scope *S, 5453 MultiTemplateParamsArg TemplateParameterLists, 5454 Declarator &D) { 5455 return HandleDeclarator(S, D, move(TemplateParameterLists)); 5456} 5457 5458Decl *Sema::ActOnStartOfFunctionTemplateDef(Scope *FnBodyScope, 5459 MultiTemplateParamsArg TemplateParameterLists, 5460 Declarator &D) { 5461 assert(getCurFunctionDecl() == 0 && "Function parsing confused"); 5462 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo(); 5463 5464 if (FTI.hasPrototype) { 5465 // FIXME: Diagnose arguments without names in C. 5466 } 5467 5468 Scope *ParentScope = FnBodyScope->getParent(); 5469 5470 D.setFunctionDefinitionKind(FDK_Definition); 5471 Decl *DP = HandleDeclarator(ParentScope, D, 5472 move(TemplateParameterLists)); 5473 if (FunctionTemplateDecl *FunctionTemplate 5474 = dyn_cast_or_null<FunctionTemplateDecl>(DP)) 5475 return ActOnStartOfFunctionDef(FnBodyScope, 5476 FunctionTemplate->getTemplatedDecl()); 5477 if (FunctionDecl *Function = dyn_cast_or_null<FunctionDecl>(DP)) 5478 return ActOnStartOfFunctionDef(FnBodyScope, Function); 5479 return 0; 5480} 5481 5482/// \brief Strips various properties off an implicit instantiation 5483/// that has just been explicitly specialized. 5484static void StripImplicitInstantiation(NamedDecl *D) { 5485 // FIXME: "make check" is clean if the call to dropAttrs() is commented out. 5486 D->dropAttrs(); 5487 5488 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 5489 FD->setInlineSpecified(false); 5490 } 5491} 5492 5493/// \brief Compute the diagnostic location for an explicit instantiation 5494// declaration or definition. 5495static SourceLocation DiagLocForExplicitInstantiation( 5496 NamedDecl* D, SourceLocation PointOfInstantiation) { 5497 // Explicit instantiations following a specialization have no effect and 5498 // hence no PointOfInstantiation. In that case, walk decl backwards 5499 // until a valid name loc is found. 5500 SourceLocation PrevDiagLoc = PointOfInstantiation; 5501 for (Decl *Prev = D; Prev && !PrevDiagLoc.isValid(); 5502 Prev = Prev->getPreviousDecl()) { 5503 PrevDiagLoc = Prev->getLocation(); 5504 } 5505 assert(PrevDiagLoc.isValid() && 5506 "Explicit instantiation without point of instantiation?"); 5507 return PrevDiagLoc; 5508} 5509 5510/// \brief Diagnose cases where we have an explicit template specialization 5511/// before/after an explicit template instantiation, producing diagnostics 5512/// for those cases where they are required and determining whether the 5513/// new specialization/instantiation will have any effect. 5514/// 5515/// \param NewLoc the location of the new explicit specialization or 5516/// instantiation. 5517/// 5518/// \param NewTSK the kind of the new explicit specialization or instantiation. 5519/// 5520/// \param PrevDecl the previous declaration of the entity. 5521/// 5522/// \param PrevTSK the kind of the old explicit specialization or instantiatin. 5523/// 5524/// \param PrevPointOfInstantiation if valid, indicates where the previus 5525/// declaration was instantiated (either implicitly or explicitly). 5526/// 5527/// \param HasNoEffect will be set to true to indicate that the new 5528/// specialization or instantiation has no effect and should be ignored. 5529/// 5530/// \returns true if there was an error that should prevent the introduction of 5531/// the new declaration into the AST, false otherwise. 5532bool 5533Sema::CheckSpecializationInstantiationRedecl(SourceLocation NewLoc, 5534 TemplateSpecializationKind NewTSK, 5535 NamedDecl *PrevDecl, 5536 TemplateSpecializationKind PrevTSK, 5537 SourceLocation PrevPointOfInstantiation, 5538 bool &HasNoEffect) { 5539 HasNoEffect = false; 5540 5541 switch (NewTSK) { 5542 case TSK_Undeclared: 5543 case TSK_ImplicitInstantiation: 5544 llvm_unreachable("Don't check implicit instantiations here"); 5545 5546 case TSK_ExplicitSpecialization: 5547 switch (PrevTSK) { 5548 case TSK_Undeclared: 5549 case TSK_ExplicitSpecialization: 5550 // Okay, we're just specializing something that is either already 5551 // explicitly specialized or has merely been mentioned without any 5552 // instantiation. 5553 return false; 5554 5555 case TSK_ImplicitInstantiation: 5556 if (PrevPointOfInstantiation.isInvalid()) { 5557 // The declaration itself has not actually been instantiated, so it is 5558 // still okay to specialize it. 5559 StripImplicitInstantiation(PrevDecl); 5560 return false; 5561 } 5562 // Fall through 5563 5564 case TSK_ExplicitInstantiationDeclaration: 5565 case TSK_ExplicitInstantiationDefinition: 5566 assert((PrevTSK == TSK_ImplicitInstantiation || 5567 PrevPointOfInstantiation.isValid()) && 5568 "Explicit instantiation without point of instantiation?"); 5569 5570 // C++ [temp.expl.spec]p6: 5571 // If a template, a member template or the member of a class template 5572 // is explicitly specialized then that specialization shall be declared 5573 // before the first use of that specialization that would cause an 5574 // implicit instantiation to take place, in every translation unit in 5575 // which such a use occurs; no diagnostic is required. 5576 for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) { 5577 // Is there any previous explicit specialization declaration? 5578 if (getTemplateSpecializationKind(Prev) == TSK_ExplicitSpecialization) 5579 return false; 5580 } 5581 5582 Diag(NewLoc, diag::err_specialization_after_instantiation) 5583 << PrevDecl; 5584 Diag(PrevPointOfInstantiation, diag::note_instantiation_required_here) 5585 << (PrevTSK != TSK_ImplicitInstantiation); 5586 5587 return true; 5588 } 5589 5590 case TSK_ExplicitInstantiationDeclaration: 5591 switch (PrevTSK) { 5592 case TSK_ExplicitInstantiationDeclaration: 5593 // This explicit instantiation declaration is redundant (that's okay). 5594 HasNoEffect = true; 5595 return false; 5596 5597 case TSK_Undeclared: 5598 case TSK_ImplicitInstantiation: 5599 // We're explicitly instantiating something that may have already been 5600 // implicitly instantiated; that's fine. 5601 return false; 5602 5603 case TSK_ExplicitSpecialization: 5604 // C++0x [temp.explicit]p4: 5605 // For a given set of template parameters, if an explicit instantiation 5606 // of a template appears after a declaration of an explicit 5607 // specialization for that template, the explicit instantiation has no 5608 // effect. 5609 HasNoEffect = true; 5610 return false; 5611 5612 case TSK_ExplicitInstantiationDefinition: 5613 // C++0x [temp.explicit]p10: 5614 // If an entity is the subject of both an explicit instantiation 5615 // declaration and an explicit instantiation definition in the same 5616 // translation unit, the definition shall follow the declaration. 5617 Diag(NewLoc, 5618 diag::err_explicit_instantiation_declaration_after_definition); 5619 5620 // Explicit instantiations following a specialization have no effect and 5621 // hence no PrevPointOfInstantiation. In that case, walk decl backwards 5622 // until a valid name loc is found. 5623 Diag(DiagLocForExplicitInstantiation(PrevDecl, PrevPointOfInstantiation), 5624 diag::note_explicit_instantiation_definition_here); 5625 HasNoEffect = true; 5626 return false; 5627 } 5628 5629 case TSK_ExplicitInstantiationDefinition: 5630 switch (PrevTSK) { 5631 case TSK_Undeclared: 5632 case TSK_ImplicitInstantiation: 5633 // We're explicitly instantiating something that may have already been 5634 // implicitly instantiated; that's fine. 5635 return false; 5636 5637 case TSK_ExplicitSpecialization: 5638 // C++ DR 259, C++0x [temp.explicit]p4: 5639 // For a given set of template parameters, if an explicit 5640 // instantiation of a template appears after a declaration of 5641 // an explicit specialization for that template, the explicit 5642 // instantiation has no effect. 5643 // 5644 // In C++98/03 mode, we only give an extension warning here, because it 5645 // is not harmful to try to explicitly instantiate something that 5646 // has been explicitly specialized. 5647 Diag(NewLoc, getLangOpts().CPlusPlus0x ? 5648 diag::warn_cxx98_compat_explicit_instantiation_after_specialization : 5649 diag::ext_explicit_instantiation_after_specialization) 5650 << PrevDecl; 5651 Diag(PrevDecl->getLocation(), 5652 diag::note_previous_template_specialization); 5653 HasNoEffect = true; 5654 return false; 5655 5656 case TSK_ExplicitInstantiationDeclaration: 5657 // We're explicity instantiating a definition for something for which we 5658 // were previously asked to suppress instantiations. That's fine. 5659 5660 // C++0x [temp.explicit]p4: 5661 // For a given set of template parameters, if an explicit instantiation 5662 // of a template appears after a declaration of an explicit 5663 // specialization for that template, the explicit instantiation has no 5664 // effect. 5665 for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) { 5666 // Is there any previous explicit specialization declaration? 5667 if (getTemplateSpecializationKind(Prev) == TSK_ExplicitSpecialization) { 5668 HasNoEffect = true; 5669 break; 5670 } 5671 } 5672 5673 return false; 5674 5675 case TSK_ExplicitInstantiationDefinition: 5676 // C++0x [temp.spec]p5: 5677 // For a given template and a given set of template-arguments, 5678 // - an explicit instantiation definition shall appear at most once 5679 // in a program, 5680 Diag(NewLoc, diag::err_explicit_instantiation_duplicate) 5681 << PrevDecl; 5682 Diag(DiagLocForExplicitInstantiation(PrevDecl, PrevPointOfInstantiation), 5683 diag::note_previous_explicit_instantiation); 5684 HasNoEffect = true; 5685 return false; 5686 } 5687 } 5688 5689 llvm_unreachable("Missing specialization/instantiation case?"); 5690} 5691 5692/// \brief Perform semantic analysis for the given dependent function 5693/// template specialization. The only possible way to get a dependent 5694/// function template specialization is with a friend declaration, 5695/// like so: 5696/// 5697/// template <class T> void foo(T); 5698/// template <class T> class A { 5699/// friend void foo<>(T); 5700/// }; 5701/// 5702/// There really isn't any useful analysis we can do here, so we 5703/// just store the information. 5704bool 5705Sema::CheckDependentFunctionTemplateSpecialization(FunctionDecl *FD, 5706 const TemplateArgumentListInfo &ExplicitTemplateArgs, 5707 LookupResult &Previous) { 5708 // Remove anything from Previous that isn't a function template in 5709 // the correct context. 5710 DeclContext *FDLookupContext = FD->getDeclContext()->getRedeclContext(); 5711 LookupResult::Filter F = Previous.makeFilter(); 5712 while (F.hasNext()) { 5713 NamedDecl *D = F.next()->getUnderlyingDecl(); 5714 if (!isa<FunctionTemplateDecl>(D) || 5715 !FDLookupContext->InEnclosingNamespaceSetOf( 5716 D->getDeclContext()->getRedeclContext())) 5717 F.erase(); 5718 } 5719 F.done(); 5720 5721 // Should this be diagnosed here? 5722 if (Previous.empty()) return true; 5723 5724 FD->setDependentTemplateSpecialization(Context, Previous.asUnresolvedSet(), 5725 ExplicitTemplateArgs); 5726 return false; 5727} 5728 5729/// \brief Perform semantic analysis for the given function template 5730/// specialization. 5731/// 5732/// This routine performs all of the semantic analysis required for an 5733/// explicit function template specialization. On successful completion, 5734/// the function declaration \p FD will become a function template 5735/// specialization. 5736/// 5737/// \param FD the function declaration, which will be updated to become a 5738/// function template specialization. 5739/// 5740/// \param ExplicitTemplateArgs the explicitly-provided template arguments, 5741/// if any. Note that this may be valid info even when 0 arguments are 5742/// explicitly provided as in, e.g., \c void sort<>(char*, char*); 5743/// as it anyway contains info on the angle brackets locations. 5744/// 5745/// \param Previous the set of declarations that may be specialized by 5746/// this function specialization. 5747bool 5748Sema::CheckFunctionTemplateSpecialization(FunctionDecl *FD, 5749 TemplateArgumentListInfo *ExplicitTemplateArgs, 5750 LookupResult &Previous) { 5751 // The set of function template specializations that could match this 5752 // explicit function template specialization. 5753 UnresolvedSet<8> Candidates; 5754 5755 DeclContext *FDLookupContext = FD->getDeclContext()->getRedeclContext(); 5756 for (LookupResult::iterator I = Previous.begin(), E = Previous.end(); 5757 I != E; ++I) { 5758 NamedDecl *Ovl = (*I)->getUnderlyingDecl(); 5759 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Ovl)) { 5760 // Only consider templates found within the same semantic lookup scope as 5761 // FD. 5762 if (!FDLookupContext->InEnclosingNamespaceSetOf( 5763 Ovl->getDeclContext()->getRedeclContext())) 5764 continue; 5765 5766 // C++ [temp.expl.spec]p11: 5767 // A trailing template-argument can be left unspecified in the 5768 // template-id naming an explicit function template specialization 5769 // provided it can be deduced from the function argument type. 5770 // Perform template argument deduction to determine whether we may be 5771 // specializing this template. 5772 // FIXME: It is somewhat wasteful to build 5773 TemplateDeductionInfo Info(Context, FD->getLocation()); 5774 FunctionDecl *Specialization = 0; 5775 if (TemplateDeductionResult TDK 5776 = DeduceTemplateArguments(FunTmpl, ExplicitTemplateArgs, 5777 FD->getType(), 5778 Specialization, 5779 Info)) { 5780 // FIXME: Template argument deduction failed; record why it failed, so 5781 // that we can provide nifty diagnostics. 5782 (void)TDK; 5783 continue; 5784 } 5785 5786 // Record this candidate. 5787 Candidates.addDecl(Specialization, I.getAccess()); 5788 } 5789 } 5790 5791 // Find the most specialized function template. 5792 UnresolvedSetIterator Result 5793 = getMostSpecialized(Candidates.begin(), Candidates.end(), 5794 TPOC_Other, 0, FD->getLocation(), 5795 PDiag(diag::err_function_template_spec_no_match) 5796 << FD->getDeclName(), 5797 PDiag(diag::err_function_template_spec_ambiguous) 5798 << FD->getDeclName() << (ExplicitTemplateArgs != 0), 5799 PDiag(diag::note_function_template_spec_matched)); 5800 if (Result == Candidates.end()) 5801 return true; 5802 5803 // Ignore access information; it doesn't figure into redeclaration checking. 5804 FunctionDecl *Specialization = cast<FunctionDecl>(*Result); 5805 5806 FunctionTemplateSpecializationInfo *SpecInfo 5807 = Specialization->getTemplateSpecializationInfo(); 5808 assert(SpecInfo && "Function template specialization info missing?"); 5809 5810 // Note: do not overwrite location info if previous template 5811 // specialization kind was explicit. 5812 TemplateSpecializationKind TSK = SpecInfo->getTemplateSpecializationKind(); 5813 if (TSK == TSK_Undeclared || TSK == TSK_ImplicitInstantiation) { 5814 Specialization->setLocation(FD->getLocation()); 5815 // C++11 [dcl.constexpr]p1: An explicit specialization of a constexpr 5816 // function can differ from the template declaration with respect to 5817 // the constexpr specifier. 5818 Specialization->setConstexpr(FD->isConstexpr()); 5819 } 5820 5821 // FIXME: Check if the prior specialization has a point of instantiation. 5822 // If so, we have run afoul of . 5823 5824 // If this is a friend declaration, then we're not really declaring 5825 // an explicit specialization. 5826 bool isFriend = (FD->getFriendObjectKind() != Decl::FOK_None); 5827 5828 // Check the scope of this explicit specialization. 5829 if (!isFriend && 5830 CheckTemplateSpecializationScope(*this, 5831 Specialization->getPrimaryTemplate(), 5832 Specialization, FD->getLocation(), 5833 false)) 5834 return true; 5835 5836 // C++ [temp.expl.spec]p6: 5837 // If a template, a member template or the member of a class template is 5838 // explicitly specialized then that specialization shall be declared 5839 // before the first use of that specialization that would cause an implicit 5840 // instantiation to take place, in every translation unit in which such a 5841 // use occurs; no diagnostic is required. 5842 bool HasNoEffect = false; 5843 if (!isFriend && 5844 CheckSpecializationInstantiationRedecl(FD->getLocation(), 5845 TSK_ExplicitSpecialization, 5846 Specialization, 5847 SpecInfo->getTemplateSpecializationKind(), 5848 SpecInfo->getPointOfInstantiation(), 5849 HasNoEffect)) 5850 return true; 5851 5852 // Mark the prior declaration as an explicit specialization, so that later 5853 // clients know that this is an explicit specialization. 5854 if (!isFriend) { 5855 SpecInfo->setTemplateSpecializationKind(TSK_ExplicitSpecialization); 5856 MarkUnusedFileScopedDecl(Specialization); 5857 } 5858 5859 // Turn the given function declaration into a function template 5860 // specialization, with the template arguments from the previous 5861 // specialization. 5862 // Take copies of (semantic and syntactic) template argument lists. 5863 const TemplateArgumentList* TemplArgs = new (Context) 5864 TemplateArgumentList(Specialization->getTemplateSpecializationArgs()); 5865 FD->setFunctionTemplateSpecialization(Specialization->getPrimaryTemplate(), 5866 TemplArgs, /*InsertPos=*/0, 5867 SpecInfo->getTemplateSpecializationKind(), 5868 ExplicitTemplateArgs); 5869 FD->setStorageClass(Specialization->getStorageClass()); 5870 5871 // The "previous declaration" for this function template specialization is 5872 // the prior function template specialization. 5873 Previous.clear(); 5874 Previous.addDecl(Specialization); 5875 return false; 5876} 5877 5878/// \brief Perform semantic analysis for the given non-template member 5879/// specialization. 5880/// 5881/// This routine performs all of the semantic analysis required for an 5882/// explicit member function specialization. On successful completion, 5883/// the function declaration \p FD will become a member function 5884/// specialization. 5885/// 5886/// \param Member the member declaration, which will be updated to become a 5887/// specialization. 5888/// 5889/// \param Previous the set of declarations, one of which may be specialized 5890/// by this function specialization; the set will be modified to contain the 5891/// redeclared member. 5892bool 5893Sema::CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous) { 5894 assert(!isa<TemplateDecl>(Member) && "Only for non-template members"); 5895 5896 // Try to find the member we are instantiating. 5897 NamedDecl *Instantiation = 0; 5898 NamedDecl *InstantiatedFrom = 0; 5899 MemberSpecializationInfo *MSInfo = 0; 5900 5901 if (Previous.empty()) { 5902 // Nowhere to look anyway. 5903 } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Member)) { 5904 for (LookupResult::iterator I = Previous.begin(), E = Previous.end(); 5905 I != E; ++I) { 5906 NamedDecl *D = (*I)->getUnderlyingDecl(); 5907 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) { 5908 if (Context.hasSameType(Function->getType(), Method->getType())) { 5909 Instantiation = Method; 5910 InstantiatedFrom = Method->getInstantiatedFromMemberFunction(); 5911 MSInfo = Method->getMemberSpecializationInfo(); 5912 break; 5913 } 5914 } 5915 } 5916 } else if (isa<VarDecl>(Member)) { 5917 VarDecl *PrevVar; 5918 if (Previous.isSingleResult() && 5919 (PrevVar = dyn_cast<VarDecl>(Previous.getFoundDecl()))) 5920 if (PrevVar->isStaticDataMember()) { 5921 Instantiation = PrevVar; 5922 InstantiatedFrom = PrevVar->getInstantiatedFromStaticDataMember(); 5923 MSInfo = PrevVar->getMemberSpecializationInfo(); 5924 } 5925 } else if (isa<RecordDecl>(Member)) { 5926 CXXRecordDecl *PrevRecord; 5927 if (Previous.isSingleResult() && 5928 (PrevRecord = dyn_cast<CXXRecordDecl>(Previous.getFoundDecl()))) { 5929 Instantiation = PrevRecord; 5930 InstantiatedFrom = PrevRecord->getInstantiatedFromMemberClass(); 5931 MSInfo = PrevRecord->getMemberSpecializationInfo(); 5932 } 5933 } else if (isa<EnumDecl>(Member)) { 5934 EnumDecl *PrevEnum; 5935 if (Previous.isSingleResult() && 5936 (PrevEnum = dyn_cast<EnumDecl>(Previous.getFoundDecl()))) { 5937 Instantiation = PrevEnum; 5938 InstantiatedFrom = PrevEnum->getInstantiatedFromMemberEnum(); 5939 MSInfo = PrevEnum->getMemberSpecializationInfo(); 5940 } 5941 } 5942 5943 if (!Instantiation) { 5944 // There is no previous declaration that matches. Since member 5945 // specializations are always out-of-line, the caller will complain about 5946 // this mismatch later. 5947 return false; 5948 } 5949 5950 // If this is a friend, just bail out here before we start turning 5951 // things into explicit specializations. 5952 if (Member->getFriendObjectKind() != Decl::FOK_None) { 5953 // Preserve instantiation information. 5954 if (InstantiatedFrom && isa<CXXMethodDecl>(Member)) { 5955 cast<CXXMethodDecl>(Member)->setInstantiationOfMemberFunction( 5956 cast<CXXMethodDecl>(InstantiatedFrom), 5957 cast<CXXMethodDecl>(Instantiation)->getTemplateSpecializationKind()); 5958 } else if (InstantiatedFrom && isa<CXXRecordDecl>(Member)) { 5959 cast<CXXRecordDecl>(Member)->setInstantiationOfMemberClass( 5960 cast<CXXRecordDecl>(InstantiatedFrom), 5961 cast<CXXRecordDecl>(Instantiation)->getTemplateSpecializationKind()); 5962 } 5963 5964 Previous.clear(); 5965 Previous.addDecl(Instantiation); 5966 return false; 5967 } 5968 5969 // Make sure that this is a specialization of a member. 5970 if (!InstantiatedFrom) { 5971 Diag(Member->getLocation(), diag::err_spec_member_not_instantiated) 5972 << Member; 5973 Diag(Instantiation->getLocation(), diag::note_specialized_decl); 5974 return true; 5975 } 5976 5977 // C++ [temp.expl.spec]p6: 5978 // If a template, a member template or the member of a class template is 5979 // explicitly specialized then that specialization shall be declared 5980 // before the first use of that specialization that would cause an implicit 5981 // instantiation to take place, in every translation unit in which such a 5982 // use occurs; no diagnostic is required. 5983 assert(MSInfo && "Member specialization info missing?"); 5984 5985 bool HasNoEffect = false; 5986 if (CheckSpecializationInstantiationRedecl(Member->getLocation(), 5987 TSK_ExplicitSpecialization, 5988 Instantiation, 5989 MSInfo->getTemplateSpecializationKind(), 5990 MSInfo->getPointOfInstantiation(), 5991 HasNoEffect)) 5992 return true; 5993 5994 // Check the scope of this explicit specialization. 5995 if (CheckTemplateSpecializationScope(*this, 5996 InstantiatedFrom, 5997 Instantiation, Member->getLocation(), 5998 false)) 5999 return true; 6000 6001 // Note that this is an explicit instantiation of a member. 6002 // the original declaration to note that it is an explicit specialization 6003 // (if it was previously an implicit instantiation). This latter step 6004 // makes bookkeeping easier. 6005 if (isa<FunctionDecl>(Member)) { 6006 FunctionDecl *InstantiationFunction = cast<FunctionDecl>(Instantiation); 6007 if (InstantiationFunction->getTemplateSpecializationKind() == 6008 TSK_ImplicitInstantiation) { 6009 InstantiationFunction->setTemplateSpecializationKind( 6010 TSK_ExplicitSpecialization); 6011 InstantiationFunction->setLocation(Member->getLocation()); 6012 } 6013 6014 cast<FunctionDecl>(Member)->setInstantiationOfMemberFunction( 6015 cast<CXXMethodDecl>(InstantiatedFrom), 6016 TSK_ExplicitSpecialization); 6017 MarkUnusedFileScopedDecl(InstantiationFunction); 6018 } else if (isa<VarDecl>(Member)) { 6019 VarDecl *InstantiationVar = cast<VarDecl>(Instantiation); 6020 if (InstantiationVar->getTemplateSpecializationKind() == 6021 TSK_ImplicitInstantiation) { 6022 InstantiationVar->setTemplateSpecializationKind( 6023 TSK_ExplicitSpecialization); 6024 InstantiationVar->setLocation(Member->getLocation()); 6025 } 6026 6027 Context.setInstantiatedFromStaticDataMember(cast<VarDecl>(Member), 6028 cast<VarDecl>(InstantiatedFrom), 6029 TSK_ExplicitSpecialization); 6030 MarkUnusedFileScopedDecl(InstantiationVar); 6031 } else if (isa<CXXRecordDecl>(Member)) { 6032 CXXRecordDecl *InstantiationClass = cast<CXXRecordDecl>(Instantiation); 6033 if (InstantiationClass->getTemplateSpecializationKind() == 6034 TSK_ImplicitInstantiation) { 6035 InstantiationClass->setTemplateSpecializationKind( 6036 TSK_ExplicitSpecialization); 6037 InstantiationClass->setLocation(Member->getLocation()); 6038 } 6039 6040 cast<CXXRecordDecl>(Member)->setInstantiationOfMemberClass( 6041 cast<CXXRecordDecl>(InstantiatedFrom), 6042 TSK_ExplicitSpecialization); 6043 } else { 6044 assert(isa<EnumDecl>(Member) && "Only member enums remain"); 6045 EnumDecl *InstantiationEnum = cast<EnumDecl>(Instantiation); 6046 if (InstantiationEnum->getTemplateSpecializationKind() == 6047 TSK_ImplicitInstantiation) { 6048 InstantiationEnum->setTemplateSpecializationKind( 6049 TSK_ExplicitSpecialization); 6050 InstantiationEnum->setLocation(Member->getLocation()); 6051 } 6052 6053 cast<EnumDecl>(Member)->setInstantiationOfMemberEnum( 6054 cast<EnumDecl>(InstantiatedFrom), TSK_ExplicitSpecialization); 6055 } 6056 6057 // Save the caller the trouble of having to figure out which declaration 6058 // this specialization matches. 6059 Previous.clear(); 6060 Previous.addDecl(Instantiation); 6061 return false; 6062} 6063 6064/// \brief Check the scope of an explicit instantiation. 6065/// 6066/// \returns true if a serious error occurs, false otherwise. 6067static bool CheckExplicitInstantiationScope(Sema &S, NamedDecl *D, 6068 SourceLocation InstLoc, 6069 bool WasQualifiedName) { 6070 DeclContext *OrigContext= D->getDeclContext()->getEnclosingNamespaceContext(); 6071 DeclContext *CurContext = S.CurContext->getRedeclContext(); 6072 6073 if (CurContext->isRecord()) { 6074 S.Diag(InstLoc, diag::err_explicit_instantiation_in_class) 6075 << D; 6076 return true; 6077 } 6078 6079 // C++11 [temp.explicit]p3: 6080 // An explicit instantiation shall appear in an enclosing namespace of its 6081 // template. If the name declared in the explicit instantiation is an 6082 // unqualified name, the explicit instantiation shall appear in the 6083 // namespace where its template is declared or, if that namespace is inline 6084 // (7.3.1), any namespace from its enclosing namespace set. 6085 // 6086 // This is DR275, which we do not retroactively apply to C++98/03. 6087 if (WasQualifiedName) { 6088 if (CurContext->Encloses(OrigContext)) 6089 return false; 6090 } else { 6091 if (CurContext->InEnclosingNamespaceSetOf(OrigContext)) 6092 return false; 6093 } 6094 6095 if (NamespaceDecl *NS = dyn_cast<NamespaceDecl>(OrigContext)) { 6096 if (WasQualifiedName) 6097 S.Diag(InstLoc, 6098 S.getLangOpts().CPlusPlus0x? 6099 diag::err_explicit_instantiation_out_of_scope : 6100 diag::warn_explicit_instantiation_out_of_scope_0x) 6101 << D << NS; 6102 else 6103 S.Diag(InstLoc, 6104 S.getLangOpts().CPlusPlus0x? 6105 diag::err_explicit_instantiation_unqualified_wrong_namespace : 6106 diag::warn_explicit_instantiation_unqualified_wrong_namespace_0x) 6107 << D << NS; 6108 } else 6109 S.Diag(InstLoc, 6110 S.getLangOpts().CPlusPlus0x? 6111 diag::err_explicit_instantiation_must_be_global : 6112 diag::warn_explicit_instantiation_must_be_global_0x) 6113 << D; 6114 S.Diag(D->getLocation(), diag::note_explicit_instantiation_here); 6115 return false; 6116} 6117 6118/// \brief Determine whether the given scope specifier has a template-id in it. 6119static bool ScopeSpecifierHasTemplateId(const CXXScopeSpec &SS) { 6120 if (!SS.isSet()) 6121 return false; 6122 6123 // C++11 [temp.explicit]p3: 6124 // If the explicit instantiation is for a member function, a member class 6125 // or a static data member of a class template specialization, the name of 6126 // the class template specialization in the qualified-id for the member 6127 // name shall be a simple-template-id. 6128 // 6129 // C++98 has the same restriction, just worded differently. 6130 for (NestedNameSpecifier *NNS = (NestedNameSpecifier *)SS.getScopeRep(); 6131 NNS; NNS = NNS->getPrefix()) 6132 if (const Type *T = NNS->getAsType()) 6133 if (isa<TemplateSpecializationType>(T)) 6134 return true; 6135 6136 return false; 6137} 6138 6139// Explicit instantiation of a class template specialization 6140DeclResult 6141Sema::ActOnExplicitInstantiation(Scope *S, 6142 SourceLocation ExternLoc, 6143 SourceLocation TemplateLoc, 6144 unsigned TagSpec, 6145 SourceLocation KWLoc, 6146 const CXXScopeSpec &SS, 6147 TemplateTy TemplateD, 6148 SourceLocation TemplateNameLoc, 6149 SourceLocation LAngleLoc, 6150 ASTTemplateArgsPtr TemplateArgsIn, 6151 SourceLocation RAngleLoc, 6152 AttributeList *Attr) { 6153 // Find the class template we're specializing 6154 TemplateName Name = TemplateD.getAsVal<TemplateName>(); 6155 ClassTemplateDecl *ClassTemplate 6156 = cast<ClassTemplateDecl>(Name.getAsTemplateDecl()); 6157 6158 // Check that the specialization uses the same tag kind as the 6159 // original template. 6160 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec); 6161 assert(Kind != TTK_Enum && 6162 "Invalid enum tag in class template explicit instantiation!"); 6163 if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(), 6164 Kind, /*isDefinition*/false, KWLoc, 6165 *ClassTemplate->getIdentifier())) { 6166 Diag(KWLoc, diag::err_use_with_wrong_tag) 6167 << ClassTemplate 6168 << FixItHint::CreateReplacement(KWLoc, 6169 ClassTemplate->getTemplatedDecl()->getKindName()); 6170 Diag(ClassTemplate->getTemplatedDecl()->getLocation(), 6171 diag::note_previous_use); 6172 Kind = ClassTemplate->getTemplatedDecl()->getTagKind(); 6173 } 6174 6175 // C++0x [temp.explicit]p2: 6176 // There are two forms of explicit instantiation: an explicit instantiation 6177 // definition and an explicit instantiation declaration. An explicit 6178 // instantiation declaration begins with the extern keyword. [...] 6179 TemplateSpecializationKind TSK 6180 = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition 6181 : TSK_ExplicitInstantiationDeclaration; 6182 6183 // Translate the parser's template argument list in our AST format. 6184 TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc); 6185 translateTemplateArguments(TemplateArgsIn, TemplateArgs); 6186 6187 // Check that the template argument list is well-formed for this 6188 // template. 6189 SmallVector<TemplateArgument, 4> Converted; 6190 if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc, 6191 TemplateArgs, false, Converted)) 6192 return true; 6193 6194 // Find the class template specialization declaration that 6195 // corresponds to these arguments. 6196 void *InsertPos = 0; 6197 ClassTemplateSpecializationDecl *PrevDecl 6198 = ClassTemplate->findSpecialization(Converted.data(), 6199 Converted.size(), InsertPos); 6200 6201 TemplateSpecializationKind PrevDecl_TSK 6202 = PrevDecl ? PrevDecl->getTemplateSpecializationKind() : TSK_Undeclared; 6203 6204 // C++0x [temp.explicit]p2: 6205 // [...] An explicit instantiation shall appear in an enclosing 6206 // namespace of its template. [...] 6207 // 6208 // This is C++ DR 275. 6209 if (CheckExplicitInstantiationScope(*this, ClassTemplate, TemplateNameLoc, 6210 SS.isSet())) 6211 return true; 6212 6213 ClassTemplateSpecializationDecl *Specialization = 0; 6214 6215 bool HasNoEffect = false; 6216 if (PrevDecl) { 6217 if (CheckSpecializationInstantiationRedecl(TemplateNameLoc, TSK, 6218 PrevDecl, PrevDecl_TSK, 6219 PrevDecl->getPointOfInstantiation(), 6220 HasNoEffect)) 6221 return PrevDecl; 6222 6223 // Even though HasNoEffect == true means that this explicit instantiation 6224 // has no effect on semantics, we go on to put its syntax in the AST. 6225 6226 if (PrevDecl_TSK == TSK_ImplicitInstantiation || 6227 PrevDecl_TSK == TSK_Undeclared) { 6228 // Since the only prior class template specialization with these 6229 // arguments was referenced but not declared, reuse that 6230 // declaration node as our own, updating the source location 6231 // for the template name to reflect our new declaration. 6232 // (Other source locations will be updated later.) 6233 Specialization = PrevDecl; 6234 Specialization->setLocation(TemplateNameLoc); 6235 PrevDecl = 0; 6236 } 6237 } 6238 6239 if (!Specialization) { 6240 // Create a new class template specialization declaration node for 6241 // this explicit specialization. 6242 Specialization 6243 = ClassTemplateSpecializationDecl::Create(Context, Kind, 6244 ClassTemplate->getDeclContext(), 6245 KWLoc, TemplateNameLoc, 6246 ClassTemplate, 6247 Converted.data(), 6248 Converted.size(), 6249 PrevDecl); 6250 SetNestedNameSpecifier(Specialization, SS); 6251 6252 if (!HasNoEffect && !PrevDecl) { 6253 // Insert the new specialization. 6254 ClassTemplate->AddSpecialization(Specialization, InsertPos); 6255 } 6256 } 6257 6258 // Build the fully-sugared type for this explicit instantiation as 6259 // the user wrote in the explicit instantiation itself. This means 6260 // that we'll pretty-print the type retrieved from the 6261 // specialization's declaration the way that the user actually wrote 6262 // the explicit instantiation, rather than formatting the name based 6263 // on the "canonical" representation used to store the template 6264 // arguments in the specialization. 6265 TypeSourceInfo *WrittenTy 6266 = Context.getTemplateSpecializationTypeInfo(Name, TemplateNameLoc, 6267 TemplateArgs, 6268 Context.getTypeDeclType(Specialization)); 6269 Specialization->setTypeAsWritten(WrittenTy); 6270 TemplateArgsIn.release(); 6271 6272 // Set source locations for keywords. 6273 Specialization->setExternLoc(ExternLoc); 6274 Specialization->setTemplateKeywordLoc(TemplateLoc); 6275 6276 if (Attr) 6277 ProcessDeclAttributeList(S, Specialization, Attr); 6278 6279 // Add the explicit instantiation into its lexical context. However, 6280 // since explicit instantiations are never found by name lookup, we 6281 // just put it into the declaration context directly. 6282 Specialization->setLexicalDeclContext(CurContext); 6283 CurContext->addDecl(Specialization); 6284 6285 // Syntax is now OK, so return if it has no other effect on semantics. 6286 if (HasNoEffect) { 6287 // Set the template specialization kind. 6288 Specialization->setTemplateSpecializationKind(TSK); 6289 return Specialization; 6290 } 6291 6292 // C++ [temp.explicit]p3: 6293 // A definition of a class template or class member template 6294 // shall be in scope at the point of the explicit instantiation of 6295 // the class template or class member template. 6296 // 6297 // This check comes when we actually try to perform the 6298 // instantiation. 6299 ClassTemplateSpecializationDecl *Def 6300 = cast_or_null<ClassTemplateSpecializationDecl>( 6301 Specialization->getDefinition()); 6302 if (!Def) 6303 InstantiateClassTemplateSpecialization(TemplateNameLoc, Specialization, TSK); 6304 else if (TSK == TSK_ExplicitInstantiationDefinition) { 6305 MarkVTableUsed(TemplateNameLoc, Specialization, true); 6306 Specialization->setPointOfInstantiation(Def->getPointOfInstantiation()); 6307 } 6308 6309 // Instantiate the members of this class template specialization. 6310 Def = cast_or_null<ClassTemplateSpecializationDecl>( 6311 Specialization->getDefinition()); 6312 if (Def) { 6313 TemplateSpecializationKind Old_TSK = Def->getTemplateSpecializationKind(); 6314 6315 // Fix a TSK_ExplicitInstantiationDeclaration followed by a 6316 // TSK_ExplicitInstantiationDefinition 6317 if (Old_TSK == TSK_ExplicitInstantiationDeclaration && 6318 TSK == TSK_ExplicitInstantiationDefinition) 6319 Def->setTemplateSpecializationKind(TSK); 6320 6321 InstantiateClassTemplateSpecializationMembers(TemplateNameLoc, Def, TSK); 6322 } 6323 6324 // Set the template specialization kind. 6325 Specialization->setTemplateSpecializationKind(TSK); 6326 return Specialization; 6327} 6328 6329// Explicit instantiation of a member class of a class template. 6330DeclResult 6331Sema::ActOnExplicitInstantiation(Scope *S, 6332 SourceLocation ExternLoc, 6333 SourceLocation TemplateLoc, 6334 unsigned TagSpec, 6335 SourceLocation KWLoc, 6336 CXXScopeSpec &SS, 6337 IdentifierInfo *Name, 6338 SourceLocation NameLoc, 6339 AttributeList *Attr) { 6340 6341 bool Owned = false; 6342 bool IsDependent = false; 6343 Decl *TagD = ActOnTag(S, TagSpec, Sema::TUK_Reference, 6344 KWLoc, SS, Name, NameLoc, Attr, AS_none, 6345 /*ModulePrivateLoc=*/SourceLocation(), 6346 MultiTemplateParamsArg(*this, 0, 0), 6347 Owned, IsDependent, SourceLocation(), false, 6348 TypeResult()); 6349 assert(!IsDependent && "explicit instantiation of dependent name not yet handled"); 6350 6351 if (!TagD) 6352 return true; 6353 6354 TagDecl *Tag = cast<TagDecl>(TagD); 6355 assert(!Tag->isEnum() && "shouldn't see enumerations here"); 6356 6357 if (Tag->isInvalidDecl()) 6358 return true; 6359 6360 CXXRecordDecl *Record = cast<CXXRecordDecl>(Tag); 6361 CXXRecordDecl *Pattern = Record->getInstantiatedFromMemberClass(); 6362 if (!Pattern) { 6363 Diag(TemplateLoc, diag::err_explicit_instantiation_nontemplate_type) 6364 << Context.getTypeDeclType(Record); 6365 Diag(Record->getLocation(), diag::note_nontemplate_decl_here); 6366 return true; 6367 } 6368 6369 // C++0x [temp.explicit]p2: 6370 // If the explicit instantiation is for a class or member class, the 6371 // elaborated-type-specifier in the declaration shall include a 6372 // simple-template-id. 6373 // 6374 // C++98 has the same restriction, just worded differently. 6375 if (!ScopeSpecifierHasTemplateId(SS)) 6376 Diag(TemplateLoc, diag::ext_explicit_instantiation_without_qualified_id) 6377 << Record << SS.getRange(); 6378 6379 // C++0x [temp.explicit]p2: 6380 // There are two forms of explicit instantiation: an explicit instantiation 6381 // definition and an explicit instantiation declaration. An explicit 6382 // instantiation declaration begins with the extern keyword. [...] 6383 TemplateSpecializationKind TSK 6384 = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition 6385 : TSK_ExplicitInstantiationDeclaration; 6386 6387 // C++0x [temp.explicit]p2: 6388 // [...] An explicit instantiation shall appear in an enclosing 6389 // namespace of its template. [...] 6390 // 6391 // This is C++ DR 275. 6392 CheckExplicitInstantiationScope(*this, Record, NameLoc, true); 6393 6394 // Verify that it is okay to explicitly instantiate here. 6395 CXXRecordDecl *PrevDecl 6396 = cast_or_null<CXXRecordDecl>(Record->getPreviousDecl()); 6397 if (!PrevDecl && Record->getDefinition()) 6398 PrevDecl = Record; 6399 if (PrevDecl) { 6400 MemberSpecializationInfo *MSInfo = PrevDecl->getMemberSpecializationInfo(); 6401 bool HasNoEffect = false; 6402 assert(MSInfo && "No member specialization information?"); 6403 if (CheckSpecializationInstantiationRedecl(TemplateLoc, TSK, 6404 PrevDecl, 6405 MSInfo->getTemplateSpecializationKind(), 6406 MSInfo->getPointOfInstantiation(), 6407 HasNoEffect)) 6408 return true; 6409 if (HasNoEffect) 6410 return TagD; 6411 } 6412 6413 CXXRecordDecl *RecordDef 6414 = cast_or_null<CXXRecordDecl>(Record->getDefinition()); 6415 if (!RecordDef) { 6416 // C++ [temp.explicit]p3: 6417 // A definition of a member class of a class template shall be in scope 6418 // at the point of an explicit instantiation of the member class. 6419 CXXRecordDecl *Def 6420 = cast_or_null<CXXRecordDecl>(Pattern->getDefinition()); 6421 if (!Def) { 6422 Diag(TemplateLoc, diag::err_explicit_instantiation_undefined_member) 6423 << 0 << Record->getDeclName() << Record->getDeclContext(); 6424 Diag(Pattern->getLocation(), diag::note_forward_declaration) 6425 << Pattern; 6426 return true; 6427 } else { 6428 if (InstantiateClass(NameLoc, Record, Def, 6429 getTemplateInstantiationArgs(Record), 6430 TSK)) 6431 return true; 6432 6433 RecordDef = cast_or_null<CXXRecordDecl>(Record->getDefinition()); 6434 if (!RecordDef) 6435 return true; 6436 } 6437 } 6438 6439 // Instantiate all of the members of the class. 6440 InstantiateClassMembers(NameLoc, RecordDef, 6441 getTemplateInstantiationArgs(Record), TSK); 6442 6443 if (TSK == TSK_ExplicitInstantiationDefinition) 6444 MarkVTableUsed(NameLoc, RecordDef, true); 6445 6446 // FIXME: We don't have any representation for explicit instantiations of 6447 // member classes. Such a representation is not needed for compilation, but it 6448 // should be available for clients that want to see all of the declarations in 6449 // the source code. 6450 return TagD; 6451} 6452 6453DeclResult Sema::ActOnExplicitInstantiation(Scope *S, 6454 SourceLocation ExternLoc, 6455 SourceLocation TemplateLoc, 6456 Declarator &D) { 6457 // Explicit instantiations always require a name. 6458 // TODO: check if/when DNInfo should replace Name. 6459 DeclarationNameInfo NameInfo = GetNameForDeclarator(D); 6460 DeclarationName Name = NameInfo.getName(); 6461 if (!Name) { 6462 if (!D.isInvalidType()) 6463 Diag(D.getDeclSpec().getLocStart(), 6464 diag::err_explicit_instantiation_requires_name) 6465 << D.getDeclSpec().getSourceRange() 6466 << D.getSourceRange(); 6467 6468 return true; 6469 } 6470 6471 // The scope passed in may not be a decl scope. Zip up the scope tree until 6472 // we find one that is. 6473 while ((S->getFlags() & Scope::DeclScope) == 0 || 6474 (S->getFlags() & Scope::TemplateParamScope) != 0) 6475 S = S->getParent(); 6476 6477 // Determine the type of the declaration. 6478 TypeSourceInfo *T = GetTypeForDeclarator(D, S); 6479 QualType R = T->getType(); 6480 if (R.isNull()) 6481 return true; 6482 6483 // C++ [dcl.stc]p1: 6484 // A storage-class-specifier shall not be specified in [...] an explicit 6485 // instantiation (14.7.2) directive. 6486 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) { 6487 Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_of_typedef) 6488 << Name; 6489 return true; 6490 } else if (D.getDeclSpec().getStorageClassSpec() 6491 != DeclSpec::SCS_unspecified) { 6492 // Complain about then remove the storage class specifier. 6493 Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_storage_class) 6494 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 6495 6496 D.getMutableDeclSpec().ClearStorageClassSpecs(); 6497 } 6498 6499 // C++0x [temp.explicit]p1: 6500 // [...] An explicit instantiation of a function template shall not use the 6501 // inline or constexpr specifiers. 6502 // Presumably, this also applies to member functions of class templates as 6503 // well. 6504 if (D.getDeclSpec().isInlineSpecified()) 6505 Diag(D.getDeclSpec().getInlineSpecLoc(), 6506 getLangOpts().CPlusPlus0x ? 6507 diag::err_explicit_instantiation_inline : 6508 diag::warn_explicit_instantiation_inline_0x) 6509 << FixItHint::CreateRemoval(D.getDeclSpec().getInlineSpecLoc()); 6510 if (D.getDeclSpec().isConstexprSpecified()) 6511 // FIXME: Add a fix-it to remove the 'constexpr' and add a 'const' if one is 6512 // not already specified. 6513 Diag(D.getDeclSpec().getConstexprSpecLoc(), 6514 diag::err_explicit_instantiation_constexpr); 6515 6516 // C++0x [temp.explicit]p2: 6517 // There are two forms of explicit instantiation: an explicit instantiation 6518 // definition and an explicit instantiation declaration. An explicit 6519 // instantiation declaration begins with the extern keyword. [...] 6520 TemplateSpecializationKind TSK 6521 = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition 6522 : TSK_ExplicitInstantiationDeclaration; 6523 6524 LookupResult Previous(*this, NameInfo, LookupOrdinaryName); 6525 LookupParsedName(Previous, S, &D.getCXXScopeSpec()); 6526 6527 if (!R->isFunctionType()) { 6528 // C++ [temp.explicit]p1: 6529 // A [...] static data member of a class template can be explicitly 6530 // instantiated from the member definition associated with its class 6531 // template. 6532 if (Previous.isAmbiguous()) 6533 return true; 6534 6535 VarDecl *Prev = Previous.getAsSingle<VarDecl>(); 6536 if (!Prev || !Prev->isStaticDataMember()) { 6537 // We expect to see a data data member here. 6538 Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_not_known) 6539 << Name; 6540 for (LookupResult::iterator P = Previous.begin(), PEnd = Previous.end(); 6541 P != PEnd; ++P) 6542 Diag((*P)->getLocation(), diag::note_explicit_instantiation_here); 6543 return true; 6544 } 6545 6546 if (!Prev->getInstantiatedFromStaticDataMember()) { 6547 // FIXME: Check for explicit specialization? 6548 Diag(D.getIdentifierLoc(), 6549 diag::err_explicit_instantiation_data_member_not_instantiated) 6550 << Prev; 6551 Diag(Prev->getLocation(), diag::note_explicit_instantiation_here); 6552 // FIXME: Can we provide a note showing where this was declared? 6553 return true; 6554 } 6555 6556 // C++0x [temp.explicit]p2: 6557 // If the explicit instantiation is for a member function, a member class 6558 // or a static data member of a class template specialization, the name of 6559 // the class template specialization in the qualified-id for the member 6560 // name shall be a simple-template-id. 6561 // 6562 // C++98 has the same restriction, just worded differently. 6563 if (!ScopeSpecifierHasTemplateId(D.getCXXScopeSpec())) 6564 Diag(D.getIdentifierLoc(), 6565 diag::ext_explicit_instantiation_without_qualified_id) 6566 << Prev << D.getCXXScopeSpec().getRange(); 6567 6568 // Check the scope of this explicit instantiation. 6569 CheckExplicitInstantiationScope(*this, Prev, D.getIdentifierLoc(), true); 6570 6571 // Verify that it is okay to explicitly instantiate here. 6572 MemberSpecializationInfo *MSInfo = Prev->getMemberSpecializationInfo(); 6573 assert(MSInfo && "Missing static data member specialization info?"); 6574 bool HasNoEffect = false; 6575 if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK, Prev, 6576 MSInfo->getTemplateSpecializationKind(), 6577 MSInfo->getPointOfInstantiation(), 6578 HasNoEffect)) 6579 return true; 6580 if (HasNoEffect) 6581 return (Decl*) 0; 6582 6583 // Instantiate static data member. 6584 Prev->setTemplateSpecializationKind(TSK, D.getIdentifierLoc()); 6585 if (TSK == TSK_ExplicitInstantiationDefinition) 6586 InstantiateStaticDataMemberDefinition(D.getIdentifierLoc(), Prev); 6587 6588 // FIXME: Create an ExplicitInstantiation node? 6589 return (Decl*) 0; 6590 } 6591 6592 // If the declarator is a template-id, translate the parser's template 6593 // argument list into our AST format. 6594 bool HasExplicitTemplateArgs = false; 6595 TemplateArgumentListInfo TemplateArgs; 6596 if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) { 6597 TemplateIdAnnotation *TemplateId = D.getName().TemplateId; 6598 TemplateArgs.setLAngleLoc(TemplateId->LAngleLoc); 6599 TemplateArgs.setRAngleLoc(TemplateId->RAngleLoc); 6600 ASTTemplateArgsPtr TemplateArgsPtr(*this, 6601 TemplateId->getTemplateArgs(), 6602 TemplateId->NumArgs); 6603 translateTemplateArguments(TemplateArgsPtr, TemplateArgs); 6604 HasExplicitTemplateArgs = true; 6605 TemplateArgsPtr.release(); 6606 } 6607 6608 // C++ [temp.explicit]p1: 6609 // A [...] function [...] can be explicitly instantiated from its template. 6610 // A member function [...] of a class template can be explicitly 6611 // instantiated from the member definition associated with its class 6612 // template. 6613 UnresolvedSet<8> Matches; 6614 for (LookupResult::iterator P = Previous.begin(), PEnd = Previous.end(); 6615 P != PEnd; ++P) { 6616 NamedDecl *Prev = *P; 6617 if (!HasExplicitTemplateArgs) { 6618 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Prev)) { 6619 if (Context.hasSameUnqualifiedType(Method->getType(), R)) { 6620 Matches.clear(); 6621 6622 Matches.addDecl(Method, P.getAccess()); 6623 if (Method->getTemplateSpecializationKind() == TSK_Undeclared) 6624 break; 6625 } 6626 } 6627 } 6628 6629 FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Prev); 6630 if (!FunTmpl) 6631 continue; 6632 6633 TemplateDeductionInfo Info(Context, D.getIdentifierLoc()); 6634 FunctionDecl *Specialization = 0; 6635 if (TemplateDeductionResult TDK 6636 = DeduceTemplateArguments(FunTmpl, 6637 (HasExplicitTemplateArgs ? &TemplateArgs : 0), 6638 R, Specialization, Info)) { 6639 // FIXME: Keep track of almost-matches? 6640 (void)TDK; 6641 continue; 6642 } 6643 6644 Matches.addDecl(Specialization, P.getAccess()); 6645 } 6646 6647 // Find the most specialized function template specialization. 6648 UnresolvedSetIterator Result 6649 = getMostSpecialized(Matches.begin(), Matches.end(), TPOC_Other, 0, 6650 D.getIdentifierLoc(), 6651 PDiag(diag::err_explicit_instantiation_not_known) << Name, 6652 PDiag(diag::err_explicit_instantiation_ambiguous) << Name, 6653 PDiag(diag::note_explicit_instantiation_candidate)); 6654 6655 if (Result == Matches.end()) 6656 return true; 6657 6658 // Ignore access control bits, we don't need them for redeclaration checking. 6659 FunctionDecl *Specialization = cast<FunctionDecl>(*Result); 6660 6661 if (Specialization->getTemplateSpecializationKind() == TSK_Undeclared) { 6662 Diag(D.getIdentifierLoc(), 6663 diag::err_explicit_instantiation_member_function_not_instantiated) 6664 << Specialization 6665 << (Specialization->getTemplateSpecializationKind() == 6666 TSK_ExplicitSpecialization); 6667 Diag(Specialization->getLocation(), diag::note_explicit_instantiation_here); 6668 return true; 6669 } 6670 6671 FunctionDecl *PrevDecl = Specialization->getPreviousDecl(); 6672 if (!PrevDecl && Specialization->isThisDeclarationADefinition()) 6673 PrevDecl = Specialization; 6674 6675 if (PrevDecl) { 6676 bool HasNoEffect = false; 6677 if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK, 6678 PrevDecl, 6679 PrevDecl->getTemplateSpecializationKind(), 6680 PrevDecl->getPointOfInstantiation(), 6681 HasNoEffect)) 6682 return true; 6683 6684 // FIXME: We may still want to build some representation of this 6685 // explicit specialization. 6686 if (HasNoEffect) 6687 return (Decl*) 0; 6688 } 6689 6690 Specialization->setTemplateSpecializationKind(TSK, D.getIdentifierLoc()); 6691 AttributeList *Attr = D.getDeclSpec().getAttributes().getList(); 6692 if (Attr) 6693 ProcessDeclAttributeList(S, Specialization, Attr); 6694 6695 if (TSK == TSK_ExplicitInstantiationDefinition) 6696 InstantiateFunctionDefinition(D.getIdentifierLoc(), Specialization); 6697 6698 // C++0x [temp.explicit]p2: 6699 // If the explicit instantiation is for a member function, a member class 6700 // or a static data member of a class template specialization, the name of 6701 // the class template specialization in the qualified-id for the member 6702 // name shall be a simple-template-id. 6703 // 6704 // C++98 has the same restriction, just worded differently. 6705 FunctionTemplateDecl *FunTmpl = Specialization->getPrimaryTemplate(); 6706 if (D.getName().getKind() != UnqualifiedId::IK_TemplateId && !FunTmpl && 6707 D.getCXXScopeSpec().isSet() && 6708 !ScopeSpecifierHasTemplateId(D.getCXXScopeSpec())) 6709 Diag(D.getIdentifierLoc(), 6710 diag::ext_explicit_instantiation_without_qualified_id) 6711 << Specialization << D.getCXXScopeSpec().getRange(); 6712 6713 CheckExplicitInstantiationScope(*this, 6714 FunTmpl? (NamedDecl *)FunTmpl 6715 : Specialization->getInstantiatedFromMemberFunction(), 6716 D.getIdentifierLoc(), 6717 D.getCXXScopeSpec().isSet()); 6718 6719 // FIXME: Create some kind of ExplicitInstantiationDecl here. 6720 return (Decl*) 0; 6721} 6722 6723TypeResult 6724Sema::ActOnDependentTag(Scope *S, unsigned TagSpec, TagUseKind TUK, 6725 const CXXScopeSpec &SS, IdentifierInfo *Name, 6726 SourceLocation TagLoc, SourceLocation NameLoc) { 6727 // This has to hold, because SS is expected to be defined. 6728 assert(Name && "Expected a name in a dependent tag"); 6729 6730 NestedNameSpecifier *NNS 6731 = static_cast<NestedNameSpecifier *>(SS.getScopeRep()); 6732 if (!NNS) 6733 return true; 6734 6735 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec); 6736 6737 if (TUK == TUK_Declaration || TUK == TUK_Definition) { 6738 Diag(NameLoc, diag::err_dependent_tag_decl) 6739 << (TUK == TUK_Definition) << Kind << SS.getRange(); 6740 return true; 6741 } 6742 6743 // Create the resulting type. 6744 ElaboratedTypeKeyword Kwd = TypeWithKeyword::getKeywordForTagTypeKind(Kind); 6745 QualType Result = Context.getDependentNameType(Kwd, NNS, Name); 6746 6747 // Create type-source location information for this type. 6748 TypeLocBuilder TLB; 6749 DependentNameTypeLoc TL = TLB.push<DependentNameTypeLoc>(Result); 6750 TL.setElaboratedKeywordLoc(TagLoc); 6751 TL.setQualifierLoc(SS.getWithLocInContext(Context)); 6752 TL.setNameLoc(NameLoc); 6753 return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result)); 6754} 6755 6756TypeResult 6757Sema::ActOnTypenameType(Scope *S, SourceLocation TypenameLoc, 6758 const CXXScopeSpec &SS, const IdentifierInfo &II, 6759 SourceLocation IdLoc) { 6760 if (SS.isInvalid()) 6761 return true; 6762 6763 if (TypenameLoc.isValid() && S && !S->getTemplateParamParent()) 6764 Diag(TypenameLoc, 6765 getLangOpts().CPlusPlus0x ? 6766 diag::warn_cxx98_compat_typename_outside_of_template : 6767 diag::ext_typename_outside_of_template) 6768 << FixItHint::CreateRemoval(TypenameLoc); 6769 6770 NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context); 6771 QualType T = CheckTypenameType(TypenameLoc.isValid()? ETK_Typename : ETK_None, 6772 TypenameLoc, QualifierLoc, II, IdLoc); 6773 if (T.isNull()) 6774 return true; 6775 6776 TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T); 6777 if (isa<DependentNameType>(T)) { 6778 DependentNameTypeLoc TL = cast<DependentNameTypeLoc>(TSI->getTypeLoc()); 6779 TL.setElaboratedKeywordLoc(TypenameLoc); 6780 TL.setQualifierLoc(QualifierLoc); 6781 TL.setNameLoc(IdLoc); 6782 } else { 6783 ElaboratedTypeLoc TL = cast<ElaboratedTypeLoc>(TSI->getTypeLoc()); 6784 TL.setElaboratedKeywordLoc(TypenameLoc); 6785 TL.setQualifierLoc(QualifierLoc); 6786 cast<TypeSpecTypeLoc>(TL.getNamedTypeLoc()).setNameLoc(IdLoc); 6787 } 6788 6789 return CreateParsedType(T, TSI); 6790} 6791 6792TypeResult 6793Sema::ActOnTypenameType(Scope *S, 6794 SourceLocation TypenameLoc, 6795 const CXXScopeSpec &SS, 6796 SourceLocation TemplateKWLoc, 6797 TemplateTy TemplateIn, 6798 SourceLocation TemplateNameLoc, 6799 SourceLocation LAngleLoc, 6800 ASTTemplateArgsPtr TemplateArgsIn, 6801 SourceLocation RAngleLoc) { 6802 if (TypenameLoc.isValid() && S && !S->getTemplateParamParent()) 6803 Diag(TypenameLoc, 6804 getLangOpts().CPlusPlus0x ? 6805 diag::warn_cxx98_compat_typename_outside_of_template : 6806 diag::ext_typename_outside_of_template) 6807 << FixItHint::CreateRemoval(TypenameLoc); 6808 6809 // Translate the parser's template argument list in our AST format. 6810 TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc); 6811 translateTemplateArguments(TemplateArgsIn, TemplateArgs); 6812 6813 TemplateName Template = TemplateIn.get(); 6814 if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) { 6815 // Construct a dependent template specialization type. 6816 assert(DTN && "dependent template has non-dependent name?"); 6817 assert(DTN->getQualifier() 6818 == static_cast<NestedNameSpecifier*>(SS.getScopeRep())); 6819 QualType T = Context.getDependentTemplateSpecializationType(ETK_Typename, 6820 DTN->getQualifier(), 6821 DTN->getIdentifier(), 6822 TemplateArgs); 6823 6824 // Create source-location information for this type. 6825 TypeLocBuilder Builder; 6826 DependentTemplateSpecializationTypeLoc SpecTL 6827 = Builder.push<DependentTemplateSpecializationTypeLoc>(T); 6828 SpecTL.setElaboratedKeywordLoc(TypenameLoc); 6829 SpecTL.setQualifierLoc(SS.getWithLocInContext(Context)); 6830 SpecTL.setTemplateKeywordLoc(TemplateKWLoc); 6831 SpecTL.setTemplateNameLoc(TemplateNameLoc); 6832 SpecTL.setLAngleLoc(LAngleLoc); 6833 SpecTL.setRAngleLoc(RAngleLoc); 6834 for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I) 6835 SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo()); 6836 return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T)); 6837 } 6838 6839 QualType T = CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs); 6840 if (T.isNull()) 6841 return true; 6842 6843 // Provide source-location information for the template specialization type. 6844 TypeLocBuilder Builder; 6845 TemplateSpecializationTypeLoc SpecTL 6846 = Builder.push<TemplateSpecializationTypeLoc>(T); 6847 SpecTL.setTemplateKeywordLoc(TemplateKWLoc); 6848 SpecTL.setTemplateNameLoc(TemplateNameLoc); 6849 SpecTL.setLAngleLoc(LAngleLoc); 6850 SpecTL.setRAngleLoc(RAngleLoc); 6851 for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I) 6852 SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo()); 6853 6854 T = Context.getElaboratedType(ETK_Typename, SS.getScopeRep(), T); 6855 ElaboratedTypeLoc TL = Builder.push<ElaboratedTypeLoc>(T); 6856 TL.setElaboratedKeywordLoc(TypenameLoc); 6857 TL.setQualifierLoc(SS.getWithLocInContext(Context)); 6858 6859 TypeSourceInfo *TSI = Builder.getTypeSourceInfo(Context, T); 6860 return CreateParsedType(T, TSI); 6861} 6862 6863 6864/// \brief Build the type that describes a C++ typename specifier, 6865/// e.g., "typename T::type". 6866QualType 6867Sema::CheckTypenameType(ElaboratedTypeKeyword Keyword, 6868 SourceLocation KeywordLoc, 6869 NestedNameSpecifierLoc QualifierLoc, 6870 const IdentifierInfo &II, 6871 SourceLocation IILoc) { 6872 CXXScopeSpec SS; 6873 SS.Adopt(QualifierLoc); 6874 6875 DeclContext *Ctx = computeDeclContext(SS); 6876 if (!Ctx) { 6877 // If the nested-name-specifier is dependent and couldn't be 6878 // resolved to a type, build a typename type. 6879 assert(QualifierLoc.getNestedNameSpecifier()->isDependent()); 6880 return Context.getDependentNameType(Keyword, 6881 QualifierLoc.getNestedNameSpecifier(), 6882 &II); 6883 } 6884 6885 // If the nested-name-specifier refers to the current instantiation, 6886 // the "typename" keyword itself is superfluous. In C++03, the 6887 // program is actually ill-formed. However, DR 382 (in C++0x CD1) 6888 // allows such extraneous "typename" keywords, and we retroactively 6889 // apply this DR to C++03 code with only a warning. In any case we continue. 6890 6891 if (RequireCompleteDeclContext(SS, Ctx)) 6892 return QualType(); 6893 6894 DeclarationName Name(&II); 6895 LookupResult Result(*this, Name, IILoc, LookupOrdinaryName); 6896 LookupQualifiedName(Result, Ctx); 6897 unsigned DiagID = 0; 6898 Decl *Referenced = 0; 6899 switch (Result.getResultKind()) { 6900 case LookupResult::NotFound: 6901 DiagID = diag::err_typename_nested_not_found; 6902 break; 6903 6904 case LookupResult::FoundUnresolvedValue: { 6905 // We found a using declaration that is a value. Most likely, the using 6906 // declaration itself is meant to have the 'typename' keyword. 6907 SourceRange FullRange(KeywordLoc.isValid() ? KeywordLoc : SS.getBeginLoc(), 6908 IILoc); 6909 Diag(IILoc, diag::err_typename_refers_to_using_value_decl) 6910 << Name << Ctx << FullRange; 6911 if (UnresolvedUsingValueDecl *Using 6912 = dyn_cast<UnresolvedUsingValueDecl>(Result.getRepresentativeDecl())){ 6913 SourceLocation Loc = Using->getQualifierLoc().getBeginLoc(); 6914 Diag(Loc, diag::note_using_value_decl_missing_typename) 6915 << FixItHint::CreateInsertion(Loc, "typename "); 6916 } 6917 } 6918 // Fall through to create a dependent typename type, from which we can recover 6919 // better. 6920 6921 case LookupResult::NotFoundInCurrentInstantiation: 6922 // Okay, it's a member of an unknown instantiation. 6923 return Context.getDependentNameType(Keyword, 6924 QualifierLoc.getNestedNameSpecifier(), 6925 &II); 6926 6927 case LookupResult::Found: 6928 if (TypeDecl *Type = dyn_cast<TypeDecl>(Result.getFoundDecl())) { 6929 // We found a type. Build an ElaboratedType, since the 6930 // typename-specifier was just sugar. 6931 return Context.getElaboratedType(ETK_Typename, 6932 QualifierLoc.getNestedNameSpecifier(), 6933 Context.getTypeDeclType(Type)); 6934 } 6935 6936 DiagID = diag::err_typename_nested_not_type; 6937 Referenced = Result.getFoundDecl(); 6938 break; 6939 6940 case LookupResult::FoundOverloaded: 6941 DiagID = diag::err_typename_nested_not_type; 6942 Referenced = *Result.begin(); 6943 break; 6944 6945 case LookupResult::Ambiguous: 6946 return QualType(); 6947 } 6948 6949 // If we get here, it's because name lookup did not find a 6950 // type. Emit an appropriate diagnostic and return an error. 6951 SourceRange FullRange(KeywordLoc.isValid() ? KeywordLoc : SS.getBeginLoc(), 6952 IILoc); 6953 Diag(IILoc, DiagID) << FullRange << Name << Ctx; 6954 if (Referenced) 6955 Diag(Referenced->getLocation(), diag::note_typename_refers_here) 6956 << Name; 6957 return QualType(); 6958} 6959 6960namespace { 6961 // See Sema::RebuildTypeInCurrentInstantiation 6962 class CurrentInstantiationRebuilder 6963 : public TreeTransform<CurrentInstantiationRebuilder> { 6964 SourceLocation Loc; 6965 DeclarationName Entity; 6966 6967 public: 6968 typedef TreeTransform<CurrentInstantiationRebuilder> inherited; 6969 6970 CurrentInstantiationRebuilder(Sema &SemaRef, 6971 SourceLocation Loc, 6972 DeclarationName Entity) 6973 : TreeTransform<CurrentInstantiationRebuilder>(SemaRef), 6974 Loc(Loc), Entity(Entity) { } 6975 6976 /// \brief Determine whether the given type \p T has already been 6977 /// transformed. 6978 /// 6979 /// For the purposes of type reconstruction, a type has already been 6980 /// transformed if it is NULL or if it is not dependent. 6981 bool AlreadyTransformed(QualType T) { 6982 return T.isNull() || !T->isDependentType(); 6983 } 6984 6985 /// \brief Returns the location of the entity whose type is being 6986 /// rebuilt. 6987 SourceLocation getBaseLocation() { return Loc; } 6988 6989 /// \brief Returns the name of the entity whose type is being rebuilt. 6990 DeclarationName getBaseEntity() { return Entity; } 6991 6992 /// \brief Sets the "base" location and entity when that 6993 /// information is known based on another transformation. 6994 void setBase(SourceLocation Loc, DeclarationName Entity) { 6995 this->Loc = Loc; 6996 this->Entity = Entity; 6997 } 6998 6999 ExprResult TransformLambdaExpr(LambdaExpr *E) { 7000 // Lambdas never need to be transformed. 7001 return E; 7002 } 7003 }; 7004} 7005 7006/// \brief Rebuilds a type within the context of the current instantiation. 7007/// 7008/// The type \p T is part of the type of an out-of-line member definition of 7009/// a class template (or class template partial specialization) that was parsed 7010/// and constructed before we entered the scope of the class template (or 7011/// partial specialization thereof). This routine will rebuild that type now 7012/// that we have entered the declarator's scope, which may produce different 7013/// canonical types, e.g., 7014/// 7015/// \code 7016/// template<typename T> 7017/// struct X { 7018/// typedef T* pointer; 7019/// pointer data(); 7020/// }; 7021/// 7022/// template<typename T> 7023/// typename X<T>::pointer X<T>::data() { ... } 7024/// \endcode 7025/// 7026/// Here, the type "typename X<T>::pointer" will be created as a DependentNameType, 7027/// since we do not know that we can look into X<T> when we parsed the type. 7028/// This function will rebuild the type, performing the lookup of "pointer" 7029/// in X<T> and returning an ElaboratedType whose canonical type is the same 7030/// as the canonical type of T*, allowing the return types of the out-of-line 7031/// definition and the declaration to match. 7032TypeSourceInfo *Sema::RebuildTypeInCurrentInstantiation(TypeSourceInfo *T, 7033 SourceLocation Loc, 7034 DeclarationName Name) { 7035 if (!T || !T->getType()->isDependentType()) 7036 return T; 7037 7038 CurrentInstantiationRebuilder Rebuilder(*this, Loc, Name); 7039 return Rebuilder.TransformType(T); 7040} 7041 7042ExprResult Sema::RebuildExprInCurrentInstantiation(Expr *E) { 7043 CurrentInstantiationRebuilder Rebuilder(*this, E->getExprLoc(), 7044 DeclarationName()); 7045 return Rebuilder.TransformExpr(E); 7046} 7047 7048bool Sema::RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS) { 7049 if (SS.isInvalid()) 7050 return true; 7051 7052 NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context); 7053 CurrentInstantiationRebuilder Rebuilder(*this, SS.getRange().getBegin(), 7054 DeclarationName()); 7055 NestedNameSpecifierLoc Rebuilt 7056 = Rebuilder.TransformNestedNameSpecifierLoc(QualifierLoc); 7057 if (!Rebuilt) 7058 return true; 7059 7060 SS.Adopt(Rebuilt); 7061 return false; 7062} 7063 7064/// \brief Rebuild the template parameters now that we know we're in a current 7065/// instantiation. 7066bool Sema::RebuildTemplateParamsInCurrentInstantiation( 7067 TemplateParameterList *Params) { 7068 for (unsigned I = 0, N = Params->size(); I != N; ++I) { 7069 Decl *Param = Params->getParam(I); 7070 7071 // There is nothing to rebuild in a type parameter. 7072 if (isa<TemplateTypeParmDecl>(Param)) 7073 continue; 7074 7075 // Rebuild the template parameter list of a template template parameter. 7076 if (TemplateTemplateParmDecl *TTP 7077 = dyn_cast<TemplateTemplateParmDecl>(Param)) { 7078 if (RebuildTemplateParamsInCurrentInstantiation( 7079 TTP->getTemplateParameters())) 7080 return true; 7081 7082 continue; 7083 } 7084 7085 // Rebuild the type of a non-type template parameter. 7086 NonTypeTemplateParmDecl *NTTP = cast<NonTypeTemplateParmDecl>(Param); 7087 TypeSourceInfo *NewTSI 7088 = RebuildTypeInCurrentInstantiation(NTTP->getTypeSourceInfo(), 7089 NTTP->getLocation(), 7090 NTTP->getDeclName()); 7091 if (!NewTSI) 7092 return true; 7093 7094 if (NewTSI != NTTP->getTypeSourceInfo()) { 7095 NTTP->setTypeSourceInfo(NewTSI); 7096 NTTP->setType(NewTSI->getType()); 7097 } 7098 } 7099 7100 return false; 7101} 7102 7103/// \brief Produces a formatted string that describes the binding of 7104/// template parameters to template arguments. 7105std::string 7106Sema::getTemplateArgumentBindingsText(const TemplateParameterList *Params, 7107 const TemplateArgumentList &Args) { 7108 return getTemplateArgumentBindingsText(Params, Args.data(), Args.size()); 7109} 7110 7111std::string 7112Sema::getTemplateArgumentBindingsText(const TemplateParameterList *Params, 7113 const TemplateArgument *Args, 7114 unsigned NumArgs) { 7115 SmallString<128> Str; 7116 llvm::raw_svector_ostream Out(Str); 7117 7118 if (!Params || Params->size() == 0 || NumArgs == 0) 7119 return std::string(); 7120 7121 for (unsigned I = 0, N = Params->size(); I != N; ++I) { 7122 if (I >= NumArgs) 7123 break; 7124 7125 if (I == 0) 7126 Out << "[with "; 7127 else 7128 Out << ", "; 7129 7130 if (const IdentifierInfo *Id = Params->getParam(I)->getIdentifier()) { 7131 Out << Id->getName(); 7132 } else { 7133 Out << '$' << I; 7134 } 7135 7136 Out << " = "; 7137 Args[I].print(getPrintingPolicy(), Out); 7138 } 7139 7140 Out << ']'; 7141 return Out.str(); 7142} 7143 7144void Sema::MarkAsLateParsedTemplate(FunctionDecl *FD, bool Flag) { 7145 if (!FD) 7146 return; 7147 FD->setLateTemplateParsed(Flag); 7148} 7149 7150bool Sema::IsInsideALocalClassWithinATemplateFunction() { 7151 DeclContext *DC = CurContext; 7152 7153 while (DC) { 7154 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(CurContext)) { 7155 const FunctionDecl *FD = RD->isLocalClass(); 7156 return (FD && FD->getTemplatedKind() != FunctionDecl::TK_NonTemplate); 7157 } else if (DC->isTranslationUnit() || DC->isNamespace()) 7158 return false; 7159 7160 DC = DC->getParent(); 7161 } 7162 return false; 7163} 7164