clang  3.7.0
SemaTemplateVariadic.cpp
Go to the documentation of this file.
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 "TypeLocBuilder.h"
14 #include "clang/AST/Expr.h"
16 #include "clang/AST/TypeLoc.h"
17 #include "clang/Sema/Lookup.h"
19 #include "clang/Sema/ScopeInfo.h"
21 #include "clang/Sema/Template.h"
22 
23 using namespace clang;
24 
25 //----------------------------------------------------------------------------
26 // Visitor that collects unexpanded parameter packs
27 //----------------------------------------------------------------------------
28 
29 namespace {
30  /// \brief A class that collects unexpanded parameter packs.
31  class CollectUnexpandedParameterPacksVisitor :
32  public RecursiveASTVisitor<CollectUnexpandedParameterPacksVisitor>
33  {
35  inherited;
36 
38 
39  bool InLambda;
40 
41  public:
42  explicit CollectUnexpandedParameterPacksVisitor(
44  : Unexpanded(Unexpanded), InLambda(false) { }
45 
46  bool shouldWalkTypesOfTypeLocs() const { return false; }
47 
48  //------------------------------------------------------------------------
49  // Recording occurrences of (unexpanded) parameter packs.
50  //------------------------------------------------------------------------
51 
52  /// \brief Record occurrences of template type parameter packs.
53  bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
54  if (TL.getTypePtr()->isParameterPack())
55  Unexpanded.push_back(std::make_pair(TL.getTypePtr(), TL.getNameLoc()));
56  return true;
57  }
58 
59  /// \brief Record occurrences of template type parameter packs
60  /// when we don't have proper source-location information for
61  /// them.
62  ///
63  /// Ideally, this routine would never be used.
64  bool VisitTemplateTypeParmType(TemplateTypeParmType *T) {
65  if (T->isParameterPack())
66  Unexpanded.push_back(std::make_pair(T, SourceLocation()));
67 
68  return true;
69  }
70 
71  /// \brief Record occurrences of function and non-type template
72  /// parameter packs in an expression.
73  bool VisitDeclRefExpr(DeclRefExpr *E) {
74  if (E->getDecl()->isParameterPack())
75  Unexpanded.push_back(std::make_pair(E->getDecl(), E->getLocation()));
76 
77  return true;
78  }
79 
80  /// \brief Record occurrences of template template parameter packs.
81  bool TraverseTemplateName(TemplateName Template) {
82  if (TemplateTemplateParmDecl *TTP
83  = dyn_cast_or_null<TemplateTemplateParmDecl>(
84  Template.getAsTemplateDecl()))
85  if (TTP->isParameterPack())
86  Unexpanded.push_back(std::make_pair(TTP, SourceLocation()));
87 
88  return inherited::TraverseTemplateName(Template);
89  }
90 
91  /// \brief Suppress traversal into Objective-C container literal
92  /// elements that are pack expansions.
93  bool TraverseObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
95  return true;
96 
97  for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) {
99  if (Element.isPackExpansion())
100  continue;
101 
102  TraverseStmt(Element.Key);
103  TraverseStmt(Element.Value);
104  }
105  return true;
106  }
107  //------------------------------------------------------------------------
108  // Pruning the search for unexpanded parameter packs.
109  //------------------------------------------------------------------------
110 
111  /// \brief Suppress traversal into statements and expressions that
112  /// do not contain unexpanded parameter packs.
113  bool TraverseStmt(Stmt *S) {
114  Expr *E = dyn_cast_or_null<Expr>(S);
115  if ((E && E->containsUnexpandedParameterPack()) || InLambda)
116  return inherited::TraverseStmt(S);
117 
118  return true;
119  }
120 
121  /// \brief Suppress traversal into types that do not contain
122  /// unexpanded parameter packs.
123  bool TraverseType(QualType T) {
124  if ((!T.isNull() && T->containsUnexpandedParameterPack()) || InLambda)
125  return inherited::TraverseType(T);
126 
127  return true;
128  }
129 
130  /// \brief Suppress traversel into types with location information
131  /// that do not contain unexpanded parameter packs.
132  bool TraverseTypeLoc(TypeLoc TL) {
133  if ((!TL.getType().isNull() &&
135  InLambda)
136  return inherited::TraverseTypeLoc(TL);
137 
138  return true;
139  }
140 
141  /// \brief Suppress traversal of non-parameter declarations, since
142  /// they cannot contain unexpanded parameter packs.
143  bool TraverseDecl(Decl *D) {
144  if ((D && isa<ParmVarDecl>(D)) || InLambda)
145  return inherited::TraverseDecl(D);
146 
147  return true;
148  }
149 
150  /// \brief Suppress traversal of template argument pack expansions.
151  bool TraverseTemplateArgument(const TemplateArgument &Arg) {
152  if (Arg.isPackExpansion())
153  return true;
154 
155  return inherited::TraverseTemplateArgument(Arg);
156  }
157 
158  /// \brief Suppress traversal of template argument pack expansions.
159  bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &ArgLoc) {
160  if (ArgLoc.getArgument().isPackExpansion())
161  return true;
162 
163  return inherited::TraverseTemplateArgumentLoc(ArgLoc);
164  }
165 
166  /// \brief Note whether we're traversing a lambda containing an unexpanded
167  /// parameter pack. In this case, the unexpanded pack can occur anywhere,
168  /// including all the places where we normally wouldn't look. Within a
169  /// lambda, we don't propagate the 'contains unexpanded parameter pack' bit
170  /// outside an expression.
171  bool TraverseLambdaExpr(LambdaExpr *Lambda) {
172  // The ContainsUnexpandedParameterPack bit on a lambda is always correct,
173  // even if it's contained within another lambda.
174  if (!Lambda->containsUnexpandedParameterPack())
175  return true;
176 
177  bool WasInLambda = InLambda;
178  InLambda = true;
179 
180  // If any capture names a function parameter pack, that pack is expanded
181  // when the lambda is expanded.
182  for (LambdaExpr::capture_iterator I = Lambda->capture_begin(),
183  E = Lambda->capture_end();
184  I != E; ++I) {
185  if (I->capturesVariable()) {
186  VarDecl *VD = I->getCapturedVar();
187  if (VD->isParameterPack())
188  Unexpanded.push_back(std::make_pair(VD, I->getLocation()));
189  }
190  }
191 
192  inherited::TraverseLambdaExpr(Lambda);
193 
194  InLambda = WasInLambda;
195  return true;
196  }
197  };
198 }
199 
200 /// \brief Determine whether it's possible for an unexpanded parameter pack to
201 /// be valid in this location. This only happens when we're in a declaration
202 /// that is nested within an expression that could be expanded, such as a
203 /// lambda-expression within a function call.
204 ///
205 /// This is conservatively correct, but may claim that some unexpanded packs are
206 /// permitted when they are not.
208  for (auto *SI : FunctionScopes)
209  if (isa<sema::LambdaScopeInfo>(SI))
210  return true;
211  return false;
212 }
213 
214 /// \brief Diagnose all of the unexpanded parameter packs in the given
215 /// vector.
216 bool
220  if (Unexpanded.empty())
221  return false;
222 
223  // If we are within a lambda expression, that lambda contains an unexpanded
224  // parameter pack, and we are done.
225  // FIXME: Store 'Unexpanded' on the lambda so we don't need to recompute it
226  // later.
227  for (unsigned N = FunctionScopes.size(); N; --N) {
228  if (sema::LambdaScopeInfo *LSI =
229  dyn_cast<sema::LambdaScopeInfo>(FunctionScopes[N-1])) {
230  LSI->ContainsUnexpandedParameterPack = true;
231  return false;
232  }
233  }
234 
237  llvm::SmallPtrSet<IdentifierInfo *, 4> NamesKnown;
238 
239  for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
240  IdentifierInfo *Name = nullptr;
241  if (const TemplateTypeParmType *TTP
242  = Unexpanded[I].first.dyn_cast<const TemplateTypeParmType *>())
243  Name = TTP->getIdentifier();
244  else
245  Name = Unexpanded[I].first.get<NamedDecl *>()->getIdentifier();
246 
247  if (Name && NamesKnown.insert(Name).second)
248  Names.push_back(Name);
249 
250  if (Unexpanded[I].second.isValid())
251  Locations.push_back(Unexpanded[I].second);
252  }
253 
254  DiagnosticBuilder DB = Diag(Loc, diag::err_unexpanded_parameter_pack)
255  << (int)UPPC << (int)Names.size();
256  for (size_t I = 0, E = std::min(Names.size(), (size_t)2); I != E; ++I)
257  DB << Names[I];
258 
259  for (unsigned I = 0, N = Locations.size(); I != N; ++I)
260  DB << SourceRange(Locations[I]);
261  return true;
262 }
263 
265  TypeSourceInfo *T,
267  // C++0x [temp.variadic]p5:
268  // An appearance of a name of a parameter pack that is not expanded is
269  // ill-formed.
271  return false;
272 
274  CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseTypeLoc(
275  T->getTypeLoc());
276  assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
277  return DiagnoseUnexpandedParameterPacks(Loc, UPPC, Unexpanded);
278 }
279 
282  // C++0x [temp.variadic]p5:
283  // An appearance of a name of a parameter pack that is not expanded is
284  // ill-formed.
286  return false;
287 
289  CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseStmt(E);
290  assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
291  return DiagnoseUnexpandedParameterPacks(E->getLocStart(), UPPC, Unexpanded);
292 }
293 
296  // C++0x [temp.variadic]p5:
297  // An appearance of a name of a parameter pack that is not expanded is
298  // ill-formed.
299  if (!SS.getScopeRep() ||
301  return false;
302 
304  CollectUnexpandedParameterPacksVisitor(Unexpanded)
305  .TraverseNestedNameSpecifier(SS.getScopeRep());
306  assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
308  UPPC, Unexpanded);
309 }
310 
313  // C++0x [temp.variadic]p5:
314  // An appearance of a name of a parameter pack that is not expanded is
315  // ill-formed.
316  switch (NameInfo.getName().getNameKind()) {
324  return false;
325 
329  // FIXME: We shouldn't need this null check!
330  if (TypeSourceInfo *TSInfo = NameInfo.getNamedTypeInfo())
331  return DiagnoseUnexpandedParameterPack(NameInfo.getLoc(), TSInfo, UPPC);
332 
334  return false;
335 
336  break;
337  }
338 
340  CollectUnexpandedParameterPacksVisitor(Unexpanded)
341  .TraverseType(NameInfo.getName().getCXXNameType());
342  assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
343  return DiagnoseUnexpandedParameterPacks(NameInfo.getLoc(), UPPC, Unexpanded);
344 }
345 
347  TemplateName Template,
349 
350  if (Template.isNull() || !Template.containsUnexpandedParameterPack())
351  return false;
352 
354  CollectUnexpandedParameterPacksVisitor(Unexpanded)
355  .TraverseTemplateName(Template);
356  assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
357  return DiagnoseUnexpandedParameterPacks(Loc, UPPC, Unexpanded);
358 }
359 
362  if (Arg.getArgument().isNull() ||
364  return false;
365 
367  CollectUnexpandedParameterPacksVisitor(Unexpanded)
368  .TraverseTemplateArgumentLoc(Arg);
369  assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
370  return DiagnoseUnexpandedParameterPacks(Arg.getLocation(), UPPC, Unexpanded);
371 }
372 
375  CollectUnexpandedParameterPacksVisitor(Unexpanded)
376  .TraverseTemplateArgument(Arg);
377 }
378 
381  CollectUnexpandedParameterPacksVisitor(Unexpanded)
382  .TraverseTemplateArgumentLoc(Arg);
383 }
384 
387  CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseType(T);
388 }
389 
392  CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseTypeLoc(TL);
393 }
394 
397  NestedNameSpecifier *Qualifier = SS.getScopeRep();
398  if (!Qualifier)
399  return;
400 
401  NestedNameSpecifierLoc QualifierLoc(Qualifier, SS.location_data());
402  CollectUnexpandedParameterPacksVisitor(Unexpanded)
403  .TraverseNestedNameSpecifierLoc(QualifierLoc);
404 }
405 
408  CollectUnexpandedParameterPacksVisitor(Unexpanded)
409  .TraverseDeclarationNameInfo(NameInfo);
410 }
411 
412 
415  SourceLocation EllipsisLoc) {
416  if (Arg.isInvalid())
417  return Arg;
418 
419  switch (Arg.getKind()) {
421  TypeResult Result = ActOnPackExpansion(Arg.getAsType(), EllipsisLoc);
422  if (Result.isInvalid())
423  return ParsedTemplateArgument();
424 
425  return ParsedTemplateArgument(Arg.getKind(), Result.get().getAsOpaquePtr(),
426  Arg.getLocation());
427  }
428 
430  ExprResult Result = ActOnPackExpansion(Arg.getAsExpr(), EllipsisLoc);
431  if (Result.isInvalid())
432  return ParsedTemplateArgument();
433 
434  return ParsedTemplateArgument(Arg.getKind(), Result.get(),
435  Arg.getLocation());
436  }
437 
440  SourceRange R(Arg.getLocation());
441  if (Arg.getScopeSpec().isValid())
442  R.setBegin(Arg.getScopeSpec().getBeginLoc());
443  Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
444  << R;
445  return ParsedTemplateArgument();
446  }
447 
448  return Arg.getTemplatePackExpansion(EllipsisLoc);
449  }
450  llvm_unreachable("Unhandled template argument kind?");
451 }
452 
454  SourceLocation EllipsisLoc) {
455  TypeSourceInfo *TSInfo;
456  GetTypeFromParser(Type, &TSInfo);
457  if (!TSInfo)
458  return true;
459 
460  TypeSourceInfo *TSResult = CheckPackExpansion(TSInfo, EllipsisLoc, None);
461  if (!TSResult)
462  return true;
463 
464  return CreateParsedType(TSResult->getType(), TSResult);
465 }
466 
469  Optional<unsigned> NumExpansions) {
470  // Create the pack expansion type and source-location information.
472  Pattern->getTypeLoc().getSourceRange(),
473  EllipsisLoc, NumExpansions);
474  if (Result.isNull())
475  return nullptr;
476 
477  TypeLocBuilder TLB;
478  TLB.pushFullCopy(Pattern->getTypeLoc());
480  TL.setEllipsisLoc(EllipsisLoc);
481 
482  return TLB.getTypeSourceInfo(Context, Result);
483 }
484 
486  SourceLocation EllipsisLoc,
487  Optional<unsigned> NumExpansions) {
488  // C++0x [temp.variadic]p5:
489  // The pattern of a pack expansion shall name one or more
490  // parameter packs that are not expanded by a nested pack
491  // expansion.
492  if (!Pattern->containsUnexpandedParameterPack()) {
493  Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
494  << PatternRange;
495  return QualType();
496  }
497 
498  return Context.getPackExpansionType(Pattern, NumExpansions);
499 }
500 
502  return CheckPackExpansion(Pattern, EllipsisLoc, None);
503 }
504 
506  Optional<unsigned> NumExpansions) {
507  if (!Pattern)
508  return ExprError();
509 
510  // C++0x [temp.variadic]p5:
511  // The pattern of a pack expansion shall name one or more
512  // parameter packs that are not expanded by a nested pack
513  // expansion.
514  if (!Pattern->containsUnexpandedParameterPack()) {
515  Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
516  << Pattern->getSourceRange();
517  return ExprError();
518  }
519 
520  // Create the pack expansion expression and source-location information.
521  return new (Context)
522  PackExpansionExpr(Context.DependentTy, Pattern, EllipsisLoc, NumExpansions);
523 }
524 
525 /// \brief Retrieve the depth and index of a parameter pack.
526 static std::pair<unsigned, unsigned>
528  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND))
529  return std::make_pair(TTP->getDepth(), TTP->getIndex());
530 
531  if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND))
532  return std::make_pair(NTTP->getDepth(), NTTP->getIndex());
533 
534  TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(ND);
535  return std::make_pair(TTP->getDepth(), TTP->getIndex());
536 }
537 
539  SourceLocation EllipsisLoc, SourceRange PatternRange,
541  const MultiLevelTemplateArgumentList &TemplateArgs, bool &ShouldExpand,
542  bool &RetainExpansion, Optional<unsigned> &NumExpansions) {
543  ShouldExpand = true;
544  RetainExpansion = false;
545  std::pair<IdentifierInfo *, SourceLocation> FirstPack;
546  bool HaveFirstPack = false;
547 
548  for (ArrayRef<UnexpandedParameterPack>::iterator i = Unexpanded.begin(),
549  end = Unexpanded.end();
550  i != end; ++i) {
551  // Compute the depth and index for this parameter pack.
552  unsigned Depth = 0, Index = 0;
553  IdentifierInfo *Name;
554  bool IsFunctionParameterPack = false;
555 
556  if (const TemplateTypeParmType *TTP
557  = i->first.dyn_cast<const TemplateTypeParmType *>()) {
558  Depth = TTP->getDepth();
559  Index = TTP->getIndex();
560  Name = TTP->getIdentifier();
561  } else {
562  NamedDecl *ND = i->first.get<NamedDecl *>();
563  if (isa<ParmVarDecl>(ND))
564  IsFunctionParameterPack = true;
565  else
566  std::tie(Depth, Index) = getDepthAndIndex(ND);
567 
568  Name = ND->getIdentifier();
569  }
570 
571  // Determine the size of this argument pack.
572  unsigned NewPackSize;
573  if (IsFunctionParameterPack) {
574  // Figure out whether we're instantiating to an argument pack or not.
575  typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
576 
577  llvm::PointerUnion<Decl *, DeclArgumentPack *> *Instantiation
579  i->first.get<NamedDecl *>());
580  if (Instantiation->is<DeclArgumentPack *>()) {
581  // We could expand this function parameter pack.
582  NewPackSize = Instantiation->get<DeclArgumentPack *>()->size();
583  } else {
584  // We can't expand this function parameter pack, so we can't expand
585  // the pack expansion.
586  ShouldExpand = false;
587  continue;
588  }
589  } else {
590  // If we don't have a template argument at this depth/index, then we
591  // cannot expand the pack expansion. Make a note of this, but we still
592  // want to check any parameter packs we *do* have arguments for.
593  if (Depth >= TemplateArgs.getNumLevels() ||
594  !TemplateArgs.hasTemplateArgument(Depth, Index)) {
595  ShouldExpand = false;
596  continue;
597  }
598 
599  // Determine the size of the argument pack.
600  NewPackSize = TemplateArgs(Depth, Index).pack_size();
601  }
602 
603  // C++0x [temp.arg.explicit]p9:
604  // Template argument deduction can extend the sequence of template
605  // arguments corresponding to a template parameter pack, even when the
606  // sequence contains explicitly specified template arguments.
607  if (!IsFunctionParameterPack) {
608  if (NamedDecl *PartialPack
610  unsigned PartialDepth, PartialIndex;
611  std::tie(PartialDepth, PartialIndex) = getDepthAndIndex(PartialPack);
612  if (PartialDepth == Depth && PartialIndex == Index)
613  RetainExpansion = true;
614  }
615  }
616 
617  if (!NumExpansions) {
618  // The is the first pack we've seen for which we have an argument.
619  // Record it.
620  NumExpansions = NewPackSize;
621  FirstPack.first = Name;
622  FirstPack.second = i->second;
623  HaveFirstPack = true;
624  continue;
625  }
626 
627  if (NewPackSize != *NumExpansions) {
628  // C++0x [temp.variadic]p5:
629  // All of the parameter packs expanded by a pack expansion shall have
630  // the same number of arguments specified.
631  if (HaveFirstPack)
632  Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict)
633  << FirstPack.first << Name << *NumExpansions << NewPackSize
634  << SourceRange(FirstPack.second) << SourceRange(i->second);
635  else
636  Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict_multilevel)
637  << Name << *NumExpansions << NewPackSize
638  << SourceRange(i->second);
639  return true;
640  }
641  }
642 
643  return false;
644 }
645 
647  const MultiLevelTemplateArgumentList &TemplateArgs) {
648  QualType Pattern = cast<PackExpansionType>(T)->getPattern();
650  CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseType(Pattern);
651 
653  for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
654  // Compute the depth and index for this parameter pack.
655  unsigned Depth;
656  unsigned Index;
657 
658  if (const TemplateTypeParmType *TTP
659  = Unexpanded[I].first.dyn_cast<const TemplateTypeParmType *>()) {
660  Depth = TTP->getDepth();
661  Index = TTP->getIndex();
662  } else {
663  NamedDecl *ND = Unexpanded[I].first.get<NamedDecl *>();
664  if (isa<ParmVarDecl>(ND)) {
665  // Function parameter pack.
666  typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
667 
668  llvm::PointerUnion<Decl *, DeclArgumentPack *> *Instantiation
670  Unexpanded[I].first.get<NamedDecl *>());
671  if (Instantiation->is<Decl*>())
672  // The pattern refers to an unexpanded pack. We're not ready to expand
673  // this pack yet.
674  return None;
675 
676  unsigned Size = Instantiation->get<DeclArgumentPack *>()->size();
677  assert((!Result || *Result == Size) && "inconsistent pack sizes");
678  Result = Size;
679  continue;
680  }
681 
682  std::tie(Depth, Index) = getDepthAndIndex(ND);
683  }
684  if (Depth >= TemplateArgs.getNumLevels() ||
685  !TemplateArgs.hasTemplateArgument(Depth, Index))
686  // The pattern refers to an unknown template argument. We're not ready to
687  // expand this pack yet.
688  return None;
689 
690  // Determine the size of the argument pack.
691  unsigned Size = TemplateArgs(Depth, Index).pack_size();
692  assert((!Result || *Result == Size) && "inconsistent pack sizes");
693  Result = Size;
694  }
695 
696  return Result;
697 }
698 
700  const DeclSpec &DS = D.getDeclSpec();
701  switch (DS.getTypeSpecType()) {
702  case TST_typename:
703  case TST_typeofType:
704  case TST_underlyingType:
705  case TST_atomic: {
706  QualType T = DS.getRepAsType().get();
707  if (!T.isNull() && T->containsUnexpandedParameterPack())
708  return true;
709  break;
710  }
711 
712  case TST_typeofExpr:
713  case TST_decltype:
714  if (DS.getRepAsExpr() &&
716  return true;
717  break;
718 
719  case TST_unspecified:
720  case TST_void:
721  case TST_char:
722  case TST_wchar:
723  case TST_char16:
724  case TST_char32:
725  case TST_int:
726  case TST_int128:
727  case TST_half:
728  case TST_float:
729  case TST_double:
730  case TST_bool:
731  case TST_decimal32:
732  case TST_decimal64:
733  case TST_decimal128:
734  case TST_enum:
735  case TST_union:
736  case TST_struct:
737  case TST_interface:
738  case TST_class:
739  case TST_auto:
740  case TST_decltype_auto:
741  case TST_unknown_anytype:
742  case TST_error:
743  break;
744  }
745 
746  for (unsigned I = 0, N = D.getNumTypeObjects(); I != N; ++I) {
747  const DeclaratorChunk &Chunk = D.getTypeObject(I);
748  switch (Chunk.Kind) {
753  // These declarator chunks cannot contain any parameter packs.
754  break;
755 
757  if (Chunk.Arr.NumElts &&
759  return true;
760  break;
762  for (unsigned i = 0, e = Chunk.Fun.NumParams; i != e; ++i) {
763  ParmVarDecl *Param = cast<ParmVarDecl>(Chunk.Fun.Params[i].Param);
764  QualType ParamTy = Param->getType();
765  assert(!ParamTy.isNull() && "Couldn't parse type?");
766  if (ParamTy->containsUnexpandedParameterPack()) return true;
767  }
768 
769  if (Chunk.Fun.getExceptionSpecType() == EST_Dynamic) {
770  for (unsigned i = 0; i != Chunk.Fun.NumExceptions; ++i) {
771  if (Chunk.Fun.Exceptions[i]
772  .Ty.get()
774  return true;
775  }
776  } else if (Chunk.Fun.getExceptionSpecType() == EST_ComputedNoexcept &&
778  return true;
779 
780  if (Chunk.Fun.hasTrailingReturnType()) {
781  QualType T = Chunk.Fun.getTrailingReturnType().get();
782  if (!T.isNull() && T->containsUnexpandedParameterPack())
783  return true;
784  }
785  break;
786 
788  if (Chunk.Mem.Scope().getScopeRep() &&
790  return true;
791  break;
792  }
793  }
794 
795  return false;
796 }
797 
798 namespace {
799 
800 // Callback to only accept typo corrections that refer to parameter packs.
801 class ParameterPackValidatorCCC : public CorrectionCandidateCallback {
802  public:
803  bool ValidateCandidate(const TypoCorrection &candidate) override {
804  NamedDecl *ND = candidate.getCorrectionDecl();
805  return ND && ND->isParameterPack();
806  }
807 };
808 
809 }
810 
811 /// \brief Called when an expression computing the size of a parameter pack
812 /// is parsed.
813 ///
814 /// \code
815 /// template<typename ...Types> struct count {
816 /// static const unsigned value = sizeof...(Types);
817 /// };
818 /// \endcode
819 ///
820 //
821 /// \param OpLoc The location of the "sizeof" keyword.
822 /// \param Name The name of the parameter pack whose size will be determined.
823 /// \param NameLoc The source location of the name of the parameter pack.
824 /// \param RParenLoc The location of the closing parentheses.
826  SourceLocation OpLoc,
827  IdentifierInfo &Name,
828  SourceLocation NameLoc,
829  SourceLocation RParenLoc) {
830  // C++0x [expr.sizeof]p5:
831  // The identifier in a sizeof... expression shall name a parameter pack.
832  LookupResult R(*this, &Name, NameLoc, LookupOrdinaryName);
833  LookupName(R, S);
834 
835  NamedDecl *ParameterPack = nullptr;
836  switch (R.getResultKind()) {
837  case LookupResult::Found:
838  ParameterPack = R.getFoundDecl();
839  break;
840 
843  if (TypoCorrection Corrected =
844  CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S, nullptr,
845  llvm::make_unique<ParameterPackValidatorCCC>(),
847  diagnoseTypo(Corrected,
848  PDiag(diag::err_sizeof_pack_no_pack_name_suggest) << &Name,
849  PDiag(diag::note_parameter_pack_here));
850  ParameterPack = Corrected.getCorrectionDecl();
851  }
852 
855  break;
856 
859  return ExprError();
860  }
861 
862  if (!ParameterPack || !ParameterPack->isParameterPack()) {
863  Diag(NameLoc, diag::err_sizeof_pack_no_pack_name)
864  << &Name;
865  return ExprError();
866  }
867 
868  MarkAnyDeclReferenced(OpLoc, ParameterPack, true);
869 
870  return new (Context) SizeOfPackExpr(Context.getSizeType(), OpLoc,
871  ParameterPack, NameLoc, RParenLoc);
872 }
873 
876  TemplateArgumentLoc OrigLoc,
877  SourceLocation &Ellipsis, Optional<unsigned> &NumExpansions) const {
878  const TemplateArgument &Argument = OrigLoc.getArgument();
879  assert(Argument.isPackExpansion());
880  switch (Argument.getKind()) {
881  case TemplateArgument::Type: {
882  // FIXME: We shouldn't ever have to worry about missing
883  // type-source info!
884  TypeSourceInfo *ExpansionTSInfo = OrigLoc.getTypeSourceInfo();
885  if (!ExpansionTSInfo)
886  ExpansionTSInfo = Context.getTrivialTypeSourceInfo(Argument.getAsType(),
887  Ellipsis);
888  PackExpansionTypeLoc Expansion =
889  ExpansionTSInfo->getTypeLoc().castAs<PackExpansionTypeLoc>();
890  Ellipsis = Expansion.getEllipsisLoc();
891 
892  TypeLoc Pattern = Expansion.getPatternLoc();
893  NumExpansions = Expansion.getTypePtr()->getNumExpansions();
894 
895  // We need to copy the TypeLoc because TemplateArgumentLocs store a
896  // TypeSourceInfo.
897  // FIXME: Find some way to avoid the copy?
898  TypeLocBuilder TLB;
899  TLB.pushFullCopy(Pattern);
900  TypeSourceInfo *PatternTSInfo =
901  TLB.getTypeSourceInfo(Context, Pattern.getType());
902  return TemplateArgumentLoc(TemplateArgument(Pattern.getType()),
903  PatternTSInfo);
904  }
905 
907  PackExpansionExpr *Expansion
908  = cast<PackExpansionExpr>(Argument.getAsExpr());
909  Expr *Pattern = Expansion->getPattern();
910  Ellipsis = Expansion->getEllipsisLoc();
911  NumExpansions = Expansion->getNumExpansions();
912  return TemplateArgumentLoc(Pattern, Pattern);
913  }
914 
916  Ellipsis = OrigLoc.getTemplateEllipsisLoc();
917  NumExpansions = Argument.getNumTemplateExpansions();
919  OrigLoc.getTemplateQualifierLoc(),
920  OrigLoc.getTemplateNameLoc());
921 
928  return TemplateArgumentLoc();
929  }
930 
931  llvm_unreachable("Invalid TemplateArgument Kind!");
932 }
933 
934 static void CheckFoldOperand(Sema &S, Expr *E) {
935  if (!E)
936  return;
937 
938  E = E->IgnoreImpCasts();
939  if (isa<BinaryOperator>(E) || isa<AbstractConditionalOperator>(E)) {
940  S.Diag(E->getExprLoc(), diag::err_fold_expression_bad_operand)
941  << E->getSourceRange()
942  << FixItHint::CreateInsertion(E->getLocStart(), "(")
943  << FixItHint::CreateInsertion(E->getLocEnd(), ")");
944  }
945 }
946 
948  tok::TokenKind Operator,
949  SourceLocation EllipsisLoc, Expr *RHS,
950  SourceLocation RParenLoc) {
951  // LHS and RHS must be cast-expressions. We allow an arbitrary expression
952  // in the parser and reduce down to just cast-expressions here.
953  CheckFoldOperand(*this, LHS);
954  CheckFoldOperand(*this, RHS);
955 
956  // [expr.prim.fold]p3:
957  // In a binary fold, op1 and op2 shall be the same fold-operator, and
958  // either e1 shall contain an unexpanded parameter pack or e2 shall contain
959  // an unexpanded parameter pack, but not both.
960  if (LHS && RHS &&
963  return Diag(EllipsisLoc,
965  ? diag::err_fold_expression_packs_both_sides
966  : diag::err_pack_expansion_without_parameter_packs)
967  << LHS->getSourceRange() << RHS->getSourceRange();
968  }
969 
970  // [expr.prim.fold]p2:
971  // In a unary fold, the cast-expression shall contain an unexpanded
972  // parameter pack.
973  if (!LHS || !RHS) {
974  Expr *Pack = LHS ? LHS : RHS;
975  assert(Pack && "fold expression with neither LHS nor RHS");
976  if (!Pack->containsUnexpandedParameterPack())
977  return Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
978  << Pack->getSourceRange();
979  }
980 
981  BinaryOperatorKind Opc = ConvertTokenKindToBinaryOpcode(Operator);
982  return BuildCXXFoldExpr(LParenLoc, LHS, Opc, EllipsisLoc, RHS, RParenLoc);
983 }
984 
986  BinaryOperatorKind Operator,
987  SourceLocation EllipsisLoc, Expr *RHS,
988  SourceLocation RParenLoc) {
989  return new (Context) CXXFoldExpr(Context.DependentTy, LParenLoc, LHS,
990  Operator, EllipsisLoc, RHS, RParenLoc);
991 }
992 
994  BinaryOperatorKind Operator) {
995  // [temp.variadic]p9:
996  // If N is zero for a unary fold-expression, the value of the expression is
997  // * -> 1
998  // + -> int()
999  // & -> -1
1000  // | -> int()
1001  // && -> true
1002  // || -> false
1003  // , -> void()
1004  // if the operator is not listed [above], the instantiation is ill-formed.
1005  //
1006  // Note that we need to use something like int() here, not merely 0, to
1007  // prevent the result from being a null pointer constant.
1008  QualType ScalarType;
1009  switch (Operator) {
1010  case BO_Add:
1011  ScalarType = Context.IntTy;
1012  break;
1013  case BO_Mul:
1014  return ActOnIntegerConstant(EllipsisLoc, 1);
1015  case BO_Or:
1016  ScalarType = Context.IntTy;
1017  break;
1018  case BO_And:
1019  return CreateBuiltinUnaryOp(EllipsisLoc, UO_Minus,
1020  ActOnIntegerConstant(EllipsisLoc, 1).get());
1021  case BO_LOr:
1022  return ActOnCXXBoolLiteral(EllipsisLoc, tok::kw_false);
1023  case BO_LAnd:
1024  return ActOnCXXBoolLiteral(EllipsisLoc, tok::kw_true);
1025  case BO_Comma:
1026  ScalarType = Context.VoidTy;
1027  break;
1028 
1029  default:
1030  return Diag(EllipsisLoc, diag::err_fold_expression_empty)
1031  << BinaryOperator::getOpcodeStr(Operator);
1032  }
1033 
1034  return new (Context) CXXScalarValueInitExpr(
1035  ScalarType, Context.getTrivialTypeSourceInfo(ScalarType, EllipsisLoc),
1036  EllipsisLoc);
1037 }
ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)
Package the given type and TSI into a ParsedType.
Definition: SemaType.cpp:4849
Name lookup found a set of overloaded functions that met the criteria.
Definition: Lookup.h:47
UnexpandedParameterPackContext
The context in which an unexpanded parameter pack is being diagnosed.
Definition: Sema.h:5875
TemplateArgument getPackExpansionPattern() const
When the template argument is a pack expansion, returns the pattern of the pack expansion.
bool containsUnexpandedParameterPack() const
Whether this nested-name-specifier contains an unexpanded parameter pack (for C++11 variadic template...
Simple class containing the result of Sema::CorrectTypo.
bool containsUnexpandedParameterPack() const
Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates)...
Definition: Expr.h:215
bool isInvalid() const
Definition: Ownership.h:159
ExprResult ActOnIntegerConstant(SourceLocation Loc, uint64_t Val)
Definition: SemaExpr.cpp:3136
IdentifierInfo * getIdentifier() const
Definition: Decl.h:163
static std::pair< unsigned, unsigned > getDepthAndIndex(NamedDecl *ND)
Retrieve the depth and index of a parameter pack.
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false)
Perform unqualified name lookup starting from a given scope.
ParsedType getAsType() const
Retrieve the template type argument's type.
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
bool hasTemplateArgument(unsigned Depth, unsigned Index) const
Determine whether there is a non-NULL template argument at the given depth and index.
Definition: Template.h:75
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1088
TypeLoc getPatternLoc() const
Definition: TypeLoc.h:1960
llvm::PointerUnion< Decl *, DeclArgumentPack * > * findInstantiationOf(const Decl *D)
Find the instantiation of the declaration D within the current instantiation scope.
PtrTy get() const
Definition: Ownership.h:163
One instance of this struct is used for each type in a declarator that is parsed. ...
Definition: DeclSpec.h:1086
A container of type source information.
Definition: Decl.h:60
Expr * getAsExpr() const
Retrieve the template argument as an expression.
Definition: TemplateBase.h:307
Describes the capture of a variable or of this, or of a C++1y init-capture.
Definition: LambdaCapture.h:26
capture_iterator capture_begin() const
Retrieve an iterator pointing to the first lambda capture.
Definition: ExprCXX.cpp:1035
ParsedType getTrailingReturnType() const
Get the trailing-return-type for this function declarator.
Definition: DeclSpec.h:1373
ObjCDictionaryElement getKeyValueElement(unsigned Index) const
Definition: ExprObjC.h:316
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaInternal.h:25
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1572
Represents an empty template argument, e.g., one that has not been deduced.
Definition: TemplateBase.h:45
SourceLocation getLocation() const
Retrieve the location of the template argument.
void setBegin(SourceLocation b)
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
Definition: Type.h:1506
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1334
SourceLocation getLocation() const
Definition: Expr.h:1002
bool isPackExpansion() const
Determine whether this template argument is a pack expansion.
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:40
Expr * IgnoreImpCasts() LLVM_READONLY
Definition: Expr.h:2803
void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool OdrUse)
Perform marking for a reference to an arbitrary declaration. It marks the declaration referenced...
Definition: SemaExpr.cpp:13367
Expr * NoexceptExpr
Pointer to the expression in the noexcept-specifier of this function, if it has one.
Definition: DeclSpec.h:1274
DeclarationName getName() const
getName - Returns the embedded declaration name.
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Definition: Sema.h:6793
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
Definition: Lookup.h:57
An element in an Objective-C dictionary literal.
Definition: ExprObjC.h:207
A C++ nested-name-specifier augmented with source location information.
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
SourceLocation getLocation() const
Fetches the primary location of the argument.
Definition: TemplateBase.h:455
A non-type template parameter, stored as an expression.
bool CheckParameterPacksForExpansion(SourceLocation EllipsisLoc, SourceRange PatternRange, ArrayRef< UnexpandedParameterPack > Unexpanded, const MultiLevelTemplateArgumentList &TemplateArgs, bool &ShouldExpand, bool &RetainExpansion, Optional< unsigned > &NumExpansions)
Determine whether we could expand a pack expansion with the given set of parameter packs into separat...
TypeSourceInfo * getTypeSourceInfo() const
Definition: TemplateBase.h:474
SourceLocation getTemplateEllipsisLoc() const
Definition: TemplateBase.h:511
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
Definition: Lookup.h:39
TypeSourceInfo * getNamedTypeInfo() const
bool isNull() const
Determine whether this template name is NULL.
Definition: TemplateName.h:220
bool containsUnexpandedParameterPack() const
Whether this template argument contains an unexpanded parameter pack.
BinaryOperatorKind
Represents the results of name lookup.
Definition: Lookup.h:30
bool DiagnoseUnexpandedParameterPacks(SourceLocation Loc, UnexpandedParameterPackContext UPPC, ArrayRef< UnexpandedParameterPack > Unexpanded)
Diagnose unexpanded parameter packs.
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
Definition: DeclSpec.h:1947
ArrayTypeInfo Arr
Definition: DeclSpec.h:1409
ParsedTemplateTy getAsTemplate() const
Retrieve the template template argument's template name.
KindType getKind() const
Determine what kind of template argument we have.
NestedNameSpecifierLoc getTemplateQualifierLoc() const
Definition: TemplateBase.h:499
char * location_data() const
Retrieve the data associated with the source-location information.
Definition: DeclSpec.h:222
capture_iterator capture_end() const
Retrieve an iterator pointing past the end of the sequence of lambda captures.
Definition: ExprCXX.cpp:1039
ExprResult ActOnCXXFoldExpr(SourceLocation LParenLoc, Expr *LHS, tok::TokenKind Operator, SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc)
Handle a C++1z fold-expression: ( expr op ... op expr ).
void DiagnoseAmbiguousLookup(LookupResult &Result)
Produce a diagnostic describing the ambiguity that resulted from name lookup.
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:68
SourceLocation getTemplateNameLoc() const
Definition: TemplateBase.h:505
Expr * Key
The key for the dictionary element.
Definition: ExprObjC.h:209
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1343
A class that does preorder depth-first traversal on the entire Clang AST and visits each node...
ParsedTemplateArgument getTemplatePackExpansion(SourceLocation EllipsisLoc) const
Retrieve a pack expansion of the given template template argument.
QualType getType() const
Definition: Decl.h:538
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type...
Definition: TypeLoc.h:53
TyLocType push(QualType T)
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
Optional< unsigned > getNumExpansions() const
Determine the number of expansions that will be produced when this pack expansion is instantiated...
Definition: ExprCXX.h:3432
Optional< unsigned > getNumTemplateExpansions() const
Retrieve the number of expansions that a template template argument expansion will produce...
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:258
TemplateArgumentLoc getTemplateArgumentPackExpansionPattern(TemplateArgumentLoc OrigLoc, SourceLocation &Ellipsis, Optional< unsigned > &NumExpansions) const
Returns the pattern of the pack expansion for a template argument.
A little helper class used to produce diagnostics.
Definition: Diagnostic.h:866
TST getTypeSpecType() const
Definition: DeclSpec.h:474
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
Definition: Lookup.h:194
bool containsUnexpandedParameterPack() const
Determines whether this template name contains an unexpanded parameter pack (for C++0x variadic templ...
bool isPackExpansion() const
Determines whether this dictionary element is a pack expansion.
Definition: ExprObjC.h:222
NameKind getNameKind() const
getNameKind - Determine what kind of name this is.
int * Depth
TypeSourceInfo * CheckPackExpansion(TypeSourceInfo *Pattern, SourceLocation EllipsisLoc, Optional< unsigned > NumExpansions)
Construct a pack expansion type from the pattern of the pack expansion.
bool containsUnexpandedParameterPacks(Declarator &D)
Determine whether the given declarator contains any unexpanded parameter packs.
Declaration of a template type parameter.
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup. Asserts that one was found.
Definition: Lookup.h:457
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:218
Represents an expression that computes the length of a parameter pack.
Definition: ExprCXX.h:3473
Represents a C++ template name within the type system.
Definition: TemplateName.h:175
Defines the clang::TypeLoc interface and its subclasses.
QualType getType() const
Get the type for which this source info wrapper provides information.
Definition: TypeLoc.h:107
const SourceRange & getRange() const
Definition: DeclSpec.h:73
SmallVector< sema::FunctionScopeInfo *, 4 > FunctionScopes
Stack containing information about each of the nested function, block, and method scopes that are cur...
Definition: Sema.h:434
void setEllipsisLoc(SourceLocation Loc)
Definition: TypeLoc.h:1948
QualType getCXXNameType() const
Represents a folding of a pack over an operator.
Definition: ExprCXX.h:3849
Data structure that captures multiple levels of template argument lists for use in template instantia...
Definition: Template.h:42
ExceptionSpecificationType getExceptionSpecType() const
Get the type of exception specification this function has.
Definition: DeclSpec.h:1364
ValueDecl * getDecl()
Definition: Expr.h:994
bool hasTrailingReturnType() const
Determine whether this function declarator had a trailing-return-type.
Definition: DeclSpec.h:1370
The result type of a method or function.
ParsedTemplateArgument ActOnPackExpansion(const ParsedTemplateArgument &Arg, SourceLocation EllipsisLoc)
Invoked when parsing a template argument followed by an ellipsis, which creates a pack expansion...
const TypeClass * getTypePtr() const
Definition: TypeLoc.h:465
TypeAndRange * Exceptions
Pointer to a new[]'d array of TypeAndRange objects that contain the types in the function's dynamic e...
Definition: DeclSpec.h:1270
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition: DeclSpec.h:81
QualType getPackExpansionType(QualType Pattern, Optional< unsigned > NumExpansions)
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:208
#define false
Definition: stdbool.h:33
NamedDecl * getPartiallySubstitutedPack(const TemplateArgument **ExplicitArgs=nullptr, unsigned *NumExplicitArgs=nullptr) const
Retrieve the partially-substitued template parameter pack.
Represents the parsed form of a C++ template argument.
unsigned getNumLevels() const
Determine the number of levels in this template argument list.
Definition: Template.h:62
Encodes a location in the source. The SourceManager can decode this to get at the full include stack...
Expr * getAsExpr() const
Retrieve the non-type template argument's expression.
Expr * getRepAsExpr() const
Definition: DeclSpec.h:489
FunctionTypeInfo Fun
Definition: DeclSpec.h:1410
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location, which defaults to the empty location.
ParsedType getRepAsType() const
Definition: DeclSpec.h:481
SourceLocation getNameLoc() const
Definition: TypeLoc.h:485
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
Name lookup found an unresolvable value declaration and cannot yet complete. This only happens in C++...
Definition: Lookup.h:52
MemberPointerTypeInfo Mem
Definition: DeclSpec.h:1412
CanQualType VoidTy
Definition: ASTContext.h:817
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
SourceLocation getBegin() const
SourceLocation getBeginLoc() const
Definition: DeclSpec.h:77
No entity found met the criteria.
Definition: Lookup.h:34
PtrTy get() const
Definition: Ownership.h:74
A template type parameter, stored as a type.
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:68
__SIZE_TYPE__ size_t
Definition: stddef.h:62
SourceLocation getExprLoc() const LLVM_READONLY
Definition: Expr.cpp:193
Expr * Value
The value of the dictionary element.
Definition: ExprObjC.h:212
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
SourceLocation getEllipsisLoc() const
Retrieve the location of the ellipsis that describes this pack expansion.
Definition: ExprCXX.h:3428
Represents a template argument.
Definition: TemplateBase.h:39
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:240
void collectUnexpandedParameterPacks(TemplateArgument Arg, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
Collect the set of unexpanded parameter packs within the given template argument. ...
const CXXScopeSpec & getScopeSpec() const
Retrieve the nested-name-specifier that precedes the template name in a template template argument...
StringRef getOpcodeStr() const
Definition: Expr.h:2980
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Definition: Lookup.h:214
SourceLocation getEllipsisLoc() const
Definition: TypeLoc.h:1944
bool isParameterPack() const
Definition: Type.h:3737
Represents a C++11 pack expansion that produces a sequence of expressions.
Definition: ExprCXX.h:3392
bool isNull() const
Determine whether this template argument has no value.
Definition: TemplateBase.h:221
static void CheckFoldOperand(Sema &S, Expr *E)
ExprResult BuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc, BinaryOperatorKind Operator)
enum clang::DeclaratorChunk::@184 Kind
unsigned getDepth() const
Get the nesting depth of the template parameter.
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Definition: TypeLoc.h:127
Name lookup found a single declaration that met the criteria. getFoundDecl() will return this declara...
Definition: Lookup.h:43
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
ExprResult BuildCXXFoldExpr(SourceLocation LParenLoc, Expr *LHS, BinaryOperatorKind Operator, SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc)
ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind)
ActOnCXXBoolLiteral - Parse {true,false} literals.
CanQualType DependentTy
Definition: ASTContext.h:832
bool isInvalid() const
Determine whether the given template argument is invalid.
ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *InputExpr)
Definition: SemaExpr.cpp:10589
The template argument is a type.
Definition: TemplateBase.h:47
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:78
const TypeClass * getTypePtr() const
Definition: TypeLoc.h:371
bool isUnexpandedParameterPackPermitted()
Determine whether it's possible for an unexpanded parameter pack to be valid in this location...
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
Definition: SemaType.cpp:2305
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
Captures information about "declaration specifiers".
Definition: DeclSpec.h:233
LookupResultKind getResultKind() const
Definition: Lookup.h:261
Expr * getPattern()
Retrieve the pattern of the pack expansion.
Definition: ExprCXX.h:3421
ExprResult ExprError()
Definition: Ownership.h:267
CanQualType IntTy
Definition: ASTContext.h:825
bool isValid() const
A scope specifier is present, and it refers to a real scope.
Definition: DeclSpec.h:201
A reference to a declared variable, function, enum, etc. [C99 6.5.1p2].
Definition: Expr.h:899
Optional< unsigned > getNumArgumentsInExpansion(QualType T, const MultiLevelTemplateArgumentList &TemplateArgs)
Determine the number of arguments in the given pack expansion type.
const DeclaratorChunk & getTypeObject(unsigned i) const
Definition: DeclSpec.h:1951
Wrapper for template type parameters.
Definition: TypeLoc.h:680
bool isParameterPack() const
Whether this declaration is a parameter pack.
Definition: DeclBase.cpp:165
A trivial tuple used to represent a source range.
SourceLocation getLocation() const
Definition: DeclBase.h:372
ASTContext & Context
Definition: Sema.h:295
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, std::unique_ptr< CorrectionCandidateCallback > CCC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr, bool RecordFailure=true)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
A template template argument, stored as a template name.
bool isNull() const
isNull - Return true if this QualType doesn't point to a type yet.
Definition: Type.h:633
void pushFullCopy(TypeLoc L)
ExprResult ActOnSizeofParameterPackExpr(Scope *S, SourceLocation OpLoc, IdentifierInfo &Name, SourceLocation NameLoc, SourceLocation RParenLoc)
Called when an expression computing the size of a parameter pack is parsed.
const TemplateArgument & getArgument() const
Definition: TemplateBase.h:466
Optional< unsigned > getNumExpansions() const
Retrieve the number of expansions that this pack expansion will generate, if known.
Definition: Type.h:4459
unsigned getNumElements() const
Definition: ExprObjC.h:314
unsigned getIndex() const
Get the index of the template parameter within its parameter list.
const DeclSpec & getDeclSpec() const
Definition: DeclSpec.h:1676