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