[Sema] TypeWrappers: Add unamanged stored properties to the synthesized memberwise init

If a stored property would be in a default memberwise initializer
it would be added to the `init` synthesized for a type wrapped type
as well i.e. a `let` property without a default.

Author: xedin

Diff for: lib/Sema/CodeSynthesis.cpp

@@ -377,9 +377,27 @@ static ConstructorDecl *createImplicitConstructor(NominalTypeDecl *decl,
 
     for (auto *member : decl->getMembers()) {
       auto *var = dyn_cast<VarDecl>(member);
-      if (!(var && var->isAccessedViaTypeWrapper()))
+      if (!var)
         continue;
 
+      if (!var->isAccessedViaTypeWrapper()) {
+        // $_storage itself.
+        if (var->getName() == ctx.Id_TypeWrapperProperty)
+          continue;
+
+        // Computed properties are not included.
+        if (!var->hasStorage())
+          continue;
+
+        // If this is a memberwise initializeable property include
+        // it into the type wrapper initializer otherwise the instance
+        // of type wrapped type wouldn't be completely initialized.
+        if (var->isMemberwiseInitialized(/*preferDeclaredProperties=*/true))
+          params.push_back(createMemberwiseInitParameter(decl, Loc, var));
+
+        continue;
+      }
+
       Identifier argName = var->getName();
       Identifier paramName = argName;
 

Diff for: lib/Sema/TypeCheckTypeWrapper.cpp

@@ -319,7 +319,8 @@ bool IsPropertyAccessedViaTypeWrapper::evaluate(Evaluator &evaluator,
     return false;
 
   // `lazy` properties are not wrapped.
-  if (property->getAttrs().hasAttribute<LazyAttr>())
+  if (property->getAttrs().hasAttribute<LazyAttr>() ||
+      property->isLazyStorageProperty())
     return false;
 
   // Properties with attached property wrappers are not considered
@@ -386,11 +387,42 @@ SynthesizeTypeWrapperInitializerBody::evaluate(Evaluator &evaluator,
                             /*Loc=*/DeclNameLoc(), /*Implicit=*/true),
       typeWrapperVar->getName());
 
-  SmallVector<Argument, 4> arguments;
+  // Check whether given parameter requires a direct assignment to
+  // intialize the property.
+  //
+  // If `$Storage` doesn't have a member that corresponds
+  // to the current parameter it means that this is a property
+  // that not managed by the type wrapper which has to be
+  // initialized by direct assignment: `self.<name> = <arg>`
+  auto useDirectAssignment = [&](ParamDecl *param) {
+    // Properties with property wrappers are always managed by the type wrapper
+    if (param->hasAttachedPropertyWrapper())
+      return false;
+    return storageType->lookupDirect(param->getName()).empty();
+  };
+
+  SmallVector<ASTNode, 2> body;
+
+  SmallVector<Argument, 4> initArgs;
   {
     for (auto *param : *ctor->getParameters()) {
       VarDecl *arg = param;
 
+      if (useDirectAssignment(param)) {
+        auto *propRef = UnresolvedDotExpr::createImplicit(
+            ctx,
+            new (ctx) DeclRefExpr({ctor->getImplicitSelfDecl()},
+                                  /*Loc=*/DeclNameLoc(), /*Implicit=*/true),
+            arg->getName());
+
+        body.push_back(new (ctx) AssignExpr(
+            propRef, /*EqualLoc=*/SourceLoc(),
+            new (ctx) DeclRefExpr({arg}, /*DeclNameLoc=*/DeclNameLoc(),
+                                  /*Implicit=*/true),
+            /*Implicit=*/true));
+        continue;
+      }
+
       // type wrappers wrap only backing storage of a wrapped
       // property, so in this case we need to pass `_<name>` to
       // `$Storage` constructor.
@@ -399,9 +431,9 @@ SynthesizeTypeWrapperInitializerBody::evaluate(Evaluator &evaluator,
         (void)param->getPropertyWrapperBackingPropertyType();
       }
 
-      arguments.push_back({/*labelLoc=*/SourceLoc(), arg->getName(),
-                           new (ctx) DeclRefExpr(arg, /*Loc=*/DeclNameLoc(),
-                                                 /*Implicit=*/true)});
+      initArgs.push_back({/*labelLoc=*/SourceLoc(), arg->getName(),
+                          new (ctx) DeclRefExpr(arg, /*Loc=*/DeclNameLoc(),
+                                                /*Implicit=*/true)});
     }
   }
 
@@ -410,7 +442,7 @@ SynthesizeTypeWrapperInitializerBody::evaluate(Evaluator &evaluator,
       TypeExpr::createImplicitForDecl(
           /*Loc=*/DeclNameLoc(), storageType, ctor,
           ctor->mapTypeIntoContext(storageType->getInterfaceType())),
-      ArgumentList::createImplicit(ctx, arguments));
+      ArgumentList::createImplicit(ctx, initArgs));
 
   auto *initRef = new (ctx) UnresolvedMemberExpr(
       /*dotLoc=*/SourceLoc(), /*declNameLoc=*/DeclNameLoc(),
@@ -422,11 +454,10 @@ SynthesizeTypeWrapperInitializerBody::evaluate(Evaluator &evaluator,
       ctx, initRef,
       ArgumentList::forImplicitSingle(ctx, ctx.Id_memberwise, storageInit));
 
-  auto *assignment = new (ctx)
-      AssignExpr(storageVarRef, /*EqualLoc=*/SourceLoc(), typeWrapperInit,
-                 /*Implicit=*/true);
+  body.push_back(new (ctx) AssignExpr(storageVarRef, /*EqualLoc=*/SourceLoc(),
+                                      typeWrapperInit,
+                                      /*Implicit=*/true));
 
-  return BraceStmt::create(ctx, /*lbloc=*/ctor->getLoc(),
-                           /*body=*/{assignment},
+  return BraceStmt::create(ctx, /*lbloc=*/ctor->getLoc(), body,
                            /*rbloc=*/ctor->getLoc(), /*implicit=*/true);
 }

Diff for: test/Interpreter/Inputs/type_wrapper_defs.swift

@@ -121,3 +121,18 @@ public struct ComplexPropWrapperTest {
   @PropWrapper public var a: [String] = ["a"]
   @PropWrapperWithoutInit(value: PropWrapper(wrappedValue: [1, 2, 3])) @PropWrapper public var b: [Int]
 }
+
+@Wrapper
+public struct PersonWithUnmanagedTest {
+  public let name: String
+
+  public lazy var age: Int = {
+    30
+  }()
+
+  public var placeOfBirth: String {
+    get { "Earth" }
+  }
+
+  @PropWrapper public var favoredColor: String = "red"
+}

Diff for: test/Interpreter/type_wrappers.swift

@@ -349,3 +349,29 @@ func testPropertyWrappers() {
 }
 
 testPropertyWrappers()
+
+do {
+  var person = PersonWithUnmanagedTest(name: "Arthur Dent")
+  // CHECK: Wrapper.init($Storage(_favoredColor: type_wrapper_defs.PropWrapper<Swift.String>(value: "red")))
+
+  print(person.name)
+  // CHECK: Arthur Dent
+
+  print(person.age)
+  // CHECK: 30
+
+  print(person.placeOfBirth)
+  // CHECK: Earth
+
+  print(person.favoredColor)
+  // CHECK: in getter
+  // CHECK-NEXT: red
+
+  person.favoredColor = "yellow"
+  // CHECK: in getter
+  // CHECK-NEXT: in setter => PropWrapper<String>(value: "yellow")
+
+  print(person.favoredColor)
+  // CHECK: in getter
+  // CHECK-NEXT: yellow
+}

Diff for: test/type/type_wrapper.swift

@@ -332,3 +332,49 @@ func propertyWrapperTests() {
     // expected-error@-2 {{cannot convert value of type 'String' to expected argument type 'Float'}}
   }
 }
+
+func testDeclarationsWithUnmanagedProperties() {
+  @NoopWrapper
+  struct WithLet { // expected-note {{'init(name:age:)' declared here}}
+    let name: String
+    var age: Int
+  }
+  _ = WithLet(age: 0) // expected-error {{missing argument for parameter 'name' in call}}
+  _ = WithLet(name: "", age: 0) // Ok
+
+  @NoopWrapper
+  struct WithDefaultedLet {
+    let name: String = "Arthur Dent"
+    var age: Int
+  }
+
+  _ = WithDefaultedLet(age: 32) // Ok
+  _ = WithDefaultedLet(name: "", age: 0) // expected-error {{extra argument 'name' in call}}
+
+  @NoopWrapper
+  struct WithLazy {
+    lazy var name: String = {
+      "Arthur Dent"
+    }()
+
+    var age: Int = 30
+  }
+
+  _ = WithLazy() // Ok
+  _ = WithLazy(name: "") // expected-error {{extra argument 'name' in call}}
+  _ = WithLazy(name: "", age: 0) // expected-error {{extra argument 'name' in call}}
+  _ = WithLazy(age: 0) // Ok
+
+  @NoopWrapper
+  struct OnlyLazyLetAndComputed {
+    let name: String
+    lazy var age: Int = {
+      30
+    }()
+    var planet: String {
+      get { "Earth" }
+    }
+  }
+
+  _ = OnlyLazyLetAndComputed(name: "Arthur Dent") // Ok
+}