[SILGen] TypeWrappers: Handle initialization of property wrapped fields without init exprs

Type wrapper synthesis cannot reply on `getExecutableInit` to
determine whether initialization should use backing wrapper
call or not, it has to check whether the init expression exists.

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);
       }

test/Interpreter/Inputs/type_wrapper_defs.swift

@@ -401,3 +401,21 @@ 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
+  }
+}

test/Interpreter/type_wrappers.swift

@@ -689,3 +689,24 @@ 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
+}