update the last of the testsuite to have parens around function type parameters.

Author: lattner

test/1_stdlib/Optional.swift

@@ -209,7 +209,7 @@ OptionalTests.test("??") {
 }
 
 OptionalTests.test("flatMap") {
-  let half: Int32 -> Int16? =
+  let half: (Int32) -> Int16? =
     { if $0 % 2 == 0 { return Int16($0 / 2) } else { return .none } }
 
   expectOptionalEqual(2 as Int16, half(4))

test/1_stdlib/Runtime.swift

@@ -255,25 +255,25 @@ Runtime.test("dynamicCasting with as") {
   expectTrue(((someP1Ref2 as AnyObject) as? P1)!.boolValue)
   expectEmpty(((someNotP1Ref as AnyObject) as? P1))
 
-  let doesThrow: Int throws -> Int = { $0 }
-  let doesNotThrow: String -> String = { $0 }
+  let doesThrow: (Int) throws -> Int = { $0 }
+  let doesNotThrow: (String) -> String = { $0 }
 
   var any: Any = doesThrow
 
-  expectTrue(doesThrow as Any is Int throws -> Int)
-  expectFalse(doesThrow as Any is String throws -> Int)
-  expectFalse(doesThrow as Any is String throws -> String)
-  expectFalse(doesThrow as Any is Int throws -> String)
-  expectFalse(doesThrow as Any is Int -> Int)
-  expectFalse(doesThrow as Any is String throws -> String)
-  expectFalse(doesThrow as Any is String -> String)
-  expectTrue(doesNotThrow as Any is String throws -> String)
-  expectTrue(doesNotThrow as Any is String -> String)
-  expectFalse(doesNotThrow as Any is Int -> String)
-  expectFalse(doesNotThrow as Any is Int -> Int)
-  expectFalse(doesNotThrow as Any is String -> Int)
-  expectFalse(doesNotThrow as Any is Int throws -> Int)
-  expectFalse(doesNotThrow as Any is Int -> Int)
+  expectTrue(doesThrow as Any is (Int) throws -> Int)
+  expectFalse(doesThrow as Any is (String) throws -> Int)
+  expectFalse(doesThrow as Any is (String) throws -> String)
+  expectFalse(doesThrow as Any is (Int) throws -> String)
+  expectFalse(doesThrow as Any is (Int) -> Int)
+  expectFalse(doesThrow as Any is (String) throws -> String)
+  expectFalse(doesThrow as Any is (String) -> String)
+  expectTrue(doesNotThrow as Any is (String) throws -> String)
+  expectTrue(doesNotThrow as Any is (String) -> String)
+  expectFalse(doesNotThrow as Any is (Int) -> String)
+  expectFalse(doesNotThrow as Any is (Int) -> Int)
+  expectFalse(doesNotThrow as Any is (String) -> Int)
+  expectFalse(doesNotThrow as Any is (Int) throws -> Int)
+  expectFalse(doesNotThrow as Any is (Int) -> Int)
 }
 
 extension Int {

test/1_stdlib/RuntimeObjC.swift

@@ -422,10 +422,10 @@ Runtime.test("Generic class ObjC runtime names") {
   expectEqual("_TtGC1a12GenericClassMVS_11PlainStruct_",
               NSStringFromClass(GenericClass<PlainStruct.Type>.self))
   expectEqual("_TtGC1a12GenericClassFMVS_11PlainStructS1__",
-              NSStringFromClass(GenericClass<PlainStruct.Type -> PlainStruct>.self))
+              NSStringFromClass(GenericClass<(PlainStruct.Type) -> PlainStruct>.self))
 
   expectEqual("_TtGC1a12GenericClassFzMVS_11PlainStructS1__",
-              NSStringFromClass(GenericClass<PlainStruct.Type throws -> PlainStruct>.self))
+              NSStringFromClass(GenericClass<(PlainStruct.Type) throws -> PlainStruct>.self))
   expectEqual("_TtGC1a12GenericClassFTVS_11PlainStructROS_9PlainEnum_Si_",
               NSStringFromClass(GenericClass<(PlainStruct, inout PlainEnum) -> Int>.self))
 

test/1_stdlib/UnsafePointer.swift.gyb

@@ -235,8 +235,8 @@ func checkPointerCorrectness(_ check: Check,
   }
 }
 
-let checkPtr: ((UnsafeMutablePointer<Missile> ->
-  (UnsafeMutablePointer<Missile>, count: Int) -> Void), Bool) -> Check -> Void
+let checkPtr: (((UnsafeMutablePointer<Missile>) ->
+  (UnsafeMutablePointer<Missile>, count: Int) -> Void), Bool) -> (Check) -> Void
   = { (f, m) in return { checkPointerCorrectness($0, f, m) } }
 
 UnsafeMutablePointerTestSuite.test("moveInitializeBackwardFrom") {

test/DebugInfo/thunks.swift

@@ -4,7 +4,7 @@
 import Foundation
 
 class Foo : NSObject {
-  dynamic func foo(_ f: Int64 -> Int64, x: Int64) -> Int64 {
+  dynamic func foo(_ f: (Int64) -> Int64, x: Int64) -> Int64 {
     return f(x)
   }
 }

test/PrintAsObjC/blocks.swift

@@ -60,7 +60,7 @@ typealias MyInt = Int
                  (Int32) -> (UInt32)) ->
                 ((Int8) -> (UInt8))) {}
 
