[Distributed][Macro] handle same type requirement

Author: ktoso

lib/Macros/Sources/SwiftMacros/DistributedProtocolMacro.swift

@@ -19,6 +19,9 @@ import SwiftSyntaxBuilder
 /// - `distributed actor $MyDistributedActor<ActorSystem>: $MyDistributedActor, _DistributedActorStub where ...`
 /// - `extension MyDistributedActor where Self: _DistributedActorStub {}`
 public struct DistributedProtocolMacro: ExtensionMacro, PeerMacro {
+
+  /// Introduce the `extension MyDistributedActor` which contains default
+  /// implementations of the protocol's requirements.
   public static func expansion(
     of node: AttributeSyntax,
     attachedTo declaration: some DeclGroupSyntax,
@@ -66,8 +69,34 @@ public struct DistributedProtocolMacro: ExtensionMacro, PeerMacro {
     }
 
     // FIXME must detect this off the protocol
-    let serializationRequirementType =
-      "Codable"
+    let serializationRequirementType: String = "Codable"
+    let specificActorSystemRequirement: TypeSyntax?
+
+    for req in proto.genericWhereClause?.requirements ?? [] {
+      print("req.requirement: \(req.requirement)")
+      switch req.requirement {
+      case .conformanceRequirement(let conformanceReq):
+        print("conf: \(conformanceReq)")
+
+      case .sameTypeRequirement(let sameTypeReq):
+        print("same type: \(sameTypeReq)")
+        if sameTypeReq.leftType.trimmedDescription == "ActorSystem" {
+          let specificActorSystemRequirement = sameTypeReq.rightType.trimmed
+
+          return [
+            """
+            distributed actor $\(proto.name.trimmed): \(proto.name.trimmed), 
+              Distributed._DistributedActorStub
+            { 
+              typealias ActorSystem = \(specificActorSystemRequirement) 
+            }
+            """
+          ]
+        }
+      case .layoutRequirement(let layoutReq):
+        print("layout: \(layoutReq)")
+      }
+    }
 
     let stubActorDecl: DeclSyntax =
       """

stdlib/public/Distributed/DistributedMacros.swift

@@ -15,8 +15,17 @@
 import Swift
 import _Concurrency
 
-#if $Macros
+// Macros are disabled when Swift is built without swift-syntax.
+#if $Macros && hasAttribute(attached)
 
+/// Enables the attached to protocol to be resolved as remote distributed
+/// actor reference.
+///
+/// ### Requirements
+///
+/// The attached to type must be a protocol that refines the `DistributedActor`
+/// protocol. It must either specify a concrete `ActorSystem` or constrain it
+/// in such way that the system's `SerializationRequirement` is statically known.
 @attached(peer, names: prefixed(`$`)) // provides $Greeter concrete stub type
 @attached(extension, names: arbitrary) // provides extension for Greeter & _DistributedActorStub
 public macro _DistributedProtocol() =

test/Distributed/Macros/distributed_macro_expansion_DistributedProtocol_sameType.swift

@@ -0,0 +1,36 @@
+// REQUIRES: swift_swift_parser, asserts
+//
+// UNSUPPORTED: back_deploy_concurrency
+// REQUIRES: concurrency
+// REQUIRES: distributed
+//
+// RUN: %empty-directory(%t)
+// RUN: %empty-directory(%t-scratch)
+
+// RUN: %target-swift-frontend-emit-module -emit-module-path %t/FakeDistributedActorSystems.swiftmodule -module-name FakeDistributedActorSystems -disable-availability-checking %S/../Inputs/FakeDistributedActorSystems.swift
+// RUN: %target-swift-frontend -typecheck -verify -disable-availability-checking -plugin-path %swift-plugin-dir -parse-as-library -I %t %S/../Inputs/FakeDistributedActorSystems.swift -dump-macro-expansions %s -dump-macro-expansions 2>&1 | %FileCheck %s --dump-input=always
+
+import Distributed
+
+@_DistributedProtocol
+protocol Greeter: DistributedActor where ActorSystem == FakeActorSystem {
+  distributed func greet(name: String) -> String
+}
+
+// @_DistributedProtocol ->
+
+// CHECK:      distributed actor $Greeter: Greeter,
+// CHECK-NEXT:    Distributed._DistributedActorStub
+// CHECK-NEXT: {
+// CHECK-NEXT:   typealias ActorSystem = FakeActorSystem
+// CHECK-NEXT: }
+
+// CHECK: extension Greeter where Self: Distributed._DistributedActorStub {
+// CHECK-NEXT:   distributed func greet(name: String) -> String {
+// CHECK-NEXT:     if #available (SwiftStdlib 6.0, *) {
+// CHECK-NEXT:       Distributed._distributedStubFatalError()
+// CHECK-NEXT:     } else {
+// CHECK-NEXT:       fatalError()
+// CHECK-NEXT:     }
+// CHECK-NEXT:   }
+// CHECK-NEXT: }

test/Distributed/Runtime/distributed_actor_remoteCall_protocol_method.swift

@@ -1,11 +1,9 @@
 // RUN: %empty-directory(%t)
-// RUN: %target-swift-frontend-emit-module -emit-module-path %t/FakeDistributedActorSystems.swiftmodule -module-name FakeDistributedActorSystems -disable-availability-checking %S/../Inputs/FakeDistributedActorSystems.swift
-// RUN: %target-build-swift -module-name main  -Xfrontend -disable-availability-checking -j2 -parse-as-library -I %t %s %S/../Inputs/FakeDistributedActorSystems.swift -o %t/a.out
+// RUN: %target-swift-frontend-emit-module -emit-module-path %t/FakeDistributedActorSystems.swiftmodule -module-name FakeDistributedActorSystems -disable-availability-checking %S/../Inputs/FakeDistributedActorSystems.swift -plugin-path %swift-plugin-dir
+// RUN: %target-build-swift -module-name main  -Xfrontend -disable-availability-checking -j2 -parse-as-library -I %t %s %S/../Inputs/FakeDistributedActorSystems.swift -plugin-path %swift-plugin-dir -o %t/a.out
 // RUN: %target-codesign %t/a.out
 // RUN: %target-run %t/a.out | %FileCheck %s --color --dump-input=always
 
-// UNSUPPORTED: OS=windows-msvc
-
 // REQUIRES: executable_test
 // REQUIRES: concurrency
 // REQUIRES: distributed
@@ -14,6 +12,9 @@
 // UNSUPPORTED: use_os_stdlib
 // UNSUPPORTED: back_deployment_runtime
 
+// FIXME(distributed): Distributed actors currently have some issues on windows, isRemote always returns false. rdar://82593574
+// UNSUPPORTED: OS=windows-msvc
+
 // FIXME(distributed): pending rework of distributed protocol target mangling
 // XFAIL: *
 
@@ -22,34 +23,11 @@ import FakeDistributedActorSystems
 
 // ==== Known actor system -----------------------------------------------------
 
-// @DistributedRemotelyJustViaProxyAccessible
+@_DistributedProtocol
 protocol GreeterDefinedSystemProtocol: DistributedActor where ActorSystem == FakeRoundtripActorSystem {
   distributed func greet() -> String
 }
 
-// start of @Proxy output =======
-extension GreeterDefinedSystemProtocol where Self == GreeterDefinedSystemProtocol_Stub {
-  static func resolve(
-    id: ID, using system: ActorSystem
-  ) throws -> any GreeterDefinedSystemProtocol {
-    print("\(Self.self).\(#function) -> return \(GreeterDefinedSystemProtocol_Stub.self)")
-
-    return try GreeterDefinedSystemProtocol_Stub.resolve(id: id, using: system)
-  }
-}
-
-distributed actor GreeterDefinedSystemProtocol_Stub: GreeterDefinedSystemProtocol {
-  typealias ActorSystem = FakeRoundtripActorSystem
-  init(actorSystem: ActorSystem) {
-    self.actorSystem = actorSystem
-  }
-
-  distributed func greet() -> String {
-    fatalError("Stub implementation")
-  }
-}
-// end of @Proxy output =======
-
 /// A concrete implementation done on the "server" side of a non-symmetric application
 distributed actor GreeterImpl: GreeterDefinedSystemProtocol {
   typealias ActorSystem = FakeRoundtripActorSystem
@@ -70,7 +48,8 @@ distributed actor GreeterImpl: GreeterDefinedSystemProtocol {
     print("local call greeting: \(realGreeting)")
     // CHECK: local call greeting: [IMPL]:Hello from GreeterImpl
 
-    let proxy: any GreeterDefinedSystemProtocol = try .resolve(id: real.id, using: roundtripSystem)
+    let proxy: any GreeterDefinedSystemProtocol =
+        try $GreeterDefinedSystemProtocol.resolve(id: real.id, using: roundtripSystem)
     let greeting = try await proxy.greet()
     // CHECK: >> remoteCall: on:main.GreeterDefinedSystemProtocol_Stub, target:greet(), invocation:FakeInvocationEncoder(genericSubs: [], arguments: [], returnType: Optional(Swift.String), errorType: nil), throwing:Swift.Never, returning:Swift.String
     // CHECK: > execute distributed target: greet(), identifier: $s4main28GreeterDefinedSystemProtocolP5greetSSyFTE