Generalize the handling of pack cleanups in reabstraction thunks

The result-reabstraction code doesn't need to handle cleanups properly
during the planning phase because of course we don't have any values
yet.  That is not true of argument reabstraction, so we need to make
sure that the recursive emitters can produce values with cleanups
so that we can collect and forward those cleanups correctly when
emitting the call.

As part of this, I've changed the code so that it should forward
outer addresses to inner address more consistently; it wouldn't
have done this before if we were breaking apart or assembling
a pack.  I'm not sure I can directly test this without figuring
out a way to get SILGen to reabstract both sides of a function,
though.

I'm not sure this is really doing borrowed vs owned arguments
correctly, if e.g. we need to rebstract one component of a tuple
that's otherwise borrowed.

Author: rjmccall

lib/SILGen/SILGenFunction.h

@@ -2515,6 +2515,13 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                                              CanPackType formalPackType,
                                              unsigned componentIndex);
 
+  /// Enter a cleanup to destroy the preceding components of a pack,
+  /// leading up to (but not including) a particular component index.
+  CleanupHandle
+  enterDestroyPrecedingPackComponentsCleanup(SILValue addr,
+                                             CanPackType formalPackType,
+                                             unsigned componentIndex);
+
   /// Enter a cleanup to destroy the preceding values in a pack-expansion
   /// component of a tuple.
   ///
@@ -2766,7 +2773,8 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   void emitDestroyPack(SILLocation loc,
                        SILValue packAddr,
                        CanPackType formalPackType,
-                       unsigned firstComponentIndex = 0);
+                       unsigned beginIndex,
+                       unsigned endIndex);
 
   /// Emit instructions to destroy a suffix of a tuple value.
   ///

lib/SILGen/SILGenPack.cpp

@@ -44,24 +44,26 @@ class DeallocPackCleanup : public Cleanup {
 class DestroyPackCleanup : public Cleanup {
   SILValue Addr;
   CanPackType FormalPackType;
-  unsigned FirstComponentIndex;
+  unsigned BeginIndex, EndIndex;
 public:
   DestroyPackCleanup(SILValue addr, CanPackType formalPackType,
-                     unsigned firstComponentIndex = 0)
+                     unsigned beginIndex, unsigned endIndex)
     : Addr(addr), FormalPackType(formalPackType),
-      FirstComponentIndex(firstComponentIndex) {}
+      BeginIndex(beginIndex), EndIndex(endIndex) {}
 
   void emit(SILGenFunction &SGF, CleanupLocation l,
             ForUnwind_t forUnwind) override {
-    SGF.emitDestroyPack(l, Addr, FormalPackType, FirstComponentIndex);
+    SGF.emitDestroyPack(l, Addr, FormalPackType, BeginIndex, EndIndex);
   }
 
   void dump(SILGenFunction &) const override {
 #ifndef NDEBUG
     llvm::errs() << "DestroyPackCleanup\n"
-                 << "State: " << getState() << "\n"
-                 << "Addr: " << Addr << "FormalPackType: " << FormalPackType
-                 << "FirstComponentIndex:" << FirstComponentIndex << "\n";
+                 << "State:" << getState() << "\n"
+                 << "Addr:" << Addr << "\n"
+                 << "FormalPackType:" << FormalPackType << "\n"
+                 << "BeginIndex:" << BeginIndex << "\n"
+                 << "EndIndex:" << EndIndex << "\n";
 #endif
   }
 };
@@ -295,19 +297,29 @@ CleanupHandle SILGenFunction::enterDeallocPackCleanup(SILValue temp) {
 
 CleanupHandle SILGenFunction::enterDestroyPackCleanup(SILValue addr,
                                                    CanPackType formalPackType) {
-  Cleanups.pushCleanup<DestroyPackCleanup>(addr, formalPackType);
+  Cleanups.pushCleanup<DestroyPackCleanup>(addr, formalPackType,
+                                           0, formalPackType->getNumElements());
   return Cleanups.getTopCleanup();
 }
 
 CleanupHandle
-SILGenFunction::enterDestroyRemainingPackComponentsCleanup(SILValue addr,
+SILGenFunction::enterDestroyPrecedingPackComponentsCleanup(SILValue addr,
                                                    CanPackType formalPackType,
                                                    unsigned componentIndex) {
   Cleanups.pushCleanup<DestroyPackCleanup>(addr, formalPackType,
-                                           componentIndex);
+                                           0, componentIndex);
   return Cleanups.getTopCleanup();
 }
 
+CleanupHandle
+SILGenFunction::enterDestroyRemainingPackComponentsCleanup(SILValue addr,
+                                                   CanPackType formalPackType,
+                                                   unsigned componentIndex) {
+  Cleanups.pushCleanup<DestroyPackCleanup>(addr, formalPackType,
+                                           componentIndex,
+                                           formalPackType->getNumElements());
+  return Cleanups.getTopCleanup();
+}
 
 CleanupHandle
 SILGenFunction::enterPartialDestroyPackCleanup(SILValue addr,
@@ -369,12 +381,15 @@ SILGenFunction::enterDestroyRemainingTupleElementsCleanup(SILValue addr,
 
 void SILGenFunction::emitDestroyPack(SILLocation loc, SILValue packAddr,
                                      CanPackType formalPackType,
-                                     unsigned firstComponentIndex) {
+                                     unsigned beginIndex,
+                                     unsigned endIndex) {
   auto packTy = packAddr->getType().castTo<SILPackType>();
 
+  assert(beginIndex <= endIndex);
+  assert(endIndex <= packTy->getNumElements());
+
   // Destroy each of the elements of the pack.
-  for (auto componentIndex :
-         range(firstComponentIndex, packTy->getNumElements())) {
+  for (auto componentIndex : range(beginIndex, endIndex)) {
     auto eltTy = packTy->getSILElementType(componentIndex);
 
     // We can skip this if the whole thing is trivial.