clang  3.8.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.
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;
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_auto_type:
741  case TST_decltype_auto:
742  case TST_unknown_anytype:
743  case TST_error:
744  break;
745  }
746 
747  for (unsigned I = 0, N = D.getNumTypeObjects(); I != N; ++I) {
748  const DeclaratorChunk &Chunk = D.getTypeObject(I);
749  switch (Chunk.Kind) {
755  // These declarator chunks cannot contain any parameter packs.
756  break;
757 
759  if (Chunk.Arr.NumElts &&
761  return true;
762  break;
764  for (unsigned i = 0, e = Chunk.Fun.NumParams; i != e; ++i) {
765  ParmVarDecl *Param = cast<ParmVarDecl>(Chunk.Fun.Params[i].Param);
766  QualType ParamTy = Param->getType();
767  assert(!ParamTy.isNull() && "Couldn't parse type?");
768  if (ParamTy->containsUnexpandedParameterPack()) return true;
769  }
770 
771  if (Chunk.Fun.getExceptionSpecType() == EST_Dynamic) {
772  for (unsigned i = 0; i != Chunk.Fun.NumExceptions; ++i) {
773  if (Chunk.Fun.Exceptions[i]
774  .Ty.get()
776  return true;
777  }
778  } else if (Chunk.Fun.getExceptionSpecType() == EST_ComputedNoexcept &&
780  return true;
781 
782  if (Chunk.Fun.hasTrailingReturnType()) {
783  QualType T = Chunk.Fun.getTrailingReturnType().get();
784  if (!T.isNull() && T->containsUnexpandedParameterPack())
785  return true;
786  }
787  break;
788 
790  if (Chunk.Mem.Scope().getScopeRep() &&
792  return true;
793  break;
794  }
795  }
796 
797  return false;
798 }
799 
800 namespace {
801 
802 // Callback to only accept typo corrections that refer to parameter packs.
803 class ParameterPackValidatorCCC : public CorrectionCandidateCallback {
804  public:
805  bool ValidateCandidate(const TypoCorrection &candidate) override {
806  NamedDecl *ND = candidate.getCorrectionDecl();
807  return ND && ND->isParameterPack();
808  }
809 };
810 
811 }
812 
813 /// \brief Called when an expression computing the size of a parameter pack
814 /// is parsed.
815 ///
816 /// \code
817 /// template<typename ...Types> struct count {
818 /// static const unsigned value = sizeof...(Types);
819 /// };
820 /// \endcode
821 ///
822 //
823 /// \param OpLoc The location of the "sizeof" keyword.
824 /// \param Name The name of the parameter pack whose size will be determined.
825 /// \param NameLoc The source location of the name of the parameter pack.
826 /// \param RParenLoc The location of the closing parentheses.
828  SourceLocation OpLoc,
830  SourceLocation NameLoc,
831  SourceLocation RParenLoc) {
832  // C++0x [expr.sizeof]p5:
833  // The identifier in a sizeof... expression shall name a parameter pack.
834  LookupResult R(*this, &Name, NameLoc, LookupOrdinaryName);
835  LookupName(R, S);
836 
837  NamedDecl *ParameterPack = nullptr;
838  switch (R.getResultKind()) {
839  case LookupResult::Found:
840  ParameterPack = R.getFoundDecl();
841  break;
842 
845  if (TypoCorrection Corrected =
846  CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S, nullptr,
847  llvm::make_unique<ParameterPackValidatorCCC>(),
849  diagnoseTypo(Corrected,
850  PDiag(diag::err_sizeof_pack_no_pack_name_suggest) << &Name,
851  PDiag(diag::note_parameter_pack_here));
852  ParameterPack = Corrected.getCorrectionDecl();
853  }
854 
857  break;
858 
861  return ExprError();
862  }
863 
864  if (!ParameterPack || !ParameterPack->isParameterPack()) {
865  Diag(NameLoc, diag::err_sizeof_pack_no_pack_name)
866  << &Name;
867  return ExprError();
868  }
869 
870  MarkAnyDeclReferenced(OpLoc, ParameterPack, true);
871 
872  return SizeOfPackExpr::Create(Context, OpLoc, ParameterPack, NameLoc,
873  RParenLoc);
874 }
875 
878  TemplateArgumentLoc OrigLoc,
879  SourceLocation &Ellipsis, Optional<unsigned> &NumExpansions) const {
880  const TemplateArgument &Argument = OrigLoc.getArgument();
881  assert(Argument.isPackExpansion());
882  switch (Argument.getKind()) {
883  case TemplateArgument::Type: {
884  // FIXME: We shouldn't ever have to worry about missing
885  // type-source info!
886  TypeSourceInfo *ExpansionTSInfo = OrigLoc.getTypeSourceInfo();
887  if (!ExpansionTSInfo)
888  ExpansionTSInfo = Context.getTrivialTypeSourceInfo(Argument.getAsType(),
889  Ellipsis);
890  PackExpansionTypeLoc Expansion =
891  ExpansionTSInfo->getTypeLoc().castAs<PackExpansionTypeLoc>();
892  Ellipsis = Expansion.getEllipsisLoc();
893 
894  TypeLoc Pattern = Expansion.getPatternLoc();
895  NumExpansions = Expansion.getTypePtr()->getNumExpansions();
896 
897  // We need to copy the TypeLoc because TemplateArgumentLocs store a
898  // TypeSourceInfo.
899  // FIXME: Find some way to avoid the copy?
900  TypeLocBuilder TLB;
901  TLB.pushFullCopy(Pattern);
902  TypeSourceInfo *PatternTSInfo =
903  TLB.getTypeSourceInfo(Context, Pattern.getType());
904  return TemplateArgumentLoc(TemplateArgument(Pattern.getType()),
905  PatternTSInfo);
906  }
907 
909  PackExpansionExpr *Expansion
910  = cast<PackExpansionExpr>(Argument.getAsExpr());
911  Expr *Pattern = Expansion->getPattern();
912  Ellipsis = Expansion->getEllipsisLoc();
913  NumExpansions = Expansion->getNumExpansions();
914  return TemplateArgumentLoc(Pattern, Pattern);
915  }
916 
918  Ellipsis = OrigLoc.getTemplateEllipsisLoc();
919  NumExpansions = Argument.getNumTemplateExpansions();
921  OrigLoc.getTemplateQualifierLoc(),
922  OrigLoc.getTemplateNameLoc());
923 
930  return TemplateArgumentLoc();
931  }
932 
933  llvm_unreachable("Invalid TemplateArgument Kind!");
934 }
935 
936 static void CheckFoldOperand(Sema &S, Expr *E) {
937  if (!E)
938  return;
939 
940  E = E->IgnoreImpCasts();
941  if (isa<BinaryOperator>(E) || isa<AbstractConditionalOperator>(E)) {
942  S.Diag(E->getExprLoc(), diag::err_fold_expression_bad_operand)
943  << E->getSourceRange()
944  << FixItHint::CreateInsertion(E->getLocStart(), "(")
945  << FixItHint::CreateInsertion(E->getLocEnd(), ")");
946  }
947 }
948 
950  tok::TokenKind Operator,
951  SourceLocation EllipsisLoc, Expr *RHS,
952  SourceLocation RParenLoc) {
953  // LHS and RHS must be cast-expressions. We allow an arbitrary expression
954  // in the parser and reduce down to just cast-expressions here.
955  CheckFoldOperand(*this, LHS);
956  CheckFoldOperand(*this, RHS);
957 
958  // [expr.prim.fold]p3:
959  // In a binary fold, op1 and op2 shall be the same fold-operator, and
960  // either e1 shall contain an unexpanded parameter pack or e2 shall contain
961  // an unexpanded parameter pack, but not both.
962  if (LHS && RHS &&
965  return Diag(EllipsisLoc,
967  ? diag::err_fold_expression_packs_both_sides
968  : diag::err_pack_expansion_without_parameter_packs)
969  << LHS->getSourceRange() << RHS->getSourceRange();
970  }
971 
972  // [expr.prim.fold]p2:
973  // In a unary fold, the cast-expression shall contain an unexpanded
974  // parameter pack.
975  if (!LHS || !RHS) {
976  Expr *Pack = LHS ? LHS : RHS;
977  assert(Pack && "fold expression with neither LHS nor RHS");
978  if (!Pack->containsUnexpandedParameterPack())
979  return Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
980  << Pack->getSourceRange();
981  }
982 
983  BinaryOperatorKind Opc = ConvertTokenKindToBinaryOpcode(Operator);
984  return BuildCXXFoldExpr(LParenLoc, LHS, Opc, EllipsisLoc, RHS, RParenLoc);
985 }
986 
988  BinaryOperatorKind Operator,
989  SourceLocation EllipsisLoc, Expr *RHS,
990  SourceLocation RParenLoc) {
991  return new (Context) CXXFoldExpr(Context.DependentTy, LParenLoc, LHS,
992  Operator, EllipsisLoc, RHS, RParenLoc);
993 }
994 
996  BinaryOperatorKind Operator) {
997  // [temp.variadic]p9:
998  // If N is zero for a unary fold-expression, the value of the expression is
999  // * -> 1
1000  // + -> int()
1001  // & -> -1
1002  // | -> int()
1003  // && -> true
1004  // || -> false
1005  // , -> void()
1006  // if the operator is not listed [above], the instantiation is ill-formed.
1007  //
1008  // Note that we need to use something like int() here, not merely 0, to
1009  // prevent the result from being a null pointer constant.
1010  QualType ScalarType;
1011  switch (Operator) {
1012  case BO_Add:
1013  ScalarType = Context.IntTy;
1014  break;
1015  case BO_Mul:
1016  return ActOnIntegerConstant(EllipsisLoc, 1);
1017  case BO_Or:
1018  ScalarType = Context.IntTy;
1019  break;
1020  case BO_And:
1021  return CreateBuiltinUnaryOp(EllipsisLoc, UO_Minus,
1022  ActOnIntegerConstant(EllipsisLoc, 1).get());
1023  case BO_LOr:
1024  return ActOnCXXBoolLiteral(EllipsisLoc, tok::kw_false);
1025  case BO_LAnd:
1026  return ActOnCXXBoolLiteral(EllipsisLoc, tok::kw_true);
1027  case BO_Comma:
1028  ScalarType = Context.VoidTy;
1029  break;
1030 
1031  default:
1032  return Diag(EllipsisLoc, diag::err_fold_expression_empty)
1033  << BinaryOperator::getOpcodeStr(Operator);
1034  }
1035 
1036  return new (Context) CXXScalarValueInitExpr(
1037  ScalarType, Context.getTrivialTypeSourceInfo(ScalarType, EllipsisLoc),
1038  EllipsisLoc);
1039 }
ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)
Package the given type and TSI into a ParsedType.
Definition: SemaType.cpp:4944
Name lookup found a set of overloaded functions that met the criteria.
Definition: Sema/Lookup.h:47
UnexpandedParameterPackContext
The context in which an unexpanded parameter pack is being diagnosed.
Definition: Sema.h:5950
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...
A (possibly-)qualified type.
Definition: Type.h:575
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:211
bool isInvalid() const
Definition: Ownership.h:159
ExprResult ActOnIntegerConstant(SourceLocation Loc, uint64_t Val)
Definition: SemaExpr.cpp:3114
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:2636
IdentifierInfo * getIdentifier() const
getIdentifier - Get the identifier that names this declaration, if there is one.
Definition: Decl.h:164
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...
The template argument is an expression, and we've not resolved it to one of the other forms yet...
Definition: TemplateBase.h:69
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:1118
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:77
TypeLoc getPatternLoc() const
Definition: TypeLoc.h:1972
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
The base class of the type hierarchy.
Definition: Type.h:1249
One instance of this struct is used for each type in a declarator that is parsed. ...
Definition: DeclSpec.h:1091
The template argument is a declaration that was provided for a pointer, reference, or pointer to member non-type template parameter.
Definition: TemplateBase.h:51
A container of type source information.
Definition: Decl.h:61
Expr * getAsExpr() const
Retrieve the template argument as an expression.
Definition: TemplateBase.h:305
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:1012
ParsedType getTrailingReturnType() const
Get the trailing-return-type for this function declarator.
Definition: DeclSpec.h:1389
ObjCDictionaryElement getKeyValueElement(unsigned Index) const
Definition: ExprObjC.h:309
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:699
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:1608
Represents an empty template argument, e.g., one that has not been deduced.
Definition: TemplateBase.h:46
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:1521
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1299
SourceLocation getLocation() const
Definition: Expr.h:1015
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
IgnoreImpCasts - Skip past any implicit casts which might surround this expression.
Definition: Expr.h:2755
void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool OdrUse)
Perform marking for a reference to an arbitrary declaration.
Definition: SemaExpr.cpp:13679
Expr * NoexceptExpr
Pointer to the expression in the noexcept-specifier of this function, if it has one.
Definition: DeclSpec.h:1282
DeclarationName getName() const
getName - Returns the embedded declaration name.
One of these records is kept for each identifier that is lexed.
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Definition: Sema.h:6873
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
Definition: Sema/Lookup.h:57
An element in an Objective-C dictionary literal.
Definition: ExprObjC.h:212
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:4381
A C++ nested-name-specifier augmented with source location information.
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
Definition: TemplateBase.h:57
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:453
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:472
SourceLocation getTemplateEllipsisLoc() const
Definition: TemplateBase.h:509
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
Definition: Sema/Lookup.h:39
TypeSourceInfo * getNamedTypeInfo() const
getNamedTypeInfo - Returns the source type info associated to the name.
bool containsUnexpandedParameterPack() const
Whether this template argument contains an unexpanded parameter pack.
BinaryOperatorKind
Represents the results of name lookup.
Definition: Sema/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:1983
ArrayTypeInfo Arr
Definition: DeclSpec.h:1432
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:497
char * location_data() const
Retrieve the data associated with the source-location information.
Definition: DeclSpec.h:217
capture_iterator capture_end() const
Retrieve an iterator pointing past the end of the sequence of lambda captures.
Definition: ExprCXX.cpp:1016
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 ).
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:38
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:63
SourceLocation getTemplateNameLoc() const
Definition: TemplateBase.h:503
Expr * Key
The key for the dictionary element.
Definition: ExprObjC.h:214
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1422
iterator end() const
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.
detail::InMemoryDirectory::const_iterator I
QualType getType() const
Definition: Decl.h:530
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type...
Definition: TypeLoc.h:53
SourceRange getRange() const
Definition: DeclSpec.h:68
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
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:3523
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:259
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:473
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
Definition: Sema/Lookup.h:194
bool containsUnexpandedParameterPack() const
Determines whether this template name contains an unexpanded parameter pack (for C++0x variadic templ...
unsigned NumParams
NumParams - This is the number of formal parameters specified by the declarator.
Definition: DeclSpec.h:1233
unsigned NumExceptions
NumExceptions - This is the number of types in the dynamic-exception- decl, if the function has one...
Definition: DeclSpec.h:1237
bool isPackExpansion() const
Determines whether this dictionary element is a pack expansion.
Definition: ExprObjC.h:227
NameKind getNameKind() const
getNameKind - Determine what kind of name this is.
int * Depth
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type...
Definition: ExprCXX.h:1683
TypeSourceInfo * CheckPackExpansion(TypeSourceInfo *Pattern, SourceLocation EllipsisLoc, Optional< unsigned > NumExpansions)
Construct a pack expansion type from the pattern of the pack expansion.
Expr - This represents one expression.
Definition: Expr.h:104
bool containsUnexpandedParameterPacks(Declarator &D)
Determine whether the given declarator contains any unexpanded parameter packs.
Declaration of a template type parameter.
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
Definition: TemplateBase.h:54
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
Definition: Sema/Lookup.h:458
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:216
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
Definition: ExprObjC.h:257
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
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
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:1960
QualType getCXXNameType() const
getCXXNameType - If this name is one of the C++ names (of a constructor, destructor, or conversion function), return the type associated with that name.
Represents a folding of a pack over an operator.
Definition: ExprCXX.h:3967
Data structure that captures multiple levels of template argument lists for use in template instantia...
Definition: Template.h:42
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
ExceptionSpecificationType getExceptionSpecType() const
Get the type of exception specification this function has.
Definition: DeclSpec.h:1380
ValueDecl * getDecl()
Definition: Expr.h:1007
bool hasTrailingReturnType() const
Determine whether this function declarator had a trailing-return-type.
Definition: DeclSpec.h:1386
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:473
TypeAndRange * Exceptions
Pointer to a new[]'d array of TypeAndRange objects that contain the types in the function's dynamic e...
Definition: DeclSpec.h:1278
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition: DeclSpec.h:76
QualType getPackExpansionType(QualType Pattern, Optional< unsigned > NumExpansions)
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:215
#define false
Definition: stdbool.h:33
NamedDecl * getPartiallySubstitutedPack(const TemplateArgument **ExplicitArgs=nullptr, unsigned *NumExplicitArgs=nullptr) const
Retrieve the partially-substitued template parameter pack.
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:145
Represents the parsed form of a C++ template argument.
enum clang::DeclaratorChunk::@183 Kind
unsigned getNumLevels() const
Determine the number of levels in this template argument list.
Definition: Template.h:62
Encodes a location in the source.
Expr * getAsExpr() const
Retrieve the non-type template argument's expression.
Expr * getRepAsExpr() const
Definition: DeclSpec.h:489
static SizeOfPackExpr * Create(ASTContext &Context, SourceLocation OperatorLoc, NamedDecl *Pack, SourceLocation PackLoc, SourceLocation RParenLoc, Optional< unsigned > Length=None, ArrayRef< TemplateArgument > PartialArgs=None)
Definition: ExprCXX.cpp:1374
FunctionTypeInfo Fun
Definition: DeclSpec.h:1433
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:493
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
Name lookup found an unresolvable value declaration and cannot yet complete.
Definition: Sema/Lookup.h:52
MemberPointerTypeInfo Mem
Definition: DeclSpec.h:1435
CanQualType VoidTy
Definition: ASTContext.h:881
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:72
No entity found met the criteria.
Definition: Sema/Lookup.h:34
const IdentifierInfo * getIdentifier() const
Definition: Type.h:4413
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:69
__SIZE_TYPE__ size_t
Definition: stddef.h:62
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:193
Expr * Value
The value of the dictionary element.
Definition: ExprObjC.h:217
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:3519
Represents a template argument.
Definition: TemplateBase.h:40
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:238
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:2937
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Definition: Sema/Lookup.h:214
SourceLocation getEllipsisLoc() const
Definition: TypeLoc.h:1956
The template argument is a pack expansion of a template name that was provided for a template templat...
Definition: TemplateBase.h:63
bool isParameterPack() const
Definition: Type.h:3781
Represents a C++11 pack expansion that produces a sequence of expressions.
Definition: ExprCXX.h:3483
bool isNull() const
Determine whether this template argument has no value.
Definition: TemplateBase.h:219
detail::InMemoryDirectory::const_iterator E
static void CheckFoldOperand(Sema &S, Expr *E)
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
ExprResult BuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc, BinaryOperatorKind Operator)
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.
Definition: Sema/Lookup.h:43
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:421
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:896
bool isNull() const
Determine whether this template name is NULL.
bool isInvalid() const
Determine whether the given template argument is invalid.
ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *InputExpr)
Definition: SemaExpr.cpp:10954
The template argument is a type.
Definition: TemplateBase.h:48
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:379
The template argument is actually a parameter pack.
Definition: TemplateBase.h:72
bool isUnexpandedParameterPackPermitted()
Determine whether an unexpanded parameter pack might be permitted in this location.
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
Definition: SemaType.cpp:2354
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:228
The template argument is a template name that was provided for a template template parameter...
Definition: TemplateBase.h:60
Expr * NumElts
This is the size of the array, or null if [] or [*] was specified.
Definition: DeclSpec.h:1153
LookupResultKind getResultKind() const
Definition: Sema/Lookup.h:262
Expr * getPattern()
Retrieve the pattern of the pack expansion.
Definition: ExprCXX.h:3512
ExprResult ExprError()
Definition: Ownership.h:267
CanQualType IntTy
Definition: ASTContext.h:889
bool isValid() const
A scope specifier is present, and it refers to a real scope.
Definition: DeclSpec.h:196
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:922
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
Return the specified TypeInfo from this declarator.
Definition: DeclSpec.h:1987
Wrapper for template type parameters.
Definition: TypeLoc.h:688
bool isParameterPack() const
Whether this declaration is a parameter pack.
Definition: DeclBase.cpp:180
A trivial tuple used to represent a source range.
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...
NamedDecl - This represents a decl with a name.
Definition: Decl.h:145
A template template argument, stored as a template name.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:642
void pushFullCopy(TypeLoc L)
Pushes a copy of the given TypeLoc onto this builder.
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:464
Optional< unsigned > getNumExpansions() const
Retrieve the number of expansions that this pack expansion will generate, if known.
Definition: Type.h:4502
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c dictionary literal.
Definition: ExprObjC.h:307
ParamInfo * Params
Params - This is a pointer to a new[]'d array of ParamInfo objects that describe the parameters speci...
Definition: DeclSpec.h:1272
unsigned getIndex() const
Get the index of the template parameter within its parameter list.
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
Definition: DeclSpec.h:1712