SILGen: Fix for tuple conversions in function argument position

Swift admits implicit conversions between tuple types to
introduce and eliminate argument labels, and re-order
argument labels. These are expressed as TupleShuffleExpr
in the AST.

SILGen has two different code paths for lowering TupleShuffleExpr,
which is also used for varargs and default arguments in call
argument emission.

These two code paths support different subsets of TupleShuffleExpr;
neither one supports the full generality of the other, but there
is some overlap.

Work around the damage by routing the two different "kinds" of
TupleShuffleExprs to the correct place in argument emission.

The next incremental step here would be to refactor ArgEmitter to
make it usable when lowering SubscriptExpr; then the RValueEmitter's
support for varargs in TupleShuffleExpr can go away. Once that's
done we can split off an ArgumentExpr from TupleShuffleExpr, and
in the fullness of time, fold ArgumentExpr into ApplyExpr.

At that point this dark corner of the AST will start to be sane...

Fixes <https://bugs.swift.org/browse/SR-2887>.

Author: slavapestov

lib/SILGen/ArgumentSource.cpp

@@ -55,7 +55,35 @@ bool ArgumentSource::requiresCalleeToEvaluate() {
   case Kind::LValue:
     return false;
   case Kind::Expr:
-    return isa<TupleShuffleExpr>(asKnownExpr());
+    // FIXME: TupleShuffleExprs come in two flavors:
+    //
+    // 1) as apply arguments, where they're used to insert default
+    // argument value and collect varargs
+    //
+    // 2) as tuple conversions, where they can introduce, eliminate
+    // and re-order fields
+    //
+    // Case 1) must be emitted by ArgEmitter, and Case 2) must be
+    // emitted by RValueEmitter.
+    //
+    // It would be good to split up TupleShuffleExpr into these two
+    // cases, and simplify ArgEmitter since it no longer has to deal
+    // with re-ordering. However for now, SubscriptExpr emits the
+    // index argument via the RValueEmitter, so the RValueEmitter has
+    // to know about varargs, duplicating some of the logic in
+    // ArgEmitter.
+    //
+    // Once this is fixed, we can also consider allowing subscripts
+    // to have default arguments.
+    if (auto *shuffleExpr = dyn_cast<TupleShuffleExpr>(asKnownExpr())) {
+      for (auto index : shuffleExpr->getElementMapping()) {
+        if (index == TupleShuffleExpr::DefaultInitialize ||
+            index == TupleShuffleExpr::CallerDefaultInitialize ||
+            index == TupleShuffleExpr::Variadic)
+          return true;
+      }
+    }
+    return false;
   }
 
   llvm_unreachable("Unhandled Kind in switch.");

test/SILGen/argument_shuffle.swift

@@ -0,0 +1,50 @@
+// RUN: %target-swift-frontend -emit-silgen %s
+
+struct Horse<T> {
+  func walk(_: (String, Int), reverse: Bool) {}
+  func trot(_: (x: String, y: Int), halfhalt: Bool) {}
+  func canter(_: T, counter: Bool) {}
+}
+
+var kevin = Horse<(x: String, y: Int)>()
+var loki = Horse<(String, Int)>()
+
+//
+
+// No conversion
+let noLabelsTuple = ("x", 1)
+kevin.walk(("x", 1), reverse: false)
+kevin.walk(noLabelsTuple, reverse: false)
+
+loki.canter(("x", 1), counter: false)
+loki.canter(noLabelsTuple, counter: false)
+
+// Introducing labels
+kevin.trot(("x", 1), halfhalt: false)
+kevin.trot(noLabelsTuple, halfhalt: false)
+
+kevin.canter(("x", 1), counter: false)
+kevin.canter(noLabelsTuple, counter: false)
+
+// Eliminating labels
+let labelsTuple = (x: "x", y: 1)
+kevin.walk((x: "x", y: 1), reverse: false)
+kevin.walk(labelsTuple, reverse: false)
+
+loki.canter((x: "x", y: 1), counter: false)
+loki.canter(labelsTuple, counter: false)
+
+// No conversion
+kevin.trot((x: "x", y: 1), halfhalt: false)
+kevin.trot(labelsTuple, halfhalt: false)
+
+kevin.canter((x: "x", y: 1), counter: false)
+kevin.canter(labelsTuple, counter: false)
+
+// Shuffling labels
+let shuffledLabelsTuple = (y: 1, x: "x")
+kevin.trot((y: 1, x: "x"), halfhalt: false)
+kevin.trot(shuffledLabelsTuple, halfhalt: false)
+
+kevin.canter((y: 1, x: "x"), counter: false)
+kevin.canter(shuffledLabelsTuple, counter: false)

test/SILGen/arguments.swift

@@ -18,25 +18,25 @@ func _deallocateUninitializedArray<T>(_: Array<T>) {}
 
 var i:Int, f:Float, c:UnicodeScalar
 
-func arg_tuple(x x: Int, y: Float) {}
+func arg_tuple(x: Int, y: Float) {}
 // CHECK-LABEL: sil hidden @_TFs9arg_tupleFT1xSi1ySf_T_
 // CHECK: bb0([[X:%[0-9]+]] : $Int, [[Y:%[0-9]+]] : $Float):
 
 arg_tuple(x: i, y: f)
 
-func arg_deep_tuples(x x: Int, y: (Float, UnicodeScalar)) {}
+func arg_deep_tuples(x: Int, y: (Float, UnicodeScalar)) {}
 // CHECK-LABEL: sil hidden @_TFs15arg_deep_tuplesFT1xSi1yTSfSc__T_
 // CHECK: bb0([[X:%[0-9]+]] : $Int, [[Y_0:%[0-9]+]] : $Float, [[Y_1:%[0-9]+]] : $UnicodeScalar):
 
 arg_deep_tuples(x:i, y:(f, c))
 var unnamed_subtuple = (f, c)
-arg_deep_tuples(x: i, y: unnamed_subtuple)
-// FIXME rdar://problem/12985801 -- tuple conversion confuses named fields
+arg_deep_tuples(x:i, y: unnamed_subtuple)
+// rdar://problem/12985801 -- tuple conversion confuses named fields
 // of a subtuple with those of outer tuple
-//var named_subtuple = (x:f, y:c)
-//arg_deep_tuples(i, named_subtuple)
+var named_subtuple = (x:f, y:c)
+arg_deep_tuples(x:i, y: named_subtuple)
 
-func arg_deep_tuples_2(x x: Int, _: (y: Float, z: UnicodeScalar)) {}
+func arg_deep_tuples_2(x: Int, _: (y: Float, z: UnicodeScalar)) {}
 // CHECK-LABEL: sil hidden @_TFs17arg_deep_tuples_2FT1xSiT1ySf1zSc__T_
 // CHECK: bb0([[X:%[0-9]+]] : $Int, [[Y:%[0-9]+]] : $Float, [[Z:%[0-9]+]] : $UnicodeScalar):