[AST/Sema] TypeWrapper: Implement synthesis of init(storageWrapper:) initializer

Author: xedin

lib/Sema/CodeSynthesis.cpp

@@ -1630,7 +1630,32 @@ void swift::addNonIsolatedToSynthesized(
 static std::pair<BraceStmt *, /*isTypeChecked=*/bool>
 synthesizeTypeWrappedTypeStorageWrapperInitializerBody(
     AbstractFunctionDecl *decl, void *) {
-  return {nullptr, /*isTypeChecked=*/false};
+  auto &ctx = decl->getASTContext();
+  auto *ctor = cast<ConstructorDecl>(decl);
+  auto *wrappedType = ctor->getDeclContext()->getSelfNominalTypeDecl();
+  auto *storageProperty = wrappedType->getTypeWrapperProperty();
+
+  // self.$storage = storageWrapper
+  SmallVector<ASTNode, 2> body;
+  {
+    auto *storageVarRef = UnresolvedDotExpr::createImplicit(
+        ctx,
+        new (ctx) DeclRefExpr({ctor->getImplicitSelfDecl()},
+                              /*Loc=*/DeclNameLoc(), /*Implicit=*/true),
+        storageProperty->getName());
+
+    auto *paramRef = new (ctx)
+        DeclRefExpr(ctor->getParameters()->get(0), /*Loc=*/DeclNameLoc(),
+                    /*Implicit=*/true);
+
+    body.push_back(new (ctx) AssignExpr(storageVarRef, /*EqualLoc=*/SourceLoc(),
+                                        paramRef,
+                                        /*Implicit=*/true));
+  }
+
+  return {BraceStmt::create(ctx, /*lbloc=*/ctor->getLoc(), body,
+                            /*rbloc=*/ctor->getLoc(), /*implicit=*/true),
+          /*isTypeChecked=*/false};
 }
 
 ConstructorDecl *SynthesizeTypeWrappedTypeStorageWrapperInitializer::evaluate(

test/Interpreter/type_wrappers.swift

@@ -625,3 +625,23 @@ do {
   // CHECK-NEXT: in read-only getter storage: \$Storage.b, property: \TypeWithLetProperties<Optional<Array<Int>>>.b
   // CHECK-NEXT: 0
 }
+
+do {
+  @Wrapper
+  struct Test<T> {
+    var a: T
+    var b: Int
+  }
+
+  let wrapper = Wrapper(for: Test<[Float?]>.self, storage: Test<[Float?]>.$Storage(a: [1.0], b: 42))
+  // CHECK: Wrapper.init(for: Test<Array<Optional<Float>>>, storage: $Storage(a: [Optional(1.0)], b: 42))
+
+  var test = Test(storageWrapper: wrapper)
+
+  print(test.a)
+  print(test.b)
+  // CHECK-NEXT: in getter storage: \$Storage.a, property: \Test<Array<Optional<Float>>>.<{{.*}} (Array<Optional<Float>>)>
+  // CHECK-NEXT: [Optional(1.0)]
+  // CHECK-NEXT: in getter storage: \$Storage.b, property: \Test<Array<Optional<Float>>>.b
+  // CHECK-NEXT: 42
+}

test/type/type_wrapper.swift

@@ -146,6 +146,9 @@ do {
 
 @typeWrapper
 struct NoopWrapper<W, S> {
+  // expected-note@-1 {{arguments to generic parameter 'W' ('Test1' and 'Test2') are expected to be equal}}
+  // expected-note@-2 {{arguments to generic parameter 'S' ('Test1.$Storage' and 'Test2.$Storage') are expected to be equal}}
+
   init(for: W.Type, storage: S) {}
 
   subscript<V>(propertyKeyPath _: KeyPath<W, V>, storageKeyPath path: KeyPath<S, V>) -> V {
@@ -608,3 +611,33 @@ do {
     var name: String
   }
 }
+
+do {
+  @NoopWrapper
+  struct Test1 {
+    var a: Int
+    var b: [String]
+  }
+
+  let wrapper = NoopWrapper(for: Test1.self, storage: Test1.$Storage(a: 42, b: [""]))
+  _ = Test1(storageWrapper: wrapper) // Ok
+
+  @NoopWrapper
+  struct Test2 {
+  }
+
+  _ = Test2(storageWrapper: NoopWrapper(for: Test2.self, storage: Test2.$Storage())) // Ok
+  _ = Test2(storageWrapper: wrapper)
+  // expected-error@-1 {{cannot convert value of type 'NoopWrapper<Test1, Test1.$Storage>' to expected argument type 'NoopWrapper<Test2, Test2.$Storage>'}}
+
+  @NoopWrapper
+  struct Test3 { // expected-note {{'init(a:b:)' declared here}}
+    var a: Int
+    @typeWrapperIgnored var b: String
+  }
+
+  // @typeWrapperIgnored suppresses `storageWrapper:` initializer
+  _ = Test3(storageWrapper: NoopWrapper(for: Test3.self, storage: Test3.$Storage(a: 42)))
+  // expected-error@-1 {{missing arguments for parameters 'a', 'b' in call}}
+  // expected-error@-2 {{extra argument 'storageWrapper' in call}}
+}