SILGen: Update for PackElementExpr captures

Fixes #68941.
Fixes #69282.
Fixes #72153.
Fixes rdar://110711746.
Fixes rdar://119212867.
Fixes rdar://124202697.

Author: slavapestov

lib/SILGen/SILGenExpr.cpp

@@ -1667,6 +1667,14 @@ RValueEmitter::visitPackExpansionExpr(PackExpansionExpr *E,
 
 RValue
 RValueEmitter::visitPackElementExpr(PackElementExpr *E, SGFContext C) {
+  // If this is a captured pack element reference, just emit the parameter value
+  // that was passed to the closure.
+  auto found = SGF.OpaqueValues.find(E);
+  if (found != SGF.OpaqueValues.end())
+    return RValue(SGF, E, SGF.manageOpaqueValue(found->second, E, C));
+
+  // Otherwise, we're going to project the address of an element from the pack
+  // itself.
   FormalEvaluationScope scope(SGF);
 
   LValue lv = SGF.emitLValue(E, SGFAccessKind::OwnedObjectRead);
@@ -5972,9 +5980,9 @@ RValue RValueEmitter::visitMakeTemporarilyEscapableExpr(
 }
 
 RValue RValueEmitter::visitOpaqueValueExpr(OpaqueValueExpr *E, SGFContext C) {
-  assert(SGF.OpaqueValues.count(E) && "Didn't bind OpaqueValueExpr");
-  auto value = SGF.OpaqueValues[E];
-  return RValue(SGF, E, SGF.manageOpaqueValue(value, E, C));
+  auto found = SGF.OpaqueValues.find(E);
+  assert(found != SGF.OpaqueValues.end());
+  return RValue(SGF, E, SGF.manageOpaqueValue(found->second, E, C));
 }
 
 RValue RValueEmitter::visitPropertyWrapperValuePlaceholderExpr(

lib/SILGen/SILGenFunction.cpp

@@ -569,10 +569,9 @@ void SILGenFunction::emitCaptures(SILLocation loc,
       continue;
     }
 
-    if (capture.isOpaqueValue()) {
-      OpaqueValueExpr *opaqueValue = capture.getOpaqueValue();
+    if (capture.isOpaqueValue() || capture.isPackElement()) {
       capturedArgs.push_back(
-          emitRValueAsSingleValue(opaqueValue).ensurePlusOne(*this, loc));
+          emitRValueAsSingleValue(capture.getExpr()).ensurePlusOne(*this, loc));
       continue;
     }
 

lib/SILGen/SILGenFunction.h

@@ -2185,9 +2185,8 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
     emitOpenExistentialExprImpl(e, emitSubExpr);
   }
 
-  /// Mapping from active opaque value expressions to their values.
-  llvm::SmallDenseMap<OpaqueValueExpr *, ManagedValue>
-    OpaqueValues;
+  /// Mapping from OpaqueValueExpr/PackElementExpr to their values.
+  llvm::SmallDenseMap<Expr *, ManagedValue> OpaqueValues;
 
   /// A mapping from opaque value expressions to the open-existential
   /// expression that determines them, used while lowering lvalues.

lib/SILGen/SILGenProlog.cpp

@@ -1052,6 +1052,49 @@ static void emitCaptureArguments(SILGenFunction &SGF,
                                  GenericSignature origGenericSig,
                                  CapturedValue capture,
                                  uint16_t ArgNo) {
+  if (auto *expr = capture.getPackElement()) {
+    SILLocation Loc(expr);
+    Loc.markAsPrologue();
+
+    auto interfaceType = expr->getType()->mapTypeOutOfContext();
+
+    auto type = SGF.F.mapTypeIntoContext(interfaceType);
+    auto &lowering = SGF.getTypeLowering(type);
+    SILType ty = lowering.getLoweredType();
+
+    SILValue arg;
+
+    auto expansion = SGF.getTypeExpansionContext();
+    auto captureKind = SGF.SGM.Types.getDeclCaptureKind(capture, expansion);
+    switch (captureKind) {
+    case CaptureKind::Constant:
+    case CaptureKind::StorageAddress:
+    case CaptureKind::Immutable: {
+      auto argIndex = SGF.F.begin()->getNumArguments();
+      // Non-escaping stored decls are captured as the address of the value.
+      auto param = SGF.F.getConventions().getParamInfoForSILArg(argIndex);
+      if (SGF.F.getConventions().isSILIndirect(param))
+        ty = ty.getAddressType();
+
+      auto *fArg = SGF.F.begin()->createFunctionArgument(ty, nullptr);
+      fArg->setClosureCapture(true);
+
+      arg = fArg;
+      break;
+    }
+
+    case CaptureKind::ImmutableBox:
+    case CaptureKind::Box:
+      llvm_unreachable("should be impossible");
+    }
+
+    ManagedValue mv = ManagedValue::forBorrowedRValue(arg);
+    auto inserted = SGF.OpaqueValues.insert(std::make_pair(expr, mv));
+    assert(inserted.second);
+    (void) inserted;
+
+    return;
+  }
 
   auto *VD = cast<VarDecl>(capture.getDecl());
 

test/Interpreter/variadic_generic_captures_2.swift

@@ -0,0 +1,72 @@
+// RUN: %target-run-simple-swift(-Xfrontend -disable-concrete-type-metadata-mangled-name-accessors)
+// RUN: %target-run-simple-swift
+
+// REQUIRES: executable_test
+
+import StdlibUnittest
+
+var captures = TestSuite("VariadicGenericCaptures")
+
+func f1<T>(_ fn: @autoclosure () -> T) {
+  _ = fn()
+}
+
+func f2<T>(_ fn: @autoclosure @escaping () -> T) {
+  _ = fn()
+}
+
+func f3<T>(_ fn: () -> T) {
+  _ = fn()
+}
+
+func f4<T>(_ fn: @escaping () -> T) {
+  _ = fn()
+}
+
+func f5<T: AnyObject>(_ fn: @autoclosure () -> T) {
+  _ = fn()
+}
+
+func f6<T: AnyObject>(_ fn: @autoclosure @escaping () -> T) {
+  _ = fn()
+}
+
+func f7<T: AnyObject>(_ fn: () -> T) {
+  _ = fn()
+}
+
+func f8<T: AnyObject>(_ fn: @escaping () -> T) {
+  _ = fn()
+}
+
+func g1<each T>(_ t: repeat each T) {
+  repeat f1(each t)
+  repeat f2(each t)
+  repeat f3 { each t }
+  repeat f4 { each t }
+  repeat _ = ({ each t }())
+  repeat _ = ({ (each t, each t) }())
+}
+
+func g2<each T: AnyObject>(_ t: repeat each T) {
+  repeat f5(each t)
+  repeat f6(each t)
+  repeat f7 { each t }
+  repeat f8 { each t }
+  repeat _ = ({ (each t, each t) }())
+}
+
+class C {
+  var x = LifetimeTracked(0)
+}
+
+class D: C {}
+
+class E: D {}
+
+captures.test("Test") {
+  g1(C(), D(), E())
+  g2(C(), D(), E())
+}
+
+runAllTests()

test/SILGen/pack_element_expr_captures.swift

@@ -0,0 +1,23 @@
+// RUN: %target-swift-emit-silgen -parse-as-library %s | %FileCheck %s
+
+func callee(_ fn: () -> Any) {}
+
+func caller<each T>(_ t: repeat each T) {
+  repeat callee { each t }
+}
+
+// CHECK-LABEL: sil hidden [ossa] @$s26pack_element_expr_captures6calleryyxxQpRvzlF : $@convention(thin) <each T> (@pack_guaranteed Pack{repeat each T}) -> () {
+// CHECK: [[FN:%.*]] = function_ref @$s26pack_element_expr_captures6calleryyxxQpRvzlFypyXEfU_ : $@convention(thin) <each τ_0_0><τ_1_0> (@in_guaranteed τ_1_0) -> @out Any
+// CHECK: [[ELT_ADDR:%.*]] = pack_element_get {{.*}} of %0 : $*Pack{repeat each T} as $*@pack_element("{{.*}}") each T
+// CHECK: [[ELT_COPY:%.*]] = alloc_stack $@pack_element("{{.*}}") each T
+// CHECK: copy_addr [[ELT_ADDR]] to [init] [[ELT_COPY]] : $*@pack_element("{{.*}}") each T
+// CHECK: [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[FN]]<Pack{repeat each T}, @pack_element("{{.*}}") each T>([[ELT_COPY]])
+// CHECK: [[CONVERTED:%.*]] = convert_escape_to_noescape [not_guaranteed] %15 : $@callee_guaranteed () -> @out Any to $@noescape @callee_guaranteed () -> @out Any
+// CHECK: [[CALLEE:%.*]]  = function_ref @$s26pack_element_expr_captures6calleeyyypyXEF : $@convention(thin) (@guaranteed @noescape @callee_guaranteed () -> @out Any) -> ()
+// CHECK: apply [[CALLEE]]([[CONVERTED]]) : $@convention(thin) (@guaranteed @noescape @callee_guaranteed () -> @out Any) -> ()
+
+// CHECK-LABEL: sil private [ossa] @$s26pack_element_expr_captures6calleryyxxQpRvzlFypyXEfU_ : $@convention(thin) <each T><τ_1_0> (@in_guaranteed τ_1_0) -> @out Any {
+// CHECK: bb0(%0 : $*Any, %1 : @closureCapture $*τ_1_0):
+// CHECK: [[ADDR:%.*]] = init_existential_addr %0 : $*Any, $τ_1_0
+// CHECK: copy_addr %1 to [init] [[ADDR]] : $*τ_1_0
+// CHECK: return

validation-test/compiler_crashers_2_fixed/issue-68941.swift

@@ -0,0 +1,10 @@
+// RUN: %target-swift-frontend -emit-ir %s -disable-availability-checking
+
+public struct S<each T> {
+    public var value: (repeat each T)
+
+    public init(_ value: repeat each T) {
+        self.value = (repeat each value)
+        let getters: (repeat () -> each T) = (repeat { each self.value })
+    }
+}

validation-test/compiler_crashers_2_fixed/rdar119212867.swift

@@ -0,0 +1,45 @@
+// RUN: %target-swift-frontend -emit-ir %s -disable-availability-checking
+
+protocol P {
+    func evaluate(_ item: Int) -> Bool
+}
+
+struct G<each F: P>: P {
+    init(filters: repeat each F) {
+        self.filters = (repeat each filters)
+    }
+
+    var filters: (repeat each F)
+
+    func evaluate(_ item: Int) -> Bool {
+        var result = true
+
+        (repeat result.and((each filters).evaluate(item)))
+
+        return result
+    }
+}
+
+private extension Bool {
+    mutating func and(_ other: @autoclosure () -> Bool) {
+        self = self && other()
+    }
+}
+
+struct S1: P {
+    func evaluate(_ item: Int) -> Bool {
+        print("S1", item)
+        return false
+    }
+}
+struct S2: P {
+    func evaluate(_ item: Int) -> Bool {
+        print("S2", item)
+        return false
+    }
+}
+
+do {
+    let filter = G(filters: S1(), S2())
+    print(filter.evaluate(5))
+}