remove ActorMessage typealias, we're comitted to Codable for now

Author: ktoso

Sources/DistributedActors/ActorContext.swift

@@ -19,7 +19,7 @@ import Logging
 /// - Warning:
 ///   - It MUST only ever be accessed from its own Actor. It is fine though to close over it in the actors behaviours.
 ///   - It MUST NOT be shared to other actors, and MUST NOT be accessed concurrently (e.g. from outside the actor).
-public class _ActorContext<Message: ActorMessage> /* TODO(sendable): NOTSendable*/ {
+public class _ActorContext<Message: Codable> /* TODO(sendable): NOTSendable*/ {
     public typealias Myself = _ActorRef<Message>
 
     /// Returns `ClusterSystem` which this context belongs to.
@@ -126,7 +126,7 @@ public class _ActorContext<Message: ActorMessage> /* TODO(sendable): NOTSendable
         file: String = #file, line: UInt = #line,
         _ behavior: _Behavior<M>
     ) throws -> _ActorRef<M>
-        where M: ActorMessage
+        where M: Codable
     {
         _undefined()
     }
@@ -145,7 +145,7 @@ public class _ActorContext<Message: ActorMessage> /* TODO(sendable): NOTSendable
         file: String = #file, line: UInt = #line,
         _ behavior: _Behavior<M>
     ) throws -> _ActorRef<M>
-        where M: ActorMessage
+        where M: Codable
     {
         _undefined()
     }
@@ -174,7 +174,7 @@ public class _ActorContext<Message: ActorMessage> /* TODO(sendable): NOTSendable
     /// - Throws: an `_ActorContextError` when an actor ref is passed in that is NOT a child of the current actor.
     ///           An actor may not terminate another's child actors. Attempting to stop `myself` using this method will
     ///           also throw, as the proper way of stopping oneself is returning a `_Behavior.stop`.
-    public func stop<M>(child ref: _ActorRef<M>) throws where M: ActorMessage {
+    public func stop<M>(child ref: _ActorRef<M>) throws where M: Codable {
         return _undefined()
     }
 
@@ -332,7 +332,7 @@ public class _ActorContext<Message: ActorMessage> /* TODO(sendable): NOTSendable
     /// being silently dropped. This can be useful when not all messages `From` have a valid representation in
     /// `Message`, or if not all `From` messages are of interest for this particular actor.
     public final func messageAdapter<From>(_ adapt: @escaping (From) -> Message?) -> _ActorRef<From>
-        where From: ActorMessage
+        where From: Codable
     {
         return self.messageAdapter(from: From.self, adapt: adapt)
     }
@@ -349,7 +349,7 @@ public class _ActorContext<Message: ActorMessage> /* TODO(sendable): NOTSendable
     /// being silently dropped. This can be useful when not all messages `From` have a valid representation in
     /// `Message`, or if not all `From` messages are of interest for this particular actor.
     public func messageAdapter<From>(from type: From.Type, adapt: @escaping (From) -> Message?) -> _ActorRef<From>
-        where From: ActorMessage
+        where From: Codable
     {
         return _undefined()
     }
@@ -365,7 +365,7 @@ public class _ActorContext<Message: ActorMessage> /* TODO(sendable): NOTSendable
     /// with an existing `_SubReceiveId`, it replaces the old one. All references will remain valid and point to
     /// the new behavior.
     public func subReceive<SubMessage>(_: _SubReceiveId<SubMessage>, _: SubMessage.Type, _: @escaping (SubMessage) throws -> Void) -> _ActorRef<SubMessage>
-        where SubMessage: ActorMessage
+        where SubMessage: Codable
     {
         return _undefined()
     }

Sources/DistributedActors/ActorMessage+Protobuf.swift

@@ -21,7 +21,7 @@ import SwiftProtobuf
 // ==== ----------------------------------------------------------------------------------------------------------------
 // MARK: Protobuf representations
 
-public protocol _AnyProtobufRepresentable: ActorMessage, SerializationRepresentable {}
+public protocol _AnyProtobufRepresentable: Codable, SerializationRepresentable {}
 
 extension _AnyProtobufRepresentable {
     public static var defaultSerializerID: Serialization.SerializerID? {
@@ -32,8 +32,6 @@ extension _AnyProtobufRepresentable {
 public protocol _AnyPublicProtobufRepresentable: _AnyProtobufRepresentable {}
 
 /// A protocol that facilitates conversion between Swift and protobuf messages.
-///
-/// - SeeAlso: `ActorMessage`
 public protocol _ProtobufRepresentable: _AnyPublicProtobufRepresentable {
     associatedtype ProtobufRepresentation: SwiftProtobuf.Message
 

Sources/DistributedActors/ActorMessages.swift

@@ -15,19 +15,14 @@
 import struct Foundation.Data
 import NIO
 
-// ==== ----------------------------------------------------------------------------------------------------------------
-// MARK: Actor Message
-
-public typealias ActorMessage = Codable // FIXME: MAKE THIS SENDABLE: & Sendable
-
 /// A `Never` can never be sent as message, even more so over the wire.
-extension Never: NonTransportableActorMessage {}
+extension Never: NotActuallyCodableMessage {}
 
 // ==== ----------------------------------------------------------------------------------------------------------------
 // MARK: Common utility messages
 
 // FIXME: we should not add Codable conformance onto a stdlib type, but rather fix this in stdlib
-extension Result: ActorMessage where Success: ActorMessage, Failure: ActorMessage {
+extension Result: Codable where Success: Codable, Failure: Codable {
     public enum DiscriminatorKeys: String, Codable {
         case success
         case failure
@@ -63,7 +58,7 @@ extension Result: ActorMessage where Success: ActorMessage, Failure: ActorMessag
 }
 
 /// Generic transportable Error type, can be used to wrap error types and represent them as best as possible for transporting.
-public struct ErrorEnvelope: Error, ActorMessage {
+public struct ErrorEnvelope: Error, Codable {
     public typealias CodableError = Error & Codable
 
     private let codableError: CodableError
@@ -133,7 +128,7 @@ public struct BestEffortStringError: Error, Codable, Equatable, CustomStringConv
 }
 
 /// Useful error wrapper which performs an best effort Error serialization as configured by the actor system.
-public struct NonTransportableAnyError: Error, NonTransportableActorMessage {
+public struct NonTransportableAnyError: Error, NotActuallyCodableMessage {
     public let failure: Error
 
     public init<Failure: Error>(_ failure: Failure) {
@@ -144,8 +139,7 @@ public struct NonTransportableAnyError: Error, NonTransportableActorMessage {
 // ==== ----------------------------------------------------------------------------------------------------------------
 // MARK: Not Transportable Actor Message (i.e. "local only")
 
-/// Marks a type as `ActorMessage` however
-/// Attempting to send such message to a remote actor WILL FAIL and log an error.
+/// Marks a type as `Codable` however attempting to send such message to a remote actor WILL FAIL and log an error.
 ///
 /// Use this with great caution and only for messages which are specifically designed to utilize the local assumption.
 ///
@@ -156,22 +150,22 @@ public struct NonTransportableAnyError: Error, NonTransportableActorMessage {
 /// No serializer is expected to be registered for such types.
 ///
 /// - Warning: Attempting to send such message over the network will fail at runtime (and log an error or warning).
-public protocol NonTransportableActorMessage: ActorMessage {}
+public protocol NotActuallyCodableMessage: Codable {}
 
-extension NonTransportableActorMessage {
+extension NotActuallyCodableMessage {
     public init(from decoder: Swift.Decoder) throws {
-        fatalError("Attempted to decode NonTransportableActorMessage message: \(Self.self)! This should never happen.")
+        fatalError("Attempted to decode NotActuallyCodableMessage message: \(Self.self)! This should never happen.")
     }
 
     public func encode(to encoder: Swift.Encoder) throws {
-        fatalError("Attempted to encode NonTransportableActorMessage message: \(Self.self)! This should never happen.")
+        fatalError("Attempted to encode NotActuallyCodableMessage message: \(Self.self)! This should never happen.")
     }
 
     public init(context: Serialization.Context, from buffer: inout ByteBuffer, using manifest: Serialization.Manifest) throws {
-        fatalError("Attempted to deserialize NonTransportableActorMessage message: \(Self.self)! This should never happen.")
+        fatalError("Attempted to deserialize NotActuallyCodableMessage message: \(Self.self)! This should never happen.")
     }
 
     public func serialize(context: Serialization.Context, to bytes: inout ByteBuffer) throws {
-        fatalError("Attempted to serialize NonTransportableActorMessage message: \(Self.self)! This should never happen.")
+        fatalError("Attempted to serialize NotActuallyCodableMessage message: \(Self.self)! This should never happen.")
     }
 }

Sources/DistributedActors/ActorRef+Ask.swift

@@ -238,7 +238,7 @@ extension AskResponse {
 ///
 // TODO: replace with a special minimal `_ActorRef` that does not require spawning or scheduling.
 internal enum AskActor {
-    enum Event: NonTransportableActorMessage {
+    enum Event: NotActuallyCodableMessage {
         case timeout
     }
 

Sources/DistributedActors/ActorRefFactory.swift

@@ -54,7 +54,7 @@ public protocol _ActorRefFactory {
         props: _Props,
         file: String, line: UInt,
         _ behavior: _Behavior<Message>
-    ) throws -> _ActorRef<Message> where Message: ActorMessage
+    ) throws -> _ActorRef<Message> where Message: Codable
 }
 
 // ==== ----------------------------------------------------------------------------------------------------------------
@@ -64,7 +64,7 @@ public protocol _ChildActorRefFactory: _ActorRefFactory {
     var children: _Children { get set } // lock-protected
 
     func stop<Message>(child ref: _ActorRef<Message>) throws
-        where Message: ActorMessage
+        where Message: Codable
 }
 
 // ==== ----------------------------------------------------------------------------------------------------------------

Sources/DistributedActors/ActorRefProvider.swift

@@ -36,7 +36,7 @@ internal protocol _ActorRefProvider: _ActorTreeTraversable {
         dispatcher: MessageDispatcher, props: _Props,
         startImmediately: Bool
     ) throws -> _ActorRef<Message>
-        where Message: ActorMessage
+        where Message: Codable
 
     /// Stops all actors created by this `_ActorRefProvider` and blocks until they have all stopped.
     func stopAll()
@@ -81,7 +81,7 @@ extension RemoteActorRefProvider {
         dispatcher: MessageDispatcher, props: _Props,
         startImmediately: Bool
     ) throws -> _ActorRef<Message>
-        where Message: ActorMessage
+        where Message: Codable
     {
         // spawn is always local, thus we delegate to the underlying provider
         return try self.localProvider._spawn(system: system, behavior: behavior, id: id, dispatcher: dispatcher, props: props, startImmediately: startImmediately)
@@ -146,7 +146,7 @@ internal struct LocalActorRefProvider: _ActorRefProvider {
         dispatcher: MessageDispatcher, props: _Props,
         startImmediately: Bool
     ) throws -> _ActorRef<Message>
-        where Message: ActorMessage
+        where Message: Codable
     {
         return try self.root.makeChild(path: id.path) {
             // the cell that holds the actual "actor", though one could say the cell *is* the actor...
@@ -203,7 +203,7 @@ public protocol _ActorTreeTraversable {
     /// Depending on the underlying implementation, the returned ref MAY be a remote one.
     ///
     /// - Returns: `deadLetters` if actor path resolves to no live actor, a valid `_ActorRef` otherwise.
-    func _resolve<Message>(context: ResolveContext<Message>) -> _ActorRef<Message> where Message: ActorMessage
+    func _resolve<Message>(context: ResolveContext<Message>) -> _ActorRef<Message> where Message: Codable
 
     /// Resolves the given actor path against the underlying actor tree.
     ///
@@ -326,7 +326,7 @@ public struct _TraversalContext<T> {
 }
 
 /// INTERNAL API: May change without any prior notice.
-public struct ResolveContext<Message: ActorMessage> {
+public struct ResolveContext<Message: Codable> {
     /// The "remaining path" of the resolve being performed
     public var selectorSegments: ArraySlice<ActorPathSegment>
 

Sources/DistributedActors/Adapters.swift

@@ -40,7 +40,7 @@ public protocol _AbstractAdapter: _ActorTreeTraversable {
 /// The adapter can be watched and shares the lifecycle with the adapted actor,
 /// meaning that it will terminate when the actor terminates. It will survive
 /// restarts after failures.
-internal final class _ActorRefAdapter<To: ActorMessage>: _AbstractAdapter {
+internal final class _ActorRefAdapter<To: Codable>: _AbstractAdapter {
     public let fromType: Any.Type
     private let target: _ActorRef<To>
     let id: ActorID
@@ -235,7 +235,7 @@ internal final class _DeadLetterAdapterPersonality: _AbstractAdapter {
 // ==== ----------------------------------------------------------------------------------------------------------------
 // MARK: SubReceiveAdapter
 
-internal final class SubReceiveAdapter<Message: ActorMessage, OwnerMessage: ActorMessage>: _AbstractAdapter {
+internal final class SubReceiveAdapter<Message: Codable, OwnerMessage: Codable>: _AbstractAdapter {
     internal let fromType: Any.Type
 
     private let target: _ActorRef<OwnerMessage>

Sources/DistributedActors/Behaviors.swift

@@ -16,7 +16,7 @@
 ///
 /// The most important behavior is `_Behavior.receive` since it allows handling incoming messages with a simple block.
 /// Various other predefined behaviors exist, such as "stopping" or "ignoring" a message.
-public struct _Behavior<Message: ActorMessage>: @unchecked Sendable {
+public struct _Behavior<Message: Codable>: @unchecked Sendable {
     @usableFromInline
     let underlying: __Behavior<Message>
 
@@ -459,7 +459,7 @@ extension _Behavior {
 }
 
 @usableFromInline
-internal enum __Behavior<Message: ActorMessage> {
+internal enum __Behavior<Message: Codable> {
     case setup(_ onStart: (_ActorContext<Message>) throws -> _Behavior<Message>)
 
     case receive(_ handle: (_ActorContext<Message>, Message) throws -> _Behavior<Message>)
@@ -501,7 +501,7 @@ internal enum StopReason {
     case failure(_Supervision.Failure)
 }
 
-public enum IllegalBehaviorError<Message: ActorMessage>: Error {
+public enum IllegalBehaviorError<Message: Codable>: Error {
     /// Some behaviors, like `.same` and `.unhandled` are not allowed to be used as initial behaviors.
     /// See their individual documentation for the rationale why that is so.
     case notAllowedAsInitial(_ behavior: _Behavior<Message>)
@@ -535,7 +535,7 @@ extension _Behavior {
 }
 
 /// Used in combination with `_Behavior.intercept` to intercept messages and signals delivered to a behavior.
-open class _Interceptor<Message: ActorMessage> {
+open class _Interceptor<Message: Codable> {
     public init() {}
 
     @inlinable

Sources/DistributedActors/Cluster/Cluster+Event.swift

@@ -19,7 +19,7 @@ extension Cluster {
     /// Represents cluster events, most notably regarding membership and reachability of other members of the cluster.
     ///
     /// Inspect them directly, or `apply` to a `Membership` copy in order to be able to react to membership state of the cluster.
-    public enum Event: ActorMessage, Equatable {
+    public enum Event: Codable, Equatable {
         case snapshot(Membership)
         case membershipChange(MembershipChange)
         case reachabilityChange(ReachabilityChange)

Sources/DistributedActors/Cluster/ClusterShell.swift

@@ -303,7 +303,7 @@ internal class ClusterShell {
     }
 
     // Due to lack of Union Types, we have to emulate them
-    enum Message: ActorMessage {
+    enum Message: Codable {
         // The external API, exposed to users of the ClusterShell
         case command(CommandMessage)
         // The external API, exposed to users of the ClusterShell to query for state
@@ -324,7 +324,7 @@ internal class ClusterShell {
     }
 
     // this is basically our API internally for this system
-    enum CommandMessage: NonTransportableActorMessage, SilentDeadLetter {
+    enum CommandMessage: NotActuallyCodableMessage, SilentDeadLetter {
         /// Connect and handshake with remote `Node`, obtaining an `UniqueNode` in the process.
         /// Once the handshake is completed, reply to `replyTo` with the handshake result, and also mark the unique node as `.joining`.
         ///
@@ -343,7 +343,7 @@ internal class ClusterShell {
         case cleanUpAssociationTombstones
     }
 
-    enum QueryMessage: NonTransportableActorMessage {
+    enum QueryMessage: NotActuallyCodableMessage {
         case associatedNodes(_ActorRef<Set<UniqueNode>>) // TODO: better type here
         case currentMembership(_ActorRef<Cluster.Membership>)
     }
@@ -362,7 +362,7 @@ internal class ClusterShell {
     }
 
     // TODO: reformulate as Wire.accept / reject?
-    internal enum HandshakeResult: Equatable, NonTransportableActorMessage {
+    internal enum HandshakeResult: Equatable, NotActuallyCodableMessage {
         case success(UniqueNode)
         case failure(HandshakeStateMachine.HandshakeConnectionError)
     }