Implement parameter arity reabstraction.

This is largely a matter of changing the main loop over subst
params in TranslateArguments to use the generators I added,
then plugging back into the general reabstraction infrastructure.

Because we don't have pack coroutines, we're kind of stuck in
the code generation for pack reabstraction: we have to write
+1 r-values into a temporary tuple and then write those tuple
element addresses into the output pack.  It's not great.  We
also have lifetime problems with things like non-escaping
closures --- we have that problem outside of reabstraction
thunks, too.

Other than that glaring problem, I'm feeling relatively good
about the code here.  It's missing some peepholes, but it should
work.  But that that's not to say that arity reabstraction works
in general; my attempts to test it have been exposing some
problems elsewhere, and in particular the closure case crashes,
which is really bad.  But this gets a few more things working,
and this PR is quite large already.

Author: rjmccall

lib/SILGen/Cleanup.cpp

@@ -444,3 +444,58 @@ CleanupCloner::cloneForTuplePackExpansionComponent(SILValue tupleAddr,
                                                  /*start at */ SILValue());
   return ManagedValue(tupleAddr, cleanup);
 }
+
+ManagedValue
+CleanupCloner::cloneForPackPackExpansionComponent(SILValue packAddr,
+                                                  CanPackType formalPackType,
+                                                  unsigned componentIndex) const {
+  if (isLValue) {
+    return ManagedValue::forLValue(packAddr);
+  }
+
+  if (!hasCleanup) {
+    return ManagedValue::forUnmanaged(packAddr);
+  }
+
+  assert(!writebackBuffer.has_value());
+  auto expansionTy = packAddr->getType().getPackElementType(componentIndex);
+  if (expansionTy.getPackExpansionPatternType().isTrivial(SGF.F))
+    return ManagedValue::forUnmanaged(packAddr);
+
+  auto cleanup =
+    SGF.enterPartialDestroyRemainingPackCleanup(packAddr, formalPackType,
+                                                componentIndex,
+                                                /*start at */ SILValue());
+  return ManagedValue(packAddr, cleanup);
+}
+
+ManagedValue
+CleanupCloner::cloneForRemainingPackComponents(SILValue packAddr,
+                                               CanPackType formalPackType,
+                                               unsigned firstComponentIndex) const {
+  if (isLValue) {
+    return ManagedValue::forLValue(packAddr);
+  }
+
+  if (!hasCleanup) {
+    return ManagedValue::forUnmanaged(packAddr);
+  }
+
+  assert(!writebackBuffer.has_value());
+  bool isTrivial = true;
+  auto packTy = packAddr->getType().castTo<SILPackType>();
+  for (auto eltTy : packTy->getElementTypes().slice(firstComponentIndex)) {
+    if (!SILType::getPrimitiveObjectType(eltTy).isTrivial(SGF.F)) {
+      isTrivial = false;
+      break;
+    }
+  }
+
+  if (isTrivial)
+    return ManagedValue::forUnmanaged(packAddr);
+
+  auto cleanup =
+    SGF.enterDestroyRemainingPackComponentsCleanup(packAddr, formalPackType,
+                                                   firstComponentIndex);
+  return ManagedValue(packAddr, cleanup);
+}

lib/SILGen/Cleanup.h

@@ -342,6 +342,14 @@ class CleanupCloner {
                                                    CanPackType inducedPackType,
                                                    unsigned componentIndex) const;
 
+  ManagedValue cloneForPackPackExpansionComponent(SILValue packAddr,
+                                                  CanPackType formalPackType,
+                                                  unsigned componentIndex) const;
+
+  ManagedValue cloneForRemainingPackComponents(SILValue packAddr,
+                                               CanPackType formalPackType,
+                                               unsigned firstComponentIndex) const;
+
   static void
   getClonersForRValue(SILGenFunction &SGF, const RValue &rvalue,
                       SmallVectorImpl<CleanupCloner> &resultingCloners);

lib/SILGen/SILGenFunction.h

@@ -2427,6 +2427,28 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                                                unsigned componentIndex,
                                                SILValue limitWithinComponent);
 
