1 //===------- SemaTemplateVariadic.cpp - C++ Variadic Templates ------------===/
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //===----------------------------------------------------------------------===/
8 //
9 //  This file implements semantic analysis for C++0x variadic templates.
10 //===----------------------------------------------------------------------===/
11 
12 #include "clang/Sema/Sema.h"
13 #include "TypeLocBuilder.h"
14 #include "clang/AST/Expr.h"
15 #include "clang/AST/RecursiveASTVisitor.h"
16 #include "clang/AST/TypeLoc.h"
17 #include "clang/Sema/Lookup.h"
18 #include "clang/Sema/ParsedTemplate.h"
19 #include "clang/Sema/ScopeInfo.h"
20 #include "clang/Sema/SemaInternal.h"
21 #include "clang/Sema/Template.h"
22 
23 using namespace clang;
24 
25 //----------------------------------------------------------------------------
26 // Visitor that collects unexpanded parameter packs
27 //----------------------------------------------------------------------------
28 
29 /// Retrieve the depth and index of a parameter pack.
30 static std::pair<unsigned, unsigned>
31 getDepthAndIndex(NamedDecl *ND) {
32   if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND))
33     return std::make_pair(TTP->getDepth(), TTP->getIndex());
34 
35   if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND))
36     return std::make_pair(NTTP->getDepth(), NTTP->getIndex());
37 
38   TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(ND);
39   return std::make_pair(TTP->getDepth(), TTP->getIndex());
40 }
41 
42 namespace {
43   /// A class that collects unexpanded parameter packs.
44   class CollectUnexpandedParameterPacksVisitor :
45     public RecursiveASTVisitor<CollectUnexpandedParameterPacksVisitor>
46   {
47     typedef RecursiveASTVisitor<CollectUnexpandedParameterPacksVisitor>
48       inherited;
49 
50     SmallVectorImpl<UnexpandedParameterPack> &Unexpanded;
51 
52     bool InLambda = false;
53     unsigned DepthLimit = (unsigned)-1;
54 
55     void addUnexpanded(NamedDecl *ND, SourceLocation Loc = SourceLocation()) {
56       if (auto *PVD = dyn_cast<ParmVarDecl>(ND)) {
57         // For now, the only problematic case is a generic lambda's templated
58         // call operator, so we don't need to look for all the other ways we
59         // could have reached a dependent parameter pack.
60         auto *FD = dyn_cast<FunctionDecl>(PVD->getDeclContext());
61         auto *FTD = FD ? FD->getDescribedFunctionTemplate() : nullptr;
62         if (FTD && FTD->getTemplateParameters()->getDepth() >= DepthLimit)
63           return;
64       } else if (getDepthAndIndex(ND).first >= DepthLimit)
65         return;
66 
67       Unexpanded.push_back({ND, Loc});
68     }
69     void addUnexpanded(const TemplateTypeParmType *T,
70                        SourceLocation Loc = SourceLocation()) {
71       if (T->getDepth() < DepthLimit)
72         Unexpanded.push_back({T, Loc});
73     }
74 
75   public:
76     explicit CollectUnexpandedParameterPacksVisitor(
77         SmallVectorImpl<UnexpandedParameterPack> &Unexpanded)
78         : Unexpanded(Unexpanded) {}
79 
80     bool shouldWalkTypesOfTypeLocs() const { return false; }
81 
82     //------------------------------------------------------------------------
83     // Recording occurrences of (unexpanded) parameter packs.
84     //------------------------------------------------------------------------
85 
86     /// Record occurrences of template type parameter packs.
87     bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
88       if (TL.getTypePtr()->isParameterPack())
89         addUnexpanded(TL.getTypePtr(), TL.getNameLoc());
90       return true;
91     }
92 
93     /// Record occurrences of template type parameter packs
94     /// when we don't have proper source-location information for
95     /// them.
96     ///
97     /// Ideally, this routine would never be used.
98     bool VisitTemplateTypeParmType(TemplateTypeParmType *T) {
99       if (T->isParameterPack())
100         addUnexpanded(T);
101 
102       return true;
103     }
104 
105     /// Record occurrences of function and non-type template
106     /// parameter packs in an expression.
107     bool VisitDeclRefExpr(DeclRefExpr *E) {
108       if (E->getDecl()->isParameterPack())
109         addUnexpanded(E->getDecl(), E->getLocation());
110 
111       return true;
112     }
113 
114     /// Record occurrences of template template parameter packs.
115     bool TraverseTemplateName(TemplateName Template) {
116       if (auto *TTP = dyn_cast_or_null<TemplateTemplateParmDecl>(
117               Template.getAsTemplateDecl())) {
118         if (TTP->isParameterPack())
119           addUnexpanded(TTP);
120       }
121 
122       return inherited::TraverseTemplateName(Template);
123     }
124 
125     /// Suppress traversal into Objective-C container literal
126     /// elements that are pack expansions.
127     bool TraverseObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
128       if (!E->containsUnexpandedParameterPack())
129         return true;
130 
131       for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) {
132         ObjCDictionaryElement Element = E->getKeyValueElement(I);
133         if (Element.isPackExpansion())
134           continue;
135 
136         TraverseStmt(Element.Key);
137         TraverseStmt(Element.Value);
138       }
139       return true;
140     }
141     //------------------------------------------------------------------------
142     // Pruning the search for unexpanded parameter packs.
143     //------------------------------------------------------------------------
144 
145     /// Suppress traversal into statements and expressions that
146     /// do not contain unexpanded parameter packs.
147     bool TraverseStmt(Stmt *S) {
148       Expr *E = dyn_cast_or_null<Expr>(S);
149       if ((E && E->containsUnexpandedParameterPack()) || InLambda)
150         return inherited::TraverseStmt(S);
151 
152       return true;
153     }
154 
155     /// Suppress traversal into types that do not contain
156     /// unexpanded parameter packs.
157     bool TraverseType(QualType T) {
158       if ((!T.isNull() && T->containsUnexpandedParameterPack()) || InLambda)
159         return inherited::TraverseType(T);
160 
161       return true;
162     }
163 
164     /// Suppress traversal into types with location information
165     /// that do not contain unexpanded parameter packs.
166     bool TraverseTypeLoc(TypeLoc TL) {
167       if ((!TL.getType().isNull() &&
168            TL.getType()->containsUnexpandedParameterPack()) ||
169           InLambda)
170         return inherited::TraverseTypeLoc(TL);
171 
172       return true;
173     }
174 
175     /// Suppress traversal of parameter packs.
176     bool TraverseDecl(Decl *D) {
177       // A function parameter pack is a pack expansion, so cannot contain
178       // an unexpanded parameter pack. Likewise for a template parameter
179       // pack that contains any references to other packs.
180       if (D->isParameterPack())
181         return true;
182 
183       return inherited::TraverseDecl(D);
184     }
185 
186     /// Suppress traversal of pack-expanded attributes.
187     bool TraverseAttr(Attr *A) {
188       if (A->isPackExpansion())
189         return true;
190 
191       return inherited::TraverseAttr(A);
192     }
193 
194     /// Suppress traversal of pack expansion expressions and types.
195     ///@{
196     bool TraversePackExpansionType(PackExpansionType *T) { return true; }
197     bool TraversePackExpansionTypeLoc(PackExpansionTypeLoc TL) { return true; }
198     bool TraversePackExpansionExpr(PackExpansionExpr *E) { return true; }
199     bool TraverseCXXFoldExpr(CXXFoldExpr *E) { return true; }
200 
201     ///@}
202 
203     /// Suppress traversal of using-declaration pack expansion.
204     bool TraverseUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
205       if (D->isPackExpansion())
206         return true;
207 
208       return inherited::TraverseUnresolvedUsingValueDecl(D);
209     }
210 
211     /// Suppress traversal of using-declaration pack expansion.
212     bool TraverseUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D) {
213       if (D->isPackExpansion())
214         return true;
215 
216       return inherited::TraverseUnresolvedUsingTypenameDecl(D);
217     }
218 
219     /// Suppress traversal of template argument pack expansions.
220     bool TraverseTemplateArgument(const TemplateArgument &Arg) {
221       if (Arg.isPackExpansion())
222         return true;
223 
224       return inherited::TraverseTemplateArgument(Arg);
225     }
226 
227     /// Suppress traversal of template argument pack expansions.
228     bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &ArgLoc) {
229       if (ArgLoc.getArgument().isPackExpansion())
230         return true;
231 
232       return inherited::TraverseTemplateArgumentLoc(ArgLoc);
233     }
234 
235     /// Suppress traversal of base specifier pack expansions.
236     bool TraverseCXXBaseSpecifier(const CXXBaseSpecifier &Base) {
237       if (Base.isPackExpansion())
238         return true;
239 
240       return inherited::TraverseCXXBaseSpecifier(Base);
241     }
242 
243     /// Suppress traversal of mem-initializer pack expansions.
244     bool TraverseConstructorInitializer(CXXCtorInitializer *Init) {
245       if (Init->isPackExpansion())
246         return true;
247 
248       return inherited::TraverseConstructorInitializer(Init);
249     }
250 
251     /// Note whether we're traversing a lambda containing an unexpanded
252     /// parameter pack. In this case, the unexpanded pack can occur anywhere,
253     /// including all the places where we normally wouldn't look. Within a
254     /// lambda, we don't propagate the 'contains unexpanded parameter pack' bit
255     /// outside an expression.
256     bool TraverseLambdaExpr(LambdaExpr *Lambda) {
257       // The ContainsUnexpandedParameterPack bit on a lambda is always correct,
258       // even if it's contained within another lambda.
259       if (!Lambda->containsUnexpandedParameterPack())
260         return true;
261 
262       bool WasInLambda = InLambda;
263       unsigned OldDepthLimit = DepthLimit;
264 
265       InLambda = true;
266       if (auto *TPL = Lambda->getTemplateParameterList())
267         DepthLimit = TPL->getDepth();
268 
269       inherited::TraverseLambdaExpr(Lambda);
270 
271       InLambda = WasInLambda;
272       DepthLimit = OldDepthLimit;
273       return true;
274     }
275 
276     /// Suppress traversal within pack expansions in lambda captures.
277     bool TraverseLambdaCapture(LambdaExpr *Lambda, const LambdaCapture *C,
278                                Expr *Init) {
279       if (C->isPackExpansion())
280         return true;
281 
282       return inherited::TraverseLambdaCapture(Lambda, C, Init);
283     }
284   };
285 }
286 
287 /// Determine whether it's possible for an unexpanded parameter pack to
288 /// be valid in this location. This only happens when we're in a declaration
289 /// that is nested within an expression that could be expanded, such as a
290 /// lambda-expression within a function call.
291 ///
292 /// This is conservatively correct, but may claim that some unexpanded packs are
293 /// permitted when they are not.
294 bool Sema::isUnexpandedParameterPackPermitted() {
295   for (auto *SI : FunctionScopes)
296     if (isa<sema::LambdaScopeInfo>(SI))
297       return true;
298   return false;
299 }
300 
301 /// Diagnose all of the unexpanded parameter packs in the given
302 /// vector.
303 bool
304 Sema::DiagnoseUnexpandedParameterPacks(SourceLocation Loc,
305                                        UnexpandedParameterPackContext UPPC,
306                                  ArrayRef<UnexpandedParameterPack> Unexpanded) {
307   if (Unexpanded.empty())
308     return false;
309 
310   // If we are within a lambda expression and referencing a pack that is not
311   // a parameter of the lambda itself, that lambda contains an unexpanded
312   // parameter pack, and we are done.
313   // FIXME: Store 'Unexpanded' on the lambda so we don't need to recompute it
314   // later.
315   SmallVector<UnexpandedParameterPack, 4> LambdaParamPackReferences;
316   for (unsigned N = FunctionScopes.size(); N; --N) {
317     sema::FunctionScopeInfo *Func = FunctionScopes[N-1];
318     // We do not permit pack expansion that would duplicate a statement
319     // expression, not even within a lambda.
320     // FIXME: We could probably support this for statement expressions that do
321     // not contain labels, and for pack expansions that expand both the stmt
322     // expr and the enclosing lambda.
323     if (std::any_of(
324             Func->CompoundScopes.begin(), Func->CompoundScopes.end(),
325             [](sema::CompoundScopeInfo &CSI) { return CSI.IsStmtExpr; }))
326       break;
327 
328     if (auto *LSI = dyn_cast<sema::LambdaScopeInfo>(Func)) {
329       if (N == FunctionScopes.size()) {
330         for (auto &Param : Unexpanded) {
331           auto *PD = dyn_cast_or_null<ParmVarDecl>(
332               Param.first.dyn_cast<NamedDecl *>());
333           if (PD && PD->getDeclContext() == LSI->CallOperator)
334             LambdaParamPackReferences.push_back(Param);
335         }
336       }
337 
338       // If we have references to a parameter pack of the innermost enclosing
339       // lambda, only diagnose those ones. We don't know whether any other
340       // unexpanded parameters referenced herein are actually unexpanded;
341       // they might be expanded at an outer level.
342       if (!LambdaParamPackReferences.empty()) {
343         Unexpanded = LambdaParamPackReferences;
344         break;
345       }
346 
347       LSI->ContainsUnexpandedParameterPack = true;
348       return false;
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->getLocStart(), 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++0x [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   if (!Pattern->containsUnexpandedParameterPack()) {
608     Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
609       << PatternRange;
610     return QualType();
611   }
612 
613   return Context.getPackExpansionType(Pattern, NumExpansions);
614 }
615 
616 ExprResult Sema::ActOnPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc) {
617   return CheckPackExpansion(Pattern, EllipsisLoc, None);
618 }
619 
620 ExprResult Sema::CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc,
621                                     Optional<unsigned> NumExpansions) {
622   if (!Pattern)
623     return ExprError();
624 
625   // C++0x [temp.variadic]p5:
626   //   The pattern of a pack expansion shall name one or more
627   //   parameter packs that are not expanded by a nested pack
628   //   expansion.
629   if (!Pattern->containsUnexpandedParameterPack()) {
630     Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
631     << Pattern->getSourceRange();
632     return ExprError();
633   }
634 
635   // Create the pack expansion expression and source-location information.
636   return new (Context)
637     PackExpansionExpr(Context.DependentTy, Pattern, EllipsisLoc, NumExpansions);
638 }
639 
640 bool Sema::CheckParameterPacksForExpansion(
641     SourceLocation EllipsisLoc, SourceRange PatternRange,
642     ArrayRef<UnexpandedParameterPack> Unexpanded,
643     const MultiLevelTemplateArgumentList &TemplateArgs, bool &ShouldExpand,
644     bool &RetainExpansion, Optional<unsigned> &NumExpansions) {
645   ShouldExpand = true;
646   RetainExpansion = false;
647   std::pair<IdentifierInfo *, SourceLocation> FirstPack;
648   bool HaveFirstPack = false;
649 
650   for (ArrayRef<UnexpandedParameterPack>::iterator i = Unexpanded.begin(),
651                                                  end = Unexpanded.end();
652                                                   i != end; ++i) {
653     // Compute the depth and index for this parameter pack.
654     unsigned Depth = 0, Index = 0;
655     IdentifierInfo *Name;
656     bool IsFunctionParameterPack = false;
657 
658     if (const TemplateTypeParmType *TTP
659         = i->first.dyn_cast<const TemplateTypeParmType *>()) {
660       Depth = TTP->getDepth();
661       Index = TTP->getIndex();
662       Name = TTP->getIdentifier();
663     } else {
664       NamedDecl *ND = i->first.get<NamedDecl *>();
665       if (isa<ParmVarDecl>(ND))
666         IsFunctionParameterPack = true;
667       else
668         std::tie(Depth, Index) = getDepthAndIndex(ND);
669 
670       Name = ND->getIdentifier();
671     }
672 
673     // Determine the size of this argument pack.
674     unsigned NewPackSize;
675     if (IsFunctionParameterPack) {
676       // Figure out whether we're instantiating to an argument pack or not.
677       typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
678 
679       llvm::PointerUnion<Decl *, DeclArgumentPack *> *Instantiation
680         = CurrentInstantiationScope->findInstantiationOf(
681                                         i->first.get<NamedDecl *>());
682       if (Instantiation->is<DeclArgumentPack *>()) {
683         // We could expand this function parameter pack.
684         NewPackSize = Instantiation->get<DeclArgumentPack *>()->size();
685       } else {
686         // We can't expand this function parameter pack, so we can't expand
687         // the pack expansion.
688         ShouldExpand = false;
689         continue;
690       }
691     } else {
692       // If we don't have a template argument at this depth/index, then we
693       // cannot expand the pack expansion. Make a note of this, but we still
694       // want to check any parameter packs we *do* have arguments for.
695       if (Depth >= TemplateArgs.getNumLevels() ||
696           !TemplateArgs.hasTemplateArgument(Depth, Index)) {
697         ShouldExpand = false;
698         continue;
699       }
700 
701       // Determine the size of the argument pack.
702       NewPackSize = TemplateArgs(Depth, Index).pack_size();
703     }
704 
705     // C++0x [temp.arg.explicit]p9:
706     //   Template argument deduction can extend the sequence of template
707     //   arguments corresponding to a template parameter pack, even when the
708     //   sequence contains explicitly specified template arguments.
709     if (!IsFunctionParameterPack && CurrentInstantiationScope) {
710       if (NamedDecl *PartialPack
711                     = CurrentInstantiationScope->getPartiallySubstitutedPack()){
712         unsigned PartialDepth, PartialIndex;
713         std::tie(PartialDepth, PartialIndex) = getDepthAndIndex(PartialPack);
714         if (PartialDepth == Depth && PartialIndex == Index)
715           RetainExpansion = true;
716       }
717     }
718 
719     if (!NumExpansions) {
720       // The is the first pack we've seen for which we have an argument.
721       // Record it.
722       NumExpansions = NewPackSize;
723       FirstPack.first = Name;
724       FirstPack.second = i->second;
725       HaveFirstPack = true;
726       continue;
727     }
728 
729     if (NewPackSize != *NumExpansions) {
730       // C++0x [temp.variadic]p5:
731       //   All of the parameter packs expanded by a pack expansion shall have
732       //   the same number of arguments specified.
733       if (HaveFirstPack)
734         Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict)
735           << FirstPack.first << Name << *NumExpansions << NewPackSize
736           << SourceRange(FirstPack.second) << SourceRange(i->second);
737       else
738         Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict_multilevel)
739           << Name << *NumExpansions << NewPackSize
740           << SourceRange(i->second);
741       return true;
742     }
743   }
744 
745   return false;
746 }
747 
748 Optional<unsigned> Sema::getNumArgumentsInExpansion(QualType T,
749                           const MultiLevelTemplateArgumentList &TemplateArgs) {
750   QualType Pattern = cast<PackExpansionType>(T)->getPattern();
751   SmallVector<UnexpandedParameterPack, 2> Unexpanded;
752   CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseType(Pattern);
753 
754   Optional<unsigned> Result;
755   for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
756     // Compute the depth and index for this parameter pack.
757     unsigned Depth;
758     unsigned Index;
759 
760     if (const TemplateTypeParmType *TTP
761           = Unexpanded[I].first.dyn_cast<const TemplateTypeParmType *>()) {
762       Depth = TTP->getDepth();
763       Index = TTP->getIndex();
764     } else {
765       NamedDecl *ND = Unexpanded[I].first.get<NamedDecl *>();
766       if (isa<ParmVarDecl>(ND)) {
767         // Function parameter pack.
768         typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
769 
770         llvm::PointerUnion<Decl *, DeclArgumentPack *> *Instantiation
771           = CurrentInstantiationScope->findInstantiationOf(
772                                         Unexpanded[I].first.get<NamedDecl *>());
773         if (Instantiation->is<Decl*>())
774           // The pattern refers to an unexpanded pack. We're not ready to expand
775           // this pack yet.
776           return None;
777 
778         unsigned Size = Instantiation->get<DeclArgumentPack *>()->size();
779         assert((!Result || *Result == Size) && "inconsistent pack sizes");
780         Result = Size;
781         continue;
782       }
783 
784       std::tie(Depth, Index) = getDepthAndIndex(ND);
785     }
786     if (Depth >= TemplateArgs.getNumLevels() ||
787         !TemplateArgs.hasTemplateArgument(Depth, Index))
788       // The pattern refers to an unknown template argument. We're not ready to
789       // expand this pack yet.
790       return None;
791 
792     // Determine the size of the argument pack.
793     unsigned Size = TemplateArgs(Depth, Index).pack_size();
794     assert((!Result || *Result == Size) && "inconsistent pack sizes");
795     Result = Size;
796   }
797 
798   return Result;
799 }
800 
801 bool Sema::containsUnexpandedParameterPacks(Declarator &D) {
802   const DeclSpec &DS = D.getDeclSpec();
803   switch (DS.getTypeSpecType()) {
804   case TST_typename:
805   case TST_typeofType:
806   case TST_underlyingType:
807   case TST_atomic: {
808     QualType T = DS.getRepAsType().get();
809     if (!T.isNull() && T->containsUnexpandedParameterPack())
810       return true;
811     break;
812   }
813 
814   case TST_typeofExpr:
815   case TST_decltype:
816     if (DS.getRepAsExpr() &&
817         DS.getRepAsExpr()->containsUnexpandedParameterPack())
818       return true;
819     break;
820 
821   case TST_unspecified:
822   case TST_void:
823   case TST_char:
824   case TST_wchar:
825   case TST_char8:
826   case TST_char16:
827   case TST_char32:
828   case TST_int:
829   case TST_int128:
830   case TST_half:
831   case TST_float:
832   case TST_double:
833   case TST_Accum:
834   case TST_Float16:
835   case TST_float128:
836   case TST_bool:
837   case TST_decimal32:
838   case TST_decimal64:
839   case TST_decimal128:
840   case TST_enum:
841   case TST_union:
842   case TST_struct:
843   case TST_interface:
844   case TST_class:
845   case TST_auto:
846   case TST_auto_type:
847   case TST_decltype_auto:
848 #define GENERIC_IMAGE_TYPE(ImgType, Id) case TST_##ImgType##_t:
849 #include "clang/Basic/OpenCLImageTypes.def"
850   case TST_unknown_anytype:
851   case TST_error:
852     break;
853   }
854 
855   for (unsigned I = 0, N = D.getNumTypeObjects(); I != N; ++I) {
856     const DeclaratorChunk &Chunk = D.getTypeObject(I);
857     switch (Chunk.Kind) {
858     case DeclaratorChunk::Pointer:
859     case DeclaratorChunk::Reference:
860     case DeclaratorChunk::Paren:
861     case DeclaratorChunk::Pipe:
862     case DeclaratorChunk::BlockPointer:
863       // These declarator chunks cannot contain any parameter packs.
864       break;
865 
866     case DeclaratorChunk::Array:
867       if (Chunk.Arr.NumElts &&
868           Chunk.Arr.NumElts->containsUnexpandedParameterPack())
869         return true;
870       break;
871     case DeclaratorChunk::Function:
872       for (unsigned i = 0, e = Chunk.Fun.NumParams; i != e; ++i) {
873         ParmVarDecl *Param = cast<ParmVarDecl>(Chunk.Fun.Params[i].Param);
874         QualType ParamTy = Param->getType();
875         assert(!ParamTy.isNull() && "Couldn't parse type?");
876         if (ParamTy->containsUnexpandedParameterPack()) return true;
877       }
878 
879       if (Chunk.Fun.getExceptionSpecType() == EST_Dynamic) {
880         for (unsigned i = 0; i != Chunk.Fun.getNumExceptions(); ++i) {
881           if (Chunk.Fun.Exceptions[i]
882                   .Ty.get()
883                   ->containsUnexpandedParameterPack())
884             return true;
885         }
886       } else if (isComputedNoexcept(Chunk.Fun.getExceptionSpecType()) &&
887                  Chunk.Fun.NoexceptExpr->containsUnexpandedParameterPack())
888         return true;
889 
890       if (Chunk.Fun.hasTrailingReturnType()) {
891         QualType T = Chunk.Fun.getTrailingReturnType().get();
892 	if (!T.isNull() && T->containsUnexpandedParameterPack())
893 	  return true;
894       }
895       break;
896 
897     case DeclaratorChunk::MemberPointer:
898       if (Chunk.Mem.Scope().getScopeRep() &&
899           Chunk.Mem.Scope().getScopeRep()->containsUnexpandedParameterPack())
900         return true;
901       break;
902     }
903   }
904 
905   return false;
906 }
907 
908 namespace {
909 
910 // Callback to only accept typo corrections that refer to parameter packs.
911 class ParameterPackValidatorCCC : public CorrectionCandidateCallback {
912  public:
913   bool ValidateCandidate(const TypoCorrection &candidate) override {
914     NamedDecl *ND = candidate.getCorrectionDecl();
915     return ND && ND->isParameterPack();
916   }
917 };
918 
919 }
920 
921 /// Called when an expression computing the size of a parameter pack
922 /// is parsed.
923 ///
924 /// \code
925 /// template<typename ...Types> struct count {
926 ///   static const unsigned value = sizeof...(Types);
927 /// };
928 /// \endcode
929 ///
930 //
931 /// \param OpLoc The location of the "sizeof" keyword.
932 /// \param Name The name of the parameter pack whose size will be determined.
933 /// \param NameLoc The source location of the name of the parameter pack.
934 /// \param RParenLoc The location of the closing parentheses.
935 ExprResult Sema::ActOnSizeofParameterPackExpr(Scope *S,
936                                               SourceLocation OpLoc,
937                                               IdentifierInfo &Name,
938                                               SourceLocation NameLoc,
939                                               SourceLocation RParenLoc) {
940   // C++0x [expr.sizeof]p5:
941   //   The identifier in a sizeof... expression shall name a parameter pack.
942   LookupResult R(*this, &Name, NameLoc, LookupOrdinaryName);
943   LookupName(R, S);
944 
945   NamedDecl *ParameterPack = nullptr;
946   switch (R.getResultKind()) {
947   case LookupResult::Found:
948     ParameterPack = R.getFoundDecl();
949     break;
950 
951   case LookupResult::NotFound:
952   case LookupResult::NotFoundInCurrentInstantiation:
953     if (TypoCorrection Corrected =
954             CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S, nullptr,
955                         llvm::make_unique<ParameterPackValidatorCCC>(),
956                         CTK_ErrorRecovery)) {
957       diagnoseTypo(Corrected,
958                    PDiag(diag::err_sizeof_pack_no_pack_name_suggest) << &Name,
959                    PDiag(diag::note_parameter_pack_here));
960       ParameterPack = Corrected.getCorrectionDecl();
961     }
962 
963   case LookupResult::FoundOverloaded:
964   case LookupResult::FoundUnresolvedValue:
965     break;
966 
967   case LookupResult::Ambiguous:
968     DiagnoseAmbiguousLookup(R);
969     return ExprError();
970   }
971 
972   if (!ParameterPack || !ParameterPack->isParameterPack()) {
973     Diag(NameLoc, diag::err_sizeof_pack_no_pack_name)
974       << &Name;
975     return ExprError();
976   }
977 
978   MarkAnyDeclReferenced(OpLoc, ParameterPack, true);
979 
980   return SizeOfPackExpr::Create(Context, OpLoc, ParameterPack, NameLoc,
981                                 RParenLoc);
982 }
983 
984 TemplateArgumentLoc
985 Sema::getTemplateArgumentPackExpansionPattern(
986       TemplateArgumentLoc OrigLoc,
987       SourceLocation &Ellipsis, Optional<unsigned> &NumExpansions) const {
988   const TemplateArgument &Argument = OrigLoc.getArgument();
989   assert(Argument.isPackExpansion());
990   switch (Argument.getKind()) {
991   case TemplateArgument::Type: {
992     // FIXME: We shouldn't ever have to worry about missing
993     // type-source info!
994     TypeSourceInfo *ExpansionTSInfo = OrigLoc.getTypeSourceInfo();
995     if (!ExpansionTSInfo)
996       ExpansionTSInfo = Context.getTrivialTypeSourceInfo(Argument.getAsType(),
997                                                          Ellipsis);
998     PackExpansionTypeLoc Expansion =
999         ExpansionTSInfo->getTypeLoc().castAs<PackExpansionTypeLoc>();
1000     Ellipsis = Expansion.getEllipsisLoc();
1001 
1002     TypeLoc Pattern = Expansion.getPatternLoc();
1003     NumExpansions = Expansion.getTypePtr()->getNumExpansions();
1004 
1005     // We need to copy the TypeLoc because TemplateArgumentLocs store a
1006     // TypeSourceInfo.
1007     // FIXME: Find some way to avoid the copy?
1008     TypeLocBuilder TLB;
1009     TLB.pushFullCopy(Pattern);
1010     TypeSourceInfo *PatternTSInfo =
1011         TLB.getTypeSourceInfo(Context, Pattern.getType());
1012     return TemplateArgumentLoc(TemplateArgument(Pattern.getType()),
1013                                PatternTSInfo);
1014   }
1015 
1016   case TemplateArgument::Expression: {
1017     PackExpansionExpr *Expansion
1018       = cast<PackExpansionExpr>(Argument.getAsExpr());
1019     Expr *Pattern = Expansion->getPattern();
1020     Ellipsis = Expansion->getEllipsisLoc();
1021     NumExpansions = Expansion->getNumExpansions();
1022     return TemplateArgumentLoc(Pattern, Pattern);
1023   }
1024 
1025   case TemplateArgument::TemplateExpansion:
1026     Ellipsis = OrigLoc.getTemplateEllipsisLoc();
1027     NumExpansions = Argument.getNumTemplateExpansions();
1028     return TemplateArgumentLoc(Argument.getPackExpansionPattern(),
1029                                OrigLoc.getTemplateQualifierLoc(),
1030                                OrigLoc.getTemplateNameLoc());
1031 
1032   case TemplateArgument::Declaration:
1033   case TemplateArgument::NullPtr:
1034   case TemplateArgument::Template:
1035   case TemplateArgument::Integral:
1036   case TemplateArgument::Pack:
1037   case TemplateArgument::Null:
1038     return TemplateArgumentLoc();
1039   }
1040 
1041   llvm_unreachable("Invalid TemplateArgument Kind!");
1042 }
1043 
1044 Optional<unsigned> Sema::getFullyPackExpandedSize(TemplateArgument Arg) {
1045   assert(Arg.containsUnexpandedParameterPack());
1046 
1047   // If this is a substituted pack, grab that pack. If not, we don't know
1048   // the size yet.
1049   // FIXME: We could find a size in more cases by looking for a substituted
1050   // pack anywhere within this argument, but that's not necessary in the common
1051   // case for 'sizeof...(A)' handling.
1052   TemplateArgument Pack;
1053   switch (Arg.getKind()) {
1054   case TemplateArgument::Type:
1055     if (auto *Subst = Arg.getAsType()->getAs<SubstTemplateTypeParmPackType>())
1056       Pack = Subst->getArgumentPack();
1057     else
1058       return None;
1059     break;
1060 
1061   case TemplateArgument::Expression:
1062     if (auto *Subst =
1063             dyn_cast<SubstNonTypeTemplateParmPackExpr>(Arg.getAsExpr()))
1064       Pack = Subst->getArgumentPack();
1065     else if (auto *Subst = dyn_cast<FunctionParmPackExpr>(Arg.getAsExpr()))  {
1066       for (ParmVarDecl *PD : *Subst)
1067         if (PD->isParameterPack())
1068           return None;
1069       return Subst->getNumExpansions();
1070     } else
1071       return None;
1072     break;
1073 
1074   case TemplateArgument::Template:
1075     if (SubstTemplateTemplateParmPackStorage *Subst =
1076             Arg.getAsTemplate().getAsSubstTemplateTemplateParmPack())
1077       Pack = Subst->getArgumentPack();
1078     else
1079       return None;
1080     break;
1081 
1082   case TemplateArgument::Declaration:
1083   case TemplateArgument::NullPtr:
1084   case TemplateArgument::TemplateExpansion:
1085   case TemplateArgument::Integral:
1086   case TemplateArgument::Pack:
1087   case TemplateArgument::Null:
1088     return None;
1089   }
1090 
1091   // Check that no argument in the pack is itself a pack expansion.
1092   for (TemplateArgument Elem : Pack.pack_elements()) {
1093     // There's no point recursing in this case; we would have already
1094     // expanded this pack expansion into the enclosing pack if we could.
1095     if (Elem.isPackExpansion())
1096       return None;
1097   }
1098   return Pack.pack_size();
1099 }
1100 
1101 static void CheckFoldOperand(Sema &S, Expr *E) {
1102   if (!E)
1103     return;
1104 
1105   E = E->IgnoreImpCasts();
1106   auto *OCE = dyn_cast<CXXOperatorCallExpr>(E);
1107   if ((OCE && OCE->isInfixBinaryOp()) || isa<BinaryOperator>(E) ||
1108       isa<AbstractConditionalOperator>(E)) {
1109     S.Diag(E->getExprLoc(), diag::err_fold_expression_bad_operand)
1110         << E->getSourceRange()
1111         << FixItHint::CreateInsertion(E->getLocStart(), "(")
1112         << FixItHint::CreateInsertion(E->getLocEnd(), ")");
1113   }
1114 }
1115 
1116 ExprResult Sema::ActOnCXXFoldExpr(SourceLocation LParenLoc, Expr *LHS,
1117                                   tok::TokenKind Operator,
1118                                   SourceLocation EllipsisLoc, Expr *RHS,
1119                                   SourceLocation RParenLoc) {
1120   // LHS and RHS must be cast-expressions. We allow an arbitrary expression
1121   // in the parser and reduce down to just cast-expressions here.
1122   CheckFoldOperand(*this, LHS);
1123   CheckFoldOperand(*this, RHS);
1124 
1125   auto DiscardOperands = [&] {
1126     CorrectDelayedTyposInExpr(LHS);
1127     CorrectDelayedTyposInExpr(RHS);
1128   };
1129 
1130   // [expr.prim.fold]p3:
1131   //   In a binary fold, op1 and op2 shall be the same fold-operator, and
1132   //   either e1 shall contain an unexpanded parameter pack or e2 shall contain
1133   //   an unexpanded parameter pack, but not both.
1134   if (LHS && RHS &&
1135       LHS->containsUnexpandedParameterPack() ==
1136           RHS->containsUnexpandedParameterPack()) {
1137     DiscardOperands();
1138     return Diag(EllipsisLoc,
1139                 LHS->containsUnexpandedParameterPack()
1140                     ? diag::err_fold_expression_packs_both_sides
1141                     : diag::err_pack_expansion_without_parameter_packs)
1142         << LHS->getSourceRange() << RHS->getSourceRange();
1143   }
1144 
1145   // [expr.prim.fold]p2:
1146   //   In a unary fold, the cast-expression shall contain an unexpanded
1147   //   parameter pack.
1148   if (!LHS || !RHS) {
1149     Expr *Pack = LHS ? LHS : RHS;
1150     assert(Pack && "fold expression with neither LHS nor RHS");
1151     DiscardOperands();
1152     if (!Pack->containsUnexpandedParameterPack())
1153       return Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
1154              << Pack->getSourceRange();
1155   }
1156 
1157   BinaryOperatorKind Opc = ConvertTokenKindToBinaryOpcode(Operator);
1158   return BuildCXXFoldExpr(LParenLoc, LHS, Opc, EllipsisLoc, RHS, RParenLoc);
1159 }
1160 
1161 ExprResult Sema::BuildCXXFoldExpr(SourceLocation LParenLoc, Expr *LHS,
1162                                   BinaryOperatorKind Operator,
1163                                   SourceLocation EllipsisLoc, Expr *RHS,
1164                                   SourceLocation RParenLoc) {
1165   return new (Context) CXXFoldExpr(Context.DependentTy, LParenLoc, LHS,
1166                                    Operator, EllipsisLoc, RHS, RParenLoc);
1167 }
1168 
1169 ExprResult Sema::BuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc,
1170                                        BinaryOperatorKind Operator) {
1171   // [temp.variadic]p9:
1172   //   If N is zero for a unary fold-expression, the value of the expression is
1173   //       &&  ->  true
1174   //       ||  ->  false
1175   //       ,   ->  void()
1176   //   if the operator is not listed [above], the instantiation is ill-formed.
1177   //
1178   // Note that we need to use something like int() here, not merely 0, to
1179   // prevent the result from being a null pointer constant.
1180   QualType ScalarType;
1181   switch (Operator) {
1182   case BO_LOr:
1183     return ActOnCXXBoolLiteral(EllipsisLoc, tok::kw_false);
1184   case BO_LAnd:
1185     return ActOnCXXBoolLiteral(EllipsisLoc, tok::kw_true);
1186   case BO_Comma:
1187     ScalarType = Context.VoidTy;
1188     break;
1189 
1190   default:
1191     return Diag(EllipsisLoc, diag::err_fold_expression_empty)
1192         << BinaryOperator::getOpcodeStr(Operator);
1193   }
1194 
1195   return new (Context) CXXScalarValueInitExpr(
1196       ScalarType, Context.getTrivialTypeSourceInfo(ScalarType, EllipsisLoc),
1197       EllipsisLoc);
1198 }
1199