Merge pull request #7102 from jrose-apple/3.1-unsplat

In Swift 3 mode, allow "tuple unsplatting" in certain cases.

Author: ematejska

lib/Sema/CSSimplify.cpp

@@ -653,6 +653,21 @@ matchCallArguments(ConstraintSystem &cs, ConstraintKind kind,
     getCalleeDeclAndArgs(cs, locator, argLabelsScratch);
   auto params = decomposeParamType(paramType, callee, calleeLevel);
 
+  if (callee && cs.getASTContext().isSwiftVersion3()
+      && argType->is<TupleType>()) {
+    // Hack: In Swift 3 mode, accept `foo(x, y)` for `foo((x, y))` when the
+    // callee is a function-typed property or an enum constructor whose
+    // argument is a single unlabeled type parameter.
+    if (auto *prop = dyn_cast<VarDecl>(callee)) {
+      auto *fnType = prop->getInterfaceType()->getAs<AnyFunctionType>();
+      if (fnType && fnType->getInput()->isTypeParameter())
+        argType = ParenType::get(cs.getASTContext(), argType);
+    } else if (auto *enumCtor = dyn_cast<EnumElementDecl>(callee)) {
+      if (enumCtor->getArgumentInterfaceType()->isTypeParameter())
+        argType = ParenType::get(cs.getASTContext(), argType);
+    }
+  }
+
   // Extract the arguments.
   auto args = decomposeArgType(argType, argLabels);
 

test/Compatibility/tuple_arguments.swift

@@ -19,13 +19,18 @@
 //   but now crash. These are bugs in Swift 3 mode that should be fixed.
 
 func concrete(_ x: Int) {}
+func concreteLabeled(x: Int) {}
 func concreteTwo(_ x: Int, _ y: Int) {} // expected-note 3 {{'concreteTwo' declared here}}
 func concreteTuple(_ x: (Int, Int)) {}
 
 do {
   concrete(3)
   concrete((3))
 
+  concreteLabeled(x: 3)
+  concreteLabeled(x: (3))
+  concreteLabeled((x: 3)) // expected-error {{missing argument label 'x:' in call}}
+
   concreteTwo(3, 4)
   concreteTwo((3, 4)) // expected-error {{missing argument for parameter #2 in call}}
 
@@ -72,6 +77,7 @@ do {
 }
 
 func generic<T>(_ x: T) {}
+func genericLabeled<T>(x: T) {}
 func genericTwo<T, U>(_ x: T, _ y: U) {} // expected-note 5 {{'genericTwo' declared here}}
 func genericTuple<T, U>(_ x: (T, U)) {}
 
@@ -81,6 +87,11 @@ do {
   generic((3))
   generic((3, 4))
 
+  genericLabeled(x: 3)
+  genericLabeled(x: 3, 4) // expected-error {{extra argument in call}}
+  genericLabeled(x: (3))
+  genericLabeled(x: (3, 4))
+
   genericTwo(3, 4)
   genericTwo((3, 4)) // expected-error {{missing argument for parameter #2 in call}}
 
@@ -250,6 +261,7 @@ do {
 
 extension Concrete {
   func generic<T>(_ x: T) {}
+  func genericLabeled<T>(x: T) {}
   func genericTwo<T, U>(_ x: T, _ y: U) {} // expected-note 5 {{'genericTwo' declared here}}
   func genericTuple<T, U>(_ x: (T, U)) {}
 }
@@ -262,6 +274,11 @@ do {
   s.generic((3))
   s.generic((3, 4))
 
+  s.genericLabeled(x: 3)
+  s.genericLabeled(x: 3, 4) // expected-error {{extra argument in call}}
+  s.genericLabeled(x: (3))
+  s.genericLabeled(x: (3, 4))
+
   s.genericTwo(3, 4)
   s.genericTwo((3, 4)) // expected-error {{missing argument for parameter #2 in call}}
 
@@ -378,6 +395,7 @@ do {
 
 extension Concrete {
   mutating func mutatingGeneric<T>(_ x: T) {}
+  mutating func mutatingGenericLabeled<T>(x: T) {}
   mutating func mutatingGenericTwo<T, U>(_ x: T, _ y: U) {} // expected-note 5 {{'mutatingGenericTwo' declared here}}
   mutating func mutatingGenericTuple<T, U>(_ x: (T, U)) {}
 }
@@ -390,6 +408,11 @@ do {
   s.mutatingGeneric((3))
   s.mutatingGeneric((3, 4))
 
+  s.mutatingGenericLabeled(x: 3)
+  s.mutatingGenericLabeled(x: 3, 4) // expected-error {{extra argument in call}}
+  s.mutatingGenericLabeled(x: (3))
+  s.mutatingGenericLabeled(x: (3, 4))
+
   s.mutatingGenericTwo(3, 4)
   s.mutatingGenericTwo((3, 4)) // expected-error {{missing argument for parameter #2 in call}}
 
@@ -512,12 +535,19 @@ struct InitTuple {
   init(_ x: (Int, Int)) {}
 }
 
+struct InitLabeledTuple {
+  init(x: (Int, Int)) {}
+}
+
 do {
   _ = InitTwo(3, 4)
   _ = InitTwo((3, 4)) // expected-error {{missing argument for parameter #2 in call}}
 
   _ = InitTuple(3, 4) // expected-error {{extra argument in call}}
   _ = InitTuple((3, 4))
+
+  _ = InitLabeledTuple(x: 3, 4) // expected-error {{extra argument in call}}
+  _ = InitLabeledTuple(x: (3, 4))
 }
 
 do {
@@ -556,6 +586,10 @@ struct SubscriptTuple {
   subscript(_ x: (Int, Int)) -> Int { get { return 0 } set { } }
 }
 
+struct SubscriptLabeledTuple {
+  subscript(x x: (Int, Int)) -> Int { get { return 0 } set { } }
+}
+
 do {
   let s1 = SubscriptTwo()
   _ = s1[3, 4]
@@ -564,6 +598,10 @@ do {
   let s2 = SubscriptTuple()
   _ = s2[3, 4] // expected-error {{extra argument in call}}
   _ = s2[(3, 4)]
+
+  let s3 = SubscriptLabeledTuple()
+  _ = s3[x: 3, 4] // expected-error {{extra argument in call}}
+  _ = s3[x: (3, 4)]
 }
 
 do {
@@ -601,6 +639,7 @@ do {
 enum Enum {
   case two(Int, Int) // expected-note 3 {{'two' declared here}}
   case tuple((Int, Int))
+  case labeledTuple(x: (Int, Int))
 }
 
 do {
@@ -609,6 +648,9 @@ do {
 
   _ = Enum.tuple(3, 4) // expected-error {{extra argument in call}}
   _ = Enum.tuple((3, 4))
+
+  _ = Enum.labeledTuple(x: 3, 4) // expected-error {{extra argument in call}}
+  _ = Enum.labeledTuple(x: (3, 4))
 }
 
 do {
@@ -643,6 +685,7 @@ struct Generic<T> {}
 
 extension Generic {
   func generic(_ x: T) {}
+  func genericLabeled(x: T) {}
   func genericTwo(_ x: T, _ y: T) {} // expected-note 2 {{'genericTwo' declared here}}
   func genericTuple(_ x: (T, T)) {}
 }
@@ -653,6 +696,9 @@ do {
   s.generic(3.0)
   s.generic((3.0))
 
+  s.genericLabeled(x: 3.0)
+  s.genericLabeled(x: (3.0))
+
   s.genericTwo(3.0, 4.0)
   s.genericTwo((3.0, 4.0)) // expected-error {{missing argument for parameter #2 in call}}
 
@@ -663,6 +709,9 @@ do {
 
   sTwo.generic(3.0, 4.0) // expected-error {{extra argument in call}}
   sTwo.generic((3.0, 4.0))
+
+  sTwo.genericLabeled(x: 3.0, 4.0) // expected-error {{extra argument in call}}
+  sTwo.genericLabeled(x: (3.0, 4.0))
 }
 
 do {
@@ -717,6 +766,7 @@ do {
 
 extension Generic {
   mutating func mutatingGeneric(_ x: T) {}
+  mutating func mutatingGenericLabeled(x: T) {}
   mutating func mutatingGenericTwo(_ x: T, _ y: T) {} // expected-note 2 {{'mutatingGenericTwo' declared here}}
   mutating func mutatingGenericTuple(_ x: (T, T)) {}
 }
@@ -727,6 +777,9 @@ do {
   s.mutatingGeneric(3.0)
   s.mutatingGeneric((3.0))
 
+  s.mutatingGenericLabeled(x: 3.0)
+  s.mutatingGenericLabeled(x: (3.0))
+
   s.mutatingGenericTwo(3.0, 4.0)
   s.mutatingGenericTwo((3.0, 4.0)) // expected-error {{missing argument for parameter #2 in call}}
 
@@ -737,6 +790,9 @@ do {
 
   sTwo.mutatingGeneric(3.0, 4.0) // expected-error {{extra argument in call}}
   sTwo.mutatingGeneric((3.0, 4.0))
+
+  sTwo.mutatingGenericLabeled(x: 3.0, 4.0) // expected-error {{extra argument in call}}
+  sTwo.mutatingGenericLabeled(x: (3.0, 4.0))
 }
 
 do {
@@ -809,7 +865,7 @@ do {
 
   let sTwo = Generic<(Double, Double)>()
 
-  sTwo.genericFunction(3.0, 4.0) // FIXME: Diagnoses in Swift 3 mode // expected-error {{extra argument in call}}
+  sTwo.genericFunction(3.0, 4.0)
   sTwo.genericFunction((3.0, 4.0)) // Does not diagnose in Swift 3 mode
 }
 
@@ -858,7 +914,7 @@ do {
 
   var sTwo = Generic<(Double, Double)>()
 
-  sTwo.genericFunction(a, b) // FIXME: Diagnoses in Swift 3 mode // expected-error {{extra argument in call}}
+  sTwo.genericFunction(a, b)
   sTwo.genericFunction((a, b)) // Does not diagnose in Swift 3 mode
   sTwo.genericFunction(d) // Does not diagnose in Swift 3 mode
 }
@@ -867,6 +923,10 @@ struct GenericInit<T> { // expected-note 2 {{'T' declared as parameter to type '
   init(_ x: T) {}
 }
 
+struct GenericInitLabeled<T> {
+  init(x: T) {}
+}
+
 struct GenericInitTwo<T> {
   init(_ x: T, _ y: T) {} // expected-note 8 {{'init' declared here}}
 }
@@ -875,26 +935,42 @@ struct GenericInitTuple<T> {
   init(_ x: (T, T)) {}
 }
 
+struct GenericInitLabeledTuple<T> {
+  init(x: (T, T)) {}
+}
+
 do {
   _ = GenericInit(3, 4)
   _ = GenericInit((3, 4))
 
+  _ = GenericInitLabeled(x: 3, 4) // expected-error {{extra argument in call}}
+  _ = GenericInitLabeled(x: (3, 4))
+
   _ = GenericInitTwo(3, 4)
   _ = GenericInitTwo((3, 4)) // expected-error {{missing argument for parameter #2 in call}}
 
   _ = GenericInitTuple(3, 4) // expected-error {{extra argument in call}}
   _ = GenericInitTuple((3, 4))
+
+  _ = GenericInitLabeledTuple(x: 3, 4) // expected-error {{extra argument in call}}
+  _ = GenericInitLabeledTuple(x: (3, 4))
 }
 
 do {
   _ = GenericInit<(Int, Int)>(3, 4)
   _ = GenericInit<(Int, Int)>((3, 4)) // expected-error {{expression type 'GenericInit<(Int, Int)>' is ambiguous without more context}}
 
+  _ = GenericInitLabeled<(Int, Int)>(x: 3, 4) // expected-error {{extra argument in call}}
+  _ = GenericInitLabeled<(Int, Int)>(x: (3, 4))
+
   _ = GenericInitTwo<Int>(3, 4)
   _ = GenericInitTwo<Int>((3, 4)) // expected-error {{missing argument for parameter #2 in call}}
 
   _ = GenericInitTuple<Int>(3, 4) // expected-error {{extra argument in call}}
   _ = GenericInitTuple<Int>((3, 4))
+
+  _ = GenericInitLabeledTuple<Int>(x: 3, 4) // expected-error {{extra argument in call}}
+  _ = GenericInitLabeledTuple<Int>(x: (3, 4))
 }
 
 do {
@@ -973,6 +1049,10 @@ struct GenericSubscript<T> {
   subscript(_ x: T) -> Int { get { return 0 } set { } }
 }
 
+struct GenericSubscriptLabeled<T> {
+  subscript(x x: T) -> Int { get { return 0 } set { } }
+}
+
 struct GenericSubscriptTwo<T> {
   subscript(_ x: T, _ y: T) -> Int { get { return 0 } set { } } // expected-note {{'subscript' declared here}}
 }
@@ -981,18 +1061,30 @@ struct GenericSubscriptTuple<T> {
   subscript(_ x: (T, T)) -> Int { get { return 0 } set { } }
 }
 
+struct GenericSubscriptLabeledTuple<T> {
+  subscript(x x: (T, T)) -> Int { get { return 0 } set { } }
+}
+
 do {
   let s1 = GenericSubscript<(Double, Double)>()
   _ = s1[3.0, 4.0]
   _ = s1[(3.0, 4.0)] // expected-error {{expression type 'Int' is ambiguous without more context}}
 
+  let s1a  = GenericSubscriptLabeled<(Double, Double)>()
+  _ = s1a [x: 3.0, 4.0] // expected-error {{extra argument in call}}
+  _ = s1a [x: (3.0, 4.0)]
+
   let s2 = GenericSubscriptTwo<Double>()
   _ = s2[3.0, 4.0]
   _ = s2[(3.0, 4.0)] // expected-error {{missing argument for parameter #2 in call}}
 
   let s3 = GenericSubscriptTuple<Double>()
   _ = s3[3.0, 4.0] // expected-error {{extra argument in call}}
   _ = s3[(3.0, 4.0)]
+
+  let s3a = GenericSubscriptLabeledTuple<Double>()
+  _ = s3a[x: 3.0, 4.0] // expected-error {{extra argument in call}}
+  _ = s3a[x: (3.0, 4.0)]
 }
 
 do {
@@ -1039,6 +1131,7 @@ do {
 
 enum GenericEnum<T> {
   case one(T)
+  case labeled(x: T)
   case two(T, T) // expected-note 8 {{'two' declared here}}
   case tuple((T, T))
 }
@@ -1047,6 +1140,11 @@ do {
   _ = GenericEnum.one(3, 4)
   _ = GenericEnum.one((3, 4))
 
+  _ = GenericEnum.labeled(x: 3, 4) // expected-error {{extra argument in call}}
+  _ = GenericEnum.labeled(x: (3, 4))
+  _ = GenericEnum.labeled(3, 4) // expected-error {{extra argument in call}}
+  _ = GenericEnum.labeled((3, 4)) // expected-error {{missing argument label 'x:' in call}}
+
   _ = GenericEnum.two(3, 4)
   _ = GenericEnum.two((3, 4)) // expected-error {{missing argument for parameter #2 in call}}
 
@@ -1055,9 +1153,14 @@ do {
 }
 
 do {
-  _ = GenericEnum<(Int, Int)>.one(3, 4) // FIXME: Diagnoses in Swift 3 mode // expected-error {{extra argument in call}}
+  _ = GenericEnum<(Int, Int)>.one(3, 4)
   _ = GenericEnum<(Int, Int)>.one((3, 4)) // Does not diagnose in Swift 3 mode
 
+  _ = GenericEnum<(Int, Int)>.labeled(x: 3, 4) // expected-error {{extra argument in call}}
+  _ = GenericEnum<(Int, Int)>.labeled(x: (3, 4))
+  _ = GenericEnum<(Int, Int)>.labeled(3, 4) // expected-error {{extra argument in call}}
+  _ = GenericEnum<(Int, Int)>.labeled((3, 4)) // expected-error {{missing argument label 'x:' in call}}
+
   _ = GenericEnum<Int>.two(3, 4)
   _ = GenericEnum<Int>.two((3, 4)) // expected-error {{missing argument for parameter #2 in call}}
 
@@ -1143,6 +1246,7 @@ protocol Protocol {
 
 extension Protocol {
   func requirement(_ x: Element) {}
+  func requirementLabeled(x: Element) {}
   func requirementTwo(_ x: Element, _ y: Element) {} // expected-note 2 {{'requirementTwo' declared here}}
   func requirementTuple(_ x: (Element, Element)) {}
 }
@@ -1157,6 +1261,9 @@ do {
   s.requirement(3.0)
   s.requirement((3.0))
 
+  s.requirementLabeled(x: 3.0)
+  s.requirementLabeled(x: (3.0))
+
   s.requirementTwo(3.0, 4.0)
   s.requirementTwo((3.0, 4.0)) // expected-error {{missing argument for parameter #2 in call}}
 
@@ -1167,6 +1274,9 @@ do {
 
   sTwo.requirement(3.0, 4.0) // expected-error {{extra argument in call}}
   sTwo.requirement((3.0, 4.0))
+
+  sTwo.requirementLabeled(x: 3.0, 4.0) // expected-error {{extra argument in call}}
+  sTwo.requirementLabeled(x: (3.0, 4.0))
 }
 
 do {