-  func returnsBlockWithInput() -> (NSObject -> ())? {
+  func returnsBlockWithInput() -> ((NSObject) -> ())? {
     return nil
   }
   func returnsBlockWithParenthesizedInput() -> ((NSObject) -> ())? {
@@ -70,27 +70,27 @@ typealias MyInt = Int
     return nil
   }
 
-  func blockWithTypealias(_ input: MyTuple -> MyInt) {}
-  func blockWithSimpleTypealias(_ input: MyInt -> MyInt) {}
+  func blockWithTypealias(_ input: (MyTuple) -> MyInt) {}
+  func blockWithSimpleTypealias(_ input: (MyInt) -> MyInt) {}
 
   func namedArguments(_ input: (f1: Float, f2: Float, d1: Double, d2: Double) -> ()) {}
   func blockTakesNamedBlock(_ input: (block: () -> ()) -> ()) {}
   func returnsBlockWithNamedInput() -> ((object: NSObject) -> ())? {
     return nil
   }
 
-  func blockWithTypealiasWithNames(_ input: MyNamedTuple -> MyInt) {}
+  func blockWithTypealiasWithNames(_ input: (MyNamedTuple) -> MyInt) {}
 
   func blockWithKeyword(_ _Nullable: (`class`: Int) -> Int) {}
 
-  func functionPointers(_ input: @convention(c) Int -> Int)
-      -> @convention(c) Int -> Int {
+  func functionPointers(_ input: @convention(c) (Int) -> Int)
+      -> @convention(c) (Int) -> Int {
     return input
   }
 
   func functionPointerTakesAndReturnsFunctionPointer(
-    _ input: @convention(c) Int -> Int
-                              -> @convention(c) Int -> Int
+    _ input: @convention(c) (Int) -> (Int)
+                              -> @convention(c) (Int) -> Int
   ) {
   }
 
@@ -99,10 +99,10 @@ typealias MyInt = Int
     return input
   }
 
-  var savedBlock: (Int -> Int)?
+  var savedBlock: ((Int) -> Int)?
   var savedBlockWithName: ((x: Int) -> Int)?
-  var savedFunctionPointer: @convention(c) Int -> Int = { $0 }
-  var savedFunctionPointer2: (@convention(c) Int -> Int)? = { $0 }
+  var savedFunctionPointer: @convention(c) (Int) -> Int = { $0 }
+  var savedFunctionPointer2: (@convention(c) (Int) -> Int)? = { $0 }
   var savedFunctionPointerWithName: @convention(c) (x: Int) -> Int = { $0 }
 
   // The following uses a clang keyword as the name.

test/PrintAsObjC/cdecl.swift

@@ -15,17 +15,17 @@
 
 /// What a nightmare!
 @_cdecl("block_nightmare")
-public func block_nightmare(x: @convention(block) Int -> Float)
-  -> @convention(block) CChar -> Double { return { _ in 0 } }
+public func block_nightmare(x: @convention(block) (Int) -> Float)
+  -> @convention(block) (CChar) -> Double { return { _ in 0 } }
 
 // CHECK-LABEL: void foo_bar(NSInteger x, NSInteger y);
 @_cdecl("foo_bar")
 func foo(x: Int, bar y: Int) {}
 
 // CHECK-LABEL: double (* _Nonnull function_pointer_nightmare(float (* _Nonnull x)(NSInteger)))(char);
 @_cdecl("function_pointer_nightmare")
-func function_pointer_nightmare(x: @convention(c) Int -> Float)
-  -> @convention(c) CChar -> Double { return { _ in 0 } }
+func function_pointer_nightmare(x: @convention(c) (Int) -> Float)
+  -> @convention(c) (CChar) -> Double { return { _ in 0 } }
 
 // CHECK-LABEL: void has_keyword_arg_names(NSInteger auto_, NSInteger union_);
 @_cdecl("has_keyword_arg_names")

test/PrintAsObjC/classes.swift

@@ -593,7 +593,7 @@ public class NonObjCClass { }
 
   init() throws { }
   init(string: String) throws { }
-  init(fn: Int -> Int) throws { }
+  init(fn: (Int) -> Int) throws { }
 }
 
 @objc class Spoon: Fungible {}

test/Serialization/Inputs/def_basic.sil

@@ -200,7 +200,7 @@ bb0:
   %O = unchecked_ref_cast %C : $C to $Builtin.UnknownObject
 
   // CHECK: class_method {{.*}} : $C, #C.doIt!1
-  %2 = class_method %C : $C, #C.doIt!1 : C -> () -> (), $@convention(method) (@guaranteed C) -> ()
+  %2 = class_method %C : $C, #C.doIt!1 : (C) -> () -> (), $@convention(method) (@guaranteed C) -> ()
 
   // CHECK: alloc_ref $D
   %D = alloc_ref $D