[Sema] TypeWrappers: Synthesize body of a memberwise initializer lazily

Make sure that memberwise initializer body doesn't force
other synthesis by emitting it lazily.

Resolves: rdar://99884355

Author: xedin

include/swift/AST/TypeCheckRequests.h

@@ -3689,22 +3689,6 @@ class SynthesizeTypeWrappedTypeMemberwiseInitializer
   bool isCached() const { return true; }
 };
 
-class SynthesizeTypeWrappedTypeMemberwiseInitializerBody
-    : public SimpleRequest<SynthesizeTypeWrappedTypeMemberwiseInitializerBody,
-                           BraceStmt *(ConstructorDecl *),
-                           RequestFlags::Cached> {
-public:
-  using SimpleRequest::SimpleRequest;
-
-private:
-  friend SimpleRequest;
-
-  BraceStmt *evaluate(Evaluator &evaluator, ConstructorDecl *) const;
-
-public:
-  bool isCached() const { return true; }
-};
-
 class SynthesizeLocalVariableForTypeWrapperStorage
     : public SimpleRequest<SynthesizeLocalVariableForTypeWrapperStorage,
                            VarDecl *(ConstructorDecl *), RequestFlags::Cached> {

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -431,9 +431,6 @@ SWIFT_REQUEST(TypeChecker, IsPropertyAccessedViaTypeWrapper,
 SWIFT_REQUEST(TypeChecker, SynthesizeTypeWrappedTypeMemberwiseInitializer,
               ConstructorDecl *(NominalTypeDecl *),
               Cached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, SynthesizeTypeWrappedTypeMemberwiseInitializerBody,
-              BraceStmt *(ConstructorDecl *),
-              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, SynthesizeLocalVariableForTypeWrapperStorage,
               VarDecl *(ConstructorDecl *),
               Cached, NoLocationInfo)

lib/Sema/CodeSynthesis.cpp

@@ -1588,6 +1588,113 @@ void swift::addNonIsolatedToSynthesized(
   value->getAttrs().add(new (ctx) NonisolatedAttr(/*isImplicit=*/true));
 }
 
+static std::pair<BraceStmt *, /*isTypeChecked=*/bool>
+synthesizeTypeWrappedTypeMemberwiseInitializerBody(AbstractFunctionDecl *decl,
+                                                   void *) {
+  auto *ctor = cast<ConstructorDecl>(decl);
+  auto &ctx = ctor->getASTContext();
+  auto *parent = ctor->getDeclContext()->getSelfNominalTypeDecl();
+
+  // self.$storage = .init(storage: $Storage(...))
+  auto *storageType = parent->getTypeWrapperStorageDecl();
+  assert(storageType);
+
+  auto *typeWrapperVar = parent->getTypeWrapperProperty();
+  assert(typeWrapperVar);
+
+  auto *storageVarRef = UnresolvedDotExpr::createImplicit(
+      ctx,
+      new (ctx) DeclRefExpr({ctor->getImplicitSelfDecl()},
+                            /*Loc=*/DeclNameLoc(), /*Implicit=*/true),
+      typeWrapperVar->getName());
+
+  // 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.
+      if (param->hasAttachedPropertyWrapper()) {
+        arg = param->getPropertyWrapperBackingProperty();
+        (void)param->getPropertyWrapperBackingPropertyType();
+      }
+
+      initArgs.push_back({/*labelLoc=*/SourceLoc(), arg->getName(),
+                          new (ctx) DeclRefExpr(arg, /*Loc=*/DeclNameLoc(),
+                                                /*Implicit=*/true)});
+    }
+  }
+
+  auto *storageInit = CallExpr::createImplicit(
+      ctx,
+      TypeExpr::createImplicitForDecl(
+          /*Loc=*/DeclNameLoc(), storageType, ctor,
+          ctor->mapTypeIntoContext(storageType->getInterfaceType())),
+      ArgumentList::createImplicit(ctx, initArgs));
+
+  auto *initRef = new (ctx) UnresolvedMemberExpr(
+      /*dotLoc=*/SourceLoc(), /*declNameLoc=*/DeclNameLoc(),
+      DeclNameRef::createConstructor(), /*implicit=*/true);
+  { initRef->setFunctionRefKind(FunctionRefKind::DoubleApply); }
+
+  auto *selfTypeRef = TypeExpr::createImplicitForDecl(
+      DeclNameLoc(), parent, parent->getDeclContext(),
+      ctor->mapTypeIntoContext(parent->getInterfaceType()));
+
+  auto *selfRef = new (ctx)
+      DotSelfExpr(selfTypeRef, /*dot=*/SourceLoc(), /*self=*/SourceLoc());
+  selfRef->setImplicit();
+
+  // .init($Storage(for:storage:))
+  Expr *typeWrapperInit = CallExpr::createImplicit(
+      ctx, initRef,
+      ArgumentList::createImplicit(
+          ctx,
+          {Argument(/*labelLoc=*/SourceLoc(), ctx.Id_for, selfRef),
+           Argument(/*labelLoc=*/SourceLoc(), ctx.Id_storage, storageInit)}));
+
+  body.push_back(new (ctx) AssignExpr(storageVarRef, /*EqualLoc=*/SourceLoc(),
+                                      typeWrapperInit,
+                                      /*Implicit=*/true));
+
+  return {BraceStmt::create(ctx, /*lbloc=*/ctor->getLoc(), body,
+                            /*rbloc=*/ctor->getLoc(), /*implicit=*/true),
+          /*isTypeChecked=*/false};
+}
+
 ConstructorDecl *SynthesizeTypeWrappedTypeMemberwiseInitializer::evaluate(
     Evaluator &evaluator, NominalTypeDecl *wrappedType) const {
   if (!wrappedType->hasTypeWrapper())
@@ -1599,12 +1706,6 @@ ConstructorDecl *SynthesizeTypeWrappedTypeMemberwiseInitializer::evaluate(
       wrappedType, ImplicitConstructorKind::TypeWrapper, ctx);
   wrappedType->addMember(ctor);
 
-  auto *body = evaluateOrDefault(
-      evaluator, SynthesizeTypeWrappedTypeMemberwiseInitializerBody{ctor},
-      nullptr);
-  if (!body)
-    return nullptr;
-
-  ctor->setBody(body, AbstractFunctionDecl::BodyKind::Parsed);
+  ctor->setBodySynthesizer(synthesizeTypeWrappedTypeMemberwiseInitializerBody);
   return ctor;
 }

