SemaTemplateVariadic.cpp revision 5a5a971908a1fd064454db44c42333a3aecf3d5b
1//===------- SemaTemplateVariadic.cpp - C++ Variadic 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++0x variadic templates. 10//===----------------------------------------------------------------------===/ 11 12#include "clang/Sema/Sema.h" 13#include "clang/Sema/Lookup.h" 14#include "clang/Sema/ParsedTemplate.h" 15#include "clang/Sema/SemaInternal.h" 16#include "clang/Sema/Template.h" 17#include "clang/AST/Expr.h" 18#include "clang/AST/RecursiveASTVisitor.h" 19#include "clang/AST/TypeLoc.h" 20 21using namespace clang; 22 23//---------------------------------------------------------------------------- 24// Visitor that collects unexpanded parameter packs 25//---------------------------------------------------------------------------- 26 27namespace { 28 /// \brief A class that collects unexpanded parameter packs. 29 class CollectUnexpandedParameterPacksVisitor : 30 public RecursiveASTVisitor<CollectUnexpandedParameterPacksVisitor> 31 { 32 typedef RecursiveASTVisitor<CollectUnexpandedParameterPacksVisitor> 33 inherited; 34 35 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded; 36 37 public: 38 explicit CollectUnexpandedParameterPacksVisitor( 39 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) 40 : Unexpanded(Unexpanded) { } 41 42 bool shouldWalkTypesOfTypeLocs() const { return false; } 43 44 //------------------------------------------------------------------------ 45 // Recording occurrences of (unexpanded) parameter packs. 46 //------------------------------------------------------------------------ 47 48 /// \brief Record occurrences of template type parameter packs. 49 bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 50 if (TL.getTypePtr()->isParameterPack()) 51 Unexpanded.push_back(std::make_pair(TL.getTypePtr(), TL.getNameLoc())); 52 return true; 53 } 54 55 /// \brief Record occurrences of template type parameter packs 56 /// when we don't have proper source-location information for 57 /// them. 58 /// 59 /// Ideally, this routine would never be used. 60 bool VisitTemplateTypeParmType(TemplateTypeParmType *T) { 61 if (T->isParameterPack()) 62 Unexpanded.push_back(std::make_pair(T, SourceLocation())); 63 64 return true; 65 } 66 67 /// \brief Record occurrences of function and non-type template 68 /// parameter packs in an expression. 69 bool VisitDeclRefExpr(DeclRefExpr *E) { 70 if (E->getDecl()->isParameterPack()) 71 Unexpanded.push_back(std::make_pair(E->getDecl(), E->getLocation())); 72 73 return true; 74 } 75 76 /// \brief Record occurrences of template template parameter packs. 77 bool TraverseTemplateName(TemplateName Template) { 78 if (TemplateTemplateParmDecl *TTP 79 = dyn_cast_or_null<TemplateTemplateParmDecl>( 80 Template.getAsTemplateDecl())) 81 if (TTP->isParameterPack()) 82 Unexpanded.push_back(std::make_pair(TTP, SourceLocation())); 83 84 return inherited::TraverseTemplateName(Template); 85 } 86 87 /// \brief Suppress traversal into Objective-C container literal 88 /// elements that are pack expansions. 89 bool TraverseObjCDictionaryLiteral(ObjCDictionaryLiteral *E) { 90 if (!E->containsUnexpandedParameterPack()) 91 return true; 92 93 for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) { 94 ObjCDictionaryElement Element = E->getKeyValueElement(I); 95 if (Element.isPackExpansion()) 96 continue; 97 98 TraverseStmt(Element.Key); 99 TraverseStmt(Element.Value); 100 } 101 return true; 102 } 103 //------------------------------------------------------------------------ 104 // Pruning the search for unexpanded parameter packs. 105 //------------------------------------------------------------------------ 106 107 /// \brief Suppress traversal into statements and expressions that 108 /// do not contain unexpanded parameter packs. 109 bool TraverseStmt(Stmt *S) { 110 if (Expr *E = dyn_cast_or_null<Expr>(S)) 111 if (E->containsUnexpandedParameterPack()) 112 return inherited::TraverseStmt(E); 113 114 return true; 115 } 116 117 /// \brief Suppress traversal into types that do not contain 118 /// unexpanded parameter packs. 119 bool TraverseType(QualType T) { 120 if (!T.isNull() && T->containsUnexpandedParameterPack()) 121 return inherited::TraverseType(T); 122 123 return true; 124 } 125 126 /// \brief Suppress traversel into types with location information 127 /// that do not contain unexpanded parameter packs. 128 bool TraverseTypeLoc(TypeLoc TL) { 129 if (!TL.getType().isNull() && 130 TL.getType()->containsUnexpandedParameterPack()) 131 return inherited::TraverseTypeLoc(TL); 132 133 return true; 134 } 135 136 /// \brief Suppress traversal of non-parameter declarations, since 137 /// they cannot contain unexpanded parameter packs. 138 bool TraverseDecl(Decl *D) { 139 if (D && isa<ParmVarDecl>(D)) 140 return inherited::TraverseDecl(D); 141 142 return true; 143 } 144 145 /// \brief Suppress traversal of template argument pack expansions. 146 bool TraverseTemplateArgument(const TemplateArgument &Arg) { 147 if (Arg.isPackExpansion()) 148 return true; 149 150 return inherited::TraverseTemplateArgument(Arg); 151 } 152 153 /// \brief Suppress traversal of template argument pack expansions. 154 bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &ArgLoc) { 155 if (ArgLoc.getArgument().isPackExpansion()) 156 return true; 157 158 return inherited::TraverseTemplateArgumentLoc(ArgLoc); 159 } 160 }; 161} 162 163/// \brief Diagnose all of the unexpanded parameter packs in the given 164/// vector. 165void 166Sema::DiagnoseUnexpandedParameterPacks(SourceLocation Loc, 167 UnexpandedParameterPackContext UPPC, 168 ArrayRef<UnexpandedParameterPack> Unexpanded) { 169 if (Unexpanded.empty()) 170 return; 171 172 SmallVector<SourceLocation, 4> Locations; 173 SmallVector<IdentifierInfo *, 4> Names; 174 llvm::SmallPtrSet<IdentifierInfo *, 4> NamesKnown; 175 176 for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { 177 IdentifierInfo *Name = 0; 178 if (const TemplateTypeParmType *TTP 179 = Unexpanded[I].first.dyn_cast<const TemplateTypeParmType *>()) 180 Name = TTP->getIdentifier(); 181 else 182 Name = Unexpanded[I].first.get<NamedDecl *>()->getIdentifier(); 183 184 if (Name && NamesKnown.insert(Name)) 185 Names.push_back(Name); 186 187 if (Unexpanded[I].second.isValid()) 188 Locations.push_back(Unexpanded[I].second); 189 } 190 191 DiagnosticBuilder DB 192 = Names.size() == 0? Diag(Loc, diag::err_unexpanded_parameter_pack_0) 193 << (int)UPPC 194 : Names.size() == 1? Diag(Loc, diag::err_unexpanded_parameter_pack_1) 195 << (int)UPPC << Names[0] 196 : Names.size() == 2? Diag(Loc, diag::err_unexpanded_parameter_pack_2) 197 << (int)UPPC << Names[0] << Names[1] 198 : Diag(Loc, diag::err_unexpanded_parameter_pack_3_or_more) 199 << (int)UPPC << Names[0] << Names[1]; 200 201 for (unsigned I = 0, N = Locations.size(); I != N; ++I) 202 DB << SourceRange(Locations[I]); 203} 204 205bool Sema::DiagnoseUnexpandedParameterPack(SourceLocation Loc, 206 TypeSourceInfo *T, 207 UnexpandedParameterPackContext UPPC) { 208 // C++0x [temp.variadic]p5: 209 // An appearance of a name of a parameter pack that is not expanded is 210 // ill-formed. 211 if (!T->getType()->containsUnexpandedParameterPack()) 212 return false; 213 214 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 215 CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseTypeLoc( 216 T->getTypeLoc()); 217 assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs"); 218 DiagnoseUnexpandedParameterPacks(Loc, UPPC, Unexpanded); 219 return true; 220} 221 222bool Sema::DiagnoseUnexpandedParameterPack(Expr *E, 223 UnexpandedParameterPackContext UPPC) { 224 // C++0x [temp.variadic]p5: 225 // An appearance of a name of a parameter pack that is not expanded is 226 // ill-formed. 227 if (!E->containsUnexpandedParameterPack()) 228 return false; 229 230 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 231 CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseStmt(E); 232 assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs"); 233 DiagnoseUnexpandedParameterPacks(E->getLocStart(), UPPC, Unexpanded); 234 return true; 235} 236 237bool Sema::DiagnoseUnexpandedParameterPack(const CXXScopeSpec &SS, 238 UnexpandedParameterPackContext UPPC) { 239 // C++0x [temp.variadic]p5: 240 // An appearance of a name of a parameter pack that is not expanded is 241 // ill-formed. 242 if (!SS.getScopeRep() || 243 !SS.getScopeRep()->containsUnexpandedParameterPack()) 244 return false; 245 246 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 247 CollectUnexpandedParameterPacksVisitor(Unexpanded) 248 .TraverseNestedNameSpecifier(SS.getScopeRep()); 249 assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs"); 250 DiagnoseUnexpandedParameterPacks(SS.getRange().getBegin(), 251 UPPC, Unexpanded); 252 return true; 253} 254 255bool Sema::DiagnoseUnexpandedParameterPack(const DeclarationNameInfo &NameInfo, 256 UnexpandedParameterPackContext UPPC) { 257 // C++0x [temp.variadic]p5: 258 // An appearance of a name of a parameter pack that is not expanded is 259 // ill-formed. 260 switch (NameInfo.getName().getNameKind()) { 261 case DeclarationName::Identifier: 262 case DeclarationName::ObjCZeroArgSelector: 263 case DeclarationName::ObjCOneArgSelector: 264 case DeclarationName::ObjCMultiArgSelector: 265 case DeclarationName::CXXOperatorName: 266 case DeclarationName::CXXLiteralOperatorName: 267 case DeclarationName::CXXUsingDirective: 268 return false; 269 270 case DeclarationName::CXXConstructorName: 271 case DeclarationName::CXXDestructorName: 272 case DeclarationName::CXXConversionFunctionName: 273 // FIXME: We shouldn't need this null check! 274 if (TypeSourceInfo *TSInfo = NameInfo.getNamedTypeInfo()) 275 return DiagnoseUnexpandedParameterPack(NameInfo.getLoc(), TSInfo, UPPC); 276 277 if (!NameInfo.getName().getCXXNameType()->containsUnexpandedParameterPack()) 278 return false; 279 280 break; 281 } 282 283 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 284 CollectUnexpandedParameterPacksVisitor(Unexpanded) 285 .TraverseType(NameInfo.getName().getCXXNameType()); 286 assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs"); 287 DiagnoseUnexpandedParameterPacks(NameInfo.getLoc(), UPPC, Unexpanded); 288 return true; 289} 290 291bool Sema::DiagnoseUnexpandedParameterPack(SourceLocation Loc, 292 TemplateName Template, 293 UnexpandedParameterPackContext UPPC) { 294 295 if (Template.isNull() || !Template.containsUnexpandedParameterPack()) 296 return false; 297 298 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 299 CollectUnexpandedParameterPacksVisitor(Unexpanded) 300 .TraverseTemplateName(Template); 301 assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs"); 302 DiagnoseUnexpandedParameterPacks(Loc, UPPC, Unexpanded); 303 return true; 304} 305 306bool Sema::DiagnoseUnexpandedParameterPack(TemplateArgumentLoc Arg, 307 UnexpandedParameterPackContext UPPC) { 308 if (Arg.getArgument().isNull() || 309 !Arg.getArgument().containsUnexpandedParameterPack()) 310 return false; 311 312 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 313 CollectUnexpandedParameterPacksVisitor(Unexpanded) 314 .TraverseTemplateArgumentLoc(Arg); 315 assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs"); 316 DiagnoseUnexpandedParameterPacks(Arg.getLocation(), UPPC, Unexpanded); 317 return true; 318} 319 320void Sema::collectUnexpandedParameterPacks(TemplateArgument Arg, 321 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) { 322 CollectUnexpandedParameterPacksVisitor(Unexpanded) 323 .TraverseTemplateArgument(Arg); 324} 325 326void Sema::collectUnexpandedParameterPacks(TemplateArgumentLoc Arg, 327 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) { 328 CollectUnexpandedParameterPacksVisitor(Unexpanded) 329 .TraverseTemplateArgumentLoc(Arg); 330} 331 332void Sema::collectUnexpandedParameterPacks(QualType T, 333 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) { 334 CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseType(T); 335} 336 337void Sema::collectUnexpandedParameterPacks(TypeLoc TL, 338 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) { 339 CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseTypeLoc(TL); 340} 341 342void Sema::collectUnexpandedParameterPacks(CXXScopeSpec &SS, 343 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) { 344 NestedNameSpecifier *Qualifier = SS.getScopeRep(); 345 if (!Qualifier) 346 return; 347 348 NestedNameSpecifierLoc QualifierLoc(Qualifier, SS.location_data()); 349 CollectUnexpandedParameterPacksVisitor(Unexpanded) 350 .TraverseNestedNameSpecifierLoc(QualifierLoc); 351} 352 353void Sema::collectUnexpandedParameterPacks(const DeclarationNameInfo &NameInfo, 354 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) { 355 CollectUnexpandedParameterPacksVisitor(Unexpanded) 356 .TraverseDeclarationNameInfo(NameInfo); 357} 358 359 360ParsedTemplateArgument 361Sema::ActOnPackExpansion(const ParsedTemplateArgument &Arg, 362 SourceLocation EllipsisLoc) { 363 if (Arg.isInvalid()) 364 return Arg; 365 366 switch (Arg.getKind()) { 367 case ParsedTemplateArgument::Type: { 368 TypeResult Result = ActOnPackExpansion(Arg.getAsType(), EllipsisLoc); 369 if (Result.isInvalid()) 370 return ParsedTemplateArgument(); 371 372 return ParsedTemplateArgument(Arg.getKind(), Result.get().getAsOpaquePtr(), 373 Arg.getLocation()); 374 } 375 376 case ParsedTemplateArgument::NonType: { 377 ExprResult Result = ActOnPackExpansion(Arg.getAsExpr(), EllipsisLoc); 378 if (Result.isInvalid()) 379 return ParsedTemplateArgument(); 380 381 return ParsedTemplateArgument(Arg.getKind(), Result.get(), 382 Arg.getLocation()); 383 } 384 385 case ParsedTemplateArgument::Template: 386 if (!Arg.getAsTemplate().get().containsUnexpandedParameterPack()) { 387 SourceRange R(Arg.getLocation()); 388 if (Arg.getScopeSpec().isValid()) 389 R.setBegin(Arg.getScopeSpec().getBeginLoc()); 390 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs) 391 << R; 392 return ParsedTemplateArgument(); 393 } 394 395 return Arg.getTemplatePackExpansion(EllipsisLoc); 396 } 397 llvm_unreachable("Unhandled template argument kind?"); 398} 399 400TypeResult Sema::ActOnPackExpansion(ParsedType Type, 401 SourceLocation EllipsisLoc) { 402 TypeSourceInfo *TSInfo; 403 GetTypeFromParser(Type, &TSInfo); 404 if (!TSInfo) 405 return true; 406 407 TypeSourceInfo *TSResult = CheckPackExpansion(TSInfo, EllipsisLoc, 408 llvm::Optional<unsigned>()); 409 if (!TSResult) 410 return true; 411 412 return CreateParsedType(TSResult->getType(), TSResult); 413} 414 415TypeSourceInfo *Sema::CheckPackExpansion(TypeSourceInfo *Pattern, 416 SourceLocation EllipsisLoc, 417 llvm::Optional<unsigned> NumExpansions) { 418 // Create the pack expansion type and source-location information. 419 QualType Result = CheckPackExpansion(Pattern->getType(), 420 Pattern->getTypeLoc().getSourceRange(), 421 EllipsisLoc, NumExpansions); 422 if (Result.isNull()) 423 return 0; 424 425 TypeSourceInfo *TSResult = Context.CreateTypeSourceInfo(Result); 426 PackExpansionTypeLoc TL = cast<PackExpansionTypeLoc>(TSResult->getTypeLoc()); 427 TL.setEllipsisLoc(EllipsisLoc); 428 429 // Copy over the source-location information from the type. 430 memcpy(TL.getNextTypeLoc().getOpaqueData(), 431 Pattern->getTypeLoc().getOpaqueData(), 432 Pattern->getTypeLoc().getFullDataSize()); 433 return TSResult; 434} 435 436QualType Sema::CheckPackExpansion(QualType Pattern, 437 SourceRange PatternRange, 438 SourceLocation EllipsisLoc, 439 llvm::Optional<unsigned> NumExpansions) { 440 // C++0x [temp.variadic]p5: 441 // The pattern of a pack expansion shall name one or more 442 // parameter packs that are not expanded by a nested pack 443 // expansion. 444 if (!Pattern->containsUnexpandedParameterPack()) { 445 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs) 446 << PatternRange; 447 return QualType(); 448 } 449 450 return Context.getPackExpansionType(Pattern, NumExpansions); 451} 452 453ExprResult Sema::ActOnPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc) { 454 return CheckPackExpansion(Pattern, EllipsisLoc, llvm::Optional<unsigned>()); 455} 456 457ExprResult Sema::CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc, 458 llvm::Optional<unsigned> NumExpansions) { 459 if (!Pattern) 460 return ExprError(); 461 462 // C++0x [temp.variadic]p5: 463 // The pattern of a pack expansion shall name one or more 464 // parameter packs that are not expanded by a nested pack 465 // expansion. 466 if (!Pattern->containsUnexpandedParameterPack()) { 467 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs) 468 << Pattern->getSourceRange(); 469 return ExprError(); 470 } 471 472 // Create the pack expansion expression and source-location information. 473 return Owned(new (Context) PackExpansionExpr(Context.DependentTy, Pattern, 474 EllipsisLoc, NumExpansions)); 475} 476 477/// \brief Retrieve the depth and index of a parameter pack. 478static std::pair<unsigned, unsigned> 479getDepthAndIndex(NamedDecl *ND) { 480 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND)) 481 return std::make_pair(TTP->getDepth(), TTP->getIndex()); 482 483 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND)) 484 return std::make_pair(NTTP->getDepth(), NTTP->getIndex()); 485 486 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(ND); 487 return std::make_pair(TTP->getDepth(), TTP->getIndex()); 488} 489 490bool Sema::CheckParameterPacksForExpansion(SourceLocation EllipsisLoc, 491 SourceRange PatternRange, 492 ArrayRef<UnexpandedParameterPack> Unexpanded, 493 const MultiLevelTemplateArgumentList &TemplateArgs, 494 bool &ShouldExpand, 495 bool &RetainExpansion, 496 llvm::Optional<unsigned> &NumExpansions) { 497 ShouldExpand = true; 498 RetainExpansion = false; 499 std::pair<IdentifierInfo *, SourceLocation> FirstPack; 500 bool HaveFirstPack = false; 501 502 for (ArrayRef<UnexpandedParameterPack>::iterator i = Unexpanded.begin(), 503 end = Unexpanded.end(); 504 i != end; ++i) { 505 // Compute the depth and index for this parameter pack. 506 unsigned Depth = 0, Index = 0; 507 IdentifierInfo *Name; 508 bool IsFunctionParameterPack = false; 509 510 if (const TemplateTypeParmType *TTP 511 = i->first.dyn_cast<const TemplateTypeParmType *>()) { 512 Depth = TTP->getDepth(); 513 Index = TTP->getIndex(); 514 Name = TTP->getIdentifier(); 515 } else { 516 NamedDecl *ND = i->first.get<NamedDecl *>(); 517 if (isa<ParmVarDecl>(ND)) 518 IsFunctionParameterPack = true; 519 else 520 llvm::tie(Depth, Index) = getDepthAndIndex(ND); 521 522 Name = ND->getIdentifier(); 523 } 524 525 // Determine the size of this argument pack. 526 unsigned NewPackSize; 527 if (IsFunctionParameterPack) { 528 // Figure out whether we're instantiating to an argument pack or not. 529 typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack; 530 531 llvm::PointerUnion<Decl *, DeclArgumentPack *> *Instantiation 532 = CurrentInstantiationScope->findInstantiationOf( 533 i->first.get<NamedDecl *>()); 534 if (Instantiation->is<DeclArgumentPack *>()) { 535 // We could expand this function parameter pack. 536 NewPackSize = Instantiation->get<DeclArgumentPack *>()->size(); 537 } else { 538 // We can't expand this function parameter pack, so we can't expand 539 // the pack expansion. 540 ShouldExpand = false; 541 continue; 542 } 543 } else { 544 // If we don't have a template argument at this depth/index, then we 545 // cannot expand the pack expansion. Make a note of this, but we still 546 // want to check any parameter packs we *do* have arguments for. 547 if (Depth >= TemplateArgs.getNumLevels() || 548 !TemplateArgs.hasTemplateArgument(Depth, Index)) { 549 ShouldExpand = false; 550 continue; 551 } 552 553 // Determine the size of the argument pack. 554 NewPackSize = TemplateArgs(Depth, Index).pack_size(); 555 } 556 557 // C++0x [temp.arg.explicit]p9: 558 // Template argument deduction can extend the sequence of template 559 // arguments corresponding to a template parameter pack, even when the 560 // sequence contains explicitly specified template arguments. 561 if (!IsFunctionParameterPack) { 562 if (NamedDecl *PartialPack 563 = CurrentInstantiationScope->getPartiallySubstitutedPack()){ 564 unsigned PartialDepth, PartialIndex; 565 llvm::tie(PartialDepth, PartialIndex) = getDepthAndIndex(PartialPack); 566 if (PartialDepth == Depth && PartialIndex == Index) 567 RetainExpansion = true; 568 } 569 } 570 571 if (!NumExpansions) { 572 // The is the first pack we've seen for which we have an argument. 573 // Record it. 574 NumExpansions = NewPackSize; 575 FirstPack.first = Name; 576 FirstPack.second = i->second; 577 HaveFirstPack = true; 578 continue; 579 } 580 581 if (NewPackSize != *NumExpansions) { 582 // C++0x [temp.variadic]p5: 583 // All of the parameter packs expanded by a pack expansion shall have 584 // the same number of arguments specified. 585 if (HaveFirstPack) 586 Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict) 587 << FirstPack.first << Name << *NumExpansions << NewPackSize 588 << SourceRange(FirstPack.second) << SourceRange(i->second); 589 else 590 Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict_multilevel) 591 << Name << *NumExpansions << NewPackSize 592 << SourceRange(i->second); 593 return true; 594 } 595 } 596 597 return false; 598} 599 600unsigned Sema::getNumArgumentsInExpansion(QualType T, 601 const MultiLevelTemplateArgumentList &TemplateArgs) { 602 QualType Pattern = cast<PackExpansionType>(T)->getPattern(); 603 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 604 CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseType(Pattern); 605 606 for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { 607 // Compute the depth and index for this parameter pack. 608 unsigned Depth; 609 unsigned Index; 610 611 if (const TemplateTypeParmType *TTP 612 = Unexpanded[I].first.dyn_cast<const TemplateTypeParmType *>()) { 613 Depth = TTP->getDepth(); 614 Index = TTP->getIndex(); 615 } else { 616 NamedDecl *ND = Unexpanded[I].first.get<NamedDecl *>(); 617 if (isa<ParmVarDecl>(ND)) { 618 // Function parameter pack. 619 typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack; 620 621 llvm::PointerUnion<Decl *, DeclArgumentPack *> *Instantiation 622 = CurrentInstantiationScope->findInstantiationOf( 623 Unexpanded[I].first.get<NamedDecl *>()); 624 if (Instantiation->is<DeclArgumentPack *>()) 625 return Instantiation->get<DeclArgumentPack *>()->size(); 626 627 continue; 628 } 629 630 llvm::tie(Depth, Index) = getDepthAndIndex(ND); 631 } 632 if (Depth >= TemplateArgs.getNumLevels() || 633 !TemplateArgs.hasTemplateArgument(Depth, Index)) 634 continue; 635 636 // Determine the size of the argument pack. 637 return TemplateArgs(Depth, Index).pack_size(); 638 } 639 640 llvm_unreachable("No unexpanded parameter packs in type expansion."); 641} 642 643bool Sema::containsUnexpandedParameterPacks(Declarator &D) { 644 const DeclSpec &DS = D.getDeclSpec(); 645 switch (DS.getTypeSpecType()) { 646 case TST_typename: 647 case TST_typeofType: 648 case TST_underlyingType: 649 case TST_atomic: { 650 QualType T = DS.getRepAsType().get(); 651 if (!T.isNull() && T->containsUnexpandedParameterPack()) 652 return true; 653 break; 654 } 655 656 case TST_typeofExpr: 657 case TST_decltype: 658 if (DS.getRepAsExpr() && 659 DS.getRepAsExpr()->containsUnexpandedParameterPack()) 660 return true; 661 break; 662 663 case TST_unspecified: 664 case TST_void: 665 case TST_char: 666 case TST_wchar: 667 case TST_char16: 668 case TST_char32: 669 case TST_int: 670 case TST_int128: 671 case TST_half: 672 case TST_float: 673 case TST_double: 674 case TST_bool: 675 case TST_decimal32: 676 case TST_decimal64: 677 case TST_decimal128: 678 case TST_enum: 679 case TST_union: 680 case TST_struct: 681 case TST_class: 682 case TST_auto: 683 case TST_unknown_anytype: 684 case TST_error: 685 break; 686 } 687 688 for (unsigned I = 0, N = D.getNumTypeObjects(); I != N; ++I) { 689 const DeclaratorChunk &Chunk = D.getTypeObject(I); 690 switch (Chunk.Kind) { 691 case DeclaratorChunk::Pointer: 692 case DeclaratorChunk::Reference: 693 case DeclaratorChunk::Paren: 694 // These declarator chunks cannot contain any parameter packs. 695 break; 696 697 case DeclaratorChunk::Array: 698 case DeclaratorChunk::Function: 699 case DeclaratorChunk::BlockPointer: 700 // Syntactically, these kinds of declarator chunks all come after the 701 // declarator-id (conceptually), so the parser should not invoke this 702 // routine at this time. 703 llvm_unreachable("Could not have seen this kind of declarator chunk"); 704 705 case DeclaratorChunk::MemberPointer: 706 if (Chunk.Mem.Scope().getScopeRep() && 707 Chunk.Mem.Scope().getScopeRep()->containsUnexpandedParameterPack()) 708 return true; 709 break; 710 } 711 } 712 713 return false; 714} 715 716namespace { 717 718// Callback to only accept typo corrections that refer to parameter packs. 719class ParameterPackValidatorCCC : public CorrectionCandidateCallback { 720 public: 721 virtual bool ValidateCandidate(const TypoCorrection &candidate) { 722 NamedDecl *ND = candidate.getCorrectionDecl(); 723 return ND && ND->isParameterPack(); 724 } 725}; 726 727} 728 729/// \brief Called when an expression computing the size of a parameter pack 730/// is parsed. 731/// 732/// \code 733/// template<typename ...Types> struct count { 734/// static const unsigned value = sizeof...(Types); 735/// }; 736/// \endcode 737/// 738// 739/// \param OpLoc The location of the "sizeof" keyword. 740/// \param Name The name of the parameter pack whose size will be determined. 741/// \param NameLoc The source location of the name of the parameter pack. 742/// \param RParenLoc The location of the closing parentheses. 743ExprResult Sema::ActOnSizeofParameterPackExpr(Scope *S, 744 SourceLocation OpLoc, 745 IdentifierInfo &Name, 746 SourceLocation NameLoc, 747 SourceLocation RParenLoc) { 748 // C++0x [expr.sizeof]p5: 749 // The identifier in a sizeof... expression shall name a parameter pack. 750 LookupResult R(*this, &Name, NameLoc, LookupOrdinaryName); 751 LookupName(R, S); 752 753 NamedDecl *ParameterPack = 0; 754 ParameterPackValidatorCCC Validator; 755 switch (R.getResultKind()) { 756 case LookupResult::Found: 757 ParameterPack = R.getFoundDecl(); 758 break; 759 760 case LookupResult::NotFound: 761 case LookupResult::NotFoundInCurrentInstantiation: 762 if (TypoCorrection Corrected = CorrectTypo(R.getLookupNameInfo(), 763 R.getLookupKind(), S, 0, 764 Validator)) { 765 std::string CorrectedQuotedStr(Corrected.getQuoted(getLangOpts())); 766 ParameterPack = Corrected.getCorrectionDecl(); 767 Diag(NameLoc, diag::err_sizeof_pack_no_pack_name_suggest) 768 << &Name << CorrectedQuotedStr 769 << FixItHint::CreateReplacement( 770 NameLoc, Corrected.getAsString(getLangOpts())); 771 Diag(ParameterPack->getLocation(), diag::note_parameter_pack_here) 772 << CorrectedQuotedStr; 773 } 774 775 case LookupResult::FoundOverloaded: 776 case LookupResult::FoundUnresolvedValue: 777 break; 778 779 case LookupResult::Ambiguous: 780 DiagnoseAmbiguousLookup(R); 781 return ExprError(); 782 } 783 784 if (!ParameterPack || !ParameterPack->isParameterPack()) { 785 Diag(NameLoc, diag::err_sizeof_pack_no_pack_name) 786 << &Name; 787 return ExprError(); 788 } 789 790 MarkAnyDeclReferenced(OpLoc, ParameterPack); 791 792 return new (Context) SizeOfPackExpr(Context.getSizeType(), OpLoc, 793 ParameterPack, NameLoc, RParenLoc); 794} 795