[Sema] Fix computations of "unexpanded packs" in substituted lambdas

clang/include/clang/AST/ComputeDependence.h

@@ -166,7 +166,7 @@ ExprDependence computeDependence(CXXTemporaryObjectExpr *E);
 ExprDependence computeDependence(CXXDefaultInitExpr *E);
 ExprDependence computeDependence(CXXDefaultArgExpr *E);
 ExprDependence computeDependence(LambdaExpr *E,
-                                 bool ContainsUnexpandedParameterPack);
+                                 bool BodyContainsUnexpandedPacks);
 ExprDependence computeDependence(CXXUnresolvedConstructExpr *E);
 ExprDependence computeDependence(CXXDependentScopeMemberExpr *E);
 ExprDependence computeDependence(MaterializeTemporaryExpr *E);

clang/include/clang/AST/ExprCXX.h

@@ -1975,7 +1975,8 @@ class LambdaExpr final : public Expr,
              LambdaCaptureDefault CaptureDefault,
              SourceLocation CaptureDefaultLoc, bool ExplicitParams,
              bool ExplicitResultType, ArrayRef<Expr *> CaptureInits,
-             SourceLocation ClosingBrace, bool ContainsUnexpandedParameterPack);
+             SourceLocation ClosingBrace,
+             bool BodyContainsUnexpandedParameterPack);
 
   /// Construct an empty lambda expression.
   LambdaExpr(EmptyShell Empty, unsigned NumCaptures);
@@ -1996,7 +1997,7 @@ class LambdaExpr final : public Expr,
          LambdaCaptureDefault CaptureDefault, SourceLocation CaptureDefaultLoc,
          bool ExplicitParams, bool ExplicitResultType,
          ArrayRef<Expr *> CaptureInits, SourceLocation ClosingBrace,
-         bool ContainsUnexpandedParameterPack);
+         bool BodyContainsUnexpandedParameterPack);
 
   /// Construct a new lambda expression that will be deserialized from
   /// an external source.
@@ -4854,15 +4855,7 @@ class CXXFoldExpr : public Expr {
   CXXFoldExpr(QualType T, UnresolvedLookupExpr *Callee,
               SourceLocation LParenLoc, Expr *LHS, BinaryOperatorKind Opcode,
               SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc,
-              std::optional<unsigned> NumExpansions)
-      : Expr(CXXFoldExprClass, T, VK_PRValue, OK_Ordinary),
-        LParenLoc(LParenLoc), EllipsisLoc(EllipsisLoc), RParenLoc(RParenLoc),
-        NumExpansions(NumExpansions ? *NumExpansions + 1 : 0), Opcode(Opcode) {
-    SubExprs[SubExpr::Callee] = Callee;
-    SubExprs[SubExpr::LHS] = LHS;
-    SubExprs[SubExpr::RHS] = RHS;
-    setDependence(computeDependence(this));
-  }
+              std::optional<unsigned> NumExpansions);
 
   CXXFoldExpr(EmptyShell Empty) : Expr(CXXFoldExprClass, Empty) {}
 

clang/include/clang/Sema/ScopeInfo.h

@@ -895,8 +895,9 @@ class LambdaScopeInfo final :
   /// Whether any of the capture expressions requires cleanups.
   CleanupInfo Cleanup;
 
-  /// Whether the lambda contains an unexpanded parameter pack.
-  bool ContainsUnexpandedParameterPack = false;
+  /// Whether the lambda body contains an unexpanded parameter pack.
+  /// Note that the captures and template paramters are handled separately.
+  bool BodyContainsUnexpandedParameterPack = false;
 
   /// Packs introduced by this lambda, if any.
   SmallVector<NamedDecl*, 4> LocalPacks;

clang/lib/AST/ComputeDependence.cpp

@@ -850,9 +850,40 @@ ExprDependence clang::computeDependence(CXXDefaultArgExpr *E) {
 }
 
 ExprDependence clang::computeDependence(LambdaExpr *E,
-                                        bool ContainsUnexpandedParameterPack) {
+                                        bool BodyContainsUnexpandedPacks) {
   auto D = toExprDependenceForImpliedType(E->getType()->getDependence());
-  if (ContainsUnexpandedParameterPack)
+
+  // Record the presence of unexpanded packs.
+  bool ContainsUnexpandedPack =
+      BodyContainsUnexpandedPacks ||
+      (E->getTemplateParameterList() &&
+       E->getTemplateParameterList()->containsUnexpandedParameterPack());
+  if (!ContainsUnexpandedPack) {
+    // Also look at captures.
+    for (const auto &C : E->explicit_captures()) {
+      if (!C.capturesVariable() || C.isPackExpansion())
+        continue;
+      auto *Var = C.getCapturedVar();
+      if ((!Var->isInitCapture() && Var->isParameterPack()) ||
+          (Var->isInitCapture() && !Var->isParameterPack() &&
+           cast<VarDecl>(Var)->getInit()->containsUnexpandedParameterPack())) {
+        ContainsUnexpandedPack = true;
+        break;
+      }
+    }
+  }
+  // FIXME: Support other attributes, e.g. by storing corresponding flag inside
+  // Attr (similar to Attr::IsPackExpansion).
+  if (!ContainsUnexpandedPack) {
+    for (auto *A : E->getCallOperator()->specific_attrs<DiagnoseIfAttr>()) {
+      if (A->getCond() && A->getCond()->containsUnexpandedParameterPack()) {
+        ContainsUnexpandedPack = true;
+        break;
+      }
+    }
+  }
+
+  if (ContainsUnexpandedPack)
     D |= ExprDependence::UnexpandedPack;
   return D;
 }

