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