Handle vanishing and variadic tuple results in reabstraction thunks.

Fixes rdar://110391963

Author: rjmccall

lib/SILGen/Cleanup.cpp

@@ -499,3 +499,35 @@ CleanupCloner::cloneForRemainingPackComponents(SILValue packAddr,
                                                    firstComponentIndex);
   return ManagedValue(packAddr, cleanup);
 }
+
+ManagedValue
+CleanupCloner::cloneForRemainingTupleComponents(SILValue tupleAddr,
+                                                CanPackType inducedPackType,
+                                                unsigned firstComponentIndex) const {
+  if (isLValue) {
+    return ManagedValue::forLValue(tupleAddr);
+  }
+
+  if (!hasCleanup) {
+    return ManagedValue::forUnmanaged(tupleAddr);
+  }
+
+  assert(!writebackBuffer.has_value());
+  bool isTrivial = true;
+  auto tupleTy = tupleAddr->getType().castTo<TupleType>();
+  for (auto eltTy : tupleTy.getElementTypes().slice(firstComponentIndex)) {
+    if (!SILType::getPrimitiveObjectType(eltTy).isTrivial(SGF.F)) {
+      isTrivial = false;
+      break;
+    }
+  }
+
+  if (isTrivial)
+    return ManagedValue::forUnmanaged(tupleAddr);
+
+  auto cleanup =
+    SGF.enterDestroyRemainingTupleElementsCleanup(tupleAddr,
+                                                  inducedPackType,
+                                                  firstComponentIndex);
+  return ManagedValue(tupleAddr, cleanup);
+}

lib/SILGen/Cleanup.h

@@ -349,6 +349,9 @@ class CleanupCloner {
   ManagedValue cloneForRemainingPackComponents(SILValue packAddr,
                                                CanPackType formalPackType,
                                                unsigned firstComponentIndex) const;
+  ManagedValue cloneForRemainingTupleComponents(SILValue tupleAddr,
+                                                CanPackType inducedPackType,
+                                                unsigned firstComponentIndex) const;
 
   static void
   getClonersForRValue(SILGenFunction &SGF, const RValue &rvalue,

lib/SILGen/SILGenFunction.cpp

@@ -990,7 +990,7 @@ SILGenFunction::emitClosureValue(SILLocation loc, SILDeclRef constant,
 
   // Get the lowered AST types:
   //  - the original type
-  auto origFormalType = AbstractionPattern(constantInfo.LoweredType);
+  auto origFormalType = AbstractionPattern(subs, constantInfo.LoweredType);
 
   // - the substituted type
   auto substFormalType = expectedType;

lib/SILGen/SILGenFunction.h

@@ -2494,6 +2494,13 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                                            unsigned componentIndex,
                                            SILValue currentIndexWithinComponent);
 
+  /// Enter a cleanup to destroy all of the components in a tuple starting
+  /// at a particular component index.
+  CleanupHandle
+  enterDestroyRemainingTupleElementsCleanup(SILValue addr,
+                                            CanPackType inducedPackType,
+                                            unsigned componentIndex);
+
   /// Copy the elements of a pack, which must consist of a single pack expansion,
   /// into a tuple value having the same pack expansion and its sole element type.
   void copyPackElementsToTuple(SILLocation loc, SILValue tupleAddr, SILValue pack,
@@ -2714,6 +2721,19 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                        CanPackType formalPackType,
                        unsigned firstComponentIndex = 0);
 
+  /// Emit instructions to destroy a suffix of a tuple value.
+  ///
+  /// \param tupleAddr - the address of the overall tuple value
+  /// \param inducedPackType - a pack type with the same shape as the
+  ///   element types of the overall tuple value; can be null if the
+  ///   tuple type doesn't contain pack expansions
+  /// \param componentIndex - the index of the first component to
+  ///   destroy in the tuple
+  void emitDestroyRemainingTupleElements(SILLocation loc,
+                                         SILValue tupleAddr,
+                                         CanPackType inducedPackType,
+                                         unsigned componentIndex);
+
   /// Emit a loop which destroys a prefix of a pack expansion component
   /// of a tuple value.
   ///

lib/SILGen/SILGenPack.cpp

@@ -207,6 +207,36 @@ class PartialDestroyRemainingTupleCleanup : public Cleanup {
   }
 };
 
+/// Cleanup to destroy the remaining elements in a tuple following a
+/// particular value.
+class DestroyRemainingTupleElementsCleanup : public Cleanup {
+  SILValue Addr;
+  unsigned ComponentIndex;
+  CanPackType InducedPackType;
+public:
+  DestroyRemainingTupleElementsCleanup(SILValue tupleAddr,
+                                       CanPackType inducedPackType,
+                                       unsigned componentIndex)
+    : Addr(tupleAddr), ComponentIndex(componentIndex),
+      InducedPackType(inducedPackType) {}
+
+  void emit(SILGenFunction &SGF, CleanupLocation l,
+            ForUnwind_t forUnwind) override {
+    SGF.emitDestroyRemainingTupleElements(l, Addr, InducedPackType,
+                                          ComponentIndex);
+  }
+
+  void dump(SILGenFunction &) const override {
+#ifndef NDEBUG
+    llvm::errs() << "DestroyRemainingTupleElementsCleanup\n"
+                 << "State:" << getState() << "\n"
+                 << "Addr:" << Addr << "\n"
+                 << "InducedPackType:" << InducedPackType << "\n"
+                 << "ComponentIndex:" << ComponentIndex << "\n";
+#endif
+  }
+};
+
 /// An ASTWalker to emit tuple values in `MaterializePackExpr` nodes.
 ///
 /// Materialized packs are emitted inside a pack expansion context before
@@ -322,6 +352,17 @@ SILGenFunction::enterPartialDestroyRemainingTupleCleanup(SILValue addr,
   return Cleanups.getTopCleanup();
 }
 
+CleanupHandle
+SILGenFunction::enterDestroyRemainingTupleElementsCleanup(SILValue addr,
+                                                   CanPackType formalPackType,
+                                                   unsigned componentIndex) {
+  Cleanups.pushCleanup<DestroyRemainingTupleElementsCleanup>(addr,
+                                            formalPackType,
+                                            componentIndex);
+  return Cleanups.getTopCleanup();
+}
+
+
 void SILGenFunction::emitDestroyPack(SILLocation loc, SILValue packAddr,
                                      CanPackType formalPackType,
                                      unsigned firstComponentIndex) {
@@ -521,6 +562,44 @@ void SILGenFunction::emitPartialDestroyRemainingTuple(SILLocation loc,
   });
 }
 