clang/lib/AST/DeclTemplate.cpp

@@ -61,27 +61,43 @@ TemplateParameterList::TemplateParameterList(const ASTContext& C,
 
     bool IsPack = P->isTemplateParameterPack();
     if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
-      if (!IsPack && NTTP->getType()->containsUnexpandedParameterPack())
-        ContainsUnexpandedParameterPack = true;
+      if (!IsPack) {
+        if (NTTP->getType()->containsUnexpandedParameterPack())
+          ContainsUnexpandedParameterPack = true;
+        else if (NTTP->hasDefaultArgument() &&
+                 NTTP->getDefaultArgument()
+                     .getArgument()
+                     .containsUnexpandedParameterPack())
+          ContainsUnexpandedParameterPack = true;
+      }
       if (NTTP->hasPlaceholderTypeConstraint())
         HasConstrainedParameters = true;
     } else if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(P)) {
-      if (!IsPack &&
-          TTP->getTemplateParameters()->containsUnexpandedParameterPack())
-        ContainsUnexpandedParameterPack = true;
-    } else if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(P)) {
-      if (const TypeConstraint *TC = TTP->getTypeConstraint()) {
-        if (TC->getImmediatelyDeclaredConstraint()
-            ->containsUnexpandedParameterPack())
+      if (!IsPack) {
+        if (TTP->getTemplateParameters()->containsUnexpandedParameterPack())
           ContainsUnexpandedParameterPack = true;
+        else if (TTP->hasDefaultArgument() &&
+                 TTP->getDefaultArgument()
+                     .getArgument()
+                     .containsUnexpandedParameterPack())
+          ContainsUnexpandedParameterPack = true;
+      }
+    } else if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(P)) {
+      if (!IsPack && TTP->hasDefaultArgument() &&
+          TTP->getDefaultArgument()
+              .getArgument()
+              .containsUnexpandedParameterPack()) {
+        ContainsUnexpandedParameterPack = true;
+      } else if (const TypeConstraint *TC = TTP->getTypeConstraint();
+                 TC && TC->getImmediatelyDeclaredConstraint()
+                           ->containsUnexpandedParameterPack()) {
+        ContainsUnexpandedParameterPack = true;
       }
       if (TTP->hasTypeConstraint())
         HasConstrainedParameters = true;
     } else {
       llvm_unreachable("unexpected template parameter type");
     }
