[SemaCXX] Fix bug where unexpanded lambda captures where assumed to be expanded

[MitalAshok]

Summary

When instantiating the closure type of a lambda in a template, sometimes a capture which is a pack is not expanded. When that happens, it is replaced with a pack of size 1 containing that pack. Before it is replaced by another instantiation where the pack is expanded, the size is reported to be 1 instead of unknown.

This checks if this is happening (i.e., trying to replace a pack declaration with a single declaration that is itself a pack), and not expanding it out in that case.

Fixes https://github.com/llvm/llvm-project/issues/63677

[cor3ntin]

This looks reasonable to me.
But can you add an entry into clang/docs/ReleaseNotes.rst?

Thanks!

[shafik]

clang/test/SemaCXX/lambda-pack-expansion.cpp

36

Can we also have an example similar to the bug report where we have multiple arguments.

[shafik]

clang/lib/Sema/TreeTransform.h

13323

Based on the changes is this comment still accurate?

[MitalAshok]

Added entry to changelog and the test from the bug report

[MitalAshok]

clang/lib/Sema/TreeTransform.h

13323

Yes, the code was just changed so it's more clear that the result either has N distinct arguments for a pack of size N or just 1 argument with a (possible dependent) pack type

[cor3ntin]

LGTM, thanks!

[cor3ntin]

@MitalAshok Are you still working on this? Do you need further help on this patch? You have commit access, correct?

clang/docs/ReleaseNotes.rst

 - Merge lambdas in require expressions in standard C++ modules.
   (`#63544 <https://github.com/llvm/llvm-project/issues/63544>`_)
 
 - Fix location of default member initialization in parenthesized aggregate
   initialization.
   (`#63903 <https://github.com/llvm/llvm-project/issues/63903>`_)
 - Fix constraint checking of non-generic lambdas.
   (`#63181 <https://github.com/llvm/llvm-project/issues/63181>`_)
+- Fix init-capture packs having a size of one before being instantiated
+  (`#63677 <https://github.com/llvm/llvm-project/issues/63677>`_)
 
 Bug Fixes to AST Handling
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 - Preserve ``namespace`` definitions that follow malformed declarations.
 
 Miscellaneous Bug Fixes
 ^^^^^^^^^^^^^^^^^^^^^^^

clang/lib/Sema/SemaTemplateInstantiate.cpp

public:
     /// this declaration.
     Decl *TransformDecl(SourceLocation Loc, Decl *D);
 
     void transformAttrs(Decl *Old, Decl *New) {
       SemaRef.InstantiateAttrs(TemplateArgs, Old, New);
     }
 
     void transformedLocalDecl(Decl *Old, ArrayRef<Decl *> NewDecls) {
-      if (Old->isParameterPack()) {
+      if (Old->isParameterPack() &&
+          (NewDecls.size() != 1 || !NewDecls.front()->isParameterPack())) {
         SemaRef.CurrentInstantiationScope->MakeInstantiatedLocalArgPack(Old);
         for (auto *New : NewDecls)
           SemaRef.CurrentInstantiationScope->InstantiatedLocalPackArg(
               Old, cast<VarDecl>(New));
         return;
       }
 
       assert(NewDecls.size() == 1 &&

clang/lib/Sema/TreeTransform.h

auto SubstInitCapture = [&](SourceLocation EllipsisLoc,
               EllipsisLoc, NumExpansions, OldVD->getIdentifier(),
               cast<VarDecl>(C->getCapturedVar())->getInitStyle() !=
                   VarDecl::CInit,
               NewExprInit);
       Result.Expansions.push_back(
           InitCaptureInfoTy(NewExprInit, NewInitCaptureType));
     };
 
     // If this is an init-capture pack, consider expanding the pack now.
     if (OldVD->isParameterPack()) {
       PackExpansionTypeLoc ExpansionTL = OldVD->getTypeSourceInfo()
                                              ->getTypeLoc()
                                              .castAs<PackExpansionTypeLoc>();
       SmallVector<UnexpandedParameterPack, 2> Unexpanded;
       SemaRef.collectUnexpandedParameterPacks(OldVD->getInit(), Unexpanded);
 
       // Determine whether the set of unexpanded parameter packs can and should
       // be expanded.
       bool Expand = true;
       bool RetainExpansion = false;
       std::optional<unsigned> OrigNumExpansions =
           ExpansionTL.getTypePtr()->getNumExpansions();
       std::optional<unsigned> NumExpansions = OrigNumExpansions;
       if (getDerived().TryExpandParameterPacks(
               ExpansionTL.getEllipsisLoc(),
               OldVD->getInit()->getSourceRange(), Unexpanded, Expand,
               RetainExpansion, NumExpansions))
         return ExprError();
+      assert(!RetainExpansion && "Should not need to retain expansion after a "
+                                 "capture since it cannot be extended");
       if (Expand) {
         for (unsigned I = 0; I != *NumExpansions; ++I) {
           Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
           SubstInitCapture(SourceLocation(), std::nullopt);
         }
-      }
-      if (!Expand || RetainExpansion) {
-        ForgetPartiallySubstitutedPackRAII Forget(getDerived());
+      } else {
         SubstInitCapture(ExpansionTL.getEllipsisLoc(), NumExpansions);
         Result.EllipsisLoc = ExpansionTL.getEllipsisLoc();
       }
     } else {
       SubstInitCapture(SourceLocation(), std::nullopt);
     }
   }
 

clang/test/SemaCXX/lambda-pack-expansion.cpp

 }
 
 void foo() {
   X x;
   take_by_copy(x); // expected-note {{in instantiation of function template specialization}}
   take_by_ref(x);
 }
 }
+
+namespace GH63677 {
+
+template<typename>
+void f() {
+  []<typename... Ts>() -> void {
+    [...us = Ts{}]{
+      (Ts(us), ...);
+    };
+  }.template operator()<int, int>();
+}
+
+template void f<int>();
+
+template <class>
+inline constexpr auto fun =
+  []<class... Ts>(Ts... ts) {
+    return [... us = (Ts&&) ts]<class Fun>(Fun&& fn) mutable {
+      return static_cast<Fun&&>(fn)(static_cast<Ts&&>(us)...);
+    };
+  };
+
+void f() {
+  [[maybe_unused]] auto s = fun<int>(1, 2, 3, 4);
+}
+
+}