xref: /freebsd/contrib/llvm-project/clang/lib/Sema/SemaTemplateVariadic.cpp (revision cfd6422a5217410fbd66f7a7a8a64d9d85e61229)
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"
14 #include "clang/AST/RecursiveASTVisitor.h"
15 #include "clang/AST/TypeLoc.h"
16 #include "clang/Sema/Lookup.h"
17 #include "clang/Sema/ParsedTemplate.h"
18 #include "clang/Sema/ScopeInfo.h"
19 #include "clang/Sema/SemaInternal.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   {
33     typedef RecursiveASTVisitor<CollectUnexpandedParameterPacksVisitor>
34       inherited;
35 
36     SmallVectorImpl<UnexpandedParameterPack> &Unexpanded;
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,
56                        SourceLocation Loc = SourceLocation()) {
57       if (T->getDepth() < DepthLimit)
58         Unexpanded.push_back({T, Loc});
59     }
60 
61   public:
62     explicit CollectUnexpandedParameterPacksVisitor(
63         SmallVectorImpl<UnexpandedParameterPack> &Unexpanded)
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) {
114       if (!E->containsUnexpandedParameterPack())
115         return true;
116 
117       for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) {
118         ObjCDictionaryElement Element = E->getKeyValueElement(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() &&
154            TL.getType()->containsUnexpandedParameterPack()) ||
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.
280 bool Sema::isUnexpandedParameterPackPermitted() {
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
290 Sema::DiagnoseUnexpandedParameterPacks(SourceLocation Loc,
291                                        UnexpandedParameterPackContext UPPC,
292                                  ArrayRef<UnexpandedParameterPack> Unexpanded) {
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) {
330         sema::FunctionScopeInfo *Func = FunctionScopes[N-1];
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 
352   SmallVector<SourceLocation, 4> Locations;
353   SmallVector<IdentifierInfo *, 4> Names;
354   llvm::SmallPtrSet<IdentifierInfo *, 4> NamesKnown;
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   DiagnosticBuilder 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 
381 bool Sema::DiagnoseUnexpandedParameterPack(SourceLocation Loc,
382                                            TypeSourceInfo *T,
383                                          UnexpandedParameterPackContext UPPC) {
384   // C++0x [temp.variadic]p5:
385   //   An appearance of a name of a parameter pack that is not expanded is
386   //   ill-formed.
387   if (!T->getType()->containsUnexpandedParameterPack())
388     return false;
389 
390   SmallVector<UnexpandedParameterPack, 2> Unexpanded;
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 
397 bool Sema::DiagnoseUnexpandedParameterPack(Expr *E,
398                                         UnexpandedParameterPackContext UPPC) {
399   // C++0x [temp.variadic]p5:
400   //   An appearance of a name of a parameter pack that is not expanded is
401   //   ill-formed.
402   if (!E->containsUnexpandedParameterPack())
403     return false;
404 
405   SmallVector<UnexpandedParameterPack, 2> Unexpanded;
406   CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseStmt(E);
407   assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
408   return DiagnoseUnexpandedParameterPacks(E->getBeginLoc(), UPPC, Unexpanded);
409 }
410 
411 bool Sema::DiagnoseUnexpandedParameterPack(const CXXScopeSpec &SS,
412                                         UnexpandedParameterPackContext UPPC) {
413   // C++0x [temp.variadic]p5:
414   //   An appearance of a name of a parameter pack that is not expanded is
415   //   ill-formed.
416   if (!SS.getScopeRep() ||
417       !SS.getScopeRep()->containsUnexpandedParameterPack())
418     return false;
419 
420   SmallVector<UnexpandedParameterPack, 2> Unexpanded;
421   CollectUnexpandedParameterPacksVisitor(Unexpanded)
422     .TraverseNestedNameSpecifier(SS.getScopeRep());
423   assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
424   return DiagnoseUnexpandedParameterPacks(SS.getRange().getBegin(),
425                                           UPPC, Unexpanded);
426 }
427 
428 bool Sema::DiagnoseUnexpandedParameterPack(const DeclarationNameInfo &NameInfo,
429                                          UnexpandedParameterPackContext UPPC) {
430   // C++0x [temp.variadic]p5:
431   //   An appearance of a name of a parameter pack that is not expanded is
432   //   ill-formed.
433   switch (NameInfo.getName().getNameKind()) {
434   case DeclarationName::Identifier:
435   case DeclarationName::ObjCZeroArgSelector:
436   case DeclarationName::ObjCOneArgSelector:
437   case DeclarationName::ObjCMultiArgSelector:
438   case DeclarationName::CXXOperatorName:
439   case DeclarationName::CXXLiteralOperatorName:
440   case DeclarationName::CXXUsingDirective:
441   case DeclarationName::CXXDeductionGuideName:
442     return false;
443 
444   case DeclarationName::CXXConstructorName:
445   case DeclarationName::CXXDestructorName:
446   case DeclarationName::CXXConversionFunctionName:
447     // FIXME: We shouldn't need this null check!
448     if (TypeSourceInfo *TSInfo = NameInfo.getNamedTypeInfo())
449       return DiagnoseUnexpandedParameterPack(NameInfo.getLoc(), TSInfo, UPPC);
450 
451     if (!NameInfo.getName().getCXXNameType()->containsUnexpandedParameterPack())
452       return false;
453 
454     break;
455   }
456 
457   SmallVector<UnexpandedParameterPack, 2> Unexpanded;
458   CollectUnexpandedParameterPacksVisitor(Unexpanded)
459     .TraverseType(NameInfo.getName().getCXXNameType());
460   assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
461   return DiagnoseUnexpandedParameterPacks(NameInfo.getLoc(), UPPC, Unexpanded);
462 }
463 
464 bool Sema::DiagnoseUnexpandedParameterPack(SourceLocation Loc,
465                                            TemplateName Template,
466                                        UnexpandedParameterPackContext UPPC) {
467 
468   if (Template.isNull() || !Template.containsUnexpandedParameterPack())
469     return false;
470 
471   SmallVector<UnexpandedParameterPack, 2> Unexpanded;
472   CollectUnexpandedParameterPacksVisitor(Unexpanded)
473     .TraverseTemplateName(Template);
474   assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
475   return DiagnoseUnexpandedParameterPacks(Loc, UPPC, Unexpanded);
476 }
477 
478 bool Sema::DiagnoseUnexpandedParameterPack(TemplateArgumentLoc Arg,
479                                          UnexpandedParameterPackContext UPPC) {
480   if (Arg.getArgument().isNull() ||
481       !Arg.getArgument().containsUnexpandedParameterPack())
482     return false;
483 
484   SmallVector<UnexpandedParameterPack, 2> Unexpanded;
485   CollectUnexpandedParameterPacksVisitor(Unexpanded)
486     .TraverseTemplateArgumentLoc(Arg);
487   assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
488   return DiagnoseUnexpandedParameterPacks(Arg.getLocation(), UPPC, Unexpanded);
489 }
490 
491 void Sema::collectUnexpandedParameterPacks(TemplateArgument Arg,
492                    SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
493   CollectUnexpandedParameterPacksVisitor(Unexpanded)
494     .TraverseTemplateArgument(Arg);
495 }
496 
497 void Sema::collectUnexpandedParameterPacks(TemplateArgumentLoc Arg,
498                    SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
499   CollectUnexpandedParameterPacksVisitor(Unexpanded)
500     .TraverseTemplateArgumentLoc(Arg);
501 }
502 
503 void Sema::collectUnexpandedParameterPacks(QualType T,
504                    SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
505   CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseType(T);
506 }
507 
508 void Sema::collectUnexpandedParameterPacks(TypeLoc TL,
509                    SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
510   CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseTypeLoc(TL);
511 }
512 
513 void Sema::collectUnexpandedParameterPacks(
514     NestedNameSpecifierLoc NNS,
515     SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
516   CollectUnexpandedParameterPacksVisitor(Unexpanded)
517       .TraverseNestedNameSpecifierLoc(NNS);
518 }
519 
520 void Sema::collectUnexpandedParameterPacks(
521     const DeclarationNameInfo &NameInfo,
522     SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
523   CollectUnexpandedParameterPacksVisitor(Unexpanded)
524     .TraverseDeclarationNameInfo(NameInfo);
525 }
526 
527 
528 ParsedTemplateArgument
529 Sema::ActOnPackExpansion(const ParsedTemplateArgument &Arg,
530                          SourceLocation EllipsisLoc) {
531   if (Arg.isInvalid())
532     return Arg;
533 
534   switch (Arg.getKind()) {
535   case ParsedTemplateArgument::Type: {
536     TypeResult Result = ActOnPackExpansion(Arg.getAsType(), EllipsisLoc);
537     if (Result.isInvalid())
538       return ParsedTemplateArgument();
539 
540     return ParsedTemplateArgument(Arg.getKind(), Result.get().getAsOpaquePtr(),
541                                   Arg.getLocation());
542   }
543 
544   case ParsedTemplateArgument::NonType: {
545     ExprResult Result = ActOnPackExpansion(Arg.getAsExpr(), EllipsisLoc);
546     if (Result.isInvalid())
547       return ParsedTemplateArgument();
548 
549     return ParsedTemplateArgument(Arg.getKind(), Result.get(),
550                                   Arg.getLocation());
551   }
552 
553   case ParsedTemplateArgument::Template:
554     if (!Arg.getAsTemplate().get().containsUnexpandedParameterPack()) {
555       SourceRange R(Arg.getLocation());
556       if (Arg.getScopeSpec().isValid())
557         R.setBegin(Arg.getScopeSpec().getBeginLoc());
558       Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
559         << R;
560       return ParsedTemplateArgument();
561     }
562 
563     return Arg.getTemplatePackExpansion(EllipsisLoc);
564   }
565   llvm_unreachable("Unhandled template argument kind?");
566 }
567 
568 TypeResult Sema::ActOnPackExpansion(ParsedType Type,
569                                     SourceLocation EllipsisLoc) {
570   TypeSourceInfo *TSInfo;
571   GetTypeFromParser(Type, &TSInfo);
572   if (!TSInfo)
573     return true;
574 
575   TypeSourceInfo *TSResult = CheckPackExpansion(TSInfo, EllipsisLoc, None);
576   if (!TSResult)
577     return true;
578 
579   return CreateParsedType(TSResult->getType(), TSResult);
580 }
581 
582 TypeSourceInfo *
583 Sema::CheckPackExpansion(TypeSourceInfo *Pattern, SourceLocation EllipsisLoc,
584                          Optional<unsigned> NumExpansions) {
585   // Create the pack expansion type and source-location information.
586   QualType Result = CheckPackExpansion(Pattern->getType(),
587                                        Pattern->getTypeLoc().getSourceRange(),
588                                        EllipsisLoc, NumExpansions);
589   if (Result.isNull())
590     return nullptr;
591 
592   TypeLocBuilder TLB;
593   TLB.pushFullCopy(Pattern->getTypeLoc());
594   PackExpansionTypeLoc TL = TLB.push<PackExpansionTypeLoc>(Result);
595   TL.setEllipsisLoc(EllipsisLoc);
596 
597   return TLB.getTypeSourceInfo(Context, Result);
598 }
599 
600 QualType Sema::CheckPackExpansion(QualType Pattern, SourceRange PatternRange,
601                                   SourceLocation EllipsisLoc,
602                                   Optional<unsigned> NumExpansions) {
603   // C++11 [temp.variadic]p5:
604   //   The pattern of a pack expansion shall name one or more
605   //   parameter packs that are not expanded by a nested pack
606   //   expansion.
607   //
608   // A pattern containing a deduced type can't occur "naturally" but arises in
609   // the desugaring of an init-capture pack.
610   if (!Pattern->containsUnexpandedParameterPack() &&
611       !Pattern->getContainedDeducedType()) {
612     Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
613       << PatternRange;
614     return QualType();
615   }
616 
617   return Context.getPackExpansionType(Pattern, NumExpansions);
618 }
619 
620 ExprResult Sema::ActOnPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc) {
621   return CheckPackExpansion(Pattern, EllipsisLoc, None);
622 }
623 
624 ExprResult Sema::CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc,
625                                     Optional<unsigned> NumExpansions) {
626   if (!Pattern)
627     return ExprError();
628 
629   // C++0x [temp.variadic]p5:
630   //   The pattern of a pack expansion shall name one or more
631   //   parameter packs that are not expanded by a nested pack
632   //   expansion.
633   if (!Pattern->containsUnexpandedParameterPack()) {
634     Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
635     << Pattern->getSourceRange();
636     CorrectDelayedTyposInExpr(Pattern);
637     return ExprError();
638   }
639 
640   // Create the pack expansion expression and source-location information.
641   return new (Context)
642     PackExpansionExpr(Context.DependentTy, Pattern, EllipsisLoc, NumExpansions);
643 }
644 
645 bool Sema::CheckParameterPacksForExpansion(
646     SourceLocation EllipsisLoc, SourceRange PatternRange,
647     ArrayRef<UnexpandedParameterPack> Unexpanded,
648     const MultiLevelTemplateArgumentList &TemplateArgs, bool &ShouldExpand,
649     bool &RetainExpansion, Optional<unsigned> &NumExpansions) {
650   ShouldExpand = true;
651   RetainExpansion = false;
652   std::pair<IdentifierInfo *, SourceLocation> FirstPack;
653   bool HaveFirstPack = false;
654   Optional<unsigned> NumPartialExpansions;
655   SourceLocation PartiallySubstitutedPackLoc;
656 
657   for (ArrayRef<UnexpandedParameterPack>::iterator i = Unexpanded.begin(),
658                                                  end = Unexpanded.end();
659                                                   i != end; ++i) {
660     // Compute the depth and index for this parameter pack.
661     unsigned Depth = 0, Index = 0;
662     IdentifierInfo *Name;
663     bool IsVarDeclPack = false;
664 
665     if (const TemplateTypeParmType *TTP
666         = i->first.dyn_cast<const TemplateTypeParmType *>()) {
667       Depth = TTP->getDepth();
668       Index = TTP->getIndex();
669       Name = TTP->getIdentifier();
670     } else {
671       NamedDecl *ND = i->first.get<NamedDecl *>();
672       if (isa<VarDecl>(ND))
673         IsVarDeclPack = true;
674       else
675         std::tie(Depth, Index) = getDepthAndIndex(ND);
676 
677       Name = ND->getIdentifier();
678     }
679 
680     // Determine the size of this argument pack.
681     unsigned NewPackSize;
682     if (IsVarDeclPack) {
683       // Figure out whether we're instantiating to an argument pack or not.
684       typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
685 
686       llvm::PointerUnion<Decl *, DeclArgumentPack *> *Instantiation
687         = CurrentInstantiationScope->findInstantiationOf(
688                                         i->first.get<NamedDecl *>());
689       if (Instantiation->is<DeclArgumentPack *>()) {
690         // We could expand this function parameter pack.
691         NewPackSize = Instantiation->get<DeclArgumentPack *>()->size();
692       } else {
693         // We can't expand this function parameter pack, so we can't expand
694         // the pack expansion.
695         ShouldExpand = false;
696         continue;
697       }
698     } else {
699       // If we don't have a template argument at this depth/index, then we
700       // cannot expand the pack expansion. Make a note of this, but we still
701       // want to check any parameter packs we *do* have arguments for.
702       if (Depth >= TemplateArgs.getNumLevels() ||
703           !TemplateArgs.hasTemplateArgument(Depth, Index)) {
704         ShouldExpand = false;
705         continue;
706       }
707 
708       // Determine the size of the argument pack.
709       NewPackSize = TemplateArgs(Depth, Index).pack_size();
710     }
711 
712     // C++0x [temp.arg.explicit]p9:
713     //   Template argument deduction can extend the sequence of template
714     //   arguments corresponding to a template parameter pack, even when the
715     //   sequence contains explicitly specified template arguments.
716     if (!IsVarDeclPack && CurrentInstantiationScope) {
717       if (NamedDecl *PartialPack
718                     = CurrentInstantiationScope->getPartiallySubstitutedPack()){
719         unsigned PartialDepth, PartialIndex;
720         std::tie(PartialDepth, PartialIndex) = getDepthAndIndex(PartialPack);
721         if (PartialDepth == Depth && PartialIndex == Index) {
722           RetainExpansion = true;
723           // We don't actually know the new pack size yet.
724           NumPartialExpansions = NewPackSize;
725           PartiallySubstitutedPackLoc = i->second;
726           continue;
727         }
728       }
729     }
730 
731     if (!NumExpansions) {
732       // The is the first pack we've seen for which we have an argument.
733       // Record it.
734       NumExpansions = NewPackSize;
735       FirstPack.first = Name;
736       FirstPack.second = i->second;
737       HaveFirstPack = true;
738       continue;
739     }
740 
741     if (NewPackSize != *NumExpansions) {
742       // C++0x [temp.variadic]p5:
743       //   All of the parameter packs expanded by a pack expansion shall have
744       //   the same number of arguments specified.
745       if (HaveFirstPack)
746         Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict)
747           << FirstPack.first << Name << *NumExpansions << NewPackSize
748           << SourceRange(FirstPack.second) << SourceRange(i->second);
749       else
750         Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict_multilevel)
751           << Name << *NumExpansions << NewPackSize
752           << SourceRange(i->second);
753       return true;
754     }
755   }
756 
757   // If we're performing a partial expansion but we also have a full expansion,
758   // expand to the number of common arguments. For example, given:
759   //
760   //   template<typename ...T> struct A {
761   //     template<typename ...U> void f(pair<T, U>...);
762   //   };
763   //
764   // ... a call to 'A<int, int>().f<int>' should expand the pack once and
765   // retain an expansion.
766   if (NumPartialExpansions) {
767     if (NumExpansions && *NumExpansions < *NumPartialExpansions) {
768       NamedDecl *PartialPack =
769           CurrentInstantiationScope->getPartiallySubstitutedPack();
770       Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict_partial)
771         << PartialPack << *NumPartialExpansions << *NumExpansions
772         << SourceRange(PartiallySubstitutedPackLoc);
773       return true;
774     }
775 
776     NumExpansions = NumPartialExpansions;
777   }
778 
779   return false;
780 }
781 
782 Optional<unsigned> Sema::getNumArgumentsInExpansion(QualType T,
783                           const MultiLevelTemplateArgumentList &TemplateArgs) {
784   QualType Pattern = cast<PackExpansionType>(T)->getPattern();
785   SmallVector<UnexpandedParameterPack, 2> Unexpanded;
786   CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseType(Pattern);
787 
788   Optional<unsigned> Result;
789   for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
790     // Compute the depth and index for this parameter pack.
791     unsigned Depth;
792     unsigned Index;
793 
794     if (const TemplateTypeParmType *TTP
795           = Unexpanded[I].first.dyn_cast<const TemplateTypeParmType *>()) {
796       Depth = TTP->getDepth();
797       Index = TTP->getIndex();
798     } else {
799       NamedDecl *ND = Unexpanded[I].first.get<NamedDecl *>();
800       if (isa<VarDecl>(ND)) {
801         // Function parameter pack or init-capture pack.
802         typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
803 
804         llvm::PointerUnion<Decl *, DeclArgumentPack *> *Instantiation
805           = CurrentInstantiationScope->findInstantiationOf(
806                                         Unexpanded[I].first.get<NamedDecl *>());
807         if (Instantiation->is<Decl*>())
808           // The pattern refers to an unexpanded pack. We're not ready to expand
809           // this pack yet.
810           return None;
811 
812         unsigned Size = Instantiation->get<DeclArgumentPack *>()->size();
813         assert((!Result || *Result == Size) && "inconsistent pack sizes");
814         Result = Size;
815         continue;
816       }
817 
818       std::tie(Depth, Index) = getDepthAndIndex(ND);
819     }
820     if (Depth >= TemplateArgs.getNumLevels() ||
821         !TemplateArgs.hasTemplateArgument(Depth, Index))
822       // The pattern refers to an unknown template argument. We're not ready to
823       // expand this pack yet.
824       return None;
825 
826     // Determine the size of the argument pack.
827     unsigned Size = TemplateArgs(Depth, Index).pack_size();
828     assert((!Result || *Result == Size) && "inconsistent pack sizes");
829     Result = Size;
830   }
831 
832   return Result;
833 }
834 
835 bool Sema::containsUnexpandedParameterPacks(Declarator &D) {
836   const DeclSpec &DS = D.getDeclSpec();
837   switch (DS.getTypeSpecType()) {
838   case TST_typename:
839   case TST_typeofType:
840   case TST_underlyingType:
841   case TST_atomic: {
842     QualType T = DS.getRepAsType().get();
843     if (!T.isNull() && T->containsUnexpandedParameterPack())
844       return true;
845     break;
846   }
847 
848   case TST_typeofExpr:
849   case TST_decltype:
850   case TST_extint:
851     if (DS.getRepAsExpr() &&
852         DS.getRepAsExpr()->containsUnexpandedParameterPack())
853       return true;
854     break;
855 
856   case TST_unspecified:
857   case TST_void:
858   case TST_char:
859   case TST_wchar:
860   case TST_char8:
861   case TST_char16:
862   case TST_char32:
863   case TST_int:
864   case TST_int128:
865   case TST_half:
866   case TST_float:
867   case TST_double:
868   case TST_Accum:
869   case TST_Fract:
870   case TST_Float16:
871   case TST_float128:
872   case TST_bool:
873   case TST_decimal32:
874   case TST_decimal64:
875   case TST_decimal128:
876   case TST_enum:
877   case TST_union:
878   case TST_struct:
879   case TST_interface:
880   case TST_class:
881   case TST_auto:
882   case TST_auto_type:
883   case TST_decltype_auto:
884   case TST_BFloat16:
885 #define GENERIC_IMAGE_TYPE(ImgType, Id) case TST_##ImgType##_t:
886 #include "clang/Basic/OpenCLImageTypes.def"
887   case TST_unknown_anytype:
888   case TST_error:
889     break;
890   }
891 
892   for (unsigned I = 0, N = D.getNumTypeObjects(); I != N; ++I) {
893     const DeclaratorChunk &Chunk = D.getTypeObject(I);
894     switch (Chunk.Kind) {
895     case DeclaratorChunk::Pointer:
896     case DeclaratorChunk::Reference:
897     case DeclaratorChunk::Paren:
898     case DeclaratorChunk::Pipe:
899     case DeclaratorChunk::BlockPointer:
900       // These declarator chunks cannot contain any parameter packs.
901       break;
902 
903     case DeclaratorChunk::Array:
904       if (Chunk.Arr.NumElts &&
905           Chunk.Arr.NumElts->containsUnexpandedParameterPack())
906         return true;
907       break;
908     case DeclaratorChunk::Function:
909       for (unsigned i = 0, e = Chunk.Fun.NumParams; i != e; ++i) {
910         ParmVarDecl *Param = cast<ParmVarDecl>(Chunk.Fun.Params[i].Param);
911         QualType ParamTy = Param->getType();
912         assert(!ParamTy.isNull() && "Couldn't parse type?");
913         if (ParamTy->containsUnexpandedParameterPack()) return true;
914       }
915 
916       if (Chunk.Fun.getExceptionSpecType() == EST_Dynamic) {
917         for (unsigned i = 0; i != Chunk.Fun.getNumExceptions(); ++i) {
918           if (Chunk.Fun.Exceptions[i]
919                   .Ty.get()
920                   ->containsUnexpandedParameterPack())
921             return true;
922         }
923       } else if (isComputedNoexcept(Chunk.Fun.getExceptionSpecType()) &&
924                  Chunk.Fun.NoexceptExpr->containsUnexpandedParameterPack())
925         return true;
926 
927       if (Chunk.Fun.hasTrailingReturnType()) {
928         QualType T = Chunk.Fun.getTrailingReturnType().get();
929         if (!T.isNull() && T->containsUnexpandedParameterPack())
930           return true;
931       }
932       break;
933 
934     case DeclaratorChunk::MemberPointer:
935       if (Chunk.Mem.Scope().getScopeRep() &&
936           Chunk.Mem.Scope().getScopeRep()->containsUnexpandedParameterPack())
937         return true;
938       break;
939     }
940   }
941 
942   if (Expr *TRC = D.getTrailingRequiresClause())
943     if (TRC->containsUnexpandedParameterPack())
944       return true;
945 
946   return false;
947 }
948 
949 namespace {
950 
951 // Callback to only accept typo corrections that refer to parameter packs.
952 class ParameterPackValidatorCCC final : public CorrectionCandidateCallback {
953  public:
954   bool ValidateCandidate(const TypoCorrection &candidate) override {
955     NamedDecl *ND = candidate.getCorrectionDecl();
956     return ND && ND->isParameterPack();
957   }
958 
959   std::unique_ptr<CorrectionCandidateCallback> clone() override {
960     return std::make_unique<ParameterPackValidatorCCC>(*this);
961   }
962 };
963 
964 }
965 
966 /// Called when an expression computing the size of a parameter pack
967 /// is parsed.
968 ///
969 /// \code
970 /// template<typename ...Types> struct count {
971 ///   static const unsigned value = sizeof...(Types);
972 /// };
973 /// \endcode
974 ///
975 //
976 /// \param OpLoc The location of the "sizeof" keyword.
977 /// \param Name The name of the parameter pack whose size will be determined.
978 /// \param NameLoc The source location of the name of the parameter pack.
979 /// \param RParenLoc The location of the closing parentheses.
980 ExprResult Sema::ActOnSizeofParameterPackExpr(Scope *S,
981                                               SourceLocation OpLoc,
982                                               IdentifierInfo &Name,
983                                               SourceLocation NameLoc,
984                                               SourceLocation RParenLoc) {
985   // C++0x [expr.sizeof]p5:
986   //   The identifier in a sizeof... expression shall name a parameter pack.
987   LookupResult R(*this, &Name, NameLoc, LookupOrdinaryName);
988   LookupName(R, S);
989 
990   NamedDecl *ParameterPack = nullptr;
991   switch (R.getResultKind()) {
992   case LookupResult::Found:
993     ParameterPack = R.getFoundDecl();
994     break;
995 
996   case LookupResult::NotFound:
997   case LookupResult::NotFoundInCurrentInstantiation: {
998     ParameterPackValidatorCCC CCC{};
999     if (TypoCorrection Corrected =
1000             CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S, nullptr,
1001                         CCC, CTK_ErrorRecovery)) {
1002       diagnoseTypo(Corrected,
1003                    PDiag(diag::err_sizeof_pack_no_pack_name_suggest) << &Name,
1004                    PDiag(diag::note_parameter_pack_here));
1005       ParameterPack = Corrected.getCorrectionDecl();
1006     }
1007     break;
1008   }
1009   case LookupResult::FoundOverloaded:
1010   case LookupResult::FoundUnresolvedValue:
1011     break;
1012 
1013   case LookupResult::Ambiguous:
1014     DiagnoseAmbiguousLookup(R);
1015     return ExprError();
1016   }
1017 
1018   if (!ParameterPack || !ParameterPack->isParameterPack()) {
1019     Diag(NameLoc, diag::err_sizeof_pack_no_pack_name)
1020       << &Name;
1021     return ExprError();
1022   }
1023 
1024   MarkAnyDeclReferenced(OpLoc, ParameterPack, true);
1025 
1026   return SizeOfPackExpr::Create(Context, OpLoc, ParameterPack, NameLoc,
1027                                 RParenLoc);
1028 }
1029 
1030 TemplateArgumentLoc
1031 Sema::getTemplateArgumentPackExpansionPattern(
1032       TemplateArgumentLoc OrigLoc,
1033       SourceLocation &Ellipsis, Optional<unsigned> &NumExpansions) const {
1034   const TemplateArgument &Argument = OrigLoc.getArgument();
1035   assert(Argument.isPackExpansion());
1036   switch (Argument.getKind()) {
1037   case TemplateArgument::Type: {
1038     // FIXME: We shouldn't ever have to worry about missing
1039     // type-source info!
1040     TypeSourceInfo *ExpansionTSInfo = OrigLoc.getTypeSourceInfo();
1041     if (!ExpansionTSInfo)
1042       ExpansionTSInfo = Context.getTrivialTypeSourceInfo(Argument.getAsType(),
1043                                                          Ellipsis);
1044     PackExpansionTypeLoc Expansion =
1045         ExpansionTSInfo->getTypeLoc().castAs<PackExpansionTypeLoc>();
1046     Ellipsis = Expansion.getEllipsisLoc();
1047 
1048     TypeLoc Pattern = Expansion.getPatternLoc();
1049     NumExpansions = Expansion.getTypePtr()->getNumExpansions();
1050 
1051     // We need to copy the TypeLoc because TemplateArgumentLocs store a
1052     // TypeSourceInfo.
1053     // FIXME: Find some way to avoid the copy?
1054     TypeLocBuilder TLB;
1055     TLB.pushFullCopy(Pattern);
1056     TypeSourceInfo *PatternTSInfo =
1057         TLB.getTypeSourceInfo(Context, Pattern.getType());
1058     return TemplateArgumentLoc(TemplateArgument(Pattern.getType()),
1059                                PatternTSInfo);
1060   }
1061 
1062   case TemplateArgument::Expression: {
1063     PackExpansionExpr *Expansion
1064       = cast<PackExpansionExpr>(Argument.getAsExpr());
1065     Expr *Pattern = Expansion->getPattern();
1066     Ellipsis = Expansion->getEllipsisLoc();
1067     NumExpansions = Expansion->getNumExpansions();
1068     return TemplateArgumentLoc(Pattern, Pattern);
1069   }
1070 
1071   case TemplateArgument::TemplateExpansion:
1072     Ellipsis = OrigLoc.getTemplateEllipsisLoc();
1073     NumExpansions = Argument.getNumTemplateExpansions();
1074     return TemplateArgumentLoc(Argument.getPackExpansionPattern(),
1075                                OrigLoc.getTemplateQualifierLoc(),
1076                                OrigLoc.getTemplateNameLoc());
1077 
1078   case TemplateArgument::Declaration:
1079   case TemplateArgument::NullPtr:
1080   case TemplateArgument::Template:
1081   case TemplateArgument::Integral:
1082   case TemplateArgument::Pack:
1083   case TemplateArgument::Null:
1084     return TemplateArgumentLoc();
1085   }
1086 
1087   llvm_unreachable("Invalid TemplateArgument Kind!");
1088 }
1089 
1090 Optional<unsigned> Sema::getFullyPackExpandedSize(TemplateArgument Arg) {
1091   assert(Arg.containsUnexpandedParameterPack());
1092 
1093   // If this is a substituted pack, grab that pack. If not, we don't know
1094   // the size yet.
1095   // FIXME: We could find a size in more cases by looking for a substituted
1096   // pack anywhere within this argument, but that's not necessary in the common
1097   // case for 'sizeof...(A)' handling.
1098   TemplateArgument Pack;
1099   switch (Arg.getKind()) {
1100   case TemplateArgument::Type:
1101     if (auto *Subst = Arg.getAsType()->getAs<SubstTemplateTypeParmPackType>())
1102       Pack = Subst->getArgumentPack();
1103     else
1104       return None;
1105     break;
1106 
1107   case TemplateArgument::Expression:
1108     if (auto *Subst =
1109             dyn_cast<SubstNonTypeTemplateParmPackExpr>(Arg.getAsExpr()))
1110       Pack = Subst->getArgumentPack();
1111     else if (auto *Subst = dyn_cast<FunctionParmPackExpr>(Arg.getAsExpr()))  {
1112       for (VarDecl *PD : *Subst)
1113         if (PD->isParameterPack())
1114           return None;
1115       return Subst->getNumExpansions();
1116     } else
1117       return None;
1118     break;
1119 
1120   case TemplateArgument::Template:
1121     if (SubstTemplateTemplateParmPackStorage *Subst =
1122             Arg.getAsTemplate().getAsSubstTemplateTemplateParmPack())
1123       Pack = Subst->getArgumentPack();
1124     else
1125       return None;
1126     break;
1127 
1128   case TemplateArgument::Declaration:
1129   case TemplateArgument::NullPtr:
1130   case TemplateArgument::TemplateExpansion:
1131   case TemplateArgument::Integral:
1132   case TemplateArgument::Pack:
1133   case TemplateArgument::Null:
1134     return None;
1135   }
1136 
1137   // Check that no argument in the pack is itself a pack expansion.
1138   for (TemplateArgument Elem : Pack.pack_elements()) {
1139     // There's no point recursing in this case; we would have already
1140     // expanded this pack expansion into the enclosing pack if we could.
1141     if (Elem.isPackExpansion())
1142       return None;
1143   }
1144   return Pack.pack_size();
1145 }
1146 
1147 static void CheckFoldOperand(Sema &S, Expr *E) {
1148   if (!E)
1149     return;
1150 
1151   E = E->IgnoreImpCasts();
1152   auto *OCE = dyn_cast<CXXOperatorCallExpr>(E);
1153   if ((OCE && OCE->isInfixBinaryOp()) || isa<BinaryOperator>(E) ||
1154       isa<AbstractConditionalOperator>(E)) {
1155     S.Diag(E->getExprLoc(), diag::err_fold_expression_bad_operand)
1156         << E->getSourceRange()
1157         << FixItHint::CreateInsertion(E->getBeginLoc(), "(")
1158         << FixItHint::CreateInsertion(E->getEndLoc(), ")");
1159   }
1160 }
1161 
1162 ExprResult Sema::ActOnCXXFoldExpr(SourceLocation LParenLoc, Expr *LHS,
1163                                   tok::TokenKind Operator,
1164                                   SourceLocation EllipsisLoc, Expr *RHS,
1165                                   SourceLocation RParenLoc) {
1166   // LHS and RHS must be cast-expressions. We allow an arbitrary expression
1167   // in the parser and reduce down to just cast-expressions here.
1168   CheckFoldOperand(*this, LHS);
1169   CheckFoldOperand(*this, RHS);
1170 
1171   auto DiscardOperands = [&] {
1172     CorrectDelayedTyposInExpr(LHS);
1173     CorrectDelayedTyposInExpr(RHS);
1174   };
1175 
1176   // [expr.prim.fold]p3:
1177   //   In a binary fold, op1 and op2 shall be the same fold-operator, and
1178   //   either e1 shall contain an unexpanded parameter pack or e2 shall contain
1179   //   an unexpanded parameter pack, but not both.
1180   if (LHS && RHS &&
1181       LHS->containsUnexpandedParameterPack() ==
1182           RHS->containsUnexpandedParameterPack()) {
1183     DiscardOperands();
1184     return Diag(EllipsisLoc,
1185                 LHS->containsUnexpandedParameterPack()
1186                     ? diag::err_fold_expression_packs_both_sides
1187                     : diag::err_pack_expansion_without_parameter_packs)
1188         << LHS->getSourceRange() << RHS->getSourceRange();
1189   }
1190 
1191   // [expr.prim.fold]p2:
1192   //   In a unary fold, the cast-expression shall contain an unexpanded
1193   //   parameter pack.
1194   if (!LHS || !RHS) {
1195     Expr *Pack = LHS ? LHS : RHS;
1196     assert(Pack && "fold expression with neither LHS nor RHS");
1197     DiscardOperands();
1198     if (!Pack->containsUnexpandedParameterPack())
1199       return Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
1200              << Pack->getSourceRange();
1201   }
1202 
1203   BinaryOperatorKind Opc = ConvertTokenKindToBinaryOpcode(Operator);
1204   return BuildCXXFoldExpr(LParenLoc, LHS, Opc, EllipsisLoc, RHS, RParenLoc,
1205                           None);
1206 }
1207 
1208 ExprResult Sema::BuildCXXFoldExpr(SourceLocation LParenLoc, Expr *LHS,
1209                                   BinaryOperatorKind Operator,
1210                                   SourceLocation EllipsisLoc, Expr *RHS,
1211                                   SourceLocation RParenLoc,
1212                                   Optional<unsigned> NumExpansions) {
1213   return new (Context) CXXFoldExpr(Context.DependentTy, LParenLoc, LHS,
1214                                    Operator, EllipsisLoc, RHS, RParenLoc,
1215                                    NumExpansions);
1216 }
1217 
1218 ExprResult Sema::BuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc,
1219                                        BinaryOperatorKind Operator) {
1220   // [temp.variadic]p9:
1221   //   If N is zero for a unary fold-expression, the value of the expression is
1222   //       &&  ->  true
1223   //       ||  ->  false
1224   //       ,   ->  void()
1225   //   if the operator is not listed [above], the instantiation is ill-formed.
1226   //
1227   // Note that we need to use something like int() here, not merely 0, to
1228   // prevent the result from being a null pointer constant.
1229   QualType ScalarType;
1230   switch (Operator) {
1231   case BO_LOr:
1232     return ActOnCXXBoolLiteral(EllipsisLoc, tok::kw_false);
1233   case BO_LAnd:
1234     return ActOnCXXBoolLiteral(EllipsisLoc, tok::kw_true);
1235   case BO_Comma:
1236     ScalarType = Context.VoidTy;
1237     break;
1238 
1239   default:
1240     return Diag(EllipsisLoc, diag::err_fold_expression_empty)
1241         << BinaryOperator::getOpcodeStr(Operator);
1242   }
1243 
1244   return new (Context) CXXScalarValueInitExpr(
1245       ScalarType, Context.getTrivialTypeSourceInfo(ScalarType, EllipsisLoc),
1246       EllipsisLoc);
1247 }
1248