[TypeChecker] NFC: Add more property wrapper tests

Author: xedin

test/Interpreter/Inputs/type_wrapper_defs.swift

@@ -0,0 +1,26 @@
+@typeWrapper
+public struct Wrapper<S> {
+  var underlying: S
+
+  public init(memberwise: S) {
+    print("Wrapper.init(\(memberwise))")
+    self.underlying = memberwise
+  }
+
+  public subscript<V>(storageKeyPath path: WritableKeyPath<S, V>) -> V {
+    get {
+      print("in getter")
+      return underlying[keyPath: path]
+    }
+    set {
+      print("in setter => \(newValue)")
+      underlying[keyPath: path] = newValue
+    }
+  }
+}
+
+@Wrapper
+public class Person<T> {
+  public var name: String
+  public var projects: [T]
+}

test/Interpreter/type_wrappers.swift

@@ -0,0 +1,39 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-build-swift -parse-as-library -emit-library -emit-module-path %t/type_wrapper_defs.swiftmodule -module-name type_wrapper_defs %S/Inputs/type_wrapper_defs.swift -o %t/%target-library-name(type_wrapper_defs)
+// RUN: %target-build-swift -ltype_wrapper_defs -module-name main -I %t -L %t %s -o %t/a.out
+// RUN: %target-run %t/a.out | %FileCheck %s
+
+import type_wrapper_defs
+
+var p: Person<String> = .init(name: "P", projects: ["A", "B"])
+// CHECK: Wrapper.init($Storage(name: "P", projects: ["A", "B"]))
+
+print(p.name)
+// CHECK: in getter
+// CHECK-NEXT: P
+print(p.projects)
+// CHECK: in getter
+// CHECK-NEXT: ["A", "B"]
+
+p.name = "OtherP"
+// CHECK: in setter => OtherP
+p.projects.append("C")
+// CHECK: in getter
+// CHECK-NEXT: in setter => ["A", "B", "C"]
+
+
+func addProjects<T>(p: inout Person<T>, _ newProjects: [T]) {
+  p.projects.append(contentsOf: newProjects)
+}
+
+addProjects(p: &p, ["D"])
+// CHECK: in getter
+// CHECK: in setter => ["A", "B", "C", "D"]
+
+print(p.name)
+// CHECK: in getter
+// CHECK-NEXT: OtherP
+
+print(p.projects)
+// CHECK: in getter
+// CHECK-NEXT: ["A", "B", "C", "D"]

test/type/type_wrapper.swift

@@ -82,3 +82,68 @@ struct InaccessibleOrInvalidSubscripts<S> {
     get { true }
   }
 }
+
+@typeWrapper
+struct NoopWrapper<S> {
+  init(memberwise: S) {}
+
+  subscript<V>(storageKeyPath path: KeyPath<S, V>) -> V {
+    get { fatalError() }
+    set { }
+  }
+}
+
+@NoopWrapper
+struct A {
+  var a: String
+  var b: Int
+}
+
+@NoopWrapper
+class GenericA<K: Hashable, V> {
+  var data: [K: V]
+}
+
+@NoopWrapper // expected-error {{type wrapper attribute 'NoopWrapper' can only be applied to a class, struct}}
+protocol P {
+}
+
+@NoopWrapper // expected-error {{type wrapper attribute 'NoopWrapper' can only be applied to a class, struct}}
+enum E {
+  var x: Int { get { 42 } }
+}
+
+func testWrappedTypeAccessChecking() {
+  let a = A(a: "", b: 42) // synthesized init
+  let b = GenericA(data: ["ultimate question": 42]) // generic synthesized init
+
+  _ = a.a // Ok
+  _ = b.data // Ok
+}
+
+struct Parent {
+  @typeWrapper
+  struct Wrapper<S> {
+    init(memberwise: S) {}
+
+    subscript<V>(storageKeyPath path: KeyPath<S, V>) -> V {
+      get { fatalError() }
+      set { }
+    }
+  }
+}
+
+func testLocalWithNestedWrapper() {
+  @Parent.Wrapper
+  class WithNestedWrapper<T> {
+    var test: [T]
+
+    var computed: String {
+      get { "" }
+    }
+  }
+
+  let t = WithNestedWrapper(test: [1, 2]) // synthesized init
+  _ = t.test // Ok
+  _ = t.computed // Ok
+}