-    // FIXME: If a default argument contains an unexpanded parameter pack, the
-    // template parameter list does too.
   }
 
   if (HasRequiresClause) {

clang/lib/AST/ExprCXX.cpp

@@ -1254,7 +1254,7 @@ LambdaExpr::LambdaExpr(QualType T, SourceRange IntroducerRange,
                        SourceLocation CaptureDefaultLoc, bool ExplicitParams,
                        bool ExplicitResultType, ArrayRef<Expr *> CaptureInits,
                        SourceLocation ClosingBrace,
-                       bool ContainsUnexpandedParameterPack)
+                       bool BodyContainsUnexpandedParameterPack)
     : Expr(LambdaExprClass, T, VK_PRValue, OK_Ordinary),
       IntroducerRange(IntroducerRange), CaptureDefaultLoc(CaptureDefaultLoc),
       ClosingBrace(ClosingBrace) {
@@ -1276,7 +1276,7 @@ LambdaExpr::LambdaExpr(QualType T, SourceRange IntroducerRange,
   // Copy the body of the lambda.
   *Stored++ = getCallOperator()->getBody();
 
-  setDependence(computeDependence(this, ContainsUnexpandedParameterPack));
+  setDependence(computeDependence(this, BodyContainsUnexpandedParameterPack));
 }
 
 LambdaExpr::LambdaExpr(EmptyShell Empty, unsigned NumCaptures)
@@ -1295,7 +1295,7 @@ LambdaExpr *LambdaExpr::Create(const ASTContext &Context, CXXRecordDecl *Class,
                                bool ExplicitParams, bool ExplicitResultType,
                                ArrayRef<Expr *> CaptureInits,
                                SourceLocation ClosingBrace,
-                               bool ContainsUnexpandedParameterPack) {
+                               bool BodyContainsUnexpandedParameterPack) {
   // Determine the type of the expression (i.e., the type of the
   // function object we're creating).
   QualType T = Context.getTypeDeclType(Class);
@@ -1305,7 +1305,7 @@ LambdaExpr *LambdaExpr::Create(const ASTContext &Context, CXXRecordDecl *Class,
   return new (Mem)
       LambdaExpr(T, IntroducerRange, CaptureDefault, CaptureDefaultLoc,
                  ExplicitParams, ExplicitResultType, CaptureInits, ClosingBrace,
-                 ContainsUnexpandedParameterPack);
+                 BodyContainsUnexpandedParameterPack);
 }
 
 LambdaExpr *LambdaExpr::CreateDeserialized(const ASTContext &C,
@@ -1944,3 +1944,21 @@ CXXParenListInitExpr *CXXParenListInitExpr::CreateEmpty(ASTContext &C,
                          alignof(CXXParenListInitExpr));
   return new (Mem) CXXParenListInitExpr(Empty, NumExprs);
 }
+
+CXXFoldExpr::CXXFoldExpr(QualType T, UnresolvedLookupExpr *Callee,
+                         SourceLocation LParenLoc, Expr *LHS,
+                         BinaryOperatorKind Opcode, SourceLocation EllipsisLoc,
+                         Expr *RHS, SourceLocation RParenLoc,
+                         std::optional<unsigned> NumExpansions)
+    : Expr(CXXFoldExprClass, T, VK_PRValue, OK_Ordinary), LParenLoc(LParenLoc),
+      EllipsisLoc(EllipsisLoc), RParenLoc(RParenLoc),
+      NumExpansions(NumExpansions ? *NumExpansions + 1 : 0), Opcode(Opcode) {
+  // We rely on asserted invariant to distnguish left and right folds.
+  assert(((LHS && LHS->containsUnexpandedParameterPack()) !=
+          (RHS && RHS->containsUnexpandedParameterPack())) &&
+         "Exactly one of LHS or RHS should contain an unexpanded pack");
+  SubExprs[SubExpr::Callee] = Callee;
+  SubExprs[SubExpr::LHS] = LHS;
+  SubExprs[SubExpr::RHS] = RHS;
+  setDependence(computeDependence(this));
+}

clang/lib/Sema/SemaLambda.cpp

@@ -1109,8 +1109,6 @@ void Sema::ActOnLambdaExpressionAfterIntroducer(LambdaIntroducer &Intro,
 
   PushDeclContext(CurScope, Method);
 
-  bool ContainsUnexpandedParameterPack = false;
-
   // Distinct capture names, for diagnostics.
   llvm::DenseMap<IdentifierInfo *, ValueDecl *> CaptureNames;
 
@@ -1312,8 +1310,6 @@ void Sema::ActOnLambdaExpressionAfterIntroducer(LambdaIntroducer &Intro,
 
         // Just ignore the ellipsis.
       }
-    } else if (Var->isParameterPack()) {
-      ContainsUnexpandedParameterPack = true;
     }
 
     if (C->Init.isUsable()) {
@@ -1328,7 +1324,6 @@ void Sema::ActOnLambdaExpressionAfterIntroducer(LambdaIntroducer &Intro,
       LSI->ExplicitCaptureRanges[LSI->Captures.size() - 1] = C->ExplicitRange;
   }
   finishLambdaExplicitCaptures(LSI);
-  LSI->ContainsUnexpandedParameterPack |= ContainsUnexpandedParameterPack;
   PopDeclContext();
 }
 
@@ -1380,8 +1375,6 @@ void Sema::ActOnLambdaClosureParameters(
     AddTemplateParametersToLambdaCallOperator(LSI->CallOperator, LSI->Lambda,
                                               TemplateParams);
     LSI->Lambda->setLambdaIsGeneric(true);
-    LSI->ContainsUnexpandedParameterPack |=
-        TemplateParams->containsUnexpandedParameterPack();
   }
   LSI->AfterParameterList = true;
 }
@@ -2079,7 +2072,7 @@ ExprResult Sema::BuildLambdaExpr(SourceLocation StartLoc, SourceLocation EndLoc,
   bool ExplicitParams;
   bool ExplicitResultType;
   CleanupInfo LambdaCleanup;
-  bool ContainsUnexpandedParameterPack;
+  bool BodyContainsUnexpandedParameterPack;
   bool IsGenericLambda;
   {
     CallOperator = LSI->CallOperator;
@@ -2088,7 +2081,8 @@ ExprResult Sema::BuildLambdaExpr(SourceLocation StartLoc, SourceLocation EndLoc,
     ExplicitParams = LSI->ExplicitParams;
     ExplicitResultType = !LSI->HasImplicitReturnType;
     LambdaCleanup = LSI->Cleanup;
-    ContainsUnexpandedParameterPack = LSI->ContainsUnexpandedParameterPack;
+    BodyContainsUnexpandedParameterPack =
+        LSI->BodyContainsUnexpandedParameterPack;
     IsGenericLambda = Class->isGenericLambda();
 
     CallOperator->setLexicalDeclContext(Class);
@@ -2227,11 +2221,10 @@ ExprResult Sema::BuildLambdaExpr(SourceLocation StartLoc, SourceLocation EndLoc,
 
   Cleanup.mergeFrom(LambdaCleanup);
 
-  LambdaExpr *Lambda = LambdaExpr::Create(Context, Class, IntroducerRange,
-                                          CaptureDefault, CaptureDefaultLoc,
-                                          ExplicitParams, ExplicitResultType,
-                                          CaptureInits, EndLoc,
-                                          ContainsUnexpandedParameterPack);
+  LambdaExpr *Lambda = LambdaExpr::Create(
+      Context, Class, IntroducerRange, CaptureDefault, CaptureDefaultLoc,
+      ExplicitParams, ExplicitResultType, CaptureInits, EndLoc,
+      BodyContainsUnexpandedParameterPack);
   // If the lambda expression's call operator is not explicitly marked constexpr
   // and we are not in a dependent context, analyze the call operator to infer
   // its constexpr-ness, suppressing diagnostics while doing so.

clang/lib/Sema/SemaTemplateVariadic.cpp

@@ -353,7 +353,11 @@ Sema::DiagnoseUnexpandedParameterPacks(SourceLocation Loc,
       }
 
       if (!EnclosingStmtExpr) {
-        LSI->ContainsUnexpandedParameterPack = true;
+        // It is ok to have unexpanded packs in captures, template parameters
+        // and parameters too, but only the body statement does not store this
+        // flag, so we have to propagate it through LamdaScopeInfo.
+        if (LSI->AfterParameterList)
+          LSI->BodyContainsUnexpandedParameterPack = true;
         return false;
       }
     } else {

clang/test/SemaCXX/fold_lambda_with_variadics.cpp

@@ -0,0 +1,78 @@
+// RUN: %clang_cc1 -fsyntax-only -std=c++20 -verify %s
+// expected-no-diagnostics
+struct tuple {
+    int x[3];
+};
+
+template <class F>
+int apply(F f, tuple v) {
+    return f(v.x[0], v.x[1], v.x[2]);
+}
+
+int Cartesian1(auto x, auto y) {
+    return apply([&](auto... xs) {
+        return (apply([xs](auto... ys) {
+            return (ys + ...);
+        }, y) + ...);
+    }, x);
+}
+
+int Cartesian2(auto x, auto y) {
+    return apply([&](auto... xs) {
+        return (apply([zs = xs](auto... ys) {
+            return (ys + ...);
+        }, y) + ...);
+    }, x);
+}
+
+template <int ...> struct Ints{};
+template <int> struct Choose {
+  template<class> struct Templ;
+};
+template <int ...x>
+int Cartesian3(auto y) {
+    return [&]<int ...xs>(Ints<xs...>) {
+        // check in default template arguments for
+        // - type template parameters,
+        (void)(apply([]<class = decltype(xs)>(auto... ys) {
+          return (ys + ...);
+        }, y) + ...);
+        // - template template parameters.
+        (void)(apply([]<template<class> class = Choose<xs>::template Templ>(auto... ys) {
+          return (ys + ...);
+        }, y) + ...);
+        // - non-type template parameters,
+        return (apply([]<int = xs>(auto... ys) {
+            return (ys + ...);
+        }, y) + ...);
+
+    }(Ints<x...>());
+}
+
+template <int ...x>
+int Cartesian4(auto y) {
+    return [&]<int ...xs>(Ints<xs...>) {
+        return (apply([]<decltype(xs) xx = 1>(auto... ys) {
+            return (ys + ...);
+        }, y) + ...);
+    }(Ints<x...>());
+}
+
+int Cartesian5(auto x, auto y) {
+    return apply([&](auto... xs) {
+        return (apply([](auto... ys) __attribute__((diagnose_if(!__is_same(decltype(xs), int), "message", "error"))) {
+            return (ys + ...);
+        }, y) + ...);
+    }, x);
+}
+
+
+int main() {
+    auto x = tuple({1, 2, 3});
+    auto y = tuple({4, 5, 6});
+    Cartesian1(x, y);
+    Cartesian2(x, y);
+    Cartesian3<1,2,3>(y);
+    Cartesian4<1,2,3>(y);
+    Cartesian5(x, y);
+}