lib/Sema/TypeCheckTypeWrapper.cpp

@@ -424,110 +424,6 @@ bool IsPropertyAccessedViaTypeWrapper::evaluate(Evaluator &evaluator,
   return true;
 }
 
-BraceStmt *SynthesizeTypeWrappedTypeMemberwiseInitializerBody::evaluate(
-    Evaluator &evaluator, ConstructorDecl *ctor) const {
-  auto &ctx = ctor->getASTContext();
-  auto *parent = ctor->getDeclContext()->getSelfNominalTypeDecl();
-
-  // self.$storage = .init(storage: $Storage(...))
-  auto *storageType = parent->getTypeWrapperStorageDecl();
-  assert(storageType);
-
-  auto *typeWrapperVar = parent->getTypeWrapperProperty();
-  assert(typeWrapperVar);
-
-  auto *storageVarRef = UnresolvedDotExpr::createImplicit(
-      ctx,
-      new (ctx) DeclRefExpr({ctor->getImplicitSelfDecl()},
-                            /*Loc=*/DeclNameLoc(), /*Implicit=*/true),
-      typeWrapperVar->getName());
-
-  // 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.
-      if (param->hasAttachedPropertyWrapper()) {
-        arg = param->getPropertyWrapperBackingProperty();
-        (void)param->getPropertyWrapperBackingPropertyType();
-      }
-
-      initArgs.push_back({/*labelLoc=*/SourceLoc(), arg->getName(),
-                          new (ctx) DeclRefExpr(arg, /*Loc=*/DeclNameLoc(),
-                                                /*Implicit=*/true)});
-    }
-  }
-
-  auto *storageInit = CallExpr::createImplicit(
-      ctx,
-      TypeExpr::createImplicitForDecl(
-          /*Loc=*/DeclNameLoc(), storageType, ctor,
-          ctor->mapTypeIntoContext(storageType->getInterfaceType())),
-      ArgumentList::createImplicit(ctx, initArgs));
-
-  auto *initRef = new (ctx) UnresolvedMemberExpr(
-      /*dotLoc=*/SourceLoc(), /*declNameLoc=*/DeclNameLoc(),
-      DeclNameRef::createConstructor(), /*implicit=*/true);
-  { initRef->setFunctionRefKind(FunctionRefKind::DoubleApply); }
-
-  auto *selfTypeRef = TypeExpr::createImplicitForDecl(
-      DeclNameLoc(), parent, parent->getDeclContext(),
-      ctor->mapTypeIntoContext(parent->getInterfaceType()));
-
-  auto *selfRef = new (ctx)
-      DotSelfExpr(selfTypeRef, /*dot=*/SourceLoc(), /*self=*/SourceLoc());
-  selfRef->setImplicit();
-
-  // .init($Storage(for:storage:))
-  Expr *typeWrapperInit = CallExpr::createImplicit(
-      ctx, initRef,
-      ArgumentList::createImplicit(
-          ctx,
-          {Argument(/*labelLoc=*/SourceLoc(), ctx.Id_for, selfRef),
-           Argument(/*labelLoc=*/SourceLoc(), ctx.Id_storage, storageInit)}));
-
-  body.push_back(new (ctx) AssignExpr(storageVarRef, /*EqualLoc=*/SourceLoc(),
-                                      typeWrapperInit,
-                                      /*Implicit=*/true));
-
-  return BraceStmt::create(ctx, /*lbloc=*/ctor->getLoc(), body,
-                           /*rbloc=*/ctor->getLoc(), /*implicit=*/true);
-}
-
 VarDecl *SynthesizeLocalVariableForTypeWrapperStorage::evaluate(
     Evaluator &evaluator, ConstructorDecl *ctor) const {
   auto &ctx = ctor->getASTContext();

test/type/type_wrapper.swift

@@ -595,5 +595,16 @@ func testWrappedSelfInReferenceOnlySubscript() {
       get { fatalError() }
     }
   }
+}
+
+// rdar://99884355 - Missing argument for parameter 'name'
+do {
+  struct Use {
+    var product = Product(name: "<no name>")
+  }
 
+  @NoopWrapper
+  struct Product {
+    var name: String
+  }
 }