[distributed] synthesize factory resolve func

Author: kavon

include/swift/AST/Decl.h

@@ -6127,6 +6127,14 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
         && getSILSynthesizeKind() == SILSynthesizeKind::MemberwiseInitializer;
   }
 
+  /// Determines whether this function represents a distributed actor
+  /// initialization factory. Such functions do not have a body that is
+  /// representable in the AST, so it must be synthesized during SILGen.
+  bool isDistributedActorFactory() const {
+    return getBodyKind() == BodyKind::SILSynthesize
+    && getSILSynthesizeKind() == SILSynthesizeKind::DistributedActorFactory;
+  }
+
   /// For a method of a class, checks whether it will require a new entry in the
   /// vtable.
   bool needsNewVTableEntry() const;

lib/SILGen/SILGenConstructor.cpp

@@ -1196,3 +1196,11 @@ void SILGenFunction::emitIVarInitializer(SILDeclRef ivarInitializer) {
 
   emitEpilog(loc);
 }
+
+
+void SILGenFunction::emitDistributedActorFactory(FuncDecl *fd) {
+  /// NOTE: this will only be reached if the resolve function is actually
+  ///       demanded. For example, by declaring the actor as `public` or
+  ///       having at least one call to the resolve init.
+  llvm_unreachable("TODO: implement emitDistributedActorFactory");
+}

lib/SILGen/SILGenFunction.cpp

@@ -510,6 +510,11 @@ SILGenFunction::emitClosureValue(SILLocation loc, SILDeclRef constant,
 void SILGenFunction::emitFunction(FuncDecl *fd) {
   MagicFunctionName = SILGenModule::getMagicFunctionName(fd);
 
+  if (fd->isDistributedActorFactory()) {
+    emitDistributedActorFactory(fd);
+    return;
+  }
+
   auto captureInfo = SGM.M.Types.getLoweredLocalCaptures(SILDeclRef(fd));
   emitProfilerIncrement(fd->getTypecheckedBody());
   emitProlog(captureInfo, fd->getParameters(), fd->getImplicitSelfDecl(), fd,

lib/SILGen/SILGenFunction.h

@@ -625,6 +625,10 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   /// destructor, then implicitly releases the elements of the class.
   void emitDestroyingDestructor(DestructorDecl *dd);
 
+  /// Given a function representing a distributed actor factory, emits the
+  /// corresponding SIL function for it.
+  void emitDistributedActorFactory(FuncDecl *fd);
+
   /// Generates code for an artificial top-level function that starts an
   /// application based on a main type and optionally a main type.
   void emitArtificialTopLevel(Decl *mainDecl);

lib/Sema/CodeSynthesisDistributedActor.cpp

@@ -47,61 +47,49 @@ using namespace swift;
 /// expected to be filled-in during SILGen.
 static void addFactoryResolveFunction(ClassDecl *decl) {
   assert(decl->isDistributedActor());
-  auto &ctx = decl->getASTContext();
+  auto &C = decl->getASTContext();
 
-  {
-    auto &C = ctx;
-    auto conformanceDC = decl;
-
-    // Expected type: (Self) -> (ActorAddress, ActorTransport) -> (Self)
-    //
-    // Param: (resolve address: AnyActorAddress)
-    auto addressType = C.getAnyActorIdentityDecl()->getDeclaredInterfaceType();
-    auto *idParamDecl = new (C) ParamDecl(
-        SourceLoc(), SourceLoc(), C.Id_resolve,
-        SourceLoc(), C.Id_id, conformanceDC);
-    idParamDecl->setImplicit();
-    idParamDecl->setSpecifier(ParamSpecifier::Default);
-    idParamDecl->setInterfaceType(addressType);
-
-    // Param: (using transport: ActorTransport)
-    auto transportType = C.getActorTransportDecl()->getDeclaredInterfaceType();
-    auto *transportParamDecl = new (C) ParamDecl(
-        SourceLoc(), SourceLoc(), C.Id_using,
-        SourceLoc(), C.Id_transport, conformanceDC);
-    transportParamDecl->setImplicit();
-    transportParamDecl->setSpecifier(ParamSpecifier::Default);
-    transportParamDecl->setInterfaceType(transportType);
-
-    auto *paramList = ParameterList::create(
-        C,
-        /*LParenLoc=*/SourceLoc(),
-        /*params=*/{idParamDecl, transportParamDecl},
-        /*RParenLoc=*/SourceLoc()
-        );
-
-    // Func name: init(resolve:using:)
-    DeclName name(C, DeclBaseName::createConstructor(), paramList);
-
-    auto *initDecl =
-        new (C) ConstructorDecl(name, SourceLoc(),
-                                /*Failable=*/false, SourceLoc(),
-                                /*Async=*/false, SourceLoc(),
-                                /*Throws=*/true, SourceLoc(),
-                                paramList,
-                                /*GenericParams=*/nullptr, conformanceDC);
-    initDecl->setImplicit();
-    // TODO: determine how to mark this as being synthesized by SILGen.
-//    initDecl->setSynthesized();
-//    initDecl->setBodySynthesizer(&createDistributedActor_init_resolve_body);
-
-    auto *nonIsoAttr = new (C) NonisolatedAttr(/*IsImplicit*/true);
-    initDecl->getAttrs().add(nonIsoAttr);
-
-    initDecl->copyFormalAccessFrom(decl, /*sourceIsParentContext=*/true);
-
-    decl->addMember(initDecl);
-  }
+  auto mkParam = [&](Identifier argName, Identifier paramName, Type ty) -> ParamDecl* {
+    auto *param = new (C) ParamDecl(SourceLoc(),
+                                    SourceLoc(), argName,
+                                    SourceLoc(), paramName, decl);
+    param->setImplicit();
+    param->setSpecifier(ParamSpecifier::Default);
+    param->setInterfaceType(ty);
+    return param;
+  };
+
+  auto addressType = C.getAnyActorIdentityDecl()->getDeclaredInterfaceType();
+  auto transportType = C.getActorTransportDecl()->getDeclaredInterfaceType();
+
+  // (_ id: AnyActorAddress, using transport: ActorTransport)
+  auto *params = ParameterList::create(
+      C,
+      /*LParenLoc=*/SourceLoc(),
+      /*params=*/{  mkParam(Identifier(), C.Id_id, addressType),
+                    mkParam(C.Id_using, C.Id_transport, transportType)
+                  },
+      /*RParenLoc=*/SourceLoc()
+      );
+
+  // Func name: resolve(_:using:)
+  DeclName name(C, C.Id_resolve, params);
+
+  // Expected type: (Self) -> (ActorAddress, ActorTransport) throws -> (Self)
+  auto *factoryDecl =
+      FuncDecl::createImplicit(C, StaticSpellingKind::KeywordStatic,
+                               name, SourceLoc(),
+                               /*async=*/false,
+                               /*throws=*/true,
+                               /*genericParams=*/nullptr,
+                               params,
+                               /*returnType*/decl->getDeclaredInterfaceType(),
+                               decl);
+
+  factoryDecl->setDistributedActorFactory();
+  factoryDecl->copyFormalAccessFrom(decl, /*sourceIsParentContext=*/true);
+
+  decl->addMember(factoryDecl);
 }
 
 /// Synthesizes an empty body of the `init(transport:)` initializer as: