[Tests] Add tests.

Author: amritpan

test/Constraints/keypath.swift

@@ -41,8 +41,10 @@ let some = Some(keyPath: \Demo.here)
 func testFunc() {
   let _: (S) -> Int = \.i
   _ = ([S]()).map(\.i)
-  _ = \S.init // expected-error {{key path cannot refer to initializer 'init()'}}
-  _ = ([S]()).map(\.init) // expected-error {{key path cannot refer to initializer 'init()'}}
+  _ = \S.Type.init
+  _ = \S.init // expected-error {{static member 'init()' cannot be used on instance of type 'S'}}
+  _ = ([S.Type]()).map(\.init)
+  _ = ([S]()).map(\.init) // expected-error {{static member 'init()' cannot be used on instance of type 'S'}}
 
   let kp = \S.i
   let _: KeyPath<S, Int> = kp // works, because type defaults to KeyPath nominal

test/Demangle/Inputs/manglings.txt

@@ -368,6 +368,8 @@ $sSUss17FixedWidthIntegerRzrlEyxqd__cSzRd__lufCSu_SiTg5 ---> generic specializat
 $s4test7genFuncyyx_q_tr0_lFSi_SbTtt1g5 ---> generic specialization <Swift.Int, Swift.Bool> of test.genFunc<A, B>(A, B) -> ()
 $sSD5IndexVy__GD ---> $sSD5IndexVy__GD
 $s4test3StrCACycfC ---> {T:$s4test3StrCACycfc} test.Str.__allocating_init() -> test.Str
+@$s8keypaths1KV3valACSi_tcfcACmTkmu : $@convention(keypath_accessor_getter) (@in_guaranteed @thick K.Type) -> @out @callee_guaranteed @substituted <τ_0_0, τ_0_1> (@in_guaranteed τ_0_0) -> @out τ_0_1 for <Int, K>)
+@$s8keypaths1KVACycfcACmTkMA : $@convention(keypath_accessor_getter) (@in_guaranteed @thick K.Type) -> @out K)
 $s18keypaths_inlinable13KeypathStructV8computedSSvpACTKq  ---> key path getter for keypaths_inlinable.KeypathStruct.computed : Swift.String : keypaths_inlinable.KeypathStruct, serialized
 $s18resilient_protocol24ResilientDerivedProtocolPxAA0c4BaseE0Tn --> associated conformance descriptor for resilient_protocol.ResilientDerivedProtocol.A: resilient_protocol.ResilientBaseProtocol
 $s3red4testyAA3ResOyxSayq_GAEs5ErrorAAq_sAFHD1__HCg_GADyxq_GsAFR_r0_lF ---> red.test<A, B where B: Swift.Error>(red.Res<A, B>) -> red.Res<A, [B]>

test/Interpreter/keypath.swift

@@ -5,9 +5,30 @@
 // UNSUPPORTED: use_os_stdlib
 // UNSUPPORTED: back_deployment_runtime
 
