Merge branch 'main' into wip-address-revamp-for-da-world

Author: ktoso

.swiftformat

@@ -1,6 +1,6 @@
 # file options
 
---swiftversion 5.2
+--swiftversion 5.4
 --exclude .build
 --exclude "**/*.pb.swift"
 --exclude "**/*+GenActor.swift"
@@ -23,3 +23,7 @@
 --disable redundantInit
 --disable redundantGet
 --disable redundantReturn
+
+# we want to have fine grained control over extensions by marking each function
+# explicitly, rather than it being forced onto the extension entirely.
+--extensionacl on-declarations

Sources/ActorSingletonPlugin/ActorSingletonPlugin.swift

@@ -95,8 +95,8 @@ extension ActorSingletonPlugin: Plugin {
 // ==== ----------------------------------------------------------------------------------------------------------------
 // MARK: Singleton refs and actors
 
-public extension ClusterSystem {
-    var singleton: ActorSingletonControl {
+extension ClusterSystem {
+    public var singleton: ActorSingletonControl {
         .init(self)
     }
 }

Sources/DistributedActors/ActorAddress.swift

@@ -213,10 +213,10 @@ extension ActorAddress {
     }
 }
 
-public extension ActorAddress {
+extension ActorAddress {
     /// :nodoc:
     @inlinable
-    var _isLocal: Bool {
+    public var _isLocal: Bool {
         switch self._location {
         case .local: return true
         default: return false
@@ -225,20 +225,20 @@ public extension ActorAddress {
 
     /// :nodoc:
     @inlinable
-    var _isRemote: Bool {
+    public var _isRemote: Bool {
         !self._isLocal
     }
 
     /// :nodoc:
     @inlinable
-    var _asRemote: Self {
+    public var _asRemote: Self {
         let remote = Self(remote: self.uniqueNode, path: self.path, incarnation: self.incarnation)
         return remote
     }
 
     /// :nodoc:
     @inlinable
-    var _asLocal: Self {
+    public var _asLocal: Self {
         let local = Self(local: self.uniqueNode, path: self.path, incarnation: self.incarnation)
         return local
     }
@@ -392,10 +392,10 @@ extension ActorPath: CustomStringConvertible {
     }
 }
 
-public extension ActorPath {
-    static let _root: ActorPath = .init() // also known as "/"
-    static let _user: ActorPath = try! ActorPath(root: "user")
-    static let _system: ActorPath = try! ActorPath(root: "system")
+extension ActorPath {
+    public static let _root: ActorPath = .init() // also known as "/"
+    public static let _user: ActorPath = try! ActorPath(root: "user")
+    public static let _system: ActorPath = try! ActorPath(root: "system")
 
     internal func makeLocalAddress(on node: UniqueNode, incarnation: ActorIncarnation) -> ActorAddress {
         .init(local: node, path: self, incarnation: incarnation)
@@ -421,14 +421,14 @@ public protocol _PathRelationships {
     func appending(segment: ActorPathSegment) -> Self
 }
 
-public extension _PathRelationships {
+extension _PathRelationships {
     /// Combines the base path with a child segment returning the concatenated path.
     internal static func / (base: Self, child: ActorPathSegment) -> Self {
         base.appending(segment: child)
     }
 
     /// Checks whether this path starts with the passed in `path`.
-    func starts(with path: ActorPath) -> Bool {
+    public func starts(with path: ActorPath) -> Bool {
         self.segments.starts(with: path.segments)
     }
 
@@ -440,7 +440,7 @@ public extension _PathRelationships {
     ///
     /// - Parameter path: The path that is suspected to be the parent of `self`
     /// - Returns: `true` if this [ActorPath] is a direct descendant of `maybeParentPath`, `false` otherwise
-    func isChildPathOf(_ maybeParentPath: _PathRelationships) -> Bool {
+    public func isChildPathOf(_ maybeParentPath: _PathRelationships) -> Bool {
         Array(self.segments.dropLast()) == maybeParentPath.segments // TODO: more efficient impl, without the copying
     }
 
@@ -452,7 +452,7 @@ public extension _PathRelationships {
     ///
     /// - Parameter path: The path that is suspected to be a child of `self`
     /// - Returns: `true` if this [ActorPath] is a direct ancestor of `maybeChildPath`, `false` otherwise
-    func isParentOf(_ maybeChildPath: _PathRelationships) -> Bool {
+    public func isParentOf(_ maybeChildPath: _PathRelationships) -> Bool {
         maybeChildPath.isChildPathOf(self)
     }
 
@@ -582,18 +582,18 @@ public struct ActorIncarnation: Equatable, Hashable, ExpressibleByIntegerLiteral
     }
 }
 
-public extension ActorIncarnation {
+extension ActorIncarnation {
     /// To be used ONLY by special actors whose existence is wellKnown and identity never-changing.
     /// Examples: `/system/deadLetters` or `/system/cluster`.
-    static let wellKnown: ActorIncarnation = .init(0)
+    public static let wellKnown: ActorIncarnation = .init(0)
 
-    static func random() -> ActorIncarnation {
+    public static func random() -> ActorIncarnation {
         ActorIncarnation(UInt32.random(in: UInt32(1) ... UInt32.max))
     }
 }
 
-internal extension ActorIncarnation {
-    init?(_ value: String?) {
+extension ActorIncarnation {
+    internal init?(_ value: String?) {
         guard let int = (value.flatMap {
             Int($0)
         }), int >= 0 else {
@@ -778,8 +778,8 @@ extension UniqueNodeID: CustomStringConvertible {
     }
 }
 
-public extension UniqueNodeID {
-    static func random() -> UniqueNodeID {
+extension UniqueNodeID {
+    public static func random() -> UniqueNodeID {
         UniqueNodeID(UInt64.random(in: 1 ... .max))
     }
 }

Sources/DistributedActors/ActorLogging.swift

@@ -73,16 +73,16 @@ internal final class LoggingContext {
 /// such as it's path or node on which it resides.
 ///
 /// The preferred way of obtaining a logger for an actor or system is `context.log` or `system.log`, rather than creating new ones.
-public extension Logger {
+extension Logger {
     /// Create a logger specific to this actor.
-    init<Act: DistributedActor>(actor: Act) where Act.ActorSystem == ClusterSystem {
+    public init<Act: DistributedActor>(actor: Act) where Act.ActorSystem == ClusterSystem {
         var log = Logger(label: "\(actor.id)")
         log[metadataKey: "actor/path"] = "\(actor.id.path)"
         log[metadataKey: "actor/id"] = "\(actor.id)"
         self = log
     }
 
-    static func make<T>(context: _ActorContext<T>) -> Logger {
+    public static func make<T>(context: _ActorContext<T>) -> Logger {
         Logger.make(context.log, path: context.path)
     }
 
@@ -283,12 +283,12 @@ public struct LogMessage {
     let line: UInt
 }
 
-public extension Logger.MetadataValue {
-    static func pretty<T>(_ value: T) -> Logger.Metadata.Value where T: CustomPrettyStringConvertible {
+extension Logger.MetadataValue {
+    public static func pretty<T>(_ value: T) -> Logger.Metadata.Value where T: CustomPrettyStringConvertible {
         Logger.MetadataValue.stringConvertible(CustomPrettyStringConvertibleMetadataValue(value))
     }
 
-    static func pretty<T>(_ value: T) -> Logger.Metadata.Value {
+    public static func pretty<T>(_ value: T) -> Logger.Metadata.Value {
         if let pretty = value as? CustomPrettyStringConvertible {
             return Logger.MetadataValue.stringConvertible(CustomPrettyStringConvertibleMetadataValue(pretty))
         } else {
@@ -309,12 +309,12 @@ struct CustomPrettyStringConvertibleMetadataValue: CustomStringConvertible {
     }
 }
 
-public extension Optional where Wrapped == Logger.MetadataValue {
-    static func lazyStringConvertible(_ makeValue: @escaping () -> CustomStringConvertible) -> Logger.Metadata.Value {
+extension Optional where Wrapped == Logger.MetadataValue {
+    public static func lazyStringConvertible(_ makeValue: @escaping () -> CustomStringConvertible) -> Logger.Metadata.Value {
         .stringConvertible(LazyMetadataBox { makeValue() })
     }
 
-    static func lazyString(_ makeValue: @escaping () -> String) -> Logger.Metadata.Value {
+    public static func lazyString(_ makeValue: @escaping () -> String) -> Logger.Metadata.Value {
         self.lazyStringConvertible(makeValue)
     }
 }
@@ -350,10 +350,10 @@ internal class LazyMetadataBox: CustomStringConvertible {
 // ==== ----------------------------------------------------------------------------------------------------------------
 // MARK: Logger extensions
 
-public extension Logger {
+extension Logger {
     /// Allows passing in a `Logger.Level?` and not log if it was `nil`.
     @inlinable
-    func log(
+    public func log(
         level: Logger.Level?,
         _ message: @autoclosure () -> Logger.Message,
         metadata: @autoclosure () -> Logger.Metadata? = nil,

Sources/DistributedActors/ActorMessage+Protobuf.swift

@@ -23,8 +23,8 @@ import SwiftProtobuf
 
 public protocol Any_ProtobufRepresentable: ActorMessage, SerializationRepresentable {}
 
-public extension Any_ProtobufRepresentable {
-    static var defaultSerializerID: Serialization.SerializerID? {
+extension Any_ProtobufRepresentable {
+    public static var defaultSerializerID: Serialization.SerializerID? {
         ._ProtobufRepresentable
     }
 }
@@ -47,8 +47,8 @@ public protocol _ProtobufRepresentable: _AnyPublic_ProtobufRepresentable {
 // Implementation note:
 // This conformance is a bit weird, and it is not usually going to be invoked through Codable
 // however it could, so we allow for this use case.
-public extension _ProtobufRepresentable {
-    init(from decoder: Decoder) throws {
+extension _ProtobufRepresentable {
+    public init(from decoder: Decoder) throws {
         guard let context = decoder.actorSerializationContext else {
             throw SerializationError.missingSerializationContext(decoder, Self.self)
         }
@@ -61,7 +61,7 @@ public extension _ProtobufRepresentable {
         try self.init(fromProto: proto, context: context)
     }
 
-    func encode(to encoder: Encoder) throws {
+    public func encode(to encoder: Encoder) throws {
         guard let context = encoder.actorSerializationContext else {
             throw SerializationError.missingSerializationContext(encoder, self)
         }
@@ -134,13 +134,13 @@ extension Internal_ProtobufRepresentable {
     }
 }
 
-public extension _ProtobufRepresentable {
-    init(context: Serialization.Context, from buffer: Serialization.Buffer, using manifest: Serialization.Manifest) throws {
+extension _ProtobufRepresentable {
+    public init(context: Serialization.Context, from buffer: Serialization.Buffer, using manifest: Serialization.Manifest) throws {
         let proto = try ProtobufRepresentation(serializedData: buffer.readData())
         try self.init(fromProto: proto, context: context)
     }
 
-    func serialize(context: Serialization.Context) throws -> Serialization.Buffer {
+    public func serialize(context: Serialization.Context) throws -> Serialization.Buffer {
         try .data(self.toProto(context: context).serializedData())
     }
 }

Sources/DistributedActors/ActorMessages.swift

@@ -164,20 +164,20 @@ public struct NonTransportableAnyError: Error, NonTransportableActorMessage {
 /// - Warning: Attempting to send such message over the network will fail at runtime (and log an error or warning).
 public protocol NonTransportableActorMessage: ActorMessage {}
 
-public extension NonTransportableActorMessage {
-    init(from decoder: Swift.Decoder) throws {
+extension NonTransportableActorMessage {
+    public init(from decoder: Swift.Decoder) throws {
         fatalError("Attempted to decode NonTransportableActorMessage message: \(Self.self)! This should never happen.")
     }
 
-    func encode(to encoder: Swift.Encoder) throws {
+    public func encode(to encoder: Swift.Encoder) throws {
         fatalError("Attempted to encode NonTransportableActorMessage message: \(Self.self)! This should never happen.")
     }
 
-    init(context: Serialization.Context, from buffer: inout ByteBuffer, using manifest: Serialization.Manifest) throws {
+    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.")
     }
 
-    func serialize(context: Serialization.Context, to bytes: inout ByteBuffer) throws {
+    public func serialize(context: Serialization.Context, to bytes: inout ByteBuffer) throws {
         fatalError("Attempted to serialize NonTransportableActorMessage message: \(Self.self)! This should never happen.")
     }
 }

Sources/DistributedActors/ActorNaming.swift

@@ -17,15 +17,15 @@ import DistributedActorsConcurrencyHelpers
 // ==== ----------------------------------------------------------------------------------------------------------------
 // MARK: Actor Name
 
-public extension ActorNaming {
+extension ActorNaming {
     /// Default actor naming strategy; whereas the name MUST be unique under a given path.
     ///
     /// I.e. if a parent actor spawns `.unique(worker)`
     ///
     /// This naming is used by the `ExpressibleByStringLiteral` and `ExpressibleByStringInterpolation` conversions.
     ///
     /// - Faults: when passed in name contains illegal characters. See `ActorNaming` for detailed rules about actor naming.
-    static func unique(_ name: String) -> ActorNaming {
+    public static func unique(_ name: String) -> ActorNaming {
         ActorNaming.validateUserProvided(nameOrPrefix: name)
         return .init(unchecked: .unique(name))
     }
@@ -35,13 +35,13 @@ public extension ActorNaming {
     /// actor, it may name them with subsequent numbers or letters of a limited alphabet.
     ///
     /// - Faults: when passed in name contains illegal characters. See `ActorNaming` for detailed rules about actor naming.
-    static func prefixed(with prefix: String) -> ActorNaming {
+    public static func prefixed(with prefix: String) -> ActorNaming {
         ActorNaming.validateUserProvided(nameOrPrefix: prefix)
         return .init(unchecked: .prefixed(prefix: prefix, suffixScheme: .letters))
     }
 
     /// Shorthand for defining "anonymous" actor names, which carry
-    static var anonymous: ActorNaming {
+    public static var anonymous: ActorNaming {
         .init(unchecked: .prefixed(prefix: "$anonymous", suffixScheme: .letters))
     }
 

Sources/DistributedActors/ActorRef+Ask.swift

@@ -71,11 +71,11 @@ extension _ActorRef: ReceivesQuestions {
         _ makeQuestion: @escaping (_ActorRef<Answer>) -> Question
     ) -> AskResponse<Answer> {
         guard let system = self._system else {
-            return .completed(.failure(AskError.systemAlreadyShutDown))
+            return .completed(.failure(RemoteCallError.clusterAlreadyShutDown))
         }
 
         if system.isShuttingDown {
-            return .completed(.failure(AskError.systemAlreadyShutDown))
+            return .completed(.failure(RemoteCallError.clusterAlreadyShutDown))
         }
 
         do {
@@ -147,11 +147,6 @@ enum AskResponse<Value> {
     case nioFuture(EventLoopFuture<Value>)
 }
 
-enum AskError: DistributedActorSystemError, Error {
-    case timedOut(TimeoutError)
-    case systemAlreadyShutDown
-}
-
 extension AskResponse {
     /// Blocks and waits until there is a response or fails with an error.
     @available(*, deprecated, message: "Blocking API will be removed in favor of async await")
@@ -203,7 +198,7 @@ extension AskResponse: _AsyncResult {
             let eventLoop = nioFuture.eventLoop
             let promise: EventLoopPromise<Value> = eventLoop.makePromise()
             let timeoutTask = eventLoop.scheduleTask(in: timeout.toNIO) {
-                promise.fail(AskError.timedOut(TimeoutError(message: "\(type(of: self)) timed out after \(timeout.prettyDescription)", timeout: timeout)))
+                promise.fail(RemoteCallError.timedOut(TimeoutError(message: "\(type(of: self)) timed out after \(timeout.prettyDescription)", timeout: timeout)))
             }
             nioFuture.whenFailure {
                 timeoutTask.cancel()
@@ -283,7 +278,7 @@ internal enum AskActor {
                         Ask was initiated from function [\(function)] in [\(file):\(line)] and \
                         expected response of type [\(String(reflecting: ResponseType.self))].
                         """
-                        completable.fail(AskError.timedOut(TimeoutError(message: errorMessage, timeout: timeout)))
+                        completable.fail(RemoteCallError.timedOut(TimeoutError(message: errorMessage, timeout: timeout)))
 
                         // FIXME: Hack to stop from subReceive. Should we allow this somehow?
                         //        Maybe add a SubReceiveContext or similar?

Sources/DistributedActors/ActorTags.swift

@@ -63,9 +63,9 @@ public protocol ActorTag: Sendable where Value == Key.Value {
     var value: Value { get }
 }
 
-public extension ActorTag {
-    var keyType: Key.Type { Key.self }
-    var id: String { Key.id }
+extension ActorTag {
+    public var keyType: Key.Type { Key.self }
+    public var id: String { Key.id }
 }
 
 public protocol ActorTagKey: Sendable {