Fix projecting a tuple element out of a tuple with packs.

At the same time, make sure we propagate contextual initializations.

I'm actually not sure this is meant to be supported, but it's fine,
we should implement it.

Fixes #80937

Author: rjmccall

lib/SILGen/SILGenExpr.cpp

@@ -2822,12 +2822,78 @@ RValue RValueEmitter::visitDynamicSubscriptExpr(
       E->getType()->getCanonicalType(), C);
 }
 
+namespace {
+class CollectValueInitialization : public Initialization {
+  ManagedValue Value;
+
+public:
+  ManagedValue getValue() const {
+    assert(Value);
+    return Value;
+  }
+
+  void copyOrInitValueInto(SILGenFunction &SGF, SILLocation loc,
+                           ManagedValue value, bool isInit) override {
+    if (!isInit) value = value.copy(SGF, loc);
+    Value = value;
+  }
+};
+}
 
 RValue RValueEmitter::visitTupleElementExpr(TupleElementExpr *E,
                                             SGFContext C) {
   assert(!E->getType()->is<LValueType>() &&
          "RValueEmitter shouldn't be called on lvalues");
-  
+
+  auto tupleType = cast<TupleType>(E->getBase()->getType()->getCanonicalType());
+  auto projectedEltInit = C.getEmitInto();
+
+  std::optional<CollectValueInitialization> collection;
+
+  // If we have an initialization to emit into, or if we'd need to emit
+  // a tuple that contains pack expansions, make a tuple initialization
+  // of it plus some black holes.
+  if (projectedEltInit || tupleType->containsPackExpansionType()) {
+    TupleInitialization tupleInit(tupleType);
+
+    auto projectedIndex = E->getFieldNumber();
+    auto numElts = tupleType->getNumElements();
+    assert(projectedIndex < numElts);
+
+    tupleInit.SubInitializations.reserve(numElts);
+    for (auto i : range(numElts)) {
+      // Create a black-hole initialization for everything except the
+      // projected index.
+      if (i != projectedIndex) {
+        tupleInit.SubInitializations.emplace_back(new BlackHoleInitialization());
+
+      // If we have an initialization for the projected initialization,
+      // put it in the right place.
+      } else if (projectedEltInit) {
+        tupleInit.SubInitializations.emplace_back(projectedEltInit,
+                                                  PointerIsNotOwned);
+
+      // Otherwise, create the collection initialization and put it in the
+      // right place.
+      } else {
+        collection.emplace();
+        tupleInit.SubInitializations.emplace_back(&*collection,
+                                                  PointerIsNotOwned);
+      }
+    }
+
+    // Emit the expression into the initialization.
+    SGF.emitExprInto(E->getBase(), &tupleInit);
+
+    // If we had an initialization to emit into, we've done so.
+    if (projectedEltInit) {
+      return RValue::forInContext();
+    }
+
+    // Otherwise, pull out the owned value.
+    return RValue(SGF, E, collection->getValue());
+  }
+
   // If our client is ok with a +0 result, then we can compute our base as +0
   // and return its element that way.  It would not be ok to reuse the Context's
   // address buffer though, since our base value will a different type than the

test/SILGen/tuple_element_projection.swift

@@ -0,0 +1,43 @@
+// RUN: %target-swift-emit-silgen -module-name test %s | %FileCheck %s
+
+func returnStringAnyPair() -> (String, Any) {
+  return ("hello", "world")
+}
+
+//   Test that we handle projections appropriately in emit-into contexts.
+// CHECK-LABEL: sil hidden [ossa] @$s4test0A17ProjectIntoReturnypyF :
+// CHECK:       bb0(%0 : $*Any):
+// CHECK-NEXT:    // function_ref
+// CHECK-NEXT:    [[FN:%.*]] = function_ref @$s4test19returnStringAnyPairSS_yptyF :
+// CHECK-NEXT:    [[STRING:%.*]] = apply [[FN]](%0)
+// CHECK-NEXT:    ignored_use [[STRING]]
+// CHECK-NEXT:    destroy_value [[STRING]]
+// CHECK-NEXT:    [[RET:%.*]] = tuple ()
+// CHECK-NEXT:    return [[RET]]
+func testProjectIntoReturn() -> Any {
+  return returnStringAnyPair().1
+}
+
+func returnAsTuple<each T>(_ args: repeat each T) -> (repeat each T) {
+  (repeat each args)
+}
+
+//   Test that we handle projections of non-pack elements of tuples.
+// CHECK-LABEL: sil hidden [ossa] @$s4test0A14PackProjectionySSxxQpRvzlF :
+// CHECK:       bb0(%0 : $*Pack{repeat each T}):
+// CHECK:         [[VALUES:%.*]] = alloc_stack [lexical] [var_decl] $(String, repeat each T, String)
+//   The result gets expanded, so we emit a pack loop to set up a pack
+//   initialization of the elements of values. Eventually we do this call:
+// CHECK:         [[FN:%.*]] = function_ref @$s4test13returnAsTupleyxxQp_txxQpRvzlF :
+// CHECK-NEXT:    apply [[FN]]<Pack{String, repeat each T, String}>(
+//   This copy is unnecessary.
+// CHECK:         [[TEMP:%.*]] = alloc_stack $(String, repeat each T, String)
+// CHECK-NEXT:    copy_addr [[VALUES]] to [init] [[TEMP]]
+// CHECK:         [[INDEX2:%.*]] = scalar_pack_index 2 of
+// CHECK-NEXT:    [[ELT2_ADDR:%.*]] = tuple_pack_element_addr [[INDEX2]] of [[TEMP]] as $*String
+// CHECK-NEXT:    [[VALUE:%.*]] = load [take] [[ELT2_ADDR]]
+// CHECK:         return [[VALUE]]
+func testPackProjection<each T>(_ args: repeat each T) -> String {
+  let values = returnAsTuple("start", repeat each args, "end")
+  return values.2
+}