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