clang  13.0.0git
SemaTemplateVariadic.cpp
Go to the documentation of this file.
1 //===------- SemaTemplateVariadic.cpp - C++ Variadic Templates ------------===/
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //===----------------------------------------------------------------------===/
7 //
8 // This file implements semantic analysis for C++0x variadic templates.
9 //===----------------------------------------------------------------------===/
10 
11 #include "clang/Sema/Sema.h"
12 #include "TypeLocBuilder.h"
13 #include "clang/AST/Expr.h"
15 #include "clang/AST/TypeLoc.h"
16 #include "clang/Sema/Lookup.h"
18 #include "clang/Sema/ScopeInfo.h"
20 #include "clang/Sema/Template.h"
21 
22 using namespace clang;
23 
24 //----------------------------------------------------------------------------
25 // Visitor that collects unexpanded parameter packs
26 //----------------------------------------------------------------------------
27 
28 namespace {
29  /// A class that collects unexpanded parameter packs.
30  class CollectUnexpandedParameterPacksVisitor :
31  public RecursiveASTVisitor<CollectUnexpandedParameterPacksVisitor>
32  {
34  inherited;
35 
37 
38  bool InLambda = false;
39  unsigned DepthLimit = (unsigned)-1;
40 
41  void addUnexpanded(NamedDecl *ND, SourceLocation Loc = SourceLocation()) {
42  if (auto *VD = dyn_cast<VarDecl>(ND)) {
43  // For now, the only problematic case is a generic lambda's templated
44  // call operator, so we don't need to look for all the other ways we
45  // could have reached a dependent parameter pack.
46  auto *FD = dyn_cast<FunctionDecl>(VD->getDeclContext());
47  auto *FTD = FD ? FD->getDescribedFunctionTemplate() : nullptr;
48  if (FTD && FTD->getTemplateParameters()->getDepth() >= DepthLimit)
49  return;
50  } else if (getDepthAndIndex(ND).first >= DepthLimit)
51  return;
52 
53  Unexpanded.push_back({ND, Loc});
54  }
55  void addUnexpanded(const TemplateTypeParmType *T,
57  if (T->getDepth() < DepthLimit)
58  Unexpanded.push_back({T, Loc});
59  }
60 
61  public:
62  explicit CollectUnexpandedParameterPacksVisitor(
64  : Unexpanded(Unexpanded) {}
65 
66  bool shouldWalkTypesOfTypeLocs() const { return false; }
67 
68  //------------------------------------------------------------------------
69  // Recording occurrences of (unexpanded) parameter packs.
70  //------------------------------------------------------------------------
71 
72  /// Record occurrences of template type parameter packs.
73  bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
74  if (TL.getTypePtr()->isParameterPack())
75  addUnexpanded(TL.getTypePtr(), TL.getNameLoc());
76  return true;
77  }
78 
79  /// Record occurrences of template type parameter packs
80  /// when we don't have proper source-location information for
81  /// them.
82  ///
83  /// Ideally, this routine would never be used.
84  bool VisitTemplateTypeParmType(TemplateTypeParmType *T) {
85  if (T->isParameterPack())
86  addUnexpanded(T);
87 
88  return true;
89  }
90 
91  /// Record occurrences of function and non-type template
92  /// parameter packs in an expression.
93  bool VisitDeclRefExpr(DeclRefExpr *E) {
94  if (E->getDecl()->isParameterPack())
95  addUnexpanded(E->getDecl(), E->getLocation());
96 
97  return true;
98  }
99 
100  /// Record occurrences of template template parameter packs.
101  bool TraverseTemplateName(TemplateName Template) {
102  if (auto *TTP = dyn_cast_or_null<TemplateTemplateParmDecl>(
103  Template.getAsTemplateDecl())) {
104  if (TTP->isParameterPack())
105  addUnexpanded(TTP);
106  }
107 
108  return inherited::TraverseTemplateName(Template);
109  }
110 
111  /// Suppress traversal into Objective-C container literal
112  /// elements that are pack expansions.
113  bool TraverseObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
115  return true;
116 
117  for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) {
119  if (Element.isPackExpansion())
120  continue;
121 
122  TraverseStmt(Element.Key);
123  TraverseStmt(Element.Value);
124  }
125  return true;
126  }
127  //------------------------------------------------------------------------
128  // Pruning the search for unexpanded parameter packs.
129  //------------------------------------------------------------------------
130 
131  /// Suppress traversal into statements and expressions that
132  /// do not contain unexpanded parameter packs.
133  bool TraverseStmt(Stmt *S) {
134  Expr *E = dyn_cast_or_null<Expr>(S);
135  if ((E && E->containsUnexpandedParameterPack()) || InLambda)
136  return inherited::TraverseStmt(S);
137 
138  return true;
139  }
140 
141  /// Suppress traversal into types that do not contain
142  /// unexpanded parameter packs.
143  bool TraverseType(QualType T) {
144  if ((!T.isNull() && T->containsUnexpandedParameterPack()) || InLambda)
145  return inherited::TraverseType(T);
146 
147  return true;
148  }
149 
150  /// Suppress traversal into types with location information
151  /// that do not contain unexpanded parameter packs.
152  bool TraverseTypeLoc(TypeLoc TL) {
153  if ((!TL.getType().isNull() &&
155  InLambda)
156  return inherited::TraverseTypeLoc(TL);
157 
158  return true;
159  }
160 
161  /// Suppress traversal of parameter packs.
162  bool TraverseDecl(Decl *D) {
163  // A function parameter pack is a pack expansion, so cannot contain
164  // an unexpanded parameter pack. Likewise for a template parameter
165  // pack that contains any references to other packs.
166  if (D && D->isParameterPack())
167  return true;
168 
169  return inherited::TraverseDecl(D);
170  }
171 
172  /// Suppress traversal of pack-expanded attributes.
173  bool TraverseAttr(Attr *A) {
174  if (A->isPackExpansion())
175  return true;
176 
177  return inherited::TraverseAttr(A);
178  }
179 
180  /// Suppress traversal of pack expansion expressions and types.
181  ///@{
182  bool TraversePackExpansionType(PackExpansionType *T) { return true; }
183  bool TraversePackExpansionTypeLoc(PackExpansionTypeLoc TL) { return true; }
184  bool TraversePackExpansionExpr(PackExpansionExpr *E) { return true; }
185  bool TraverseCXXFoldExpr(CXXFoldExpr *E) { return true; }
186 
187  ///@}
188 
189  /// Suppress traversal of using-declaration pack expansion.
190  bool TraverseUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
191  if (D->isPackExpansion())
192  return true;
193 
194  return inherited::TraverseUnresolvedUsingValueDecl(D);
195  }
196 
197  /// Suppress traversal of using-declaration pack expansion.
198  bool TraverseUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D) {
199  if (D->isPackExpansion())
200  return true;
201 
202  return inherited::TraverseUnresolvedUsingTypenameDecl(D);
203  }
204 
205  /// Suppress traversal of template argument pack expansions.
206  bool TraverseTemplateArgument(const TemplateArgument &Arg) {
207  if (Arg.isPackExpansion())
208  return true;
209 
210  return inherited::TraverseTemplateArgument(Arg);
211  }
212 
213  /// Suppress traversal of template argument pack expansions.
214  bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &ArgLoc) {
215  if (ArgLoc.getArgument().isPackExpansion())
216  return true;
217 
218  return inherited::TraverseTemplateArgumentLoc(ArgLoc);
219  }
220 
221  /// Suppress traversal of base specifier pack expansions.
222  bool TraverseCXXBaseSpecifier(const CXXBaseSpecifier &Base) {
223  if (Base.isPackExpansion())
224  return true;
225 
226  return inherited::TraverseCXXBaseSpecifier(Base);
227  }
228 
229  /// Suppress traversal of mem-initializer pack expansions.
230  bool TraverseConstructorInitializer(CXXCtorInitializer *Init) {
231  if (Init->isPackExpansion())
232  return true;
233 
234  return inherited::TraverseConstructorInitializer(Init);
235  }
236 
237  /// Note whether we're traversing a lambda containing an unexpanded
238  /// parameter pack. In this case, the unexpanded pack can occur anywhere,
239  /// including all the places where we normally wouldn't look. Within a
240  /// lambda, we don't propagate the 'contains unexpanded parameter pack' bit
241  /// outside an expression.
242  bool TraverseLambdaExpr(LambdaExpr *Lambda) {
243  // The ContainsUnexpandedParameterPack bit on a lambda is always correct,
244  // even if it's contained within another lambda.
245  if (!Lambda->containsUnexpandedParameterPack())
246  return true;
247 
248  bool WasInLambda = InLambda;
249  unsigned OldDepthLimit = DepthLimit;
250 
251  InLambda = true;
252  if (auto *TPL = Lambda->getTemplateParameterList())
253  DepthLimit = TPL->getDepth();
254 
255  inherited::TraverseLambdaExpr(Lambda);
256 
257  InLambda = WasInLambda;
258  DepthLimit = OldDepthLimit;
259  return true;
260  }
261 
262  /// Suppress traversal within pack expansions in lambda captures.
263  bool TraverseLambdaCapture(LambdaExpr *Lambda, const LambdaCapture *C,
264  Expr *Init) {
265  if (C->isPackExpansion())
266  return true;
267 
268  return inherited::TraverseLambdaCapture(Lambda, C, Init);
269  }
270  };
271 }
272 
273 /// Determine whether it's possible for an unexpanded parameter pack to
274 /// be valid in this location. This only happens when we're in a declaration
275 /// that is nested within an expression that could be expanded, such as a
276 /// lambda-expression within a function call.
277 ///
278 /// This is conservatively correct, but may claim that some unexpanded packs are
279 /// permitted when they are not.
281  for (auto *SI : FunctionScopes)
282  if (isa<sema::LambdaScopeInfo>(SI))
283  return true;
284  return false;
285 }
286 
287 /// Diagnose all of the unexpanded parameter packs in the given
288 /// vector.
289 bool
293  if (Unexpanded.empty())
294  return false;
295 
296  // If we are within a lambda expression and referencing a pack that is not
297  // declared within the lambda itself, that lambda contains an unexpanded
298  // parameter pack, and we are done.
299  // FIXME: Store 'Unexpanded' on the lambda so we don't need to recompute it
300  // later.
301  SmallVector<UnexpandedParameterPack, 4> LambdaParamPackReferences;
302  if (auto *LSI = getEnclosingLambda()) {
303  for (auto &Pack : Unexpanded) {
304  auto DeclaresThisPack = [&](NamedDecl *LocalPack) {
305  if (auto *TTPT = Pack.first.dyn_cast<const TemplateTypeParmType *>()) {
306  auto *TTPD = dyn_cast<TemplateTypeParmDecl>(LocalPack);
307  return TTPD && TTPD->getTypeForDecl() == TTPT;
308  }
309  return declaresSameEntity(Pack.first.get<NamedDecl *>(), LocalPack);
310  };
311  if (std::find_if(LSI->LocalPacks.begin(), LSI->LocalPacks.end(),
312  DeclaresThisPack) != LSI->LocalPacks.end())
313  LambdaParamPackReferences.push_back(Pack);
314  }
315 
316  if (LambdaParamPackReferences.empty()) {
317  // Construct in lambda only references packs declared outside the lambda.
318  // That's OK for now, but the lambda itself is considered to contain an
319  // unexpanded pack in this case, which will require expansion outside the
320  // lambda.
321 
322  // We do not permit pack expansion that would duplicate a statement
323  // expression, not even within a lambda.
324  // FIXME: We could probably support this for statement expressions that
325  // do not contain labels.
326  // FIXME: This is insufficient to detect this problem; consider
327  // f( ({ bad: 0; }) + pack ... );
328  bool EnclosingStmtExpr = false;
329  for (unsigned N = FunctionScopes.size(); N; --N) {
331  if (std::any_of(
332  Func->CompoundScopes.begin(), Func->CompoundScopes.end(),
333  [](sema::CompoundScopeInfo &CSI) { return CSI.IsStmtExpr; })) {
334  EnclosingStmtExpr = true;
335  break;
336  }
337  // Coumpound-statements outside the lambda are OK for now; we'll check
338  // for those when we finish handling the lambda.
339  if (Func == LSI)
340  break;
341  }
342 
343  if (!EnclosingStmtExpr) {
344  LSI->ContainsUnexpandedParameterPack = true;
345  return false;
346  }
347  } else {
348  Unexpanded = LambdaParamPackReferences;
349  }
350  }
351 
355 
356  for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
357  IdentifierInfo *Name = nullptr;
358  if (const TemplateTypeParmType *TTP
359  = Unexpanded[I].first.dyn_cast<const TemplateTypeParmType *>())
360  Name = TTP->getIdentifier();
361  else
362  Name = Unexpanded[I].first.get<NamedDecl *>()->getIdentifier();
363 
364  if (Name && NamesKnown.insert(Name).second)
365  Names.push_back(Name);
366 
367  if (Unexpanded[I].second.isValid())
368  Locations.push_back(Unexpanded[I].second);
369  }
370 
371  auto DB = Diag(Loc, diag::err_unexpanded_parameter_pack)
372  << (int)UPPC << (int)Names.size();
373  for (size_t I = 0, E = std::min(Names.size(), (size_t)2); I != E; ++I)
374  DB << Names[I];
375 
376  for (unsigned I = 0, N = Locations.size(); I != N; ++I)
377  DB << SourceRange(Locations[I]);
378  return true;
379 }
380 
382  TypeSourceInfo *T,
384  // C++0x [temp.variadic]p5:
385  // An appearance of a name of a parameter pack that is not expanded is
386  // ill-formed.
388  return false;
389 
391  CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseTypeLoc(
392  T->getTypeLoc());
393  assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
394  return DiagnoseUnexpandedParameterPacks(Loc, UPPC, Unexpanded);
395 }
396 
399  // C++0x [temp.variadic]p5:
400  // An appearance of a name of a parameter pack that is not expanded is
401  // ill-formed.
403  return false;
404 
406  CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseStmt(E);
407  assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
408  return DiagnoseUnexpandedParameterPacks(E->getBeginLoc(), UPPC, Unexpanded);
409 }
410 
413  return false;
414 
416  CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseStmt(RE);
417  assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
418 
419  // We only care about unexpanded references to the RequiresExpr's own
420  // parameter packs.
421  auto Parms = RE->getLocalParameters();
422  llvm::SmallPtrSet<NamedDecl*, 8> ParmSet(Parms.begin(), Parms.end());
424  for (auto Parm : Unexpanded)
425  if (ParmSet.contains(Parm.first.dyn_cast<NamedDecl*>()))
426  UnexpandedParms.push_back(Parm);
427  if (UnexpandedParms.empty())
428  return false;
429 
431  UnexpandedParms);
432 }
433 
436  // C++0x [temp.variadic]p5:
437  // An appearance of a name of a parameter pack that is not expanded is
438  // ill-formed.
439  if (!SS.getScopeRep() ||
441  return false;
442 
444  CollectUnexpandedParameterPacksVisitor(Unexpanded)
445  .TraverseNestedNameSpecifier(SS.getScopeRep());
446  assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
448  UPPC, Unexpanded);
449 }
450 
453  // C++0x [temp.variadic]p5:
454  // An appearance of a name of a parameter pack that is not expanded is
455  // ill-formed.
456  switch (NameInfo.getName().getNameKind()) {
465  return false;
466 
470  // FIXME: We shouldn't need this null check!
471  if (TypeSourceInfo *TSInfo = NameInfo.getNamedTypeInfo())
472  return DiagnoseUnexpandedParameterPack(NameInfo.getLoc(), TSInfo, UPPC);
473 
475  return false;
476 
477  break;
478  }
479 
481  CollectUnexpandedParameterPacksVisitor(Unexpanded)
482  .TraverseType(NameInfo.getName().getCXXNameType());
483  assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
484  return DiagnoseUnexpandedParameterPacks(NameInfo.getLoc(), UPPC, Unexpanded);
485 }
486 
488  TemplateName Template,
490 
491  if (Template.isNull() || !Template.containsUnexpandedParameterPack())
492  return false;
493 
495  CollectUnexpandedParameterPacksVisitor(Unexpanded)
496  .TraverseTemplateName(Template);
497  assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
498  return DiagnoseUnexpandedParameterPacks(Loc, UPPC, Unexpanded);
499 }
500 
503  if (Arg.getArgument().isNull() ||
505  return false;
506 
508  CollectUnexpandedParameterPacksVisitor(Unexpanded)
509  .TraverseTemplateArgumentLoc(Arg);
510  assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
511  return DiagnoseUnexpandedParameterPacks(Arg.getLocation(), UPPC, Unexpanded);
512 }
513 
516  CollectUnexpandedParameterPacksVisitor(Unexpanded)
517  .TraverseTemplateArgument(Arg);
518 }
519 
522  CollectUnexpandedParameterPacksVisitor(Unexpanded)
523  .TraverseTemplateArgumentLoc(Arg);
524 }
525 
528  CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseType(T);
529 }
530 
533  CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseTypeLoc(TL);
534 }
535 
539  CollectUnexpandedParameterPacksVisitor(Unexpanded)
540  .TraverseNestedNameSpecifierLoc(NNS);
541 }
542 
544  const DeclarationNameInfo &NameInfo,
546  CollectUnexpandedParameterPacksVisitor(Unexpanded)
547  .TraverseDeclarationNameInfo(NameInfo);
548 }
549 
550 
553  SourceLocation EllipsisLoc) {
554  if (Arg.isInvalid())
555  return Arg;
556 
557  switch (Arg.getKind()) {
559  TypeResult Result = ActOnPackExpansion(Arg.getAsType(), EllipsisLoc);
560  if (Result.isInvalid())
561  return ParsedTemplateArgument();
562 
563  return ParsedTemplateArgument(Arg.getKind(), Result.get().getAsOpaquePtr(),
564  Arg.getLocation());
565  }
566 
568  ExprResult Result = ActOnPackExpansion(Arg.getAsExpr(), EllipsisLoc);
569  if (Result.isInvalid())
570  return ParsedTemplateArgument();
571 
572  return ParsedTemplateArgument(Arg.getKind(), Result.get(),
573  Arg.getLocation());
574  }
575 
578  SourceRange R(Arg.getLocation());
579  if (Arg.getScopeSpec().isValid())
580  R.setBegin(Arg.getScopeSpec().getBeginLoc());
581  Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
582  << R;
583  return ParsedTemplateArgument();
584  }
585 
586  return Arg.getTemplatePackExpansion(EllipsisLoc);
587  }
588  llvm_unreachable("Unhandled template argument kind?");
589 }
590 
592  SourceLocation EllipsisLoc) {
593  TypeSourceInfo *TSInfo;
594  GetTypeFromParser(Type, &TSInfo);
595  if (!TSInfo)
596  return true;
597 
598  TypeSourceInfo *TSResult = CheckPackExpansion(TSInfo, EllipsisLoc, None);
599  if (!TSResult)
600  return true;
601 
602  return CreateParsedType(TSResult->getType(), TSResult);
603 }
604 
607  Optional<unsigned> NumExpansions) {
608  // Create the pack expansion type and source-location information.
609  QualType Result = CheckPackExpansion(Pattern->getType(),
610  Pattern->getTypeLoc().getSourceRange(),
611  EllipsisLoc, NumExpansions);
612  if (Result.isNull())
613  return nullptr;
614 
615  TypeLocBuilder TLB;
616  TLB.pushFullCopy(Pattern->getTypeLoc());
618  TL.setEllipsisLoc(EllipsisLoc);
619 
620  return TLB.getTypeSourceInfo(Context, Result);
621 }
622 
624  SourceLocation EllipsisLoc,
625  Optional<unsigned> NumExpansions) {
626  // C++11 [temp.variadic]p5:
627  // The pattern of a pack expansion shall name one or more
628  // parameter packs that are not expanded by a nested pack
629  // expansion.
630  //
631  // A pattern containing a deduced type can't occur "naturally" but arises in
632  // the desugaring of an init-capture pack.
633  if (!Pattern->containsUnexpandedParameterPack() &&
634  !Pattern->getContainedDeducedType()) {
635  Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
636  << PatternRange;
637  return QualType();
638  }
639 
640  return Context.getPackExpansionType(Pattern, NumExpansions,
641  /*ExpectPackInType=*/false);
642 }
643 
645  return CheckPackExpansion(Pattern, EllipsisLoc, None);
646 }
647 
649  Optional<unsigned> NumExpansions) {
650  if (!Pattern)
651  return ExprError();
652 
653  // C++0x [temp.variadic]p5:
654  // The pattern of a pack expansion shall name one or more
655  // parameter packs that are not expanded by a nested pack
656  // expansion.
657  if (!Pattern->containsUnexpandedParameterPack()) {
658  Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
659  << Pattern->getSourceRange();
660  CorrectDelayedTyposInExpr(Pattern);
661  return ExprError();
662  }
663 
664  // Create the pack expansion expression and source-location information.
665  return new (Context)
666  PackExpansionExpr(Context.DependentTy, Pattern, EllipsisLoc, NumExpansions);
667 }
668 
670  SourceLocation EllipsisLoc, SourceRange PatternRange,
672  const MultiLevelTemplateArgumentList &TemplateArgs, bool &ShouldExpand,
673  bool &RetainExpansion, Optional<unsigned> &NumExpansions) {
674  ShouldExpand = true;
675  RetainExpansion = false;
676  std::pair<IdentifierInfo *, SourceLocation> FirstPack;
677  bool HaveFirstPack = false;
678  Optional<unsigned> NumPartialExpansions;
679  SourceLocation PartiallySubstitutedPackLoc;
680 
681  for (ArrayRef<UnexpandedParameterPack>::iterator i = Unexpanded.begin(),
682  end = Unexpanded.end();
683  i != end; ++i) {
684  // Compute the depth and index for this parameter pack.
685  unsigned Depth = 0, Index = 0;
686  IdentifierInfo *Name;
687  bool IsVarDeclPack = false;
688 
689  if (const TemplateTypeParmType *TTP
690  = i->first.dyn_cast<const TemplateTypeParmType *>()) {
691  Depth = TTP->getDepth();
692  Index = TTP->getIndex();
693  Name = TTP->getIdentifier();
694  } else {
695  NamedDecl *ND = i->first.get<NamedDecl *>();
696  if (isa<VarDecl>(ND))
697  IsVarDeclPack = true;
698  else
699  std::tie(Depth, Index) = getDepthAndIndex(ND);
700 
701  Name = ND->getIdentifier();
702  }
703 
704  // Determine the size of this argument pack.
705  unsigned NewPackSize;
706  if (IsVarDeclPack) {
707  // Figure out whether we're instantiating to an argument pack or not.
708  typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
709 
710  llvm::PointerUnion<Decl *, DeclArgumentPack *> *Instantiation
712  i->first.get<NamedDecl *>());
713  if (Instantiation->is<DeclArgumentPack *>()) {
714  // We could expand this function parameter pack.
715  NewPackSize = Instantiation->get<DeclArgumentPack *>()->size();
716  } else {
717  // We can't expand this function parameter pack, so we can't expand
718  // the pack expansion.
719  ShouldExpand = false;
720  continue;
721  }
722  } else {
723  // If we don't have a template argument at this depth/index, then we
724  // cannot expand the pack expansion. Make a note of this, but we still
725  // want to check any parameter packs we *do* have arguments for.
726  if (Depth >= TemplateArgs.getNumLevels() ||
727  !TemplateArgs.hasTemplateArgument(Depth, Index)) {
728  ShouldExpand = false;
729  continue;
730  }
731 
732  // Determine the size of the argument pack.
733  NewPackSize = TemplateArgs(Depth, Index).pack_size();
734  }
735 
736  // C++0x [temp.arg.explicit]p9:
737  // Template argument deduction can extend the sequence of template
738  // arguments corresponding to a template parameter pack, even when the
739  // sequence contains explicitly specified template arguments.
740  if (!IsVarDeclPack && CurrentInstantiationScope) {
741  if (NamedDecl *PartialPack
743  unsigned PartialDepth, PartialIndex;
744  std::tie(PartialDepth, PartialIndex) = getDepthAndIndex(PartialPack);
745  if (PartialDepth == Depth && PartialIndex == Index) {
746  RetainExpansion = true;
747  // We don't actually know the new pack size yet.
748  NumPartialExpansions = NewPackSize;
749  PartiallySubstitutedPackLoc = i->second;
750  continue;
751  }
752  }
753  }
754 
755  if (!NumExpansions) {
756  // The is the first pack we've seen for which we have an argument.
757  // Record it.
758  NumExpansions = NewPackSize;
759  FirstPack.first = Name;
760  FirstPack.second = i->second;
761  HaveFirstPack = true;
762  continue;
763  }
764 
765  if (NewPackSize != *NumExpansions) {
766  // C++0x [temp.variadic]p5:
767  // All of the parameter packs expanded by a pack expansion shall have
768  // the same number of arguments specified.
769  if (HaveFirstPack)
770  Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict)
771  << FirstPack.first << Name << *NumExpansions << NewPackSize
772  << SourceRange(FirstPack.second) << SourceRange(i->second);
773  else
774  Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict_multilevel)
775  << Name << *NumExpansions << NewPackSize
776  << SourceRange(i->second);
777  return true;
778  }
779  }
780 
781  // If we're performing a partial expansion but we also have a full expansion,
782  // expand to the number of common arguments. For example, given:
783  //
784  // template<typename ...T> struct A {
785  // template<typename ...U> void f(pair<T, U>...);
786  // };
787  //
788  // ... a call to 'A<int, int>().f<int>' should expand the pack once and
789  // retain an expansion.
790  if (NumPartialExpansions) {
791  if (NumExpansions && *NumExpansions < *NumPartialExpansions) {
792  NamedDecl *PartialPack =
794  Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict_partial)
795  << PartialPack << *NumPartialExpansions << *NumExpansions
796  << SourceRange(PartiallySubstitutedPackLoc);
797  return true;
798  }
799 
800  NumExpansions = NumPartialExpansions;
801  }
802 
803  return false;
804 }
805 
807  const MultiLevelTemplateArgumentList &TemplateArgs) {
808  QualType Pattern = cast<PackExpansionType>(T)->getPattern();
810  CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseType(Pattern);
811 
812  Optional<unsigned> Result;
813  for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
814  // Compute the depth and index for this parameter pack.
815  unsigned Depth;
816  unsigned Index;
817 
818  if (const TemplateTypeParmType *TTP
819  = Unexpanded[I].first.dyn_cast<const TemplateTypeParmType *>()) {
820  Depth = TTP->getDepth();
821  Index = TTP->getIndex();
822  } else {
823  NamedDecl *ND = Unexpanded[I].first.get<NamedDecl *>();
824  if (isa<VarDecl>(ND)) {
825  // Function parameter pack or init-capture pack.
826  typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
827 
828  llvm::PointerUnion<Decl *, DeclArgumentPack *> *Instantiation
830  Unexpanded[I].first.get<NamedDecl *>());
831  if (Instantiation->is<Decl*>())
832  // The pattern refers to an unexpanded pack. We're not ready to expand
833  // this pack yet.
834  return None;
835 
836  unsigned Size = Instantiation->get<DeclArgumentPack *>()->size();
837  assert((!Result || *Result == Size) && "inconsistent pack sizes");
838  Result = Size;
839  continue;
840  }
841 
842  std::tie(Depth, Index) = getDepthAndIndex(ND);
843  }
844  if (Depth >= TemplateArgs.getNumLevels() ||
845  !TemplateArgs.hasTemplateArgument(Depth, Index))
846  // The pattern refers to an unknown template argument. We're not ready to
847  // expand this pack yet.
848  return None;
849 
850  // Determine the size of the argument pack.
851  unsigned Size = TemplateArgs(Depth, Index).pack_size();
852  assert((!Result || *Result == Size) && "inconsistent pack sizes");
853  Result = Size;
854  }
855 
856  return Result;
857 }
858 
860  const DeclSpec &DS = D.getDeclSpec();
861  switch (DS.getTypeSpecType()) {
862  case TST_typename:
863  case TST_typeofType:
864  case TST_underlyingType:
865  case TST_atomic: {
866  QualType T = DS.getRepAsType().get();
867  if (!T.isNull() && T->containsUnexpandedParameterPack())
868  return true;
869  break;
870  }
871 
872  case TST_typeofExpr:
873  case TST_decltype:
874  case TST_extint:
875  if (DS.getRepAsExpr() &&
877  return true;
878  break;
879 
880  case TST_unspecified:
881  case TST_void:
882  case TST_char:
883  case TST_wchar:
884  case TST_char8:
885  case TST_char16:
886  case TST_char32:
887  case TST_int:
888  case TST_int128:
889  case TST_half:
890  case TST_float:
891  case TST_double:
892  case TST_Accum:
893  case TST_Fract:
894  case TST_Float16:
895  case TST_float128:
896  case TST_bool:
897  case TST_decimal32:
898  case TST_decimal64:
899  case TST_decimal128:
900  case TST_enum:
901  case TST_union:
902  case TST_struct:
903  case TST_interface:
904  case TST_class:
905  case TST_auto:
906  case TST_auto_type:
907  case TST_decltype_auto:
908  case TST_BFloat16:
909 #define GENERIC_IMAGE_TYPE(ImgType, Id) case TST_##ImgType##_t:
910 #include "clang/Basic/OpenCLImageTypes.def"
911  case TST_unknown_anytype:
912  case TST_error:
913  break;
914  }
915 
916  for (unsigned I = 0, N = D.getNumTypeObjects(); I != N; ++I) {
917  const DeclaratorChunk &Chunk = D.getTypeObject(I);
918  switch (Chunk.Kind) {
924  // These declarator chunks cannot contain any parameter packs.
925  break;
926 
928  if (Chunk.Arr.NumElts &&
930  return true;
931  break;
933  for (unsigned i = 0, e = Chunk.Fun.NumParams; i != e; ++i) {
934  ParmVarDecl *Param = cast<ParmVarDecl>(Chunk.Fun.Params[i].Param);
935  QualType ParamTy = Param->getType();
936  assert(!ParamTy.isNull() && "Couldn't parse type?");
937  if (ParamTy->containsUnexpandedParameterPack()) return true;
938  }
939 
940  if (Chunk.Fun.getExceptionSpecType() == EST_Dynamic) {
941  for (unsigned i = 0; i != Chunk.Fun.getNumExceptions(); ++i) {
942  if (Chunk.Fun.Exceptions[i]
943  .Ty.get()
945  return true;
946  }
947  } else if (isComputedNoexcept(Chunk.Fun.getExceptionSpecType()) &&
949  return true;
950 
951  if (Chunk.Fun.hasTrailingReturnType()) {
952  QualType T = Chunk.Fun.getTrailingReturnType().get();
953  if (!T.isNull() && T->containsUnexpandedParameterPack())
954  return true;
955  }
956  break;
957 
959  if (Chunk.Mem.Scope().getScopeRep() &&
961  return true;
962  break;
963  }
964  }
965 
966  if (Expr *TRC = D.getTrailingRequiresClause())
967  if (TRC->containsUnexpandedParameterPack())
968  return true;
969 
970  return false;
971 }
972 
973 namespace {
974 
975 // Callback to only accept typo corrections that refer to parameter packs.
976 class ParameterPackValidatorCCC final : public CorrectionCandidateCallback {
977  public:
978  bool ValidateCandidate(const TypoCorrection &candidate) override {
979  NamedDecl *ND = candidate.getCorrectionDecl();
980  return ND && ND->isParameterPack();
981  }
982 
983  std::unique_ptr<CorrectionCandidateCallback> clone() override {
984  return std::make_unique<ParameterPackValidatorCCC>(*this);
985  }
986 };
987 
988 }
989 
990 /// Called when an expression computing the size of a parameter pack
991 /// is parsed.
992 ///
993 /// \code
994 /// template<typename ...Types> struct count {
995 /// static const unsigned value = sizeof...(Types);
996 /// };
997 /// \endcode
998 ///
999 //
1000 /// \param OpLoc The location of the "sizeof" keyword.
1001 /// \param Name The name of the parameter pack whose size will be determined.
1002 /// \param NameLoc The source location of the name of the parameter pack.
1003 /// \param RParenLoc The location of the closing parentheses.
1005  SourceLocation OpLoc,
1006  IdentifierInfo &Name,
1007  SourceLocation NameLoc,
1008  SourceLocation RParenLoc) {
1009  // C++0x [expr.sizeof]p5:
1010  // The identifier in a sizeof... expression shall name a parameter pack.
1011  LookupResult R(*this, &Name, NameLoc, LookupOrdinaryName);
1012  LookupName(R, S);
1013 
1014  NamedDecl *ParameterPack = nullptr;
1015  switch (R.getResultKind()) {
1016  case LookupResult::Found:
1017  ParameterPack = R.getFoundDecl();
1018  break;
1019 
1022  ParameterPackValidatorCCC CCC{};
1023  if (TypoCorrection Corrected =
1024  CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S, nullptr,
1025  CCC, CTK_ErrorRecovery)) {
1026  diagnoseTypo(Corrected,
1027  PDiag(diag::err_sizeof_pack_no_pack_name_suggest) << &Name,
1028  PDiag(diag::note_parameter_pack_here));
1029  ParameterPack = Corrected.getCorrectionDecl();
1030  }
1031  break;
1032  }
1035  break;
1036 
1039  return ExprError();
1040  }
1041 
1042  if (!ParameterPack || !ParameterPack->isParameterPack()) {
1043  Diag(NameLoc, diag::err_sizeof_pack_no_pack_name)
1044  << &Name;
1045  return ExprError();
1046  }
1047 
1048  MarkAnyDeclReferenced(OpLoc, ParameterPack, true);
1049 
1050  return SizeOfPackExpr::Create(Context, OpLoc, ParameterPack, NameLoc,
1051  RParenLoc);
1052 }
1053 
1056  TemplateArgumentLoc OrigLoc,
1057  SourceLocation &Ellipsis, Optional<unsigned> &NumExpansions) const {
1058  const TemplateArgument &Argument = OrigLoc.getArgument();
1059  assert(Argument.isPackExpansion());
1060  switch (Argument.getKind()) {
1061  case TemplateArgument::Type: {
1062  // FIXME: We shouldn't ever have to worry about missing
1063  // type-source info!
1064  TypeSourceInfo *ExpansionTSInfo = OrigLoc.getTypeSourceInfo();
1065  if (!ExpansionTSInfo)
1066  ExpansionTSInfo = Context.getTrivialTypeSourceInfo(Argument.getAsType(),
1067  Ellipsis);
1068  PackExpansionTypeLoc Expansion =
1069  ExpansionTSInfo->getTypeLoc().castAs<PackExpansionTypeLoc>();
1070  Ellipsis = Expansion.getEllipsisLoc();
1071 
1072  TypeLoc Pattern = Expansion.getPatternLoc();
1073  NumExpansions = Expansion.getTypePtr()->getNumExpansions();
1074 
1075  // We need to copy the TypeLoc because TemplateArgumentLocs store a
1076  // TypeSourceInfo.
1077  // FIXME: Find some way to avoid the copy?
1078  TypeLocBuilder TLB;
1079  TLB.pushFullCopy(Pattern);
1080  TypeSourceInfo *PatternTSInfo =
1081  TLB.getTypeSourceInfo(Context, Pattern.getType());
1082  return TemplateArgumentLoc(TemplateArgument(Pattern.getType()),
1083  PatternTSInfo);
1084  }
1085 
1087  PackExpansionExpr *Expansion
1088  = cast<PackExpansionExpr>(Argument.getAsExpr());
1089  Expr *Pattern = Expansion->getPattern();
1090  Ellipsis = Expansion->getEllipsisLoc();
1091  NumExpansions = Expansion->getNumExpansions();
1092  return TemplateArgumentLoc(Pattern, Pattern);
1093  }
1094 
1096  Ellipsis = OrigLoc.getTemplateEllipsisLoc();
1097  NumExpansions = Argument.getNumTemplateExpansions();
1099  OrigLoc.getTemplateQualifierLoc(),
1100  OrigLoc.getTemplateNameLoc());
1101 
1108  return TemplateArgumentLoc();
1109  }
1110 
1111  llvm_unreachable("Invalid TemplateArgument Kind!");
1112 }
1113 
1115  assert(Arg.containsUnexpandedParameterPack());
1116 
1117  // If this is a substituted pack, grab that pack. If not, we don't know
1118  // the size yet.
1119  // FIXME: We could find a size in more cases by looking for a substituted
1120  // pack anywhere within this argument, but that's not necessary in the common
1121  // case for 'sizeof...(A)' handling.
1122  TemplateArgument Pack;
1123  switch (Arg.getKind()) {
1125  if (auto *Subst = Arg.getAsType()->getAs<SubstTemplateTypeParmPackType>())
1126  Pack = Subst->getArgumentPack();
1127  else
1128  return None;
1129  break;
1130 
1132  if (auto *Subst =
1133  dyn_cast<SubstNonTypeTemplateParmPackExpr>(Arg.getAsExpr()))
1134  Pack = Subst->getArgumentPack();
1135  else if (auto *Subst = dyn_cast<FunctionParmPackExpr>(Arg.getAsExpr())) {
1136  for (VarDecl *PD : *Subst)
1137  if (PD->isParameterPack())
1138  return None;
1139  return Subst->getNumExpansions();
1140  } else
1141  return None;
1142  break;
1143 
1147  Pack = Subst->getArgumentPack();
1148  else
1149  return None;
1150  break;
1151 
1158  return None;
1159  }
1160 
1161  // Check that no argument in the pack is itself a pack expansion.
1162  for (TemplateArgument Elem : Pack.pack_elements()) {
1163  // There's no point recursing in this case; we would have already
1164  // expanded this pack expansion into the enclosing pack if we could.
1165  if (Elem.isPackExpansion())
1166  return None;
1167  }
1168  return Pack.pack_size();
1169 }
1170 
1171 static void CheckFoldOperand(Sema &S, Expr *E) {
1172  if (!E)
1173  return;
1174 
1175  E = E->IgnoreImpCasts();
1176  auto *OCE = dyn_cast<CXXOperatorCallExpr>(E);
1177  if ((OCE && OCE->isInfixBinaryOp()) || isa<BinaryOperator>(E) ||
1178  isa<AbstractConditionalOperator>(E)) {
1179  S.Diag(E->getExprLoc(), diag::err_fold_expression_bad_operand)
1180  << E->getSourceRange()
1182  << FixItHint::CreateInsertion(E->getEndLoc(), ")");
1183  }
1184 }
1185 
1187  tok::TokenKind Operator,
1188  SourceLocation EllipsisLoc, Expr *RHS,
1189  SourceLocation RParenLoc) {
1190  // LHS and RHS must be cast-expressions. We allow an arbitrary expression
1191  // in the parser and reduce down to just cast-expressions here.
1192  CheckFoldOperand(*this, LHS);
1193  CheckFoldOperand(*this, RHS);
1194 
1195  auto DiscardOperands = [&] {
1198  };
1199 
1200  // [expr.prim.fold]p3:
1201  // In a binary fold, op1 and op2 shall be the same fold-operator, and
1202  // either e1 shall contain an unexpanded parameter pack or e2 shall contain
1203  // an unexpanded parameter pack, but not both.
1204  if (LHS && RHS &&
1207  DiscardOperands();
1208  return Diag(EllipsisLoc,
1210  ? diag::err_fold_expression_packs_both_sides
1211  : diag::err_pack_expansion_without_parameter_packs)
1212  << LHS->getSourceRange() << RHS->getSourceRange();
1213  }
1214 
1215  // [expr.prim.fold]p2:
1216  // In a unary fold, the cast-expression shall contain an unexpanded
1217  // parameter pack.
1218  if (!LHS || !RHS) {
1219  Expr *Pack = LHS ? LHS : RHS;
1220  assert(Pack && "fold expression with neither LHS nor RHS");
1221  DiscardOperands();
1222  if (!Pack->containsUnexpandedParameterPack())
1223  return Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
1224  << Pack->getSourceRange();
1225  }
1226 
1227  BinaryOperatorKind Opc = ConvertTokenKindToBinaryOpcode(Operator);
1228 
1229  // Perform first-phase name lookup now.
1230  UnresolvedLookupExpr *ULE = nullptr;
1231  {
1232  UnresolvedSet<16> Functions;
1233  LookupBinOp(S, EllipsisLoc, Opc, Functions);
1234  if (!Functions.empty()) {
1238  /*NamingClass*/ nullptr, NestedNameSpecifierLoc(),
1239  DeclarationNameInfo(OpName, EllipsisLoc), Functions);
1240  if (Callee.isInvalid())
1241  return ExprError();
1242  ULE = cast<UnresolvedLookupExpr>(Callee.get());
1243  }
1244  }
1245 
1246  return BuildCXXFoldExpr(ULE, LParenLoc, LHS, Opc, EllipsisLoc, RHS, RParenLoc,
1247  None);
1248 }
1249 
1251  SourceLocation LParenLoc, Expr *LHS,
1252  BinaryOperatorKind Operator,
1253  SourceLocation EllipsisLoc, Expr *RHS,
1254  SourceLocation RParenLoc,
1255  Optional<unsigned> NumExpansions) {
1256  return new (Context)
1257  CXXFoldExpr(Context.DependentTy, Callee, LParenLoc, LHS, Operator,
1258  EllipsisLoc, RHS, RParenLoc, NumExpansions);
1259 }
1260 
1262  BinaryOperatorKind Operator) {
1263  // [temp.variadic]p9:
1264  // If N is zero for a unary fold-expression, the value of the expression is
1265  // && -> true
1266  // || -> false
1267  // , -> void()
1268  // if the operator is not listed [above], the instantiation is ill-formed.
1269  //
1270  // Note that we need to use something like int() here, not merely 0, to
1271  // prevent the result from being a null pointer constant.
1272  QualType ScalarType;
1273  switch (Operator) {
1274  case BO_LOr:
1275  return ActOnCXXBoolLiteral(EllipsisLoc, tok::kw_false);
1276  case BO_LAnd:
1277  return ActOnCXXBoolLiteral(EllipsisLoc, tok::kw_true);
1278  case BO_Comma:
1279  ScalarType = Context.VoidTy;
1280  break;
1281 
1282  default:
1283  return Diag(EllipsisLoc, diag::err_fold_expression_empty)
1284  << BinaryOperator::getOpcodeStr(Operator);
1285  }
1286 
1287  return new (Context) CXXScalarValueInitExpr(
1288  ScalarType, Context.getTrivialTypeSourceInfo(ScalarType, EllipsisLoc),
1289  EllipsisLoc);
1290 }
clang::SourceRange::setBegin
void setBegin(SourceLocation b)
Definition: SourceLocation.h:224
clang::TST_half
@ TST_half
Definition: Specifiers.h:54
clang::PackExpansionExpr::getPattern
Expr * getPattern()
Retrieve the pattern of the pack expansion.
Definition: ExprCXX.h:4080
clang::DeclaratorChunk::FunctionTypeInfo::NumParams
unsigned NumParams
NumParams - This is the number of formal parameters specified by the declarator.
Definition: DeclSpec.h:1315
clang::OpaquePtr::get
PtrTy get() const
Definition: Ownership.h:80
CheckFoldOperand
static void CheckFoldOperand(Sema &S, Expr *E)
Definition: SemaTemplateVariadic.cpp:1171
clang::LookupResult::NotFound
@ NotFound
No entity found met the criteria.
Definition: Lookup.h:50
clang::TST_Float16
@ TST_Float16
Definition: Specifiers.h:55
clang::TST_char8
@ TST_char8
Definition: Specifiers.h:48
clang::TST_bool
@ TST_bool
Definition: Specifiers.h:62
TypeLocBuilder.h
clang::DeclaratorChunk::FunctionTypeInfo::hasTrailingReturnType
bool hasTrailingReturnType() const
Determine whether this function declarator had a trailing-return-type.
Definition: DeclSpec.h:1498
clang::PackExpansionExpr::getEllipsisLoc
SourceLocation getEllipsisLoc() const
Retrieve the location of the ellipsis that describes this pack expansion.
Definition: ExprCXX.h:4087
clang::DeclRefExpr::getLocation
SourceLocation getLocation() const
Definition: Expr.h:1293
clang::TypeSourceInfo::getType
QualType getType() const
Return the type wrapped by this type source info.
Definition: Type.h:6402
clang::ObjCDictionaryElement
An element in an Objective-C dictionary literal.
Definition: ExprObjC.h:263
clang::DeclarationName::Identifier
@ Identifier
Definition: DeclarationName.h:203
clang::TST_underlyingType
@ TST_underlyingType
Definition: Specifiers.h:75
clang::DeclarationName::CXXLiteralOperatorName
@ CXXLiteralOperatorName
Definition: DeclarationName.h:212
clang::ObjCDictionaryLiteral::getNumElements
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c dictionary literal.
Definition: ExprObjC.h:360
clang::SourceRange
A trivial tuple used to represent a source range.
Definition: SourceLocation.h:212
clang::Sema::ActOnCXXBoolLiteral
ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind)
ActOnCXXBoolLiteral - Parse {true,false} literals.
Definition: SemaExprCXX.cpp:785
clang::LambdaCapture
Describes the capture of a variable or of this, or of a C++1y init-capture.
Definition: LambdaCapture.h:25
clang::TST_interface
@ TST_interface
Definition: Specifiers.h:70
clang::TemplateName::containsUnexpandedParameterPack
bool containsUnexpandedParameterPack() const
Determines whether this template name contains an unexpanded parameter pack (for C++0x variadic templ...
Definition: TemplateName.cpp:219
clang::TypoCorrection
Simple class containing the result of Sema::CorrectTypo.
Definition: TypoCorrection.h:42
clang::FixItHint::CreateInsertion
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:96
clang::DeclaratorChunk::Mem
MemberPointerTypeInfo Mem
Definition: DeclSpec.h:1554
clang::TemplateArgument::pack_elements
ArrayRef< TemplateArgument > pack_elements() const
Iterator range referencing all of the elements of a template argument pack.
Definition: TemplateBase.h:366
clang::Declarator::getNumTypeObjects
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
Definition: DeclSpec.h:2236
clang::TST_unspecified
@ TST_unspecified
Definition: Specifiers.h:44
clang::TemplateArgument::Null
@ Null
Represents an empty template argument, e.g., one that has not been deduced.
Definition: TemplateBase.h:68
clang::LookupResult::FoundOverloaded
@ FoundOverloaded
Name lookup found a set of overloaded functions that met the criteria.
Definition: Lookup.h:63
clang::TypeLocBuilder::pushFullCopy
void pushFullCopy(TypeLoc L)
Pushes a copy of the given TypeLoc onto this builder.
Definition: TypeLocBuilder.cpp:18
clang::TST_typename
@ TST_typename
Definition: Specifiers.h:71
SemaInternal.h
clang::ASTContext::VoidTy
CanQualType VoidTy
Definition: ASTContext.h:995
clang::DeclarationName::CXXConstructorName
@ CXXConstructorName
Definition: DeclarationName.h:206
llvm::SmallVector
Definition: LLVM.h:38
Lookup.h
clang::TemplateArgumentLoc::getTemplateEllipsisLoc
SourceLocation getTemplateEllipsisLoc() const
Definition: TemplateBase.h:553
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:89
clang::Sema::FunctionScopes
SmallVector< sema::FunctionScopeInfo *, 4 > FunctionScopes
Stack containing information about each of the nested function, block, and method scopes that are cur...
Definition: Sema.h:785
clang::NamedDecl
This represents a decl that may have a name.
Definition: Decl.h:223
clang::SourceRange::getBegin
SourceLocation getBegin() const
Definition: SourceLocation.h:221
clang::TST_void
@ TST_void
Definition: Specifiers.h:45
clang::Sema::UPPC_Requirement
@ UPPC_Requirement
Definition: Sema.h:7999
clang::DeclSpec::getRepAsExpr
Expr * getRepAsExpr() const
Definition: DeclSpec.h:494
clang::ASTContext::DeclarationNames
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:614
clang::TypeLocBuilder::getTypeSourceInfo
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
Definition: TypeLocBuilder.h:101
clang::Stmt::getSourceRange
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:324
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:661
clang::TemplateName::getAsTemplateDecl
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known.
Definition: TemplateName.cpp:101
AttributeLangSupport::C
@ C
Definition: SemaDeclAttr.cpp:52
clang::UnresolvedUsingValueDecl::isPackExpansion
bool isPackExpansion() const
Determine whether this is a pack expansion.
Definition: DeclCXX.h:3648
clang::TST_struct
@ TST_struct
Definition: Specifiers.h:68
clang::DeclaratorChunk::Function
@ Function
Definition: DeclSpec.h:1177
clang::RequiresExpr
C++2a [expr.prim.req]: A requires-expression provides a concise way to express requirements on templa...
Definition: ExprConcepts.h:475
clang::DeclaratorChunk::Fun
FunctionTypeInfo Fun
Definition: DeclSpec.h:1552
clang::EST_Dynamic
@ EST_Dynamic
throw(T1, T2)
Definition: ExceptionSpecificationType.h:23
clang::LookupResult
Represents the results of name lookup.
Definition: Lookup.h:46
clang::ParmVarDecl
Represents a parameter to a function.
Definition: Decl.h:1630
clang::Sema::Diag
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
Definition: Sema.cpp:1778
clang::Sema::getFullyPackExpandedSize
Optional< unsigned > getFullyPackExpandedSize(TemplateArgument Arg)
Given a template argument that contains an unexpanded parameter pack, but which has already been subs...
Definition: SemaTemplateVariadic.cpp:1114
int
__device__ int
Definition: __clang_hip_libdevice_declares.h:63
clang::Type::getContainedDeducedType
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type.
Definition: Type.cpp:1879
clang::LookupResult::NotFoundInCurrentInstantiation
@ NotFoundInCurrentInstantiation
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
Definition: Lookup.h:55
clang::TemplateArgument::Declaration
@ Declaration
The template argument is a declaration that was provided for a pointer, reference,...
Definition: TemplateBase.h:75
clang::BinaryOperator::getOpcodeStr
StringRef getOpcodeStr() const
Definition: Expr.h:3792
clang::Sema::BuildEmptyCXXFoldExpr
ExprResult BuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc, BinaryOperatorKind Operator)
Definition: SemaTemplateVariadic.cpp:1261
clang::DeclarationName::CXXDeductionGuideName
@ CXXDeductionGuideName
Definition: DeclarationName.h:210
clang::Type::containsUnexpandedParameterPack
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
Definition: Type.h:1866
clang::TST_enum
@ TST_enum
Definition: Specifiers.h:66
clang::TST_error
@ TST_error
Definition: Specifiers.h:83
llvm::Optional< unsigned >
llvm::SmallPtrSet
Definition: ASTContext.h:81
clang::TST_auto
@ TST_auto
Definition: Specifiers.h:76
clang::TypeSpecTypeLoc::getNameLoc
SourceLocation getNameLoc() const
Definition: TypeLoc.h:523
clang::TemplateArgument::isNull
bool isNull() const
Determine whether this template argument has no value.
Definition: TemplateBase.h:248
clang::CXXScopeSpec
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:64
clang::isComputedNoexcept
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
Definition: ExceptionSpecificationType.h:39
clang::Expr::containsUnexpandedParameterPack
bool containsUnexpandedParameterPack() const
Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates).
Definition: Expr.h:232
clang::ConcreteTypeLoc::getTypePtr
const TypeClass * getTypePtr() const
Definition: TypeLoc.h:409
clang::DeclaratorChunk::FunctionTypeInfo::getExceptionSpecType
ExceptionSpecificationType getExceptionSpecType() const
Get the type of exception specification this function has.
Definition: DeclSpec.h:1479
clang::ASTContext::getPackExpansionType
QualType getPackExpansionType(QualType Pattern, Optional< unsigned > NumExpansions, bool ExpectPackInType=true)
Form a pack expansion type with the given pattern.
Definition: ASTContext.cpp:4997
clang::DeclaratorChunk::FunctionTypeInfo::getTrailingReturnType
ParsedType getTrailingReturnType() const
Get the trailing-return-type for this function declarator.
Definition: DeclSpec.h:1501
clang::DeclaratorChunk::Arr
ArrayTypeInfo Arr
Definition: DeclSpec.h:1551
clang::ParsedTemplateArgument::Type
@ Type
A template type parameter, stored as a type.
Definition: ParsedTemplate.h:34
clang::TST_auto_type
@ TST_auto_type
Definition: Specifiers.h:78
clang::Expr::IgnoreImpCasts
Expr * IgnoreImpCasts() LLVM_READONLY
Skip past any implicit casts which might surround this expression until reaching a fixed point.
Definition: Expr.cpp:2756
clang::TST_unknown_anytype
@ TST_unknown_anytype
Definition: Specifiers.h:79
clang::TemplateArgument::getAsExpr
Expr * getAsExpr() const
Retrieve the template argument as an expression.
Definition: TemplateBase.h:342
clang::DeclarationName
The name of a declaration.
Definition: DeclarationName.h:145
clang::Sema::BuildCXXFoldExpr
ExprResult BuildCXXFoldExpr(UnresolvedLookupExpr *Callee, SourceLocation LParenLoc, Expr *LHS, BinaryOperatorKind Operator, SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc, Optional< unsigned > NumExpansions)
Definition: SemaTemplateVariadic.cpp:1250
clang::TemplateArgumentLoc::getTypeSourceInfo
TypeSourceInfo * getTypeSourceInfo() const
Definition: TemplateBase.h:514
clang::TemplateArgument::Expression
@ Expression
The template argument is an expression, and we've not resolved it to one of the other forms yet,...
Definition: TemplateBase.h:97
clang::ObjCDictionaryElement::isPackExpansion
bool isPackExpansion() const
Determines whether this dictionary element is a pack expansion.
Definition: ExprObjC.h:278
clang::Declarator::getTrailingRequiresClause
Expr * getTrailingRequiresClause()
Sets a trailing requires clause for this declarator.
Definition: DeclSpec.h:2473
clang::Sema::Context
ASTContext & Context
Definition: Sema.h:411
clang::Type
The base class of the type hierarchy.
Definition: Type.h:1478
clang::CXXFoldExpr
Represents a folding of a pack over an operator.
Definition: ExprCXX.h:4576
clang::ExprError
ExprResult ExprError()
Definition: Ownership.h:278
clang::TemplateArgument::Integral
@ Integral
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
Definition: TemplateBase.h:83
clang::Sema::CheckParameterPacksForExpansion
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...
Definition: SemaTemplateVariadic.cpp:669
clang::Declarator::getDeclSpec
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
Definition: DeclSpec.h:1910
clang::TemplateArgument::NullPtr
@ NullPtr
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
Definition: TemplateBase.h:79
clang::UnresolvedSetImpl::empty
bool empty() const
Definition: UnresolvedSet.h:126
clang::UnresolvedUsingTypenameDecl
Represents a dependent using declaration which was marked with typename.
Definition: DeclCXX.h:3690
clang::TemplateArgumentLoc::getLocation
SourceLocation getLocation() const
Definition: TemplateBase.h:495
clang::TypeLocBuilder::push
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
Definition: TypeLocBuilder.h:93
clang::PackExpansionTypeLoc
Definition: TypeLoc.h:2437
Template.h
clang::Sema::getEnclosingLambda
sema::LambdaScopeInfo * getEnclosingLambda() const
Get the innermost lambda enclosing the current location, if any.
Definition: Sema.cpp:2109
clang::NestedNameSpecifier::containsUnexpandedParameterPack
bool containsUnexpandedParameterPack() const
Whether this nested-name-specifier contains an unexpanded parameter pack (for C++11 variadic template...
Definition: NestedNameSpecifier.cpp:242
min
__DEVICE__ int min(int __a, int __b)
Definition: __clang_cuda_math.h:195
clang::TemplateArgument::getKind
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:245
clang::DeclaratorChunk::FunctionTypeInfo::Exceptions
TypeAndRange * Exceptions
Pointer to a new[]'d array of TypeAndRange objects that contain the types in the function's dynamic e...
Definition: DeclSpec.h:1352
clang::PackExpansionType
Represents a pack expansion of types.
Definition: Type.h:5627
clang::UnresolvedLookupExpr
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
Definition: ExprCXX.h:3073
clang::Sema::MarkAnyDeclReferenced
void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse)
Perform marking for a reference to an arbitrary declaration.
Definition: SemaExpr.cpp:18573
clang::DeclSpec::getTypeSpecType
TST getTypeSpecType() const
Definition: DeclSpec.h:476
clang::Sema::CreateParsedType
ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)
Package the given type and TSI into a ParsedType.
Definition: SemaType.cpp:6293
clang::TST_decltype
@ TST_decltype
Definition: Specifiers.h:74
clang::PackExpansionTypeLoc::getEllipsisLoc
SourceLocation getEllipsisLoc() const
Definition: TypeLoc.h:2441
clang::LambdaExpr
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1865
clang::Sema::UnexpandedParameterPackContext
UnexpandedParameterPackContext
The context in which an unexpanded parameter pack is being diagnosed.
Definition: Sema.h:7934
clang::Scope
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
clang::CXXScopeSpec::isValid
bool isValid() const
A scope specifier is present, and it refers to a real scope.
Definition: DeclSpec.h:197
clang::DeclarationName::CXXDestructorName
@ CXXDestructorName
Definition: DeclarationName.h:207
clang::LambdaExpr::getTemplateParameterList
TemplateParameterList * getTemplateParameterList() const
If this is a generic lambda expression, retrieve the template parameter list associated with it,...
Definition: ExprCXX.cpp:1264
clang::Sema::ActOnCXXFoldExpr
ExprResult ActOnCXXFoldExpr(Scope *S, SourceLocation LParenLoc, Expr *LHS, tok::TokenKind Operator, SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc)
Handle a C++1z fold-expression: ( expr op ... op expr ).
Definition: SemaTemplateVariadic.cpp:1186
clang::ObjCDictionaryElement::Key
Expr * Key
The key for the dictionary element.
Definition: ExprObjC.h:265
clang::ASTContext::DependentTy
CanQualType DependentTy
Definition: ASTContext.h:1025
clang::DeclaratorChunk::Kind
enum clang::DeclaratorChunk::@206 Kind
clang::DeclaratorChunk::Pipe
@ Pipe
Definition: DeclSpec.h:1177
getIdentifier
static StringRef getIdentifier(const Token &Tok)
Definition: ParsePragma.cpp:1311
clang::DeclarationNameTable::getCXXOperatorName
DeclarationName getCXXOperatorName(OverloadedOperatorKind Op)
Get the name of the overloadable C++ operator corresponding to Op.
Definition: DeclarationName.h:639
clang::ObjCDictionaryLiteral
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
Definition: ExprObjC.h:306
clang::DeclaratorChunk::FunctionTypeInfo::getNumExceptions
unsigned getNumExceptions() const
Get the number of dynamic exception specifications.
Definition: DeclSpec.h:1484
clang::DeclaratorChunk::TypeAndRange::Ty
ParsedType Ty
Definition: DeclSpec.h:1272
clang::RecursiveASTVisitor
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
Definition: RecursiveASTVisitor.h:164
Depth
int Depth
Definition: ASTDiff.cpp:191
clang::Type::getAs
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:7153
clang::TST_atomic
@ TST_atomic
Definition: Specifiers.h:80
clang::TemplateArgument
Represents a template argument.
Definition: TemplateBase.h:62
clang::Sema::DiagnoseUnexpandedParameterPack
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
Definition: SemaTemplateVariadic.cpp:381
clang::DeclarationName::CXXOperatorName
@ CXXOperatorName
Definition: DeclarationName.h:209
clang::DeclaratorChunk::FunctionTypeInfo::NoexceptExpr
Expr * NoexceptExpr
Pointer to the expression in the noexcept-specifier of this function, if it has one.
Definition: DeclSpec.h:1356
clang::MultiLevelTemplateArgumentList
Data structure that captures multiple levels of template argument lists for use in template instantia...
Definition: Template.h:75
clang::DeclarationNameInfo::getNamedTypeInfo
TypeSourceInfo * getNamedTypeInfo() const
getNamedTypeInfo - Returns the source type info associated to the name.
Definition: DeclarationName.h:797
clang::Sema::PDiag
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaInternal.h:24
clang::Stmt::getEndLoc
SourceLocation getEndLoc() const LLVM_READONLY
Definition: Stmt.cpp:348
clang::Sema::GetTypeFromParser
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
Definition: SemaType.cpp:2935
clang::DeclRefExpr::getDecl
ValueDecl * getDecl()
Definition: Expr.h:1285
clang::DeclaratorChunk::ArrayTypeInfo::NumElts
Expr * NumElts
This is the size of the array, or null if [] or [*] was specified.
Definition: DeclSpec.h:1239
clang::TemplateArgumentLoc
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:457
Expr.h
clang::UnresolvedSet
A set of unresolved declarations.
Definition: UnresolvedSet.h:148
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:844
clang::TemplateArgumentLoc::getArgument
const TemplateArgument & getArgument() const
Definition: TemplateBase.h:506
clang::ParsedTemplateArgument::getTemplatePackExpansion
ParsedTemplateArgument getTemplatePackExpansion(SourceLocation EllipsisLoc) const
Retrieve a pack expansion of the given template template argument.
Definition: SemaTemplate.cpp:907
clang::Sema::DiagnoseAmbiguousLookup
void DiagnoseAmbiguousLookup(LookupResult &Result)
Produce a diagnostic describing the ambiguity that resulted from name lookup.
Definition: SemaLookup.cpp:2519
clang::MultiLevelTemplateArgumentList::getNumLevels
unsigned getNumLevels() const
Determine the number of levels in this template argument list.
Definition: Template.h:114
clang::TST_char
@ TST_char
Definition: Specifiers.h:46
clang::TST_int
@ TST_int
Definition: Specifiers.h:51
clang::TST_int128
@ TST_int128
Definition: Specifiers.h:52
clang::DeclarationName::CXXUsingDirective
@ CXXUsingDirective
Definition: DeclarationName.h:215
clang::NestedNameSpecifierLoc
A C++ nested-name-specifier augmented with source location information.
Definition: NestedNameSpecifier.h:243
clang::ParsedTemplateArgument::Template
@ Template
A template template argument, stored as a template name.
Definition: ParsedTemplate.h:38
Base
clang::TemplateArgument::isPackExpansion
bool isPackExpansion() const
Determine whether this template argument is a pack expansion.
Definition: TemplateBase.cpp:171
clang::RequiresExpr::getLocalParameters
ArrayRef< ParmVarDecl * > getLocalParameters() const
Definition: ExprConcepts.h:512
clang::SubstTemplateTemplateParmPackStorage
A structure for storing an already-substituted template template parameter pack.
Definition: TemplateName.h:135
clang::SubstTemplateTypeParmPackType
Represents the result of substituting a set of types for a template type parameter pack.
Definition: Type.h:4892
clang::UnresolvedUsingValueDecl
Represents a dependent using declaration which was not marked with typename.
Definition: DeclCXX.h:3594
clang::PackExpansionExpr
Represents a C++11 pack expansion that produces a sequence of expressions.
Definition: ExprCXX.h:4051
clang::DeclaratorChunk::FunctionTypeInfo::Params
ParamInfo * Params
Params - This is a pointer to a new[]'d array of ParamInfo objects that describe the parameters speci...
Definition: DeclSpec.h:1340
clang::LookupResult::Ambiguous
@ Ambiguous
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
Definition: Lookup.h:73
clang::Sema::DiagnoseUnexpandedParameterPacks
bool DiagnoseUnexpandedParameterPacks(SourceLocation Loc, UnexpandedParameterPackContext UPPC, ArrayRef< UnexpandedParameterPack > Unexpanded)
Diagnose unexpanded parameter packs.
Definition: SemaTemplateVariadic.cpp:290
clang::Sema::LookupName
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false)
Perform unqualified name lookup starting from a given scope.
Definition: SemaLookup.cpp:1907
Sema.h
clang::TypeLocBuilder
Definition: TypeLocBuilder.h:22
clang::ParsedTemplateArgument::getScopeSpec
const CXXScopeSpec & getScopeSpec() const
Retrieve the nested-name-specifier that precedes the template name in a template template argument.
Definition: ParsedTemplate.h:98
clang::TemplateName::isNull
bool isNull() const
Determine whether this template name is NULL.
Definition: TemplateName.cpp:80
clang::DeclaratorChunk::ParamInfo::Param
Decl * Param
Definition: DeclSpec.h:1254
clang::Sema::DiagnoseUnexpandedParameterPackInRequiresExpr
bool DiagnoseUnexpandedParameterPackInRequiresExpr(RequiresExpr *RE)
If the given requirees-expression contains an unexpanded reference to one of its own parameter packs,...
Definition: SemaTemplateVariadic.cpp:411
clang::DeclaratorChunk::Array
@ Array
Definition: DeclSpec.h:1177
clang::DeclarationNameInfo::getName
DeclarationName getName() const
getName - Returns the embedded declaration name.
Definition: DeclarationName.h:781
clang::ParsedTemplateArgument
Represents the parsed form of a C++ template argument.
Definition: ParsedTemplate.h:29
clang::UnresolvedUsingTypenameDecl::isPackExpansion
bool isPackExpansion() const
Determine whether this is a pack expansion.
Definition: DeclCXX.h:3738
clang::Sema::CorrectTypo
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, 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...
Definition: SemaLookup.cpp:4999
clang::TST_decimal32
@ TST_decimal32
Definition: Specifiers.h:63
clang::OpaquePtr< QualType >
clang::TemplateTypeParmType
Definition: Type.h:4760
clang::DeclarationName::CXXConversionFunctionName
@ CXXConversionFunctionName
Definition: DeclarationName.h:208
clang::PackExpansionExpr::getNumExpansions
Optional< unsigned > getNumExpansions() const
Determine the number of expansions that will be produced when this pack expansion is instantiated,...
Definition: ExprCXX.h:4091
clang::Sema::containsUnexpandedParameterPacks
bool containsUnexpandedParameterPacks(Declarator &D)
Determine whether the given declarator contains any unexpanded parameter packs.
Definition: SemaTemplateVariadic.cpp:859
clang::sema::FunctionScopeInfo
Retains information about a function, method, or block that is currently being parsed.
Definition: ScopeInfo.h:98
clang::TemplateArgument::TemplateExpansion
@ TemplateExpansion
The template argument is a pack expansion of a template name that was provided for a template templat...
Definition: TemplateBase.h:91
clang::Sema::diagnoseTypo
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
Definition: SemaLookup.cpp:5296
clang::Sema::LookupBinOp
void LookupBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc, UnresolvedSetImpl &Functions)
Definition: SemaExpr.cpp:14441
clang::ObjCDictionaryLiteral::getKeyValueElement
ObjCDictionaryElement getKeyValueElement(unsigned Index) const
Definition: ExprObjC.h:362
clang::RequiresExpr::getBeginLoc
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: ExprConcepts.h:540
clang::ParsedTemplateArgument::getKind
KindType getKind() const
Determine what kind of template argument we have.
Definition: ParsedTemplate.h:73
clang::TST_float
@ TST_float
Definition: Specifiers.h:59
clang::TST_typeofExpr
@ TST_typeofExpr
Definition: Specifiers.h:73
clang::tok::TokenKind
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
clang::Sema::CTK_ErrorRecovery
@ CTK_ErrorRecovery
Definition: Sema.h:4140
clang::TemplateArgument::containsUnexpandedParameterPack
bool containsUnexpandedParameterPack() const
Whether this template argument contains an unexpanded parameter pack.
Definition: TemplateBase.cpp:194
clang::Sema::getTemplateArgumentPackExpansionPattern
TemplateArgumentLoc getTemplateArgumentPackExpansionPattern(TemplateArgumentLoc OrigLoc, SourceLocation &Ellipsis, Optional< unsigned > &NumExpansions) const
Returns the pattern of the pack expansion for a template argument.
Definition: SemaTemplateVariadic.cpp:1055
clang::TST_Accum
@ TST_Accum
Definition: Specifiers.h:56
clang::LocalInstantiationScope::getPartiallySubstitutedPack
NamedDecl * getPartiallySubstitutedPack(const TemplateArgument **ExplicitArgs=nullptr, unsigned *NumExplicitArgs=nullptr) const
Retrieve the partially-substitued template parameter pack.
Definition: SemaTemplateInstantiate.cpp:3685
clang::ParsedTemplateArgument::isInvalid
bool isInvalid() const
Determine whether the given template argument is invalid.
Definition: ParsedTemplate.h:70
clang::MultiLevelTemplateArgumentList::hasTemplateArgument
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:149
clang::Attr::isPackExpansion
bool isPackExpansion() const
Definition: Attr.h:103
clang::DeclaratorChunk::Paren
@ Paren
Definition: DeclSpec.h:1177
clang::NamedDecl::getIdentifier
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:244
clang::TemplateName
Represents a C++ template name within the type system.
Definition: TemplateName.h:192
clang::Expr::getExprLoc
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:228
clang::QualType::isNull
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:726
clang::TST_decimal64
@ TST_decimal64
Definition: Specifiers.h:64
clang::Sema::CreateUnresolvedLookupExpr
ExprResult CreateUnresolvedLookupExpr(CXXRecordDecl *NamingClass, NestedNameSpecifierLoc NNSLoc, DeclarationNameInfo DNI, const UnresolvedSetImpl &Fns, bool PerformADL=true)
Definition: SemaOverload.cpp:13204
llvm::ArrayRef
Definition: LLVM.h:34
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:89
clang::PackExpansionTypeLoc::setEllipsisLoc
void setEllipsisLoc(SourceLocation Loc)
Definition: TypeLoc.h:2445
clang::TypeLoc
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:58
clang::DeclarationName::ObjCZeroArgSelector
@ ObjCZeroArgSelector
Definition: DeclarationName.h:204
clang::TemplateArgument::getNumTemplateExpansions
Optional< unsigned > getNumTemplateExpansions() const
Retrieve the number of expansions that a template template argument expansion will produce,...
Definition: TemplateBase.cpp:198
clang::ParsedTemplateArgument::getAsExpr
Expr * getAsExpr() const
Retrieve the non-type template argument's expression.
Definition: ParsedTemplate.h:82
clang::Sema
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:352
clang::TypeLoc::getType
QualType getType() const
Get the type for which this source info wrapper provides information.
Definition: TypeLoc.h:132
clang::DeclarationName::ObjCOneArgSelector
@ ObjCOneArgSelector
Definition: DeclarationName.h:205
clang::PackExpansionTypeLoc::getPatternLoc
TypeLoc getPatternLoc() const
Definition: TypeLoc.h:2457
clang::TST_wchar
@ TST_wchar
Definition: Specifiers.h:47
clang::TemplateTypeParmTypeLoc
Wrapper for template type parameters.
Definition: TypeLoc.h:734
clang::DeclaratorChunk::Pointer
@ Pointer
Definition: DeclSpec.h:1177
clang::LookupResult::getResultKind
LookupResultKind getResultKind() const
Definition: Lookup.h:321
clang::BinaryOperatorKind
BinaryOperatorKind
Definition: OperationKinds.h:25
clang::Sema::CurrentInstantiationScope
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Definition: Sema.h:9064
clang::IdentifierInfo
One of these records is kept for each identifier that is lexed.
Definition: IdentifierTable.h:59
clang::TST_decimal128
@ TST_decimal128
Definition: Specifiers.h:65
clang::DeclaratorChunk::MemberPointerTypeInfo::Scope
CXXScopeSpec & Scope()
Definition: DeclSpec.h:1530
clang::Sema::ActOnPackExpansion
ParsedTemplateArgument ActOnPackExpansion(const ParsedTemplateArgument &Arg, SourceLocation EllipsisLoc)
Invoked when parsing a template argument followed by an ellipsis, which creates a pack expansion.
Definition: SemaTemplateVariadic.cpp:552
clang::ActionResult
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc.
Definition: Ownership.h:152
clang::Sema::collectUnexpandedParameterPacks
void collectUnexpandedParameterPacks(TemplateArgument Arg, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
Collect the set of unexpanded parameter packs within the given template argument.
Definition: SemaTemplateVariadic.cpp:514
clang::TST_class
@ TST_class
Definition: Specifiers.h:69
ScopeInfo.h
clang::SizeOfPackExpr::Create
static SizeOfPackExpr * Create(ASTContext &Context, SourceLocation OperatorLoc, NamedDecl *Pack, SourceLocation PackLoc, SourceLocation RParenLoc, Optional< unsigned > Length=None, ArrayRef< TemplateArgument > PartialArgs=None)
Definition: ExprCXX.cpp:1554
clang::TST_char32
@ TST_char32
Definition: Specifiers.h:50
clang::DeclarationName::getNameKind
NameKind getNameKind() const
Determine what kind of name this is.
Definition: DeclarationName.h:384
clang::Decl::isParameterPack
bool isParameterPack() const
Whether this declaration is a parameter pack.
Definition: DeclBase.cpp:211
clang::TemplateArgument::Type
@ Type
The template argument is a type.
Definition: TemplateBase.h:71
clang::TemplateTypeParmType::getDepth
unsigned getDepth() const
Definition: Type.h:4801
clang
Dataflow Directional Tag Classes.
Definition: CalledOnceCheck.h:17
clang::sema::FunctionScopeInfo::CompoundScopes
SmallVector< CompoundScopeInfo, 4 > CompoundScopes
The stack of currently active compound stamement scopes in the function.
Definition: ScopeInfo.h:210
clang::TemplateArgument::getPackExpansionPattern
TemplateArgument getPackExpansionPattern() const
When the template argument is a pack expansion, returns the pattern of the pack expansion.
Definition: TemplateBase.cpp:318
clang::sema::CompoundScopeInfo
Contains information about the compound statement currently being parsed.
Definition: ScopeInfo.h:68
RecursiveASTVisitor.h
clang::TST_extint
@ TST_extint
Definition: Specifiers.h:53
clang::TemplateArgument::Template
@ Template
The template argument is a template name that was provided for a template template parameter.
Definition: TemplateBase.h:87
clang::ParsedTemplateArgument::NonType
@ NonType
A non-type template parameter, stored as an expression.
Definition: ParsedTemplate.h:36
clang::Stmt
Stmt - This represents one statement.
Definition: Stmt.h:68
clang::TemplateArgument::getAsTemplate
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
Definition: TemplateBase.h:293
clang::DeclaratorChunk::MemberPointer
@ MemberPointer
Definition: DeclSpec.h:1177
clang::Declarator
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1803
clang::CXXScalarValueInitExpr
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type.
Definition: ExprCXX.h:2093
clang::TST_char16
@ TST_char16
Definition: Specifiers.h:49
clang::TypoCorrection::getCorrectionDecl
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
Definition: TypoCorrection.h:151
clang::CXXScopeSpec::getScopeRep
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition: DeclSpec.h:77
clang::CXXBaseSpecifier
Represents a base class of a C++ class.
Definition: DeclCXX.h:146
clang::CorrectionCandidateCallback
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
Definition: TypoCorrection.h:281
clang::Attr
Attr - This represents one attribute.
Definition: Attr.h:46
clang::LookupResult::Found
@ Found
Name lookup found a single declaration that met the criteria.
Definition: Lookup.h:59
clang::TypeSourceInfo
A container of type source information.
Definition: Type.h:6391
clang::BinaryOperator::getOverloadedOperator
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given binary opcode.
Definition: Expr.cpp:1964
clang::Declarator::getTypeObject
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
Definition: DeclSpec.h:2240
clang::LookupResult::getLookupKind
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Definition: Lookup.h:253
unsigned
clang::Stmt::getBeginLoc
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:336
clang::DeclaratorChunk
One instance of this struct is used for each type in a declarator that is parsed.
Definition: DeclSpec.h:1173
clang::LookupResult::getFoundDecl
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
Definition: Lookup.h:517
clang::TST_BFloat16
@ TST_BFloat16
Definition: Specifiers.h:58
clang::Sema::ActOnSizeofParameterPackExpr
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.
Definition: SemaTemplateVariadic.cpp:1004
clang::TypeLoc::getSourceRange
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Definition: TypeLoc.h:152
clang::ASTContext::getTrivialTypeSourceInfo
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
Definition: ASTContext.cpp:2880
clang::Sema::isUnexpandedParameterPackPermitted
bool isUnexpandedParameterPackPermitted()
Determine whether an unexpanded parameter pack might be permitted in this location.
Definition: SemaTemplateVariadic.cpp:280
clang::TST_typeofType
@ TST_typeofType
Definition: Specifiers.h:72
clang::InheritingConcreteTypeLoc::getTypePtr
const TypeClass * getTypePtr() const
Definition: TypeLoc.h:502
clang::TST_float128
@ TST_float128
Definition: Specifiers.h:61
clang::Sema::getNumArgumentsInExpansion
Optional< unsigned > getNumArgumentsInExpansion(QualType T, const MultiLevelTemplateArgumentList &TemplateArgs)
Determine the number of arguments in the given pack expansion type.
Definition: SemaTemplateVariadic.cpp:806
clang::TemplateName::getAsSubstTemplateTemplateParmPack
SubstTemplateTemplateParmPackStorage * getAsSubstTemplateTemplateParmPack() const
Retrieve the substituted template template parameter pack, if known.
Definition: TemplateName.cpp:140
clang::TemplateArgument::pack_size
unsigned pack_size() const
The number of template arguments in the given template argument pack.
Definition: TemplateBase.h:372
clang::Sema::Subst
bool Subst(const TemplateArgumentLoc *Args, unsigned NumArgs, TemplateArgumentListInfo &Result, const MultiLevelTemplateArgumentList &TemplateArgs)
Definition: SemaTemplateInstantiate.cpp:3539
clang::Sema::LookupOrdinaryName
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
Definition: Sema.h:3903
clang::TypeLoc::castAs
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type.
Definition: TypeLoc.h:77
llvm::SmallVectorImpl
Definition: LLVM.h:39
clang::DeclarationName::ObjCMultiArgSelector
@ ObjCMultiArgSelector
Definition: DeclarationName.h:217
clang::ValueDecl::getType
QualType getType() const
Definition: Decl.h:655
clang::PackExpansionType::getNumExpansions
Optional< unsigned > getNumExpansions() const
Retrieve the number of expansions that this pack expansion will generate, if known.
Definition: Type.h:5652
clang::TemplateArgumentLoc::getTemplateQualifierLoc
NestedNameSpecifierLoc getTemplateQualifierLoc() const
Definition: TemplateBase.h:539
clang::Expr
This represents one expression.
Definition: Expr.h:109
clang::ParsedTemplateArgument::getLocation
SourceLocation getLocation() const
Retrieve the location of the template argument.
Definition: ParsedTemplate.h:94
clang::DeclarationName::getCXXNameType
QualType getCXXNameType() const
If this name is one of the C++ names (of a constructor, destructor, or conversion function),...
Definition: DeclarationName.h:439
clang::TemplateArgumentLoc::getTemplateNameLoc
SourceLocation getTemplateNameLoc() const
Definition: TemplateBase.h:546
clang::getDepthAndIndex
std::pair< unsigned, unsigned > getDepthAndIndex(NamedDecl *ND)
Retrieve the depth and index of a template parameter.
Definition: SemaInternal.h:65
clang::TemplateTypeParmType::isParameterPack
bool isParameterPack() const
Definition: Type.h:4803
clang::TST_Fract
@ TST_Fract
Definition: Specifiers.h:57
clang::CXXScopeSpec::getRange
SourceRange getRange() const
Definition: DeclSpec.h:69
clang::ObjCDictionaryElement::Value
Expr * Value
The value of the dictionary element.
Definition: ExprObjC.h:268
clang::CXXCtorInitializer
Represents a C++ base or member initializer.
Definition: DeclCXX.h:2162
clang::CXXScopeSpec::getBeginLoc
SourceLocation getBeginLoc() const
Definition: DeclSpec.h:73
clang::DeclarationNameInfo::getLoc
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
Definition: DeclarationName.h:787
clang::Sema::CheckPackExpansion
TypeSourceInfo * CheckPackExpansion(TypeSourceInfo *Pattern, SourceLocation EllipsisLoc, Optional< unsigned > NumExpansions)
Construct a pack expansion type from the pattern of the pack expansion.
Definition: SemaTemplateVariadic.cpp:606
clang::DeclarationNameInfo
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
Definition: DeclarationName.h:758
clang::TST_decltype_auto
@ TST_decltype_auto
Definition: Specifiers.h:77
clang::ParsedTemplateArgument::getAsType
ParsedType getAsType() const
Retrieve the template type argument's type.
Definition: ParsedTemplate.h:76
clang::TST_union
@ TST_union
Definition: Specifiers.h:67
clang::TST_double
@ TST_double
Definition: Specifiers.h:60
clang::DeclRefExpr
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1213
clang::LookupResult::FoundUnresolvedValue
@ FoundUnresolvedValue
Name lookup found an unresolvable value declaration and cannot yet complete.
Definition: Lookup.h:68
clang::LookupResult::getLookupNameInfo
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
Definition: Lookup.h:233
clang::DeclSpec
Captures information about "declaration specifiers".
Definition: DeclSpec.h:229
clang::ParsedTemplateArgument::getAsTemplate
ParsedTemplateTy getAsTemplate() const
Retrieve the template template argument's template name.
Definition: ParsedTemplate.h:88
clang::DeclSpec::getRepAsType
ParsedType getRepAsType() const
Definition: DeclSpec.h:486
TypeLoc.h
clang::LocalInstantiationScope::findInstantiationOf
llvm::PointerUnion< Decl *, DeclArgumentPack * > * findInstantiationOf(const Decl *D)
Find the instantiation of the declaration D within the current instantiation scope.
Definition: SemaTemplateInstantiate.cpp:3567
clang::declaresSameEntity
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1198
clang::TemplateArgument::getAsType
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:269
clang::TypeSourceInfo::getTypeLoc
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:244
ParsedTemplate.h
clang::TemplateArgument::Pack
@ Pack
The template argument is actually a parameter pack.
Definition: TemplateBase.h:101
clang::DeclaratorChunk::Reference
@ Reference
Definition: DeclSpec.h:1177
clang::Sema::CorrectDelayedTyposInExpr
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, bool RecoverUncorrectedTypos=false, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult { return E;})
Process any TypoExprs in the given Expr and its children, generating diagnostics as appropriate and r...
Definition: SemaExprCXX.cpp:8384
clang::DeclaratorChunk::BlockPointer
@ BlockPointer
Definition: DeclSpec.h:1177