Merge pull request #62699 from xedin/type-wrapper-fixes

[SILGen/DI] TypeWrapper: Few improvements to synthesis in user-defined initializers

Author: xedin

lib/SILGen/SILGenDecl.cpp

@@ -1347,6 +1347,16 @@ void SILGenFunction::emitPatternBinding(PatternBindingDecl *PBD,
   auto initialization = emitPatternBindingInitialization(PBD->getPattern(idx),
                                                          JumpDest::invalid());
 
+  auto getWrappedValueExpr = [&](VarDecl *var) -> Expr * {
+    if (auto *orig = var->getOriginalWrappedProperty()) {
+      auto initInfo = orig->getPropertyWrapperInitializerInfo();
+      if (auto *placeholder = initInfo.getWrappedValuePlaceholder()) {
+        return placeholder->getOriginalWrappedValue();
+      }
+    }
+    return nullptr;
+  };
+
   auto emitInitializer = [&](Expr *initExpr, VarDecl *var, bool forLocalContext,
                              InitializationPtr &initialization) {
     // If an initial value expression was specified by the decl, emit it into
@@ -1355,14 +1365,11 @@ void SILGenFunction::emitPatternBinding(PatternBindingDecl *PBD,
 
     if (forLocalContext) {
       if (auto *orig = var->getOriginalWrappedProperty()) {
-        auto initInfo = orig->getPropertyWrapperInitializerInfo();
-        if (auto *placeholder = initInfo.getWrappedValuePlaceholder()) {
-          initExpr = placeholder->getOriginalWrappedValue();
-
+        if (auto *initExpr = getWrappedValueExpr(var)) {
           auto value = emitRValue(initExpr);
           emitApplyOfPropertyWrapperBackingInitializer(
-              PBD, orig, getForwardingSubstitutionMap(), std::move(value))
-              .forwardInto(*this, SILLocation(PBD), initialization.get());
+            PBD, orig, getForwardingSubstitutionMap(), std::move(value))
+            .forwardInto(*this, SILLocation(PBD), initialization.get());
           return;
         }
       }
@@ -1430,7 +1437,11 @@ void SILGenFunction::emitPatternBinding(PatternBindingDecl *PBD,
 
       auto &fieldInit = fieldInits[i];
       if (initExpr) {
-        emitInitializer(initExpr, field, /*forLocalContext=*/true, fieldInit);
+        // If there is wrapped value expression, we have to emit a
+        // backing property initializer call, otherwise let's use
+        // default expression (which is just `.init()` call).
+        emitInitializer(initExpr, field, bool(getWrappedValueExpr(field)),
+                        fieldInit);
       } else {
         fieldInit->finishUninitialized(*this);
       }

lib/SILGen/SILGenType.cpp

@@ -1115,6 +1115,14 @@ class SILGenType : public TypeMemberVisitor<SILGenType> {
       if (auto *normal = dyn_cast<NormalProtocolConformance>(conformance))
         SGM.getWitnessTable(normal);
     }
+
+    // Emit `init(for:storage)` initializer as it would be used
+    // by DI and IRGen later on.
+    if (auto typeWrapperInfo = theType->getTypeWrapper()) {
+      auto *ctor = typeWrapperInfo->Wrapper->getTypeWrapperInitializer();
+      assert(ctor);
+      (void)SGM.getFunction(SILDeclRef(ctor), NotForDefinition);
+    }
   }
 
   //===--------------------------------------------------------------------===//

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

@@ -401,3 +401,53 @@ public protocol WrappedProtocol {
 
   var v: T { get set }
 }
+
+@propertyWrapper
+public struct PropWrapperWithDefaultInit<T> {
+  typealias Wrapped = T
+
+  public var wrappedValue: T {
+    get { value! }
+    set { value = newValue }
+  }
+
+  var value: T?
+
+  public init() {}
+
+  public init(wrappedValue: 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

@@ -689,3 +689,38 @@ do {
   // CHECK-NEXT: in getter storage: \$Storage.v
   // CHECK-NEXT: 1
 }
+
+do {
+  @Wrapper
+  class Test {
+    @PropWrapperWithDefaultInit var x: Int
+
+    required init() {}
+
+    required init(x: Int) {
+      self.x = x
+    }
+  }
+
+  var test = Test(x: 42)
+  print(test.x)
+  // CHECK: Wrapper.init(for: Test, storage: $Storage(_x: type_wrapper_defs.PropWrapperWithDefaultInit<Swift.Int>(value: nil)))
+  // CHECK-NEXT: in (reference type) getter storage: \$Storage._x
+  // CHECK-NEXT: in (reference type) setter => PropWrapperWithDefaultInit<Int>(value: Optional(42))
+  // 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)))
+}