[Sema] TypeWrappers/NFC: Move initializer synthesis into a request

Author: xedin

include/swift/AST/TypeCheckRequests.h

@@ -3655,6 +3655,22 @@ class SynthesizeTypeWrapperInitializer
   bool isCached() const { return true; }
 };
 
+class SynthesizeTypeWrapperInitializerBody
+    : public SimpleRequest<SynthesizeTypeWrapperInitializerBody,
+                           BraceStmt *(ConstructorDecl *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  BraceStmt *evaluate(Evaluator &evaluator, ConstructorDecl *) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 void simple_display(llvm::raw_ostream &out, ASTNode node);
 void simple_display(llvm::raw_ostream &out, Type value);
 void simple_display(llvm::raw_ostream &out, const TypeRepr *TyR);

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -426,3 +426,6 @@ SWIFT_REQUEST(TypeChecker, IsPropertyAccessedViaTypeWrapper,
 SWIFT_REQUEST(TypeChecker, SynthesizeTypeWrapperInitializer,
               ConstructorDecl *(NominalTypeDecl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, SynthesizeTypeWrapperInitializerBody,
+              BraceStmt *(ConstructorDecl *),
+              Cached, NoLocationInfo)

lib/Sema/CodeSynthesis.cpp

@@ -1496,63 +1496,6 @@ void swift::addNonIsolatedToSynthesized(
   value->getAttrs().add(new (ctx) NonisolatedAttr(/*isImplicit=*/true));
 }
 
-static std::pair<BraceStmt *, bool>
-synthesizeTypeWrapperInitializerBody(AbstractFunctionDecl *fn, void *context) {
-  auto *ctor = cast<ConstructorDecl>(fn);
-  auto &ctx = ctor->getASTContext();
-  auto *parent = ctor->getDeclContext()->getSelfNominalTypeDecl();
-
-  // self.$_storage = .init(memberwise: $Storage(...))
-  auto *storageType =
-      evaluateOrDefault(ctx.evaluator, GetTypeWrapperStorage{parent}, nullptr);
-  assert(storageType);
-
-  auto *typeWrapperVar =
-      evaluateOrDefault(ctx.evaluator, GetTypeWrapperProperty{parent}, nullptr);
-  assert(typeWrapperVar);
-
-  auto *storageVarRef = UnresolvedDotExpr::createImplicit(
-      ctx,
-      new (ctx) DeclRefExpr({ctor->getImplicitSelfDecl()},
-                            /*Loc=*/DeclNameLoc(), /*Implicit=*/true),
-      typeWrapperVar->getName());
-
-  SmallVector<Argument, 4> arguments;
-  {
-    for (auto *param : *ctor->getParameters()) {
-      arguments.push_back({/*labelLoc=*/SourceLoc(), param->getName(),
-                           new (ctx) DeclRefExpr(param, /*Loc=*/DeclNameLoc(),
-                                                 /*Implicit=*/true)});
-    }
-  }
-
-  auto *storageInit = CallExpr::createImplicit(
-      ctx,
-      TypeExpr::createImplicitForDecl(
-          /*Loc=*/DeclNameLoc(), storageType, ctor,
-          ctor->mapTypeIntoContext(storageType->getInterfaceType())),
-      ArgumentList::createImplicit(ctx, arguments));
-
-  auto *initRef = new (ctx) UnresolvedMemberExpr(
-      /*dotLoc=*/SourceLoc(), /*declNameLoc=*/DeclNameLoc(),
-      DeclNameRef::createConstructor(), /*implicit=*/true);
-  { initRef->setFunctionRefKind(FunctionRefKind::DoubleApply); }
-
-  // .init($Storage(...))
-  Expr *typeWrapperInit = CallExpr::createImplicit(
-      ctx, initRef,
-      ArgumentList::forImplicitSingle(ctx, ctx.Id_memberwise, storageInit));
-
-  auto *assignment = new (ctx)
-      AssignExpr(storageVarRef, /*EqualLoc=*/SourceLoc(), typeWrapperInit,
-                 /*Implicit=*/true);
-
-  return {BraceStmt::create(ctx, /*lbloc=*/ctor->getLoc(),
-                            /*body=*/{assignment},
-                            /*rbloc=*/ctor->getLoc(), /*implicit=*/true),
-          /*isTypeChecked=*/false};
-}
-
 ConstructorDecl *
 SynthesizeTypeWrapperInitializer::evaluate(Evaluator &evaluator,
                                            NominalTypeDecl *wrappedType) const {
@@ -1565,6 +1508,11 @@ SynthesizeTypeWrapperInitializer::evaluate(Evaluator &evaluator,
       wrappedType, ImplicitConstructorKind::TypeWrapper, ctx);
   wrappedType->addMember(ctor);
 
-  ctor->setBodySynthesizer(synthesizeTypeWrapperInitializerBody);
+  auto *body = evaluateOrDefault(
+      evaluator, SynthesizeTypeWrapperInitializerBody{ctor}, nullptr);
+  if (!body)
+    return nullptr;
+
+  ctor->setBody(body, AbstractFunctionDecl::BodyKind::Parsed);
   return ctor;
 }

lib/Sema/TypeCheckTypeWrapper.cpp

@@ -365,3 +365,58 @@ bool IsPropertyAccessedViaTypeWrapper::evaluate(Evaluator &evaluator,
 
   return true;
 }
+
+BraceStmt *
+SynthesizeTypeWrapperInitializerBody::evaluate(Evaluator &evaluator,
+                                               ConstructorDecl *ctor) const {
+  auto &ctx = ctor->getASTContext();
+  auto *parent = ctor->getDeclContext()->getSelfNominalTypeDecl();
+
+  // self.$_storage = .init(memberwise: $Storage(...))
+  auto *storageType =
+      evaluateOrDefault(ctx.evaluator, GetTypeWrapperStorage{parent}, nullptr);
+  assert(storageType);
+
+  auto *typeWrapperVar = parent->getTypeWrapperProperty();
+  assert(typeWrapperVar);
+
+  auto *storageVarRef = UnresolvedDotExpr::createImplicit(
+      ctx,
+      new (ctx) DeclRefExpr({ctor->getImplicitSelfDecl()},
+                            /*Loc=*/DeclNameLoc(), /*Implicit=*/true),
+      typeWrapperVar->getName());
+
+  SmallVector<Argument, 4> arguments;
+  {
+    for (auto *param : *ctor->getParameters()) {
+      arguments.push_back({/*labelLoc=*/SourceLoc(), param->getName(),
+                           new (ctx) DeclRefExpr(param, /*Loc=*/DeclNameLoc(),
+                                                 /*Implicit=*/true)});
+    }
+  }
+
+  auto *storageInit = CallExpr::createImplicit(
+      ctx,
+      TypeExpr::createImplicitForDecl(
+          /*Loc=*/DeclNameLoc(), storageType, ctor,
+          ctor->mapTypeIntoContext(storageType->getInterfaceType())),
+      ArgumentList::createImplicit(ctx, arguments));
+
+  auto *initRef = new (ctx) UnresolvedMemberExpr(
+      /*dotLoc=*/SourceLoc(), /*declNameLoc=*/DeclNameLoc(),
+      DeclNameRef::createConstructor(), /*implicit=*/true);
+  { initRef->setFunctionRefKind(FunctionRefKind::DoubleApply); }
+
+  // .init($Storage(...))
+  Expr *typeWrapperInit = CallExpr::createImplicit(
+      ctx, initRef,
+      ArgumentList::forImplicitSingle(ctx, ctx.Id_memberwise, storageInit));
+
+  auto *assignment = new (ctx)
+      AssignExpr(storageVarRef, /*EqualLoc=*/SourceLoc(), typeWrapperInit,
+                 /*Implicit=*/true);
+
+  return BraceStmt::create(ctx, /*lbloc=*/ctor->getLoc(),
+                           /*body=*/{assignment},
+                           /*rbloc=*/ctor->getLoc(), /*implicit=*/true);
+}