[DI] TypeWrappers: Support conformance requirements on Wrapper/Storage parameters

Author: xedin

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -1315,15 +1315,24 @@ void LifetimeChecker::injectTypeWrapperStorageInitalization() {
         wrapperInitArgs.push_back(storageObj);
         wrapperInitArgs.push_back(typeWrapperType);
 
-        // <wrapper-var> = <TypeWrapper>.init(storage: tmpStorage)
-        auto wrapperInitResult = b.createApply(
-            loc, typeWrapperInitRef,
-            SubstitutionMap::get(typeWrapperInit->getGenericSignature(),
-                                 /*substitutions=*/
-                                 {wrappedType->getMetatypeInstanceType(),
-                                  storageType.getASTType()},
-                                 /*conformances=*/{}),
-            wrapperInitArgs);
+        TypeSubstitutionMap wrapperInitSubs;
+        {
+          auto sig =
+              typeWrapperInit->getGenericSignature().getCanonicalSignature();
+          wrapperInitSubs[sig.getGenericParams()[0]] =
+              wrappedType->getMetatypeInstanceType();
+          wrapperInitSubs[sig.getGenericParams()[1]] = storageType.getASTType();
+        }
+
+        // <wrapper-var> = <TypeWrapper>.init(for: <Type>, storage: tmpStorage)
+        auto wrapperInitResult =
+            b.createApply(loc, typeWrapperInitRef,
+                          SubstitutionMap::get(
+                              typeWrapperInit->getGenericSignature(),
+                              QueryTypeSubstitutionMap{wrapperInitSubs},
+                              LookUpConformanceInModule(
+                                  ctor->getDeclContext()->getParentModule())),
+                          wrapperInitArgs);
 
         // self.$storage is a property access so it has to has to be wrapped
         // in begin/end access instructions.

test/Interpreter/Inputs/type_wrapper_defs.swift

@@ -419,3 +419,35 @@ public struct PropWrapperWithDefaultInit<T> {
     self.value = wrappedValue
   }
 }
+
+@typeWrapper
+public struct WrapperWithConformance<W : WrappedTypesOnly, S> {
+  var underlying: S
+
+  public init(for wrappedType: W.Type, storage: S) {
+    print("WrapperWithConformance.init(for: \(wrappedType), storage: \(storage))")
+    self.underlying = storage
+  }
+
+  public subscript<V>(propertyKeyPath propertyPath: KeyPath<W, V>,
+    storageKeyPath storagePath: KeyPath<S, V>) -> V {
+    get {
+      print("in read-only getter storage: \(storagePath)")
+      return underlying[keyPath: storagePath]
+    }
+  }
+
+  public subscript<V>(propertyKeyPath propertyPath: KeyPath<W, V>,
+    storageKeyPath storagePath: WritableKeyPath<S, V>) -> V {
+    get {
+      print("in getter storage: \(storagePath)")
+      return underlying[keyPath: storagePath]
+    }
+    set {
+      print("in setter => \(newValue)")
+      underlying[keyPath: storagePath] = newValue
+    }
+  }
+}
+
+public protocol WrappedTypesOnly {}

test/Interpreter/type_wrappers.swift

@@ -710,3 +710,17 @@ do {
   // CHECK-NEXT: in (reference type) getter storage: \$Storage._x
   // CHECK-NEXT: 42
 }
+
+do {
+  @WrapperWithConformance
+  struct Test : WrappedTypesOnly {
+    var a: Int = 42
+    var b: String = ""
+    @PropWrapperWithDefaultInit var c: [Int]
+
+    init() {}
+  }
+
+  let test = Test()
+  // CHECK: WrapperWithConformance.init(for: Test, storage: $Storage(a: 42, b: "", _c: type_wrapper_defs.PropWrapperWithDefaultInit<Swift.Array<Swift.Int>>(value: nil)))
+}