[Sema] TypeWrappers: Synthesize init parameters for property wrapped members

Since properties with property wrappers are not supported, default
init synthesis needs to handle them as well by using correct interface
type depending on outer wrapper capabilities and setting correct
default expression.

Author: xedin

lib/Sema/CodeSynthesis.cpp

@@ -190,23 +190,44 @@ static void maybeAddMemberwiseDefaultArg(ParamDecl *arg, VarDecl *var,
 
 static void maybeAddTypeWrapperDefaultArg(ParamDecl *arg, VarDecl *var,
                                           ASTContext &ctx) {
-  assert(var->isAccessedViaTypeWrapper());
+  assert(var->isAccessedViaTypeWrapper() || var->hasAttachedPropertyWrapper());
 
-  if (!var->getParentPattern()->getSingleVar())
+  if (!(var->getParentPattern() && var->getParentPattern()->getSingleVar()))
     return;
 
   auto *PBD = var->getParentPatternBinding();
 
-  auto *initExpr = PBD->getInit(/*index=*/0);
+  Expr *initExpr = nullptr;
+
+  if (var->hasAttachedPropertyWrapper()) {
+    auto initInfo = var->getPropertyWrapperInitializerInfo();
+
+    if (initInfo.hasInitFromWrappedValue()) {
+      initExpr =
+          initInfo.getWrappedValuePlaceholder()->getOriginalWrappedValue();
+    }
+  } else {
+    initExpr = PBD->getInit(/*index=*/0);
+  }
+
   if (!initExpr)
     return;
 
   // Type wrapper variables are never initialized directly,
   // initialization expression (if any) becomes an default
   // argument of the initializer synthesized by the type wrapper.
-  PBD->setInitializerSubsumed(/*index=*/0);
+  {
+    // Since type wrapper is applied to backing property, that's
+    // the the initializer it subsumes.
+    if (var->hasAttachedPropertyWrapper()) {
+      auto *backingVar = var->getPropertyWrapperBackingProperty();
+      PBD = backingVar->getParentPatternBinding();
+    }
 
-  arg->setDefaultExpr(initExpr, /*isTypeChecked=*/false);
+    PBD->setInitializerSubsumed(/*index=*/0);
+  }
+
+  arg->setDefaultExpr(initExpr, PBD->isInitializerChecked(/*index=*/0));
   arg->setDefaultArgumentKind(DefaultArgumentKind::Normal);
 }
 
@@ -354,11 +375,51 @@ static ConstructorDecl *createImplicitConstructor(NominalTypeDecl *decl,
       if (!(var && var->isAccessedViaTypeWrapper()))
         continue;
 
-      auto *arg = new (ctx) ParamDecl(SourceLoc(), Loc, var->getName(), Loc,
-                                      var->getName(), decl);
+      Identifier argName = var->getName();
+      Identifier paramName = argName;
+
+      auto paramInterfaceType = var->getValueInterfaceType();
+      DeclAttributes attrs;
+
+      // If this is a backing storage of a property wrapped property
+      // let's use wrapped property as a parameter and synthesize
+      // appropriate property wrapper initialization upon assignment.
+      if (auto *wrappedVar = var->getOriginalWrappedProperty(
+              PropertyWrapperSynthesizedPropertyKind::Backing)) {
+        // If there is `init(wrappedValue:)` or default value for a wrapped
+        // property we should use wrapped type, otherwise let's proceed with
+        // wrapper type.
+        if (wrappedVar->isPropertyMemberwiseInitializedWithWrappedType()) {
+          var = wrappedVar;
+          // If parameter have to get wrapped type, let's re-map both argument
+          // and parameter name to match wrapped property and let property
+          // wrapper attributes generate wrapped value and projection variables.
+          argName = wrappedVar->getName();
+          paramName = argName;
+
+          paramInterfaceType = var->getPropertyWrapperInitValueInterfaceType();
+          // The parameter needs to have all of the property wrapper
+          // attributes to generate projection and wrapper variables.
+          for (auto *attr : wrappedVar->getAttachedPropertyWrappers())
+            attrs.add(attr);
+        } else {
+          // If parameter has to have wrapper type then argument type should
+          // match that of a wrapped property but parameter name stays the same
+          // since it represents the type of backing storage and could be passed
+          // to `$Storage` constructor directly.
+          argName = wrappedVar->getName();
+        }
+      }
+
+      if (!paramInterfaceType || paramInterfaceType->hasError())
+        continue;
+
+      auto *arg =
+          new (ctx) ParamDecl(SourceLoc(), Loc, argName, Loc, paramName, decl);
 
+      arg->getAttrs().add(attrs);
       arg->setSpecifier(ParamSpecifier::Default);
-      arg->setInterfaceType(var->getValueInterfaceType());
+      arg->setInterfaceType(paramInterfaceType);
       arg->setImplicit();
 
       maybeAddTypeWrapperDefaultArg(arg, var, ctx);

lib/Sema/TypeCheckTypeWrapper.cpp

@@ -389,8 +389,18 @@ SynthesizeTypeWrapperInitializerBody::evaluate(Evaluator &evaluator,
   SmallVector<Argument, 4> arguments;
   {
     for (auto *param : *ctor->getParameters()) {
-      arguments.push_back({/*labelLoc=*/SourceLoc(), param->getName(),
-                           new (ctx) DeclRefExpr(param, /*Loc=*/DeclNameLoc(),
+      VarDecl *arg = param;
+
+      // type wrappers wrap only backing storage of a wrapped
+      // property, so in this case we need to pass `_<name>` to
+      // `$Storage` constructor.
+      if (param->hasAttachedPropertyWrapper()) {
+        arg = param->getPropertyWrapperBackingProperty();
+        (void)param->getPropertyWrapperBackingPropertyType();
+      }
+
+      arguments.push_back({/*labelLoc=*/SourceLoc(), arg->getName(),
+                           new (ctx) DeclRefExpr(arg, /*Loc=*/DeclNameLoc(),
                                                  /*Implicit=*/true)});
     }
   }

test/Interpreter/Inputs/type_wrapper_defs.swift

@@ -19,6 +19,64 @@ public struct Wrapper<S> {
   }
 }
 
+@propertyWrapper
+public struct PropWrapper<Value> {
+  public var value: Value
+
+  public init(wrappedValue: Value) {
+    self.value = wrappedValue
+  }
+
+  public var projectedValue: Self { return self }
+
+  public var wrappedValue: Value {
+    get {
+      self.value
+    }
+    set {
+      self.value = newValue
+    }
+  }
+}
+
+@propertyWrapper
+public struct PropWrapperWithoutInit<Value> {
+  public var value: Value
+
+  public init(value: Value) {
+    self.value = value
+  }
+
+  public var projectedValue: Self { return self }
+
+  public var wrappedValue: Value {
+    get {
+      self.value
+    }
+    set {
+      self.value = newValue
+    }
+  }
+}
+
+@propertyWrapper
+public struct PropWrapperWithoutProjection<Value> {
+  public var value: Value
+
+  public init(wrappedValue: Value) {
+    self.value = wrappedValue
+  }
+
+  public var wrappedValue: Value {
+    get {
+      self.value
+    }
+    set {
+      self.value = newValue
+    }
+  }
+}
+
 @Wrapper
 public class Person<T> {
   public var name: String
@@ -30,3 +88,36 @@ public struct PersonWithDefaults {
   public var name: String = "<no name>"
   public var age: Int = 99
 }
+
+@Wrapper
+public struct PropWrapperTest {
+  @PropWrapper public var test: Int
+}
+
+@Wrapper
+public struct DefaultedPropWrapperTest {
+  @PropWrapper public var test: Int = 0
+}
+
+@Wrapper
+public struct DefaultedPropWrapperWithArgTest {
+  @PropWrapper(wrappedValue: 3) public var test: Int
+}
+
+@Wrapper
+public struct PropWrapperNoInitTest {
+  @PropWrapperWithoutInit public var a: Int
+  @PropWrapperWithoutInit(value: "b") public var b: String
+}
+
+@Wrapper
+public struct PropWrapperNoProjectionTest {
+  @PropWrapperWithoutProjection public var a: Int = 0
+  @PropWrapperWithoutProjection(wrappedValue: PropWrapper(wrappedValue: "b")) @PropWrapper public var b: String
+}
+
+@Wrapper
+public struct ComplexPropWrapperTest {
+  @PropWrapper public var a: [String] = ["a"]
+  @PropWrapperWithoutInit(value: PropWrapper(wrappedValue: [1, 2, 3])) @PropWrapper public var b: [Int]
+}