Make use of curried function declaration syntax an error.

<rdar://problem/23111018>

Author: cwillmor

include/swift/AST/DiagnosticsParse.def

@@ -671,8 +671,8 @@ ERROR(parameter_operator_keyword_argument,none,
 ERROR(parameter_unnamed,none,
       "unnamed parameters must be written with the empty name '_'", ())
 
-WARNING(parameter_curry_syntax_removed,none,
-        "curried function declaration syntax will be removed in a future version of Swift; use a single parameter list", ())
+ERROR(parameter_curry_syntax_removed,none,
+      "curried function declaration syntax has been removed; use a single parameter list", ())
 
 //------------------------------------------------------------------------------
 // Statement parsing diagnostics

lib/Parse/ParsePattern.cpp

@@ -520,7 +520,7 @@ Parser::parseFunctionArguments(SmallVectorImpl<Identifier> &NamePieces,
     paramContext = ParameterContextKind::Curried;
   }
 
-  // If the decl uses currying syntax, warn that that syntax is going away.
+  // If the decl uses currying syntax, complain that that syntax has gone away.
   if (BodyParams.size() - FirstBodyPatternIndex > 1) {
     SourceRange allPatternsRange(
       BodyParams[FirstBodyPatternIndex]->getStartLoc(),

test/Constraints/diagnostics.swift

@@ -260,9 +260,9 @@ func rdar21784170() {
 }
 
 // <rdar://problem/21829141> BOGUS: unexpected trailing closure
-func expect<T, U>(_: T)(_: U.Type) {}  //  expected-warning{{curried function declaration syntax will be removed in a future version of Swift}}
-func expect<T, U>(_: T, _: Int = 1)(_: U.Type) {} //  expected-warning{{curried function declaration syntax will be removed in a future version of Swift}}
-expect(Optional(3))(Optional<Int>.self)
+func expect<T, U>(_: T) -> (U.Type) -> () { return { ty in () } } // expected-note{{found this candidate}}
+func expect<T, U>(_: T, _: Int = 1) -> (U.Type) -> () { return { ty in () } } // expected-note{{found this candidate}}
+expect(Optional(3))(Optional<Int>.self) // expected-error{{ambiguous use of 'expect'}}
 
 // <rdar://problem/19804707> Swift Enum Scoping Oddity
 func rdar19804707() {
@@ -300,8 +300,8 @@ func r20789423() {
 
 
 
-func f7(a: Int)(b : Int) -> Int { // expected-warning{{curried function declaration syntax will be removed in a future version of Swift}}
-  return a+b
+func f7(a: Int) -> (b: Int) -> Int {
+  return { b in a+b }
 }
 
 f7(1)(b: 1)
@@ -319,7 +319,7 @@ f8(b: 1.0)         // expected-error {{cannot convert value of type 'Double' to
 
 class CurriedClass {
   func method1() {}
-  func method2(a: Int)(b : Int) {} // expected-warning{{curried function declaration syntax will be removed in a future version of Swift}}
+  func method2(a: Int) -> (b : Int) -> () { return { b in () } }
   func method3(a: Int, b : Int) {}
 }
 

test/Constraints/members.swift

@@ -41,7 +41,7 @@ struct Z {
   func getI() -> Int { return i }
   mutating func incI() {}
 
-  func curried(x: Int)(y: Int) -> Int { return x + y } // expected-warning{{curried function declaration syntax will be removed in a future version of Swift}}
+  func curried(x: Int) -> (Int) -> Int { return { y in x + y } }
 
   subscript (k : Int) -> Int {
     get {
@@ -78,7 +78,7 @@ var incI = z.incI // expected-error{{partial application of 'mutating'}}
 var zi = z.getI()
 var zcurried1 = z.curried
 var zcurried2 = z.curried(0)
-var zcurriedFull = z.curried(0)(y: 1)
+var zcurriedFull = z.curried(0)(1)
 
 ////
 // Members of modules
@@ -110,15 +110,15 @@ enum W {
   case Omega
 
   func foo(x: Int) {}
-  func curried(x: Int)(y: Int) {} // expected-warning{{curried function declaration syntax will be removed in a future version of Swift}}
+  func curried(x: Int) -> (Int) -> () {}
 }
 
 var w = W.Omega
 var foo = w.foo
 var fooFull : () = w.foo(0)
 var wcurried1 = w.curried
 var wcurried2 = w.curried(0)
-var wcurriedFull : () = w.curried(0)(y: 1)
+var wcurriedFull : () = w.curried(0)(1)
 
 // Member of enum Type
 func enumMetatypeMember(opt: Int?) {
@@ -328,7 +328,7 @@ protocol Functional {
   func apply(v: Vector) -> Scalar
 }
 protocol Coalgebra {
-  func coproduct(f: Functional)(v1: Vector, v2: Vector) -> Scalar // expected-warning{{curried function declaration syntax will be removed in a future version of Swift}}
+  func coproduct(f: Functional) -> (v1: Vector, v2: Vector) -> Scalar
 }
 
 // Make sure existential is closed early when we partially apply

test/Constraints/tuple.swift

@@ -72,11 +72,13 @@ extension Int : PosixErrorReturn {
 }
 
 func posixCantFail<A, T : protocol<Comparable, PosixErrorReturn>>
-  (f:(A) -> T)(args:A) -> T // expected-warning{{curried function declaration syntax will be removed in a future version of Swift}}
+  (f:(A) -> T) -> (args:A) -> T
 {
-  let result = f(args)
-  assert(result != T.errorReturnValue())
-  return result
+  return { args in
+    let result = f(args)
+    assert(result != T.errorReturnValue())
+    return result
+  }
 }
 
 func open(name: String, oflag: Int) -> Int { }

test/DebugInfo/argument.swift

@@ -54,13 +54,6 @@ class A {
 
 }
 
-// Curried functions have their arguments backwards.
-// CHECK: !DILocalVariable(name: "b", arg: 1,{{.*}} line: [[@LINE+2]]
-// CHECK: !DILocalVariable(name: "a", arg: 2,{{.*}} line: [[@LINE+1]]
-func uncurry (a: Int64) (b: Int64) -> (Int64, Int64) {
-  return (a, b)
-}
-
 // CHECK: !DILocalVariable(name: "x", arg: 1,{{.*}} line: [[@LINE+2]]
 // CHECK: !DILocalVariable(name: "y", arg: 2,{{.*}} line: [[@LINE+1]]
 func tuple(x: Int64, y: (Int64, Float, String)) -> Int64 {

test/Generics/same_type_constraints.swift

@@ -85,8 +85,8 @@ public struct LazySequenceOf<S : SequenceType, A where S.Generator.Element == A>
   public subscript(i : A) -> A { return i }
 }
 
-public func iterate<A>(f : A -> A)(x : A) -> LazySequenceOf<Iterate<A>, A>? { // expected-warning{{curried function declaration syntax will be removed in a future version of Swift}}
-  return nil
+public func iterate<A>(f : A -> A) -> (x : A) -> LazySequenceOf<Iterate<A>, A>? {
+  return { x in nil }
 }
 
 public final class Iterate<A> : SequenceType {

test/IDE/print_ast_tc_decls.swift

@@ -177,30 +177,6 @@ struct d0100_FooStruct {
   }
 // PASS_COMMON-NEXT: {{^}}  subscript (i: Int, j: Int) -> Double { get }{{$}}
 
-  func curriedVoidFunc1()() {} // expected-warning{{curried function declaration syntax will be removed in a future version of Swift}}
-// PASS_COMMON-NEXT: {{^}}  func curriedVoidFunc1()(){{$}}
-
-  func curriedVoidFunc2()(a: Int) {} // expected-warning{{curried function declaration syntax will be removed in a future version of Swift}}
-// PASS_COMMON-NEXT: {{^}}  func curriedVoidFunc2()(a: Int){{$}}
-
-  func curriedVoidFunc3(a: Int)() {} // expected-warning{{curried function declaration syntax will be removed in a future version of Swift}}
-// PASS_COMMON-NEXT: {{^}}  func curriedVoidFunc3(a: Int)(){{$}}
-
-  func curriedVoidFunc4(a: Int)(b: Int) {} // expected-warning{{curried function declaration syntax will be removed in a future version of Swift}}
-// PASS_COMMON-NEXT: {{^}}  func curriedVoidFunc4(a: Int)(b: Int){{$}}
-
-  func curriedStringFunc1()() -> String { return "" } // expected-warning{{curried function declaration syntax will be removed in a future version of Swift}}
-// PASS_COMMON-NEXT: {{^}}  func curriedStringFunc1()() -> String{{$}}
-
-  func curriedStringFunc2()(a: Int) -> String { return "" } // expected-warning{{curried function declaration syntax will be removed in a future version of Swift}}
-// PASS_COMMON-NEXT: {{^}}  func curriedStringFunc2()(a: Int) -> String{{$}}
-
-  func curriedStringFunc3(a: Int)() -> String { return "" } // expected-warning{{curried function declaration syntax will be removed in a future version of Swift}}
-// PASS_COMMON-NEXT: {{^}}  func curriedStringFunc3(a: Int)() -> String{{$}}
-
-  func curriedStringFunc4(a: Int)(b: Int) -> String { return "" } // expected-warning{{curried function declaration syntax will be removed in a future version of Swift}}
-// PASS_COMMON-NEXT: {{^}}  func curriedStringFunc4(a: Int)(b: Int) -> String{{$}}
-
   func bodyNameVoidFunc1(a: Int, b x: Float) {}
 // PASS_COMMON-NEXT: {{^}}  func bodyNameVoidFunc1(a: Int, b x: Float){{$}}
 

test/IDE/print_types.swift

@@ -99,7 +99,7 @@ func testVariadicFuncType(a: Int, b: Float...) {}
 // CHECK: FuncDecl '''testVariadicFuncType''' (Int, b: Float...) -> (){{$}}
 // FULL:  FuncDecl '''testVariadicFuncType''' (Swift.Int, b: Swift.Float...) -> (){{$}}
 
-func testCurriedFuncType1(a: Int)(b: Float) {} // expected-warning{{curried function declaration syntax will be removed in a future version of Swift}}
+func testCurriedFuncType1(a: Int) -> (b: Float) -> () {}
 // CHECK: FuncDecl '''testCurriedFuncType1''' (Int) -> (b: Float) -> (){{$}}
 // FULL:  FuncDecl '''testCurriedFuncType1''' (Swift.Int) -> (b: Swift.Float) -> (){{$}}
 

test/IRGen/class.sil

@@ -11,7 +11,6 @@ import Swift
 // CHECK: [[TYPE:%swift.type]] = type
 // CHECK: [[C_CLASS:%C5class1C]] = type
 // CHECK: [[REF:%swift.refcounted]] = type
-// CHECK: [[D_CLASS:%C5class1D]] = type
 // CHECK: [[OBJCOBJ:%objc_object]] = type
 
 class C {}
@@ -44,26 +43,6 @@ sil_vtable C {}
 // \ CHECK:   i64 add (i64 ptrtoint ({{.*}}* @_DATA__TtC5class1C to i64), i64 1)
 // \ CHECK: }
 
-//   CHECK: @_TMfC5class1D = internal global { {{.*}} } {
-// \ CHECK:   void ([[D_CLASS]]*)* @_TFC5class1DD,
-// \ CHECK:   i8** @_TWVBo,
-// \ CHECK:   i64 ptrtoint ([[OBJCCLASS]]* @_TMmC5class1D to i64),
-// \ CHECK:   [[OBJCCLASS]]* @"OBJC_CLASS_$_SwiftObject",
-// \ CHECK:   [[OPAQUE]]* @_objc_empty_cache,
-// \ CHECK:   [[OPAQUE]]* null,
-// \ CHECK:   i64 add (i64 ptrtoint ({{.*}}* @_DATA__TtC5class1D to i64), i64 1),
-// \ CHECK:   i32 3,
-// \ CHECK:   i32 0,
-// \ CHECK:   i32 16,
-// \ CHECK:   i16 7,
-// \ CHECK:   i16 0,
-// \ CHECK:   i32 112,
-// \ CHECK:   i32 16,
-// \ CHECK:   {{.*}}* @_TMnC5class1D,
-// \ CHECK:   i8* null,
-// \ CHECK:   i32 (i16, i8, [[D_CLASS]]*)* @_TFC5class1D8multiplyfS0_fT1xBi8__FT1yBi16__Bi32_
-// \ CHECK: }
-
 // Destroying destructor
 // CHECK: define [[REF]]* @_TFC5class1Cd([[C_CLASS]]*) {{.*}} {
 // CHECK-NEXT: entry:
@@ -109,28 +88,6 @@ entry(%c : $C):
   return %r : $Builtin.UnknownObject
 }
 
-// Part of rdar://16079147
-// vtable tested above
-class D {
-  func multiply(x x : Builtin.Int8)(y : Builtin.Int16) -> Builtin.Int32
-}
-
-sil @_TFC5class1DD : $@convention(method) (@owned D) -> () {
-bb0(%0 : $D):
-  %1 = tuple ()
-  return %1 : $()
-}
-
-sil hidden @_TFC5class1D8multiplyfS0_fT1xBi8__FT1yBi16__Bi32_ : $@convention(method) (Builtin.Int16, Builtin.Int8, @guaranteed D) -> Builtin.Int32 {
-bb0(%0 : $Builtin.Int16, %1 : $Builtin.Int8, %2 : $D):
-  %3 = integer_literal $Builtin.Int32, 0
-  return %3 : $Builtin.Int32
-}
-
-sil_vtable D {
-  #D.multiply!2: _TFC5class1D8multiplyfS0_fT1xBi8__FT1yBi16__Bi32_
-}
-
 // CHECK-LABEL: define %C5class1C* @alloc_ref_dynamic(%swift.type*)
 sil @alloc_ref_dynamic : $@convention(thin) (@thick C.Type) -> @owned C {
 bb0(%0 : $@thick C.Type):

test/IRGen/partial_apply_generic.swift

@@ -25,8 +25,11 @@ struct Spoon: Runcible {
   typealias Element = Mince
 }
 
-func split<Seq: Runcible>(seq: Seq)(isSeparator: Seq.Element -> Bool) { }
-
+func split<Seq: Runcible>(seq: Seq) -> (Seq.Element -> Bool) -> () {
+  return {(isSeparator: Seq.Element -> Bool) in
+    return ()
+  }
+}
 var seq = Spoon()
 var x = seq ~> split
 
@@ -39,10 +42,15 @@ var x = seq ~> split
 // CHECK:         tail call { i8*, %swift.refcounted* } @_TF21partial_apply_generic5split{{.*}}(%swift.opaque* noalias nocapture [[REABSTRACT]],
 
 struct HugeStruct { var a, b, c, d: Int }
-func hugeStructReturn()(h: HugeStruct) -> HugeStruct { return h }
-var y = hugeStructReturn()
-// CHECK-LABEL: define internal void @_TPA__TF21partial_apply_generic16hugeStructReturn{{.*}}(%V21partial_apply_generic10HugeStruct* noalias nocapture sret, %V21partial_apply_generic10HugeStruct* noalias nocapture dereferenceable({{.*}}), %swift.refcounted*) {{.*}} {
-// CHECK:   tail call void @_TF21partial_apply_generic16hugeStructReturn{{.*}}(%V21partial_apply_generic10HugeStruct* noalias nocapture sret %0, %V21partial_apply_generic10HugeStruct* noalias nocapture dereferenceable({{.*}}) %1)
+struct S {
+  func hugeStructReturn(h: HugeStruct) -> HugeStruct { return h }
+}
+
+let s = S()
+var y = s.hugeStructReturn
+// CHECK-LABEL: define internal void @_TPA__TFV21partial_apply_generic1S16hugeStructReturnfVS_10HugeStructS1_(%V21partial_apply_generic10HugeStruct* noalias nocapture sret, %V21partial_apply_generic10HugeStruct* noalias nocapture dereferenceable(32), %swift.refcounted*) #0 {
+// CHECK: entry:
+// CHECK:   tail call void @_TFV21partial_apply_generic1S16hugeStructReturnfVS_10HugeStructS1_(%V21partial_apply_generic10HugeStruct* noalias nocapture sret %0, %V21partial_apply_generic10HugeStruct* noalias nocapture dereferenceable(32) %1) #0
 // CHECK:   ret void
 // CHECK: }
 

test/Interpreter/currying_generics.swift

@@ -1,12 +1,12 @@
 // RUN: %target-run-simple-swift | FileCheck %s
 // REQUIRES: executable_test
 
-func curry<T, U, V>(f: (T, U) -> V)(_ x: T)(_ y: U) -> V {
-  return f(x, y)
+func curry<T, U, V>(f: (T, U) -> V) -> (T) -> (U) -> V {
+  return { x in { y in f(x, y) } }
 }
 
-func curry<T1, T2, T3, T4>(f: (T1, T2, T3) -> T4)(_ x: T1)(_ y: T2)(_ z: T3) -> T4 {
-  return f(x, y, z)
+func curry<T1, T2, T3, T4>(f: (T1, T2, T3) -> T4) -> (T1) -> (T2) -> (T3) -> T4 {
+  return { x in { y in { z in f(x, y, z) } } }
 }
 
 func concat(x: String, _ y: String, _ z: String) -> String {
@@ -91,8 +91,8 @@ print(test_compose_closure(20)) // CHECK-NEXT: 21
 
 // rdar://problem/18988428
 
-func clamp<T: Comparable>(minValue: T, _ maxValue: T)(n: T) -> T {
-    return max(minValue, min(n, maxValue))
+func clamp<T: Comparable>(minValue: T, _ maxValue: T) -> (n: T) -> T {
+    return { n in max(minValue, min(n, maxValue)) }
 }
 
 let clampFoo2 = clamp(10.0, 30.0)
@@ -105,8 +105,8 @@ func pair<T,U> (a: T) -> U -> (T,U) {
 	return { b in (a,b)	}
 }
 
-func pair_<T,U> (a: T)(b: U) -> (T,U) {
-	return (a,b)
+func pair_<T,U> (a: T) -> (b: U) -> (T,U) {
+	return { b in (a,b) }
 }
 
 infix operator <+> { }
@@ -130,20 +130,20 @@ print((b <+> pair_)(a!)) // CHECK-NEXT: (42, 23)
 struct Identity<A> { let value: A }
 struct Const<A, B> { let value: A }
 
-func fmap<A, B>(f: A -> B)(_ identity: Identity<A>) -> Identity<B> {
-	return Identity(value: f(identity.value))
+func fmap<A, B>(f: A -> B) -> (Identity<A>) -> Identity<B> {
+	return { identity in Identity(value: f(identity.value)) }
 }
 
-func fmap<A, B>(f: A -> B)(_ const: Const<A, B>) -> Const<A, B> {
-	return const
+func fmap<A, B>(f: A -> B) -> (Const<A, B>) -> Const<A, B> {
+	return { const in const }
 }
 
 // really Const()
 func _Const<A, B>(a: A) -> Const<A, B> {
 	return Const(value: a)
 }
-func const<A, B>(a: A)(_: B) -> A {
-	return a
+func const<A, B>(a: A) -> (B) -> A {
+	return { _ in a }
 }
 
 // really Identity()
@@ -160,24 +160,24 @@ func runIdentity<A>(i: Identity<A>) -> A {
 }
 
 
-func view<S, A>(lens: (A -> Const<A, S>) -> S -> ((A -> S) -> Const<A, S> -> Const<A, S>) -> Const<A, S>)(_ s: S) -> A {
-	return getConst(lens(_Const)(s)(fmap))
+func view<S, A>(lens: (A -> Const<A, S>) -> S -> ((A -> S) -> Const<A, S> -> Const<A, S>) -> Const<A, S>) -> (S) -> A {
+	return { s in getConst(lens(_Const)(s)(fmap)) }
 }
 
-func over<S, A>(lens: (A -> Identity<A>) -> S -> ((A -> S) -> Identity<A> -> Identity<S>) -> Identity<S>)(_ f: A -> A)(_ s: S) -> S {
-	return runIdentity(lens({ _Identity(f($0)) })(s)(fmap))
+func over<S, A>(lens: (A -> Identity<A>) -> S -> ((A -> S) -> Identity<A> -> Identity<S>) -> Identity<S>) -> (A -> A) -> (S) -> S {
+	return { f in { s in runIdentity(lens({ _Identity(f($0)) })(s)(fmap)) } }
 }
 
-func set<S, A>(lens: (A -> Identity<A>) -> S -> ((A -> S) -> Identity<A> -> Identity<S>) -> Identity<S>)(_ x: A)(_ y: S) -> S {
-	return over(lens)(const(x))(y)
+func set<S, A>(lens: (A -> Identity<A>) -> S -> ((A -> S) -> Identity<A> -> Identity<S>) -> Identity<S>) -> (A) -> (S) -> S {
+	return { x in { y in over(lens)(const(x))(y) } }
 }
 
-func _1<A, B, C, D>(f: A -> C)(_ x: A, _ y: B)(_ fmap: (A -> (A, B)) -> C -> D) -> D {
-	return fmap({ ($0, y) })(f(x))
+func _1<A, B, C, D>(f: A -> C) -> (A, B) -> ((A -> (A, B)) -> C -> D) -> D {
+	return { (x, y) in { fmap in fmap({ ($0, y) })(f(x)) } }
 }
 
-func _2<A, B, C, D>(f: B -> C)(_ x: A, _ y: B)(_ fmap: (B -> (A, B)) -> C -> D) -> D {
-	return fmap({ (x, $0) })(f(y))
+func _2<A, B, C, D>(f: B -> C) -> (A, B) -> ((B -> (A, B)) -> C -> D) -> D {
+    return { (x, y) in { fmap in fmap({ (x, $0) })(f(y)) } }
 }
 
 

test/Interpreter/currying_protocols.swift

@@ -10,7 +10,7 @@ struct Steroids {}
 protocol Gymnast {
   func backflip(angle: Double) -> Self
   func compete() -> Medal -> Self
-  func scandal()(s: Steroids) -> ()
+  func scandal() -> (Steroids) -> ()
   static func currentYear() -> Int
 }
 
@@ -27,8 +27,8 @@ final class Archimedes : Gymnast {
     }
   }
 
-  func scandal()(s: Steroids) -> () {
-    print("Archimedes don't do that")
+  func scandal() -> (Steroids) -> () {
+    return { s in print("Archimedes don't do that") }
   }
 
   static func currentYear() -> Int {