[Distributed] SIL invocation of initialize remote done

Author: ktoso

include/swift/Runtime/RuntimeFunctions.def

@@ -1697,16 +1697,6 @@ FUNCTION(DistributedActorInitializeRemote,
          ARGS(TypeMetadataPtrTy),
          ATTRS(NoUnwind))
 
-// OpaqueValue* swift_distributedActor_remote_create(
-//     OpaqueValue *identity,
-//     OpaqueValue *transport);
-FUNCTION(DistributedActorRemoteCreate,
-         swift_distributedActor_remote_create, SwiftCC,
-         ConcurrencyAvailability,
-         RETURNS(OpaquePtrTy), // TODO: is this the right type here?
-         ARGS(OpaquePtrTy, OpaquePtrTy),
-         ATTRS(NoUnwind))
-
 // void swift_distributedActor_destroy(DefaultActor *actor); // TODO: ProxyActor *proxy?
 FUNCTION(DistributedActorDestroy,
          swift_distributedActor_destroy, SwiftCC,

lib/AST/Builtins.cpp

@@ -1465,8 +1465,16 @@ static ValueDecl *getDefaultActorInitDestroy(ASTContext &ctx,
 static ValueDecl *getDistributedActorInitializeRemote(ASTContext &ctx,
                                                       Identifier id) {
   return getBuiltinFunction(ctx, id, _thin,
-                            _parameters(_nativeObject),
+                            _generics(_unrestricted), // TODO(distributed): restrict to DistributedActor
+                            _parameters(_metatype(_typeparam(0))),
+//                            _parameters(_nativeObject),
                             _rawPointer);
+
+//  return getBuiltinFunction(ctx, id, _thin,
+//                            _generics(_unrestricted), // TODO(distributed): restrict to DistributedActor
+//                            _parameters(_metatype(_typeparam(0))),
+// //                            _parameters(_nativeObject),
+//                            _rawPointer);
 }
 
 static ValueDecl *getDistributedActorDestroy(ASTContext &ctx,

lib/IRGen/GenBuiltin.cpp

@@ -389,14 +389,23 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
 
   if (Builtin.ID == BuiltinValueKind::InitializeDistributedRemoteActor) {
     auto fn = IGF.IGM.getDistributedActorInitializeRemoteFn();
-    auto actor = args.claimNext();
-    actor = IGF.Builder.CreateBitCast(actor, IGF.IGM.RefCountedPtrTy);
-    // init(resolve address, using transport)
-    auto call = IGF.Builder.CreateCall(fn, {
-      actor
-      // TODO: might have to carry `address, transport` depending on how we implement the resolve initializers
-    });
+    auto actorTy = args.claimNext();
+    fprintf(stderr, "[%s:%d] (%s) ARGUMENT ONE\n", __FILE__, __LINE__, __FUNCTION__);
+    actorTy->dump();
+    fprintf(stderr, "[%s:%d] (%s) ARGUMENT ONE CAST\n", __FILE__, __LINE__, __FUNCTION__);
+    actorTy = IGF.Builder.CreateBitCast(actorTy, IGF.IGM.TypeMetadataPtrTy);
+    actorTy->dump();
+    auto call = IGF.Builder.CreateCall(fn, { actorTy });
     call->setCallingConv(IGF.IGM.SwiftCC);
+    call->setDoesNotThrow();
+    fprintf(stderr, "[%s:%d] (%s) CALL\n", __FILE__, __LINE__, __FUNCTION__);
+    call->dump();
+
+    // Cast back to opaque value
+//    auto result = IGF.Builder.CreateBitCast(call, IGF.IGM.OpaquePtrTy);
+//    out.add(result);
+    out.add(call);
+
     return;
   }
 

lib/SIL/Utils/MemAccessUtils.cpp

@@ -1876,6 +1876,7 @@ static void visitBuiltinAddress(BuiltinInst *builtin,
     case BuiltinValueKind::AutoDiffCreateLinearMapContext:
     case BuiltinValueKind::AutoDiffAllocateSubcontext:
     case BuiltinValueKind::InitializeDefaultActor:
+    case BuiltinValueKind::InitializeDistributedRemoteActor:
     case BuiltinValueKind::DestroyDefaultActor:
     case BuiltinValueKind::GetCurrentExecutor:
     case BuiltinValueKind::StartAsyncLet:

lib/SILGen/SILGenDistributed.cpp

@@ -422,6 +422,8 @@ void SILGenFunction::emitDistributedActorFactory(FuncDecl *fd) {
     auto selfMetatype =
         getLoweredType(F.mapTypeIntoContext(selfArg.getType().getASTType()));
     SILValue selfMetatypeValue = B.createMetatype(loc, selfMetatype);
+    fprintf(stderr, "[%s:%d] (%s)     SILValue selfMetatypeValue = B.createMetatype(loc, selfMetatype);\n", __FILE__, __LINE__, __FUNCTION__);
+    selfMetatypeValue->dump();
 
     // --- get the uninitialized allocation from the runtime system.
     FullExpr scope(Cleanups, CleanupLocation(fd));
@@ -435,10 +437,13 @@ void SILGenFunction::emitDistributedActorFactory(FuncDecl *fd) {
         /*subs*/ {},
         {selfMetatypeValue});
 
-    // ==== Initialize identity and transport
+//    ManagedValue remoteCast =
+//        B.createUncheckedBitCast(loc, ManagedValue::forUnmanaged(remote), returnTy);
+
+    // ==== Initialize distributed actor properties
     // --- Store the identity: self.id = identity
-    emitDistributedActorIdentityStore(
-        C, *this, /*actorSelf*/remote, fd, identityArg);
+//    emitDistributedActorIdentityStore(
+//        C, *this, /*actorSelf*/remote, fd, identityArg);
 
     // --- Store the transport: self.transport = transport
     // FIXME(distributed): IMPLEMENT:
@@ -447,6 +452,7 @@ void SILGenFunction::emitDistributedActorFactory(FuncDecl *fd) {
 
     // ==== Return the fully initialized remote instance
     B.createReturn(loc, remote);
+//    B.createReturn(loc, remoteCast);
 
  //   // ==== Branch to return the fully initialized remote instance
 //    B.createBranch(loc, returnBB, {remote});

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -2466,7 +2466,7 @@ void LifetimeChecker::processUninitializedRelease(SILInstruction *Release,
       auto classDecl = TheMemory.getASTType().getClassOrBoundGenericClass();
       if (classDecl && classDecl->isRootDefaultActor()) {
         if (classDecl->isDistributedActor())
-          emitDistributedActorDestroy(B, Loc, Pointer);
+          emitDistributedActorDestroy(B, Loc, Pointer); // FIXME(distributed): this will be different only for if it is 'remote'
         else
           emitDefaultActorDestroy(B, Loc, Pointer);
       }

test/Distributed/actor_protocols.swift

@@ -52,14 +52,16 @@ actor A2: DistributedActor {
   init(transport: ActorTransport) {
     fatalError()
   }
-  init(resolve id: AnyActorIdentity, using transport: ActorTransport) throws {
+
+  static func resolve(_ identity: AnyActorIdentity, using transport: ActorTransport) throws -> Self {
     fatalError()
   }
 }
 
 @available(SwiftStdlib 5.5, *)
 class C2: DistributedActor {
   // expected-error@-1{{non-actor type 'C2' cannot conform to the 'Actor' protocol}}
+  // expected-error@-2{{non-final class 'C2' cannot conform to `Sendable`; use `@unchecked Sendable`}}
   nonisolated var id: AnyActorIdentity {
     fatalError()
   }
@@ -70,7 +72,7 @@ class C2: DistributedActor {
   required init(transport: ActorTransport) {
     fatalError()
   }
-  required init(resolve id: AnyActorIdentity, using transport: ActorTransport) throws {
+  static func resolve(_ identity: AnyActorIdentity, using transport: ActorTransport) throws -> Self {
     fatalError()
   }
 }

test/Distributed/distributed_actor_resolve.swift

@@ -13,7 +13,7 @@ distributed actor Capybara { }
 //distributed actor GuineaPing: Wheeker { }
 
 @available(SwiftStdlib 5.5, *)
-func test<Identity: ActorIdentity>(identity: Identity, transport: ActorTransport) async throws {
+func test(identity: AnyActorIdentity, transport: ActorTransport) async throws {
   let _: Capybara = try Capybara.resolve(identity, using: transport)
 
 // TODO: implement resolve being able to be called on a distributed actor protocol