[ConstraintSystem] Strip labels from enum elements when passed as values

lib/Sema/ConstraintSystem.cpp

@@ -712,30 +712,53 @@ void ConstraintSystem::recordOpenedTypes(
 
 /// Determine how many levels of argument labels should be removed from the
 /// function type when referencing the given declaration.
-static unsigned getNumRemovedArgumentLabels(ASTContext &ctx, ValueDecl *decl,
+static unsigned getNumRemovedArgumentLabels(TypeChecker &TC, ValueDecl *decl,
                                             bool isCurriedInstanceReference,
                                             FunctionRefKind functionRefKind) {
+  unsigned numParameterLists = 0;
+
+  // Enum element with associated value has to be treated
+  // as regular function value and all of the labels have to be
+  // stripped from its parameters.
+  //
+  // enum E {
+  //   case foo(a: Int)
+  // }
+  // let bar: [Int] = []
+  // bar.map(E.foo)
+  //
+  // `E.foo` has to act as a regular function type passed as a value.
+  if (!TC.getLangOpts().isSwiftVersion3()) {
+    if (auto *EED = dyn_cast<EnumElementDecl>(decl)) {
+      numParameterLists = EED->hasAssociatedValues() ? 2 : 1;
+    }
+  }
+
   // Only applicable to functions. Nothing else should have argument labels in
   // the type.
-  auto func = dyn_cast<AbstractFunctionDecl>(decl);
-  if (!func) return 0;
+  if (auto func = dyn_cast<AbstractFunctionDecl>(decl))
+    numParameterLists = func->getNumParameterLists();
+
+  if (numParameterLists == 0)
+    return 0;
 
   switch (functionRefKind) {
   case FunctionRefKind::Unapplied:
   case FunctionRefKind::Compound:
     // Always remove argument labels from unapplied references and references
     // that use a compound name.
-    return func->getNumParameterLists();
+    return numParameterLists;
 
   case FunctionRefKind::SingleApply:
     // If we have fewer than two parameter lists, leave the labels.
-    if (func->getNumParameterLists() < 2) return 0;
+    if (numParameterLists < 2)
+      return 0;
 
     // If this is a curried reference to an instance method, where 'self' is
     // being applied, e.g., "ClassName.instanceMethod(self)", remove the
     // argument labels from the resulting function type. The 'self' parameter is
     // always unlabeled, so this operation is a no-op for the actual application.
-    return isCurriedInstanceReference ? func->getNumParameterLists() : 1;
+    return isCurriedInstanceReference ? numParameterLists : 1;
 
   case FunctionRefKind::DoubleApply:
     // Never remove argument labels from a double application.
@@ -796,7 +819,7 @@ ConstraintSystem::getTypeOfReference(ValueDecl *value,
     auto openedType =
       openFunctionType(
         funcType,
-        getNumRemovedArgumentLabels(TC.Context, funcDecl,
+        getNumRemovedArgumentLabels(TC, funcDecl,
                                     /*isCurriedInstanceReference=*/false,
                                     functionRefKind),
         locator, replacements,
@@ -1113,7 +1136,7 @@ ConstraintSystem::getTypeOfMemberReference(
   auto &replacements = replacementsPtr ? *replacementsPtr : localReplacements;
   bool isCurriedInstanceReference = value->isInstanceMember() && !isInstance;
   unsigned numRemovedArgumentLabels =
-    getNumRemovedArgumentLabels(TC.Context, value, isCurriedInstanceReference,
+    getNumRemovedArgumentLabels(TC, value, isCurriedInstanceReference,
                                 functionRefKind);
 
   AnyFunctionType *funcType;

test/Compatibility/enum_cases.swift

@@ -0,0 +1,91 @@
+// RUN: %target-typecheck-verify-swift -swift-version 3
+
+// Tests for enum case behavior in Swift 3
+
+enum E {
+  case foo(bar: String)
+  case bar(_: String)
+  case two(x: Int, y: Int)
+  case tuple((x: Int, y: Int))
+}
+
+enum G_E<T> {
+  case foo(bar: T)
+  case bar(_: T)
+  case two(x: T, y: T)
+  case tuple((x: T, y: T))
+}
+
+let arr: [String] = []
+let _ = arr.map(E.foo) // Ok
+let _ = arr.map(E.bar) // Ok
+let _ = arr.map(E.two) // expected-error {{cannot convert value of type '(Int, Int) -> E' to expected argument type '(String) -> _'}}
+let _ = arr.map(E.tuple) // expected-error {{cannot convert value of type '((x: Int, y: Int)) -> E' to expected argument type '(String) -> _'}}
+
+let _ = arr.map(G_E<String>.foo) // Ok
+let _ = arr.map(G_E<String>.bar) // Ok
+let _ = arr.map(G_E<String>.two) // expected-error {{cannot convert value of type '(String, String) -> G_E<String>' to expected argument type '(String) -> _'}}
+let _ = arr.map(G_E<Int>.tuple) // expected-error {{cannot convert value of type '((x: Int, y: Int)) -> G_E<Int>' to expected argument type '(String) -> _'}}
+
+let _ = E.foo("hello") // expected-error {{missing argument label 'bar:' in call}}
+let _ = E.bar("hello") // Ok
+
+let _ = G_E<String>.foo("hello") // expected-error {{missing argument label 'bar:' in call}}
+let _ = G_E<String>.bar("hello") // Ok
+
+// Passing enum case as an argument to generic function
+
+func bar_1<T>(_: (T) -> E) {}
+func bar_2<T>(_: (T) -> G_E<T>) {}
+func bar_3<T, U>(_: (T) -> G_E<U>) {}
+
+bar_1(E.foo) // Ok
+bar_1(E.bar) // Ok
+bar_1(E.two) // Ok in Swift 3
+bar_1(E.tuple) // Ok - it's going to be ((x: Int, y: Int))
+
+bar_2(G_E<String>.foo) // Ok
+bar_2(G_E<Int>.bar) // Ok
+bar_2(G_E<Int>.two) // expected-error {{cannot convert value of type '(Int, Int) -> G_E<Int>' to expected argument type '(_) -> G_E<_>'}}
+bar_2(G_E<Int>.tuple) // expected-error {{cannot convert value of type '((x: Int, y: Int)) -> G_E<Int>' to expected argument type '(_) -> G_E<_>'}}
+bar_3(G_E<Int>.tuple) // Ok
+
+// Regular enum case assigned as a value
+
+let foo: (String) -> E = E.foo // Ok
+let _ = foo("hello") // Ok
+
+let bar: (String) -> E = E.bar // Ok
+let _ = bar("hello") // Ok
+
+let two: (Int, Int) -> E = E.two // Ok
+let _ = two(0, 42) // Ok
+
+let tuple: ((x: Int, y: Int)) -> E = E.tuple // Ok
+let _ = tuple((x: 0, y: 42)) // Ok
+
+// Generic enum case assigned as a value
+
+let g_foo: (String) -> G_E<String> = G_E<String>.foo // Ok
+let _ = g_foo("hello") // Ok
+
+let g_bar: (String) -> G_E<String> = G_E<String>.bar // Ok
+let _ = g_bar("hello") // Ok
+
+let g_two: (Int, Int) -> G_E<Int> = G_E<Int>.two // Ok
+let _ = g_two(0, 42) // Ok
+
+let g_tuple: ((x: Int, y: Int)) -> G_E<Int> = G_E<Int>.tuple // Ok
+let _ = g_tuple((x: 0, y: 42)) // Ok
+
+// Following example doesn't work in Swift 3 mode because Foo.a and Foo.b have different argument types
+// since the labels are not striped from them.
+
+enum Foo {
+  case a(x: Int)
+  case b(y: Int)
+}
+
+func foo<T>(_: T, _: T) {}
+foo(Foo.a, Foo.b) // expected-error {{cannot invoke 'foo' with an argument list of type '((Int) -> Foo, (Int) -> Foo)}}
+// expected-note@-1 {{expected an argument list of type '(T, T)'}}

test/Constraints/enum_cases.swift

@@ -0,0 +1,88 @@
+// RUN: %target-typecheck-verify-swift -swift-version 4
+
+// See test/Compatibility/enum_cases.swift for Swift 3 behavior
+
+enum E {
+  case foo(bar: String)
+  case bar(_: String)
+  case two(x: Int, y: Int)
+  case tuple((x: Int, y: Int))
+}
+
+enum G_E<T> {
+  case foo(bar: T)
+  case bar(_: T)
+  case two(x: T, y: T)
+  case tuple((x: T, y: T))
+}
+
+let arr: [String] = []
+let _ = arr.map(E.foo) // Ok
+let _ = arr.map(E.bar) // Ok
+let _ = arr.map(E.two) // expected-error {{cannot convert value of type '(Int, Int) -> E' to expected argument type '(String) -> _'}}
+let _ = arr.map(E.tuple) // expected-error {{cannot convert value of type '((x: Int, y: Int)) -> E' to expected argument type '(String) -> _'}}
+
+let _ = arr.map(G_E<String>.foo) // Ok
+let _ = arr.map(G_E<String>.bar) // Ok
+let _ = arr.map(G_E<String>.two) // expected-error {{cannot convert value of type '(String, String) -> G_E<String>' to expected argument type '(String) -> _'}}
+let _ = arr.map(G_E<Int>.tuple) // expected-error {{cannot convert value of type '((x: Int, y: Int)) -> G_E<Int>' to expected argument type '(String) -> _'}}
+
+let _ = E.foo("hello") // expected-error {{missing argument label 'bar:' in call}}
+let _ = E.bar("hello") // Ok
+
+let _ = G_E<String>.foo("hello") // expected-error {{missing argument label 'bar:' in call}}
+let _ = G_E<String>.bar("hello") // Ok
+
+// Passing enum case as an argument to generic function
+
+func bar_1<T>(_: (T) -> E) {}
+func bar_2<T>(_: (T) -> G_E<T>) {}
+func bar_3<T, U>(_: (T) -> G_E<U>) {}
+
+bar_1(E.foo) // Ok
+bar_1(E.bar) // Ok
+bar_1(E.two) // expected-error {{cannot convert value of type '(Int, Int) -> E' to expected argument type '(_) -> E'}}
+bar_1(E.tuple) // Ok - it's going to be ((x: Int, y: Int))
+
+bar_2(G_E<String>.foo) // Ok
+bar_2(G_E<Int>.bar) // Ok
+bar_2(G_E<Int>.two) // expected-error {{cannot convert value of type '(Int, Int) -> G_E<Int>' to expected argument type '(_) -> G_E<_>'}}
+bar_2(G_E<Int>.tuple) // expected-error {{cannot convert value of type '((x: Int, y: Int)) -> G_E<Int>' to expected argument type '(_) -> G_E<_>'}}
+bar_3(G_E<Int>.tuple) // Ok
+
+// Regular enum case assigned as a value
+
+let foo: (String) -> E = E.foo // Ok
+let _ = foo("hello") // Ok
+
+let bar: (String) -> E = E.bar // Ok
+let _ = bar("hello") // Ok
+
+let two: (Int, Int) -> E = E.two // Ok
+let _ = two(0, 42) // Ok
+
+let tuple: ((x: Int, y: Int)) -> E = E.tuple // Ok
+let _ = tuple((x: 0, y: 42)) // Ok
+
+// Generic enum case assigned as a value
+
+let g_foo: (String) -> G_E<String> = G_E<String>.foo // Ok
+let _ = g_foo("hello") // Ok
+
+let g_bar: (String) -> G_E<String> = G_E<String>.bar // Ok
+let _ = g_bar("hello") // Ok
+
+let g_two: (Int, Int) -> G_E<Int> = G_E<Int>.two // Ok
+let _ = g_two(0, 42) // Ok
+
+let g_tuple: ((x: Int, y: Int)) -> G_E<Int> = G_E<Int>.tuple // Ok
+let _ = g_tuple((x: 0, y: 42)) // Ok
+
+
+enum Foo {
+  case a(x: Int)
+  case b(y: Int)
+}
+
+func foo<T>(_: T, _: T) {}
+foo(Foo.a, Foo.b) // Ok in Swift 4 because we strip labels from the arguments