+void SILGenFunction::emitDestroyRemainingTupleElements(
+       SILLocation loc, SILValue tupleAddr,
+       CanPackType inducedPackType, unsigned firstComponentIndex) {
+  auto tupleTy = tupleAddr->getType().castTo<TupleType>();
+  bool containsExpansions = tupleTy->containsPackExpansionType();
+  assert(!containsExpansions || inducedPackType);
+
+  // Destroy each of the elements of the pack.
+  for (auto componentIndex :
+         range(firstComponentIndex, tupleTy->getNumElements())) {
+    auto eltTy = tupleAddr->getType().getTupleElementType(componentIndex);
+
+    // We can skip this if the whole thing is trivial.
+    auto &eltTL = getTypeLowering(eltTy);
+    if (eltTL.isTrivial()) continue;
+
+    // If it's an expansion component, emit a "partial"-destroy loop.
+    if (auto expansion = eltTy.getAs<PackExpansionType>()) {
+      emitPartialDestroyRemainingTuple(loc, tupleAddr, inducedPackType,
+                                       componentIndex, /*limit*/ nullptr);
+
+    // If it's a scalar component, project and destroy it.
+    } else {
+      SILValue eltAddr;
+      if (containsExpansions) {
+        auto packIndex =
+          B.createScalarPackIndex(loc, componentIndex, inducedPackType);
+        eltAddr =
+          B.createTuplePackElementAddr(loc, packIndex, tupleAddr, eltTy);
+      } else {
+        eltAddr =
+          B.createTupleElementAddr(loc, tupleAddr, componentIndex, eltTy);
+      }
+      B.createDestroyAddr(loc, eltAddr);
+    }
+  }
+}
+
 void SILGenFunction::copyPackElementsToTuple(SILLocation loc,
                                              SILValue tupleAddr,
                                              SILValue pack,