PartialApplySimplification: Use a tuple in a box.

IRGen only implements box lowering for single-field boxes at the moment.
We can represent closure contexts that don't capture type info as just
capturing a tuple of the values, so let's do that for now to allow
for initial end-to-end testing of the pass.

Author: jckarter

lib/SILOptimizer/Transforms/PartialApplySimplification.cpp

@@ -297,11 +297,31 @@ void PartialApplySimplificationPass::processKnownCallee(SILFunction *callee,
       LLVM_DEBUG(llvm::dbgs() << "TODO: Nonescaping partial_apply not yet implemented\n");
       return;
     }
-    
+    if (origTy->getInvocationGenericSignature()) {
+      LLVM_DEBUG(llvm::dbgs() << "TODO: generic partial_apply not yet implemented\n");
+      return;
+    }
+
+    // TODO: SILBoxType is only implemented for a single field right now, so
+    // represent the captures as a tuple.
+#if MULTI_FIELD_BOXES_ARE_SUPPORTED
     auto newBoxLayout = SILLayout::get(C,
        origTy->getInvocationGenericSignature(),
        boxFields,
        /*capturesGenerics*/ !origTy->getInvocationGenericSignature().isNull());
+#else
+    llvm::SmallVector<TupleTypeElt, 4> tupleElts;
+    for (auto field : boxFields) {
+      tupleElts.push_back(TupleTypeElt(field.getLoweredType()));
+    }
+    auto tupleTy = TupleType::get(tupleElts, C)->getCanonicalType();
+    SILField tupleField(tupleTy, /*mutable*/ false);
+    
+    auto newBoxLayout = SILLayout::get(C,
+                                       origTy->getInvocationGenericSignature(),
+                                       tupleField,
+                                       /*capturesGenerics*/ false);
+#endif
     SubstitutionMap identitySubstitutionMap;
     if (auto origSig = origTy->getInvocationGenericSignature()) {
       identitySubstitutionMap = origSig->getIdentitySubstitutionMap();
@@ -358,9 +378,15 @@ void PartialApplySimplificationPass::processKnownCallee(SILFunction *callee,
       for (unsigned i = 0; i < appliedBBArgs.size(); ++i) {
         auto appliedArg = appliedBBArgs[i];
         auto param = partiallyAppliedParams[i];
-        
-        auto proj = B.createProjectBox(loc, boxArg, i);
-        
+
+#if MULTI_FIELD_BOXES_ARE_SUPPORTED
+        SILValue proj = B.createProjectBox(loc, boxArg, i);
+#else
+        SILValue proj = B.createProjectBox(loc, boxArg, 0);
+        if (boxFields.size() > 1) {
+          proj = B.createTupleElementAddr(loc, proj, i);
+        }
+#endif
         // Load the value out of the box according to the current ownership
         // mode of the function and the calling convention for the parameter.
         SILValue projectedArg;
@@ -493,7 +519,14 @@ void PartialApplySimplificationPass::processKnownCallee(SILFunction *callee,
       auto appliedArgs = pa->getArguments();
       for (unsigned i = 0; i < appliedArgs.size(); ++i) {
         auto arg = appliedArgs[i];
-        auto proj = B.createProjectBox(loc, newBox, i);
+#if MULTI_FIELD_BOXES_ARE_SUPPORTED
+        SILValue proj = B.createProjectBox(loc, newBox, i);
+#else
+        SILValue proj = B.createProjectBox(loc, newBox, 0);
+        if (boxFields.size() > 1) {
+          proj = B.createTupleElementAddr(loc, proj, i);
+        }
+#endif
         auto param = partiallyAppliedParams[i];
 
         switch (auto conv = param.getConvention()) {

test/SILOptimizer/partial_apply_simplification.sil

@@ -16,7 +16,7 @@ entry(%x : $Int, %y : $Int):
 // CHECK-LABEL: sil @closure_common_uses_user_a
 // CHECK:       bb0([[Y:%.*]] : $Int):
 // CHECK:         [[F:%.*]] = function_ref @closure_common_uses
-// CHECK-NEXT:    [[BOX:%.*]] = alloc_box ${ let Int }
+// CHECK-NEXT:    [[BOX:%.*]] = alloc_box [reflection] ${ let Int }
 // CHECK-NEXT:    [[BOX_0:%.*]] = project_box [[BOX]] : ${ let Int }, 0
 // CHECK-NEXT:    store [[Y]] to [[BOX_0]]
 // CHECK-NEXT:    [[C:%.*]] = partial_apply [callee_guaranteed] [[F]]([[BOX]])
@@ -30,7 +30,7 @@ entry(%y : $Int):
 // CHECK-LABEL: sil @closure_common_uses_user_b
 // CHECK:       bb0([[Y:%.*]] : $Int):
 // CHECK:         [[F:%.*]] = function_ref @closure_common_uses
-// CHECK-NEXT:    [[BOX:%.*]] = alloc_box ${ let Int }
+// CHECK-NEXT:    [[BOX:%.*]] = alloc_box [reflection] ${ let Int }
 // CHECK-NEXT:    [[BOX_0:%.*]] = project_box [[BOX]] : ${ let Int }, 0
 // CHECK-NEXT:    store [[Y]] to [[BOX_0]]
 // CHECK-NEXT:    [[C:%.*]] = partial_apply [callee_guaranteed] [[F]]([[BOX]])
@@ -83,7 +83,7 @@ entry(%r : $*Int, %x : $Int, %y : $Int):
 // CHECK-LABEL: sil @closure_out_param_user
 // CHECK:       bb0([[Y:%.*]] : $Int):
 // CHECK:         [[F:%.*]] = function_ref @closure_out_param
-// CHECK-NEXT:    [[BOX:%.*]] = alloc_box ${ let Int }
+// CHECK-NEXT:    [[BOX:%.*]] = alloc_box [reflection] ${ let Int }
 // CHECK-NEXT:    [[BOX_0:%.*]] = project_box [[BOX]] : ${ let Int }, 0
 // CHECK-NEXT:    store [[Y]] to [[BOX_0]]
 // CHECK-NEXT:    [[C:%.*]] = partial_apply [callee_guaranteed] [[F]]([[BOX]])
@@ -93,3 +93,42 @@ entry(%y : $Int):
   %c = partial_apply [callee_guaranteed] %f(%y) : $@convention(thin) (Int, Int) -> @out Int
   return %c : $@callee_guaranteed (Int) -> @out Int
 }
+
+sil @add : $@convention(thin) (Int, Int) -> Int
+
+// CHECK-LABEL: sil private @closure_multi_capture
+// CHECK-SAME:    : $@convention(method) (Int, @guaranteed { let (Int, Int) }) -> Int
+// CHECK:       bb0([[X:%.*]] : $Int, [[YZ:%.*]] : ${ let (Int, Int) }):
+// CHECK-NEXT:   [[BOX_PROJ:%.*]] = project_box [[YZ]] :
+// CHECK-NEXT:   [[BOX_0:%.*]] = tuple_element_addr [[BOX_PROJ]] : {{.*}}, 0
+// CHECK-NEXT:   [[Y:%.*]] = load [[BOX_0]] : $*Int
+// CHECK-NEXT:   [[BOX_PROJ:%.*]] = project_box [[YZ]] :
+// CHECK-NEXT:   [[BOX_1:%.*]] = tuple_element_addr [[BOX_PROJ]] : {{.*}}, 1
+// CHECK-NEXT:   [[Z:%.*]] = load [[BOX_1]] : $*Int
+// CHECK:   [[ADD:%.*]] = function_ref @add
+// CHECK-NEXT:   apply [[ADD]]([[Y]], [[Z]])
+sil private @closure_multi_capture : $@convention(thin) (Int, Int, Int) -> Int {
+entry(%x : $Int, %y : $Int, %z : $Int):
+  %f = function_ref @add : $@convention(thin) (Int, Int) -> Int
+  %r = apply %f(%y, %z) : $@convention(thin) (Int, Int) -> Int
+  return %r : $Int
+}
+
+// CHECK-LABEL: sil @closure_multi_capture_user
+// CHECK:       bb0([[Y:%.*]] : $Int, [[Z:%.*]] : $Int):
+// CHECK:         [[BOX:%.*]] = alloc_box [reflection] ${ let (Int, Int) }
+// CHECK:         [[BOX_PROJ:%.*]] = project_box [[BOX]]
+// CHECK:         [[BOX_0:%.*]] = tuple_element_addr [[BOX_PROJ]] : {{.*}}, 0
+// CHECK:         store [[Y]] to [[BOX_0]]
+// CHECK:         [[BOX_PROJ:%.*]] = project_box [[BOX]]
+// CHECK:         [[BOX_1:%.*]] = tuple_element_addr [[BOX_PROJ]] : {{.*}}, 1
+// CHECK:         store [[Z]] to [[BOX_1]]
+// CHECK:         [[RESULT:%.*]] = partial_apply [callee_guaranteed] {{%.*}}([[BOX]])
+// CHECK:         return [[RESULT]]
+sil @closure_multi_capture_user : $@convention(thin) (Int, Int) -> @owned @callee_guaranteed (Int) -> Int {
+entry(%y : $Int, %z : $Int):
+  %f = function_ref @closure_multi_capture : $@convention(thin) (Int, Int, Int) -> Int
+  %c = partial_apply [callee_guaranteed] %f(%y, %z) : $@convention(thin) (Int, Int, Int) -> Int
+  return %c : $@callee_guaranteed (Int) -> Int
+}
+