Merge pull request #65295 from rjmccall/vanishing-tuple-results

Handle vanishing tuples when emitting a result plan into an initalization

Author: rjmccall

lib/SILGen/ResultPlan.cpp

@@ -430,7 +430,7 @@ class PackExpansionResultPlan : public ResultPlan {
 public:
   PackExpansionResultPlan(ResultPlanBuilder &builder,
                           SILValue packAddr,
-                          Optional<MutableArrayRef<InitializationPtr>> inits,
+                          Optional<ArrayRef<Initialization*>> inits,
                           AbstractionPattern origExpansionType,
                           CanTupleEltTypeArrayRef substEltTypes)
       : PackAddr(packAddr) {
@@ -443,7 +443,7 @@ class PackExpansionResultPlan : public ResultPlan {
 
     ComponentPlans.reserve(substEltTypes.size());
     for (auto i : indices(substEltTypes)) {
-      Initialization *init = inits ? (*inits)[i].get() : nullptr;
+      Initialization *init = inits ? (*inits)[i] : nullptr;
       CanType substEltType = substEltTypes[i];
 
       if (isa<PackExpansionType>(substEltType)) {
@@ -635,33 +635,49 @@ class TupleRValueResultPlan final : public ResultPlan {
 class TupleInitializationResultPlan final : public ResultPlan {
   Initialization *tupleInit;
   SmallVector<InitializationPtr, 4> eltInitsBuffer;
-  MutableArrayRef<InitializationPtr> eltInits;
   SmallVector<ResultPlanPtr, 4> eltPlans;
+  bool origTupleVanishes;
 
 public:
   TupleInitializationResultPlan(ResultPlanBuilder &builder,
                                 Initialization *tupleInit,
                                 AbstractionPattern origType,
-                                CanType substType)
-      : tupleInit(tupleInit) {
+                                CanType substType,
+                                bool origTupleVanishes)
+      : tupleInit(tupleInit), origTupleVanishes(origTupleVanishes) {
+
     // Get the sub-initializations.
-    eltInits = tupleInit->splitIntoTupleElements(builder.SGF, builder.loc,
-                                                 substType, eltInitsBuffer);
+    SmallVector<Initialization*, 4> eltInits;
+    if (origTupleVanishes) {
+      eltInits.push_back(tupleInit);
+    } else {
+      MutableArrayRef<InitializationPtr> ownedEltInits
+        = tupleInit->splitIntoTupleElements(builder.SGF, builder.loc,
+                                            substType, eltInitsBuffer);
+
+      // The ownership of these inits is maintained in eltInitsBuffer
+      // (or tupleInit internally), but we need to create a temporary
+      // array of unowned references to the inits, after which we can
+      // throw away the ArrayRef that was returned to us.
+      eltInits.reserve(ownedEltInits.size());
+      for (auto &eltInit : ownedEltInits) {
+        eltInits.push_back(eltInit.get());
+      }
+    }
 
     // Create plans for all the sub-initializations.
     eltPlans.reserve(origType.getNumTupleElements());
-
     origType.forEachTupleElement(substType,
                                  [&](TupleElementGenerator &elt) {
       auto origEltType = elt.getOrigType();
       auto substEltTypes = elt.getSubstTypes();
       if (!elt.isOrigPackExpansion()) {
-        Initialization *eltInit = eltInits[elt.getSubstIndex()].get();
+        Initialization *eltInit = eltInits[elt.getSubstIndex()];
         eltPlans.push_back(builder.build(eltInit, origEltType,
                                          substEltTypes[0]));
       } else {
-        auto componentInits =
-          eltInits.slice(elt.getSubstIndex(), substEltTypes.size());
+        auto componentInits = llvm::makeArrayRef(eltInits)
+               .slice(elt.getSubstIndex(), substEltTypes.size());
         eltPlans.push_back(builder.buildForPackExpansion(componentInits,
                                                          origEltType,
                                                          substEltTypes));
@@ -678,7 +694,12 @@ class TupleInitializationResultPlan final : public ResultPlan {
       assert(eltRV.isInContext());
       (void)eltRV;
     }
-    tupleInit->finishInitialization(SGF);
+
+    // Finish the tuple initialization; but if the tuple vanished,
+    // this is handled in the loop above.
+    if (!origTupleVanishes) {
+      tupleInit->finishInitialization(SGF);
+    }
 
     return RValue::forInContext();
   }
@@ -1179,7 +1200,7 @@ ResultPlanPtr ResultPlanBuilder::buildForScalar(Initialization *init,
 }
 
 ResultPlanPtr ResultPlanBuilder::
-    buildForPackExpansion(Optional<MutableArrayRef<InitializationPtr>> inits,
+    buildForPackExpansion(Optional<ArrayRef<Initialization*>> inits,
                           AbstractionPattern origExpansionType,
                           CanTupleEltTypeArrayRef substTypes) {
   assert(!inits || inits->size() == substTypes.size());
@@ -1301,10 +1322,16 @@ ResultPlanBuilder::buildScalarIntoPack(SILValue packAddr,
 ResultPlanPtr ResultPlanBuilder::buildForTuple(Initialization *init,
                                                AbstractionPattern origType,
                                                CanType substType) {
-  // If we have an initialization, and we can split it, do so.
-  if (init && init->canSplitIntoTupleElements()) {
-    return ResultPlanPtr(
-        new TupleInitializationResultPlan(*this, init, origType, substType));
+  // If we have an initialization, and we can split the initialization,
+  // emit directly into the initialization.  If the orig tuple vanishes,
+  // that counts as the initialization being splittable.
+  if (init) {
+    bool vanishes = origType.getVanishingTupleElementPatternType().hasValue();
+    if (vanishes || init->canSplitIntoTupleElements()) {
+      return ResultPlanPtr(
+        new TupleInitializationResultPlan(*this, init, origType, substType,
+                                          vanishes));
+    }
   }
 
   auto substTupleType = dyn_cast<TupleType>(substType);

lib/SILGen/ResultPlan.h

@@ -98,7 +98,7 @@ struct ResultPlanBuilder {
   ResultPlanPtr buildForTuple(Initialization *emitInto,
                               AbstractionPattern origType,
                               CanType substType);
-  ResultPlanPtr buildForPackExpansion(Optional<MutableArrayRef<InitializationPtr>> inits,
+  ResultPlanPtr buildForPackExpansion(Optional<ArrayRef<Initialization*>> inits,
                                       AbstractionPattern origExpansionType,
                                       CanTupleEltTypeArrayRef substTypes);
   ResultPlanPtr buildPackExpansionIntoPack(SILValue packAddr,

test/SILGen/variadic-generic-vanishing-tuples.swift

@@ -75,3 +75,29 @@ public func testArgPassingExpansion<X>(arg: G<X>) {
 public func testArgPassingPartial() {
   Holder< >.takePartial(arg: 0)
 }
+
+func makeTuple<each T>(_ t: repeat each T) -> (repeat each T) {
+  return (repeat each t)
+}
+
+// rdar://107972801
+// CHECK-LABEL: sil {{.*}}@$s4main7makeOneyxxlF : $@convention(thin) <T> (@in_guaranteed T) -> @out T {
+// CHECK:       bb0(%0 : $*T, %1 : $*T):
+// CHECK:         [[RET_PACK:%.*]] = alloc_pack $Pack{T}
+// CHECK-NEXT:    [[INDEX:%.*]] = scalar_pack_index 0 of $Pack{T}
+// CHECK-NEXT:    pack_element_set %0 : $*T into [[INDEX]] of [[RET_PACK]] :
+// CHECK-NEXT:    [[ARG_PACK:%.*]] = alloc_pack $Pack{T}
+// CHECK-NEXT:    [[TEMP:%.*]] = alloc_stack $T
+// CHECK-NEXT:    copy_addr %1 to [init] [[TEMP]] : $*T
+// CHECK-NEXT:    [[INDEX:%.*]] = scalar_pack_index 0 of $Pack{T}
+// CHECK-NEXT:    pack_element_set [[TEMP]] : $*T into [[INDEX]] of [[ARG_PACK]] :
+// CHECK-NEXT:    // function_ref
+// CHECK-NEXT:    [[FN:%.*]] = function_ref @$s4main9makeTupleyxxQp_txxQpRvzlF : $@convention(thin) <each τ_0_0> (@pack_guaranteed Pack{repeat each τ_0_0}) -> @pack_out Pack{repeat each τ_0_0}
+// CHECK-NEXT:    apply [[FN]]<Pack{T}>([[RET_PACK]], [[ARG_PACK]])
+// CHECK-NEXT:    destroy_addr [[TEMP]] : $*T
+// CHECK-NEXT:    dealloc_stack [[TEMP]] : $*T
+// CHECK-NEXT:    dealloc_pack [[ARG_PACK]] : $*Pack{T}
+// CHECK-NEXT:    dealloc_pack [[RET_PACK]] : $*Pack{T}
+public func makeOne<T>(_ t: T) -> T {
+  return makeTuple(t)
+}