+  /// Enter a cleanup to destroy the following values in a
+  /// pack-expansion component of a pack.  Note that this only destroys
+  /// the values *in that specific component*, not all the other values
+  /// in the pack.
+  ///
+  /// \param currentIndexWithinComponent - the current index in the
+  ///   pack expansion component; any elements in the component that
+  ///   *follow* this component will be destroyed. If nil, all the
+  ///   elements in the component will be destroyed
+  CleanupHandle
+  enterPartialDestroyRemainingPackCleanup(SILValue addr,
+                                          CanPackType formalPackType,
+                                          unsigned componentIndex,
+                                          SILValue currentIndexWithinComponent);
+
+  /// Enter a cleanup to destroy all of the components in a pack starting
+  /// at a particular component index.
+  CleanupHandle
+  enterDestroyRemainingPackComponentsCleanup(SILValue addr,
+                                             CanPackType formalPackType,
+                                             unsigned componentIndex);
+
   /// Enter a cleanup to destroy the preceding values in a pack-expansion
   /// component of a tuple.
   ///
@@ -2439,7 +2461,9 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                                                 SILValue limitWithinComponent);
 
   /// Enter a cleanup to destroy the following values in a
-  /// pack-expansion component of a tuple
+  /// pack-expansion component of a tuple.  Note that this only destroys
+  /// the values *in that specific component*, not all the other values
+  /// in the tuple.
   ///
   /// \param currentIndexWithinComponent - the current index in the
   ///   pack expansion component; any elements in the component that
@@ -2560,6 +2584,10 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   std::pair<GenericEnvironment*, SILType>
   createOpenedElementValueEnvironment(SILType packExpansionTy);
 
+  GenericEnvironment *
+  createOpenedElementValueEnvironment(ArrayRef<SILType> packExpansionTys,
+                                      ArrayRef<SILType*> eltTys);
+
   /// Emit a dynamic loop over a single pack-expansion component of a pack.
   ///
   /// \param formalPackType - a pack type with the right shape for the
@@ -2610,6 +2638,26 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                                                 SILValue packExpansionIndex,
                                                 SILValue packIndex)> emitBody);
 
+  /// Emit a transform on each element of a pack-expansion component
+  /// of a pack, write the result into a pack-expansion component of
+  /// another pack.
+  ///
+  /// \param inputPackAddr - the address of the input pack; the cleanup
+  ///   on this pack should be a cleanup for just the pack component,
+  ///   not for the entire pack
+  ManagedValue emitPackTransform(SILLocation loc,
+                                 ManagedValue inputPackAddr,
+                                 CanPackType inputFormalPackType,
+                                 unsigned inputComponentIndex,
+                                 SILValue outputPackAddr,
+                                 CanPackType outputFormalPackType,
+                                 unsigned outputComponentIndex,
+                                 bool isSimpleProjection,
+                                 bool outputIsPlusOne,
+              llvm::function_ref<ManagedValue(ManagedValue input,
+                                              SILType outputTy,
+                                              SGFContext context)> emitBody);
+
   /// Emit a loop which destroys a prefix of a pack expansion component
   /// of a pack value.
   ///
@@ -2634,7 +2682,8 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   ///   overall pack value
   void emitDestroyPack(SILLocation loc,
                        SILValue packAddr,
-                       CanPackType formalPackType);
+                       CanPackType formalPackType,
+                       unsigned firstComponentIndex = 0);
 
   /// Emit a loop which destroys a prefix of a pack expansion component
   /// of a tuple value.
@@ -2669,6 +2718,23 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                                         CanPackType inducedPackType,
                                         unsigned componentIndex,
                                         SILValue currentIndexWithinComponent);
+
+  /// Emit a loop which destroys a suffix of a pack expansion component
+  /// of a pack value.
+  ///
+  /// \param packAddr - the address of the overall pack value
+  /// \param formalPackType - a pack type with the same shape as the
+  ///   component types of the overall pack value
+  /// \param componentIndex - the index of the pack expansion component
+  ///   within the pack
+  /// \param currentIndexWithinComponent - the current index in the
+  ///   pack expansion component; all elements *following* this index will
+  ///   be destroyed
+  void emitPartialDestroyRemainingPack(SILLocation loc,
+                                       SILValue packAddr,
+                                       CanPackType formalPackType,
+                                       unsigned componentIndex,
+                                       SILValue currentIndexWithinComponent);
 };