-class MyLabel {
+class MyLabel: Hashable {
   var text = "label"
   static var isVisible = true
+  func x(val value: Int) -> Int { return value }
+  static func y(val value: Int) -> Int { return value }
+  func saveClosure(_ closure: @escaping () -> Void) {
+    storedClosure = closure
+  }
+  func executeStoredClosure() {
+    storedClosure?()
+  }
+  private var storedClosure: (() -> Void)?
+  
+  required init() {}
+  required init(customText: String) {
+      text = customText
+  }
+  
+  static func == (lhs: MyLabel, rhs: MyLabel) -> Bool {
+      return lhs === rhs
+  }
+  func hash(into hasher: inout Hasher) {
+      hasher.combine(ObjectIdentifier(self))
+  }
 }
 
 class Controller {
@@ -57,11 +78,6 @@ class Controller {
   }
 }
 
-struct S {
-  var a: Int
-  static let b: Double = 100.0
-}
-
 struct Container<V> {
   var v : V
   init(_ v: V) {
@@ -70,16 +86,30 @@ struct Container<V> {
   func useKeyPath<V2: AnyObject>(_ keyPath: KeyPath<V, V2>) -> String {
     return (v[keyPath: keyPath] as! MyLabel).text
   }
+  func invokeKeyPathMethod<V2, R>(
+      _ keyPath: KeyPath<V, V2>,
+      method: KeyPath<V2, (Int) -> R>,
+      arg: Int
+    ) -> R {
+    let instance = v[keyPath: keyPath]
+    return instance[keyPath: method](arg)
+  }
 }
 
 extension Container where V: Controller {
   func test() -> String {
     return useKeyPath(\.label)
   }
+  func testKeyPathMethod() -> Int {
+    let result = invokeKeyPathMethod(\.label, method: \MyLabel.x(val:), arg: 10)
+    return result
+  }
 }
 
 // CHECK: label
 print(Container(Controller()).test())
+// CHECK: 10
+print(Container(Controller()).testKeyPathMethod())
 
 struct MetatypeContainer<V> {
   var v : V.Type
@@ -92,10 +122,38 @@ struct MetatypeContainer<V> {
     }
     return false
   }
+  func getKeyPathMethodVal() -> Int {
+    if let labelType = v as? MyLabel.Type {
+      return labelType.y(val: 20)
+    }
+    return 0
+  }
+  func createInstanceWithDefaultInit() -> MyLabel? {
+    if let labelType = v as? MyLabel.Type {
+      return labelType.init()
+    }
+    return nil
+  }
+  func createInstanceWithCustomInit(customText: String) -> MyLabel? {
+    if let labelType = v as? MyLabel.Type {
+      return labelType.init(customText: customText)
+    }
+    return nil
+  }
 }
 
 // CHECK: true
 print(MetatypeContainer(MyLabel.self).useMetatypeKeyPath())
+// CHECK: 20
+print(MetatypeContainer(MyLabel.self).getKeyPathMethodVal())
+// CHECK: label
+if let instance = MetatypeContainer(MyLabel.self).createInstanceWithDefaultInit() {
+  print(instance.text)
+}
+// CHECK: Custom Label
+if let customInstance = MetatypeContainer(MyLabel.self).createInstanceWithCustomInit(customText: "Custom Label") {
+  print(customInstance.text)
+}
 
 public class GenericController<U> {
   init(_ u: U) {
@@ -116,13 +174,28 @@ public func generic_class_constrained_keypath<U, V>(_ c: V) where V : GenericCon
 // CHECK: label
 generic_class_constrained_keypath(GenericController(5))
 
+struct S {
+  var year = 2024
+  static let millenium: Int = 3
+  init() {}
+  init(val value: Int = 2024) { year = value }
+  
+  var add: (Int, Int) -> Int { return { $0 + $1 } }
+  func add(this: Int) -> Int { this + this}
+  func add(that: Int) -> Int { that + that }
+  static func subtract(_ val: Int) -> Int { return millenium - val }
+  nonisolated func nonisolatedNextYear() -> Int { year + 1 }
+  consuming func consume() { print(year) }
+  subscript(index: Int) -> Int { return year + index}
+}
+
 // CHECK: {{\\Controller\.secondLabel!\.text|\\Controller\.<computed 0x.* \(Optional<MyLabel>\)>!\.<computed 0x.* \(String\)>}}
 print(\Controller.secondLabel!.text)
 
 // CHECK: {{\\Controller\.subscript\(_: String\)|\\Controller\.<computed 0x.* \(String\)>}}
 print(\Controller["abc"])
-// CHECK: \S.a
-print(\S.a)
+// CHECK: \S.year
+print(\S.year)
 // CHECK: {{\\Controller\.subscript\(int: Int, str: String, _: Int\)|\\Controller\.<computed 0x.* \(Int\)>}}
 print(\Controller[int: 0, str: "", 0])
 // CHECK: {{\\Controller\.thirdLabel|\\Controller\.<computed 0x.* \(Optional<MyLabel>\)>}}
@@ -146,13 +219,98 @@ print(\Controller[array: [42], array2: [42]])
 // CHECK: {{\\Controller\.(fourthLabel|<computed .* \(Optional<MyLabel\.Type>\)>)!\.<computed .* \(Bool\)>}}
 print(\Controller.fourthLabel!.isVisible)
 
-// CHECK: \S.Type.<computed {{.*}} (Double)>
-print(\S.Type.b)
+// CHECK: \S.Type.<computed {{.*}} (Int)>
+print(\S.Type.millenium)
 // CHECK: {{\\Controller\.(fifthLabel|<computed .* \(Optional<MyLabel\.Type>\)>)\?\.<computed .* \(Bool\)>?}}
 print(\Controller.fifthLabel?.isVisible)
 // CHECK: \Int.Type.<computed {{.*}} (Int)> 
 print(\Int.Type.zero)
 
+// CHECK: \S.Type.<computed {{.*}} (() -> S)>
+print(\S.Type.init)
+// CHECK: \S.Type.<computed {{.*}} (S)>
+print(\S.Type.init())
+// CHECK: \S.Type.<computed {{.*}} ((Int) -> S)>
+print(\S.Type.init(val:))
+// CHECK: \S.Type.<computed {{.*}} (S)>
+print(\S.Type.init(val: 2025))
+// CHECK: \S.Type.<computed {{.*}} (S)>.year
+print(\S.Type.init(val: 2025).year)
+// CHECK: 2024
+let kp = \S.Type.init()[0]
+let result = S.self[keyPath: kp]
+print(result)
+// CHECK: 7
+let kpAdd = \S.add
+let resultAdd = S()[keyPath: kpAdd](3, 4)
+print(resultAdd)
+// CHECK: \S.<computed {{.*}} ((Int) -> Int)>
+print(\S.add(this:))
+// CHECK: \S.<computed {{.*}} (Int)>
+print(\S.add(that: 1))
+// CHECK: \S.Type.<computed {{.*}} ((Int) -> Int)>
+print(\S.Type.subtract)
+// CHECK: \S.Type.<computed {{.*}} (Int)>
+print(\S.Type.subtract(1))
+// CHECK: \S.<computed {{.*}} (() -> Int)>
+print(\S.nonisolatedNextYear)
+// CHECK: \S.<computed {{.*}} (Int)>
+print(\S.nonisolatedNextYear())
+// CHECK: \S.Type.<computed {{.*}} (S)>.<computed {{.*}} (Int)>
+print(\S.Type.init(val:2025).nonisolatedNextYear())
+// CHECK: 2026
+let kpMethodProperty = \S.Type.init(val:2025).nonisolatedNextYear().description
+let resultMethodProperty = S.self[keyPath: kpMethodProperty]
+print(resultMethodProperty)
+// CHECK: \S.Type.<computed {{.*}} (S)>.<computed {{.*}} (Int)>.<computed {{.*}} (Int)>
+print(\S.Type.init(val:2025).nonisolatedNextYear().signum())
+// // CHECK: \S.<computed {{.*}} (())>
+print(\S.consume())
+
+// CHECK: false
+print(\S.add(that: 1) == \S.add(this: 1))
+// CHECK: false
+print(\S.add(that: 1) == \S.add(this: 2))
+// CHECK: false
+print(\S.Type.init(val: 2024) == \S.Type.init(val: 2025))
+// CHECK: false
+print(\S.Type.init(val: 2024).nonisolatedNextYear() == \S.Type.init(val: 2025))
+// CHECK: true
+print(\S.Type.init(val: 2024).add(this: 1) != \S.Type.init(val: 2025))
+
+class E: Hashable {
+  static func == (lhs: E, rhs: E) -> Bool { return lhs === rhs }
+  func hash(into hasher: inout Hasher) {
+    hasher.combine(ObjectIdentifier(self))
+  }
+}
+struct BaseType {
+  func foo(hashableParam e: E) {}
+}
+let hashableInstance = E()
+// CHECK: \BaseType.<computed {{.*}} (())>
+print(\BaseType.foo(hashableParam: hashableInstance))
+
+protocol Describable {
+  func describe() -> String
+}
+struct C: Describable {
+  var name: String
+  func describe() -> String { return "\(name)" }
+}
+// CHECK: \C.<computed {{.*}} (() -> String)>
+print(\C.describe)
+
+// CHECK: false
+print(\S.Type.init(val:2025) == \S.Type.init(val:2026))
+// CHECK: false
+print(\S.Type.init(val:2025).nonisolatedNextYear() == \S.Type.init(val:2026).nonisolatedNextYear())
+// CHECK: true
+print(\S.Type.init(val:2025).nonisolatedNextYear() == \S.Type.init(val:2025).nonisolatedNextYear())
+// CHECK: false
+print(\MyLabel.x(val:10) == \MyLabel.x(val:20))
+// CHECK: true
+print(\MyLabel.Type.y(val:10) == \MyLabel.Type.y(val:10))
 
 do {
   struct S {
@@ -208,3 +366,48 @@ do {
   // CHECK: true
   print(StaticExample<MyLabel>().isVisible)
 }
+
+do {
+  @dynamicMemberLookup
+  struct InstanceDynamicMemberLookup<T> {
+      var obj: T
+      
+      subscript<U>(dynamicMember member: KeyPath<T, (Int) -> U>) -> (Int) -> U {
+          get { obj[keyPath: member] }
+      }
+  }
+
+  // CHECK: 50
+  let instanceDynamicLookup = InstanceDynamicMemberLookup(obj: MyLabel())
+  print(instanceDynamicLookup.x(50))
+}
+
+extension MyLabel {
+  static var defaultInitializer: () -> MyLabel { return MyLabel.init }
+  static var customInitializer: (String) -> MyLabel { return MyLabel.init(customText:) }
+}
+
+do {
+  @dynamicMemberLookup
+  struct StaticDynamicMemberLookup<T> {
+    subscript<U>(dynamicMember keyPath: KeyPath<T.Type, (Int) -> U>) -> (Int) -> U {
+        return T.self[keyPath: keyPath]
+    }
+    subscript<U>(dynamicMember keyPath: KeyPath<T.Type, () -> U>) -> () -> U {
+      return T.self[keyPath: keyPath]
+    }
+    subscript<U>(dynamicMember keyPath: KeyPath<T.Type, (String) -> U>) -> (String) -> U {
+        return T.self[keyPath: keyPath]
+    }
+  }
+  
+  // CHECK: 60
+  let staticDynamicLookup = StaticDynamicMemberLookup<MyLabel>()
+  print(staticDynamicLookup.y(60))
+  // CHECK: label
+  let defaultInstance = staticDynamicLookup.defaultInitializer()
+  print(defaultInstance.text)
+  // CHECK: Custom Label
+  let customInstance = staticDynamicLookup.customInitializer("Custom Label")
+  print(customInstance.text)
+}

test/Interpreter/static_keypaths.swift

@@ -30,6 +30,13 @@ public struct AStruct {
   public static var property2: Int = 2
   private(set) public static var property3: Int = 1
   private(set) public static var property4: Int = 4
+  public static func x(val value: Int) -> Int { return value }
+  public static func y(val value: Int) -> Int { return value }
+  
+  public init(val value: Int = 2024) {
+    year = value
+  }
+  public var year: Int
 }
 
 //--- LibB.swift
@@ -41,6 +48,10 @@ public let keyPath3FromLibB = \AStruct.Type.property3
 public let keyPath4FromLibB = \AStruct.Type.property4
 public var keyPath5FromLibB = \AStruct.Type.property1 // WritableKeyPath with public setter
 public var keyPath6FromLibB = \Int.Type.zero
+public let keyPath7FromLibB = \AStruct.Type.x(val: 10)
+public let keyPath8FromLibB = \AStruct.Type.y(val: 10)
+public let keyPath9FromLibB = \AStruct.Type.init
+public let keyPath10FromLibB = \AStruct.Type.init(val: 2025)
 
 //--- LibC.swift
 import LibA
@@ -51,6 +62,9 @@ public let keyPath3FromLibC = \AStruct.Type.property3 // Read-only with private
 public let keyPath4FromLibC = \AStruct.Type.property4
 public var keyPath5FromLibC = \Int.Type.zero
 public var keyPath6FromLibC = \Int.Type.max
+public let keyPath7FromLibC = \AStruct.Type.x(val: 10)
+public let keyPath8FromLibC = \AStruct.Type.init
+public let keyPath9FromLibC = \AStruct.Type.init(val: 2026)
 
 //--- main.swift
 import LibB
@@ -73,3 +87,12 @@ print(keyPath5FromLibB == keyPath3FromLibC)
 print(keyPath6FromLibB == keyPath5FromLibC)
 // Check: false
 print(keyPath6FromLibB == keyPath6FromLibC)
+
+// CHECK: true
+print(keyPath7FromLibB == keyPath7FromLibC)
+// CHECK: false
+print(keyPath8FromLibB == keyPath7FromLibC)
+// CHECK: true
+print(keyPath9FromLibB == keyPath8FromLibC)
+// CHECK: true
+print(keyPath10FromLibB != keyPath9FromLibC)