[NFC] Allow the pack input value to be "written back" to the generator

This will be necessary in order to adopt this in TranslateArguments.

Author: rjmccall

lib/SILGen/SILGenPoly.cpp

@@ -905,12 +905,12 @@ class OuterPackArgGenerator {
 
   OuterPackArgGenerator(Expander &expander) : TheExpander(expander) {}
 
-  bool isFinished() const { llvm_unreachable("don't call this"); }
-  void finish() { llvm_unreachable("don't call this"); }
-  void advance() { llvm_unreachable("don't call this"); }
-  reference claimNext() const {
+  reference claimNext() {
     return TheExpander.claimNextOuterPackArg();
   }
+  void finishCurrent(ManagedValue packAddr) {
+    TheExpander.finishCurrentOuterPackArg(packAddr);
+  }
 };
 
 /// A CRTP helper class for classes that supervise a translation between
@@ -2669,19 +2669,13 @@ class ResultPlanner : public ExpanderBase<ResultPlanner> {
   public:
     InnerPackResultGenerator(ResultPlanner &planner) : planner(planner) {}
 
-    bool isFinished() const {
-      return planner.AllInnerResults.empty();
-    }
     ManagedValue claimNext() {
       SILResultInfo resultInfo = planner.claimNextInnerResult();
       return ManagedValue::forLValue(
         planner.addInnerIndirectPackResultTemporary(resultInfo));
     }
-    void advance() {
-      llvm_unreachable("should always be claimed from");
-    }
-    void finish() {
-      llvm_unreachable("should not be finished directly");
+    void finishCurrent(ManagedValue packAddr) {
+      // ignore this
     }
   };
 
@@ -2883,6 +2877,9 @@ class ResultPlanner : public ExpanderBase<ResultPlanner> {
 
     return OuterArgs.claimNext();
   }
+  void finishCurrentOuterPackArg(ManagedValue packAddr) {
+    // ignore; all of the cleanup changes should be irrelevant
+  }
 
   /// Create a temporary address suitable for passing to the given inner
   /// indirect result and add it as an inner indirect result.
@@ -2906,7 +2903,7 @@ class ResultPlanner : public ExpanderBase<ResultPlanner> {
     return temporary;
   }
 
-  SimpleGeneratorRef<ManagedValue> getInnerPackGenerator() {
+  PackGeneratorRef getInnerPackGenerator() {
     return InnerPacks;
   }
 
@@ -3163,7 +3160,7 @@ void ExpanderBase<Impl>::expandVanishingTuple(AbstractionPattern origType,
 
   bool foundSurvivor = false;
 
-  auto packInputs = [&]() -> SimpleGeneratorRef<ManagedValue> {
+  auto packInputs = [&]() -> PackGeneratorRef {
     if (forInner) {
       return asImpl().getInnerPackGenerator();
     } else {

lib/SILGen/TupleGenerators.h

@@ -27,6 +27,43 @@
 namespace swift {
 namespace Lowering {
 
+/// A reference to a generator suitable for handling pack inputs.
+/// Has the same basic liveness characteristics as SimpleGeneratorRef.
+class PackGeneratorRef {
+  struct VTable {
+    ManagedValue (*claimNext)(void *impl);
+    void (*finishCurrent)(void *impl, ManagedValue packAddr);
+  };
+
+  template <class Impl>
+  struct VTableImpl {
+    static constexpr VTable vtable = {
+      [](void *impl) {
+        return static_cast<Impl*>(impl)->claimNext();
+      },
+      [](void *impl, ManagedValue packAddr) {
+        static_cast<Impl*>(impl)->finishCurrent(packAddr);
+      }
+    };
+  };
+
+  void *pointer;
+  const VTable *vtable;
+public:
+  template <class G>
+  PackGeneratorRef(G &generator,
+    std::enable_if_t<!std::is_same_v<std::remove_const_t<G>, PackGeneratorRef>,
+                     bool> = false)
+    : pointer(&generator), vtable(&VTableImpl<G>::vtable) {}
+
+  ManagedValue claimNext() {
+    return vtable->claimNext(pointer);
+  }
+  void finishCurrent(ManagedValue packAddr) {
+    vtable->finishCurrent(pointer, packAddr);
+  }
+};
+
 /// A generator for destructuring a tuple type that is recursively
 /// expanded in some sequence.  In SIL, this sort of expansion
 /// happens in both function parameters and function results.
@@ -48,7 +85,7 @@ namespace Lowering {
 /// reaches them.
 class ExpandedTupleInputGenerator {
   const ASTContext &ctx;
-  SimpleGeneratorRef<ManagedValue> packInputs;
+  PackGeneratorRef packInputs;
   TupleElementGenerator origElt;
 
   /// If origElt.isPackExpansion(), this is the pack currently
@@ -82,10 +119,22 @@ class ExpandedTupleInputGenerator {
       if (substEltIndex != origElt.getSubstTypes().size())
         return;
 
-      // Otherwise, advance, and ready the next orig element if we
-      // didn't finish.
+      // Otherwise, we need to advance and ready the next orig element.
+
+      // If the current orig element is a pack expansion, tell the
+      // pack generator about the completed pack value.
+      if (origElt.isOrigPackExpansion()) {
+        assert(packValue.isValid());
+        packInputs.finishCurrent(packValue);
+      }
+
+      // Advance to the next orig element.  If we're out of elements,
+      // we're done.
       origElt.advance();
       if (origElt.isFinished()) return;
+
+      // Ready the next orig element, which may include generating a pack
+      // value.
       readyOrigElement();
     }
   }
@@ -110,12 +159,14 @@ class ExpandedTupleInputGenerator {
 
   void updatePackValue(ManagedValue newPackValue) {
     assert(isOrigPackExpansion());
+    assert(packValue.isValid());
+    assert(newPackValue.isValid());
     packValue = newPackValue;
   }
 
 public:
   ExpandedTupleInputGenerator(const ASTContext &ctx,
-                              SimpleGeneratorRef<ManagedValue> inputs,
+                              PackGeneratorRef inputs,
                               AbstractionPattern origTupleType,
                               CanType substType)
     : ctx(ctx), packInputs(inputs), origElt(origTupleType, substType) {