SemaTemplateVariadic.cpp revision db5d44b775c60166074acd184ca9f1981c10c2a7 
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->getIdentifier();
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 = 0, Index = 0;
479    IdentifierInfo *Name;
480    bool IsFunctionParameterPack = false;
481
482    if (const TemplateTypeParmType *TTP
483        = Unexpanded[I].first.dyn_cast<const TemplateTypeParmType *>()) {
484      Depth = TTP->getDepth();
485      Index = TTP->getIndex();
486      Name = TTP->getIdentifier();
487    } else {
488      NamedDecl *ND = Unexpanded[I].first.get<NamedDecl *>();
489      if (isa<ParmVarDecl>(ND))
490        IsFunctionParameterPack = true;
491      else
492        llvm::tie(Depth, Index) = getDepthAndIndex(ND);
493
494      Name = ND->getIdentifier();
495    }
496
497    // Determine the size of this argument pack.
498    unsigned NewPackSize;
499    if (IsFunctionParameterPack) {
500      // Figure out whether we're instantiating to an argument pack or not.
501      typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
502
503      llvm::PointerUnion<Decl *, DeclArgumentPack *> *Instantiation
504        = CurrentInstantiationScope->findInstantiationOf(
505                                        Unexpanded[I].first.get<NamedDecl *>());
506      if (Instantiation->is<DeclArgumentPack *>()) {
507        // We could expand this function parameter pack.
508        NewPackSize = Instantiation->get<DeclArgumentPack *>()->size();
509      } else {
510        // We can't expand this function parameter pack, so we can't expand
511        // the pack expansion.
512        ShouldExpand = false;
513        continue;
514      }
515    } else {
516      // If we don't have a template argument at this depth/index, then we
517      // cannot expand the pack expansion. Make a note of this, but we still
518      // want to check any parameter packs we *do* have arguments for.
519      if (Depth >= TemplateArgs.getNumLevels() ||
520          !TemplateArgs.hasTemplateArgument(Depth, Index)) {
521        ShouldExpand = false;
522        continue;
523      }
524
525      // Determine the size of the argument pack.
526      NewPackSize = TemplateArgs(Depth, Index).pack_size();
527    }
528
529    // C++0x [temp.arg.explicit]p9:
530    //   Template argument deduction can extend the sequence of template
531    //   arguments corresponding to a template parameter pack, even when the
532    //   sequence contains explicitly specified template arguments.
533    if (!IsFunctionParameterPack) {
534      if (NamedDecl *PartialPack
535                    = CurrentInstantiationScope->getPartiallySubstitutedPack()){
536        unsigned PartialDepth, PartialIndex;
537        llvm::tie(PartialDepth, PartialIndex) = getDepthAndIndex(PartialPack);
538        if (PartialDepth == Depth && PartialIndex == Index)
539          RetainExpansion = true;
540      }
541    }
542
543    if (!NumExpansions) {
544      // The is the first pack we've seen for which we have an argument.
545      // Record it.
546      NumExpansions = NewPackSize;
547      FirstPack.first = Name;
548      FirstPack.second = Unexpanded[I].second;
549      HaveFirstPack = true;
550      continue;
551    }
552
553    if (NewPackSize != *NumExpansions) {
554      // C++0x [temp.variadic]p5:
555      //   All of the parameter packs expanded by a pack expansion shall have
556      //   the same number of arguments specified.
557      if (HaveFirstPack)
558        Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict)
559          << FirstPack.first << Name << *NumExpansions << NewPackSize
560          << SourceRange(FirstPack.second) << SourceRange(Unexpanded[I].second);
561      else
562        Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict_multilevel)
563          << Name << *NumExpansions << NewPackSize
564          << SourceRange(Unexpanded[I].second);
565      return true;
566    }
567  }
568
569  return false;
570}
571
572unsigned Sema::getNumArgumentsInExpansion(QualType T,
573                          const MultiLevelTemplateArgumentList &TemplateArgs) {
574  QualType Pattern = cast<PackExpansionType>(T)->getPattern();
575  llvm::SmallVector<UnexpandedParameterPack, 2> Unexpanded;
576  CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseType(Pattern);
577
578  for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
579    // Compute the depth and index for this parameter pack.
580    unsigned Depth;
581    unsigned Index;
582
583    if (const TemplateTypeParmType *TTP
584          = Unexpanded[I].first.dyn_cast<const TemplateTypeParmType *>()) {
585      Depth = TTP->getDepth();
586      Index = TTP->getIndex();
587    } else {
588      NamedDecl *ND = Unexpanded[I].first.get<NamedDecl *>();
589      if (isa<ParmVarDecl>(ND)) {
590        // Function parameter pack.
591        typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
592
593        llvm::PointerUnion<Decl *, DeclArgumentPack *> *Instantiation
594          = CurrentInstantiationScope->findInstantiationOf(
595                                        Unexpanded[I].first.get<NamedDecl *>());
596        if (Instantiation->is<DeclArgumentPack *>())
597          return Instantiation->get<DeclArgumentPack *>()->size();
598
599        continue;
600      }
601
602      llvm::tie(Depth, Index) = getDepthAndIndex(ND);
603    }
604    if (Depth >= TemplateArgs.getNumLevels() ||
605        !TemplateArgs.hasTemplateArgument(Depth, Index))
606      continue;
607
608    // Determine the size of the argument pack.
609    return TemplateArgs(Depth, Index).pack_size();
610  }
611
612  llvm_unreachable("No unexpanded parameter packs in type expansion.");
613  return 0;
614}
615
616bool Sema::containsUnexpandedParameterPacks(Declarator &D) {
617  const DeclSpec &DS = D.getDeclSpec();
618  switch (DS.getTypeSpecType()) {
619  case TST_typename:
620  case TST_typeofType:
621  case TST_underlying_type: {
622    QualType T = DS.getRepAsType().get();
623    if (!T.isNull() && T->containsUnexpandedParameterPack())
624      return true;
625    break;
626  }
627
628  case TST_typeofExpr:
629  case TST_decltype:
630    if (DS.getRepAsExpr() &&
631        DS.getRepAsExpr()->containsUnexpandedParameterPack())
632      return true;
633    break;
634
635  case TST_unspecified:
636  case TST_void:
637  case TST_char:
638  case TST_wchar:
639  case TST_char16:
640  case TST_char32:
641  case TST_int:
642  case TST_float:
643  case TST_double:
644  case TST_bool:
645  case TST_decimal32:
646  case TST_decimal64:
647  case TST_decimal128:
648  case TST_enum:
649  case TST_union:
650  case TST_struct:
651  case TST_class:
652  case TST_auto:
653  case TST_unknown_anytype:
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