[test] Fix #keyPath2/\ validation tests.

Author: huonw

test/stdlib/KeyPath.swift

@@ -78,24 +78,24 @@ struct ComputedB {
 
 keyPath.test("key path in-place instantiation") {
   for _ in 1...2 {
-    let s_x = (#keyPath2(S<Int>, .x) as AnyKeyPath) as! WritableKeyPath<S<Int>, Int>
-    let s_y = (#keyPath2(S<Int>, .y) as AnyKeyPath) as! WritableKeyPath<S<Int>, LifetimeTracked?>
-    let s_z = (#keyPath2(S<Int>, .z) as AnyKeyPath) as! WritableKeyPath<S<Int>, Int>
-    let s_p = (#keyPath2(S<Int>, .p) as AnyKeyPath) as! WritableKeyPath<S<Int>, Point>
-    let s_p_x = (#keyPath2(S<Int>, .p.x) as AnyKeyPath) as! WritableKeyPath<S<Int>, Double>
-    let s_p_y = (#keyPath2(S<Int>, .p.y) as AnyKeyPath) as! WritableKeyPath<S<Int>, Double>
-    let s_c = (#keyPath2(S<Int>, .c) as AnyKeyPath) as! WritableKeyPath<S<Int>, C<Int>>
-    let s_c_x = (#keyPath2(S<Int>, .c.x) as AnyKeyPath) as! ReferenceWritableKeyPath<S<Int>, Int>
-
-    let c_x = (#keyPath2(C<Int>, .x) as AnyKeyPath) as! ReferenceWritableKeyPath<C<Int>, Int>
+    let s_x = (\S<Int>.x as AnyKeyPath) as! WritableKeyPath<S<Int>, Int>
+    let s_y = (\S<Int>.y as AnyKeyPath) as! WritableKeyPath<S<Int>, LifetimeTracked?>
+    let s_z = (\S<Int>.z as AnyKeyPath) as! WritableKeyPath<S<Int>, Int>
+    let s_p = (\S<Int>.p as AnyKeyPath) as! WritableKeyPath<S<Int>, Point>
+    let s_p_x = (\S<Int>.p.x as AnyKeyPath) as! WritableKeyPath<S<Int>, Double>
+    let s_p_y = (\S<Int>.p.y as AnyKeyPath) as! WritableKeyPath<S<Int>, Double>
+    let s_c = (\S<Int>.c as AnyKeyPath) as! WritableKeyPath<S<Int>, C<Int>>
+    let s_c_x = (\S<Int>.c.x as AnyKeyPath) as! ReferenceWritableKeyPath<S<Int>, Int>
+
+    let c_x = (\C<Int>.x as AnyKeyPath) as! ReferenceWritableKeyPath<C<Int>, Int>
     let s_c_x_2 = s_c.appending(path: c_x)
 
     expectEqual(s_c_x, s_c_x_2)
     expectEqual(s_c_x_2, s_c_x)
     expectEqual(s_c_x.hashValue, s_c_x_2.hashValue)
 
-    let point_x = (#keyPath2(Point, .x) as AnyKeyPath) as! WritableKeyPath<Point, Double>
-    let point_y = (#keyPath2(Point, .y) as AnyKeyPath) as! WritableKeyPath<Point, Double>
+    let point_x = (\Point.x as AnyKeyPath) as! WritableKeyPath<Point, Double>
+    let point_y = (\Point.y as AnyKeyPath) as! WritableKeyPath<Point, Double>
 
     let s_p_x_2 = s_p.appending(path: point_x)
     let s_p_y_2 = s_p.appending(path: point_y)
@@ -107,19 +107,19 @@ keyPath.test("key path in-place instantiation") {
     expectEqual(s_p_y_2, s_p_y)
     expectEqual(s_p_y_2.hashValue, s_p_y.hashValue)
 
-    let ca_readOnly = (#keyPath2(ComputedA, .readOnly) as AnyKeyPath) as! KeyPath<ComputedA, ComputedB>
-    let ca_nonmutating = (#keyPath2(ComputedA, .nonmutating) as AnyKeyPath) as! ReferenceWritableKeyPath<ComputedA, ComputedB>
-    let ca_reabstracted = (#keyPath2(ComputedA, .reabstracted) as AnyKeyPath) as! ReferenceWritableKeyPath<ComputedA, () -> ()>
+    let ca_readOnly = (\ComputedA.readOnly as AnyKeyPath) as! KeyPath<ComputedA, ComputedB>
+    let ca_nonmutating = (\ComputedA.nonmutating as AnyKeyPath) as! ReferenceWritableKeyPath<ComputedA, ComputedB>
+    let ca_reabstracted = (\ComputedA.reabstracted as AnyKeyPath) as! ReferenceWritableKeyPath<ComputedA, () -> ()>
 
-    let cb_readOnly = (#keyPath2(ComputedB, .readOnly) as AnyKeyPath) as! KeyPath<ComputedB, ComputedA>
-    let cb_mutating = (#keyPath2(ComputedB, .mutating) as AnyKeyPath) as! WritableKeyPath<ComputedB, ComputedA>
-    let cb_nonmutating = (#keyPath2(ComputedB, .nonmutating) as AnyKeyPath) as! ReferenceWritableKeyPath<ComputedB, ComputedA>
-    let cb_reabstracted = (#keyPath2(ComputedB, .reabstracted) as AnyKeyPath) as! WritableKeyPath<ComputedB, () -> ()>
+    let cb_readOnly = (\ComputedB.readOnly as AnyKeyPath) as! KeyPath<ComputedB, ComputedA>
+    let cb_mutating = (\ComputedB.mutating as AnyKeyPath) as! WritableKeyPath<ComputedB, ComputedA>
+    let cb_nonmutating = (\ComputedB.nonmutating as AnyKeyPath) as! ReferenceWritableKeyPath<ComputedB, ComputedA>
+    let cb_reabstracted = (\ComputedB.reabstracted as AnyKeyPath) as! WritableKeyPath<ComputedB, () -> ()>
 
-    let ca_readOnly_mutating = (#keyPath2(ComputedA, .readOnly.mutating) as AnyKeyPath) as! KeyPath<ComputedA, ComputedA>
-    let cb_mutating_readOnly = (#keyPath2(ComputedB, .mutating.readOnly) as AnyKeyPath) as! KeyPath<ComputedB, ComputedB>
-    let ca_readOnly_nonmutating = (#keyPath2(ComputedA, .readOnly.nonmutating) as AnyKeyPath) as! ReferenceWritableKeyPath<ComputedA, ComputedA>
-    let cb_readOnly_reabstracted = (#keyPath2(ComputedB, .readOnly.reabstracted) as AnyKeyPath) as! ReferenceWritableKeyPath<ComputedB, () -> ()>
+    let ca_readOnly_mutating = (\ComputedA.readOnly.mutating as AnyKeyPath) as! KeyPath<ComputedA, ComputedA>
+    let cb_mutating_readOnly = (\ComputedB.mutating.readOnly as AnyKeyPath) as! KeyPath<ComputedB, ComputedB>
+    let ca_readOnly_nonmutating = (\ComputedA.readOnly.nonmutating as AnyKeyPath) as! ReferenceWritableKeyPath<ComputedA, ComputedA>
+    let cb_readOnly_reabstracted = (\ComputedB.readOnly.reabstracted as AnyKeyPath) as! ReferenceWritableKeyPath<ComputedB, () -> ()>
 
     let ca_readOnly_mutating2 = ca_readOnly.appending(path: cb_mutating)
     expectEqual(ca_readOnly_mutating, ca_readOnly_mutating2)
@@ -150,24 +150,24 @@ keyPath.test("key path in-place instantiation") {
 keyPath.test("key path generic instantiation") {
   func testWithGenericParam<T: Equatable>(_: T.Type) -> ReferenceWritableKeyPath<S<T>, Int> {
     for i in 1...2 {
-      let s_x = (#keyPath2(S<T>, .x) as AnyKeyPath) as! WritableKeyPath<S<T>, Int>
-      let s_y = (#keyPath2(S<T>, .y) as AnyKeyPath) as! WritableKeyPath<S<T>, LifetimeTracked?>
-      let s_z = (#keyPath2(S<T>, .z) as AnyKeyPath) as! WritableKeyPath<S<T>, T>
-      let s_p = (#keyPath2(S<T>, .p) as AnyKeyPath) as! WritableKeyPath<S<T>, Point>
-      let s_p_x = (#keyPath2(S<T>, .p.x) as AnyKeyPath) as! WritableKeyPath<S<T>, Double>
-      let s_p_y = (#keyPath2(S<T>, .p.y) as AnyKeyPath) as! WritableKeyPath<S<T>, Double>
-      let s_c = (#keyPath2(S<T>, .c) as AnyKeyPath) as! WritableKeyPath<S<T>, C<T>>
-      let s_c_x = (#keyPath2(S<T>, .c.x) as AnyKeyPath) as! ReferenceWritableKeyPath<S<T>, Int>
-
-      let c_x = (#keyPath2(C<T>, .x) as AnyKeyPath) as! ReferenceWritableKeyPath<C<T>, Int>
+      let s_x = (\S<T>.x as AnyKeyPath) as! WritableKeyPath<S<T>, Int>
+      let s_y = (\S<T>.y as AnyKeyPath) as! WritableKeyPath<S<T>, LifetimeTracked?>
+      let s_z = (\S<T>.z as AnyKeyPath) as! WritableKeyPath<S<T>, T>
+      let s_p = (\S<T>.p as AnyKeyPath) as! WritableKeyPath<S<T>, Point>
+      let s_p_x = (\S<T>.p.x as AnyKeyPath) as! WritableKeyPath<S<T>, Double>
+      let s_p_y = (\S<T>.p.y as AnyKeyPath) as! WritableKeyPath<S<T>, Double>
+      let s_c = (\S<T>.c as AnyKeyPath) as! WritableKeyPath<S<T>, C<T>>
+      let s_c_x = (\S<T>.c.x as AnyKeyPath) as! ReferenceWritableKeyPath<S<T>, Int>
+
+      let c_x = (\C<T>.x as AnyKeyPath) as! ReferenceWritableKeyPath<C<T>, Int>
       let s_c_x_2 = s_c.appending(path: c_x)
 
       expectEqual(s_c_x, s_c_x_2)
       expectEqual(s_c_x_2, s_c_x)
       expectEqual(s_c_x.hashValue, s_c_x_2.hashValue)
 
-      let point_x = (#keyPath2(Point, .x) as AnyKeyPath) as! WritableKeyPath<Point, Double>
-      let point_y = (#keyPath2(Point, .y) as AnyKeyPath) as! WritableKeyPath<Point, Double>
+      let point_x = (\Point.x as AnyKeyPath) as! WritableKeyPath<Point, Double>
+      let point_y = (\Point.y as AnyKeyPath) as! WritableKeyPath<Point, Double>
 
       let s_p_x_2 = s_p.appending(path: point_x)
       let s_p_y_2 = s_p.appending(path: point_y)
@@ -184,15 +184,15 @@ keyPath.test("key path generic instantiation") {
     fatalError()
   }
   let s_c_x_int = testWithGenericParam(Int.self)
-  let s_c_x_int2 = #keyPath2(S<Int>, .c.x)
+  let s_c_x_int2 = \S<Int>.c.x
   expectEqual(s_c_x_int, s_c_x_int2)
 
   let s_c_x_string = testWithGenericParam(String.self)
-  let s_c_x_string2 = #keyPath2(S<String>, .c.x)
+  let s_c_x_string2 = \S<String>.c.x
   expectEqual(s_c_x_string, s_c_x_string2)
 
   let s_c_x_lt = testWithGenericParam(LifetimeTracked.self)
-  let s_c_x_lt2 = #keyPath2(S<LifetimeTracked>, .c.x)
+  let s_c_x_lt2 = \S<LifetimeTracked>.c.x
   expectEqual(s_c_x_lt, s_c_x_lt2)
 }
 

test/stdlib/KeyPathObjC.swift

@@ -33,22 +33,22 @@ class Bar: NSObject {
 var testKVCStrings = TestSuite("KVC strings")
 
 testKVCStrings.test("KVC strings") {
-  expectEqual((#keyPath2(NonObjC, .x))._kvcKeyPathString, nil)
-  expectEqual((#keyPath2(NonObjC, .y))._kvcKeyPathString, nil)
-  expectEqual((#keyPath2(Foo, .int))._kvcKeyPathString, "int")
-  expectEqual((#keyPath2(Foo, .bar))._kvcKeyPathString, "bar")
-  expectEqual((#keyPath2(Foo, .bar.foo))._kvcKeyPathString, "bar.foo")
-  expectEqual((#keyPath2(Foo, .bar.foo.bar))._kvcKeyPathString, "bar.foo.bar")
-  expectEqual((#keyPath2(Foo, .nonobjc))._kvcKeyPathString, nil)
-  expectEqual((#keyPath2(Foo, .bar.foo.nonobjc.y))._kvcKeyPathString, nil)
-  expectEqual((#keyPath2(Foo, .differentName))._kvcKeyPathString, "thisIsADifferentName")
-  expectEqual((#keyPath2(Bar, .foo))._kvcKeyPathString, "foo")
+  expectEqual((\NonObjC.x)._kvcKeyPathString, nil)
+  expectEqual((\NonObjC.y)._kvcKeyPathString, nil)
+  expectEqual((\Foo.int)._kvcKeyPathString, "int")
+  expectEqual((\Foo.bar)._kvcKeyPathString, "bar")
+  expectEqual((\Foo.bar.foo)._kvcKeyPathString, "bar.foo")
+  expectEqual((\Foo.bar.foo.bar)._kvcKeyPathString, "bar.foo.bar")
+  expectEqual((\Foo.nonobjc)._kvcKeyPathString, nil)
+  expectEqual((\Foo.bar.foo.nonobjc.y)._kvcKeyPathString, nil)
+  expectEqual((\Foo.differentName)._kvcKeyPathString, "thisIsADifferentName")
+  expectEqual((\Bar.foo)._kvcKeyPathString, "foo")
 
-  let foo_bar = #keyPath2(Foo, .bar)
-  let foo_nonobjc = #keyPath2(Foo, .nonobjc)
-  let bar_foo = #keyPath2(Bar, .foo)
+  let foo_bar = \Foo.bar
+  let foo_nonobjc = \Foo.nonobjc
+  let bar_foo = \Bar.foo
 
-  let nonobjc_y = #keyPath2(NonObjC, .y)
+  let nonobjc_y = \NonObjC.y
 
   do {
     let foo_bar_foo = foo_bar.appending(path: bar_foo)