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