=build use 5.7 package definition; adjust build; define minimum platforms

Author: ktoso

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:5.6
+// swift-tools-version:5.7
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import class Foundation.ProcessInfo
@@ -228,6 +228,13 @@ let products: [PackageDescription.Product] = [
 
 var package = Package(
     name: "swift-distributed-actors",
+    platforms: [
+        // we require the 'distributed actor' language and runtime feature:
+        .iOS(.v16),
+        .macOS(.v13),
+        .tvOS(.v16),
+        .watchOS(.v9),
+    ],
     products: products,
 
     dependencies: dependencies,

Sources/DistributedActors/ActorTags.swift

@@ -22,11 +22,11 @@ public struct ActorTags {
     // We still might re-think how we represent the storage.
     private var _storage: [String: Sendable & Codable] = [:] // FIXME: fix the key as AnyActorTagKey
 
-    init() {
+    public init() {
         // empty tags
     }
 
-    init(tags: [any ActorTag]) {
+    public init(tags: [any ActorTag]) {
         for tag in tags {
             self._storage[tag.id] = tag.value
         }

Sources/DistributedActors/Behaviors.swift

@@ -557,14 +557,12 @@ open class _Interceptor<Message: Codable> {
 }
 
 extension _Interceptor {
-    @inlinable
     static func handleMessage(context: _ActorContext<Message>, behavior: _Behavior<Message>, interceptor: _Interceptor<Message>, message: Message) throws -> _Behavior<Message> {
         let next = try interceptor.interceptMessage(target: behavior, context: context, message: message)
 
         return try _Interceptor.deduplicate(context: context, behavior: next, interceptor: interceptor)
     }
 
-    @inlinable
     static func deduplicate(context: _ActorContext<Message>, behavior: _Behavior<Message>, interceptor: _Interceptor<Message>) throws -> _Behavior<Message> {
         func deduplicate0(_ behavior: _Behavior<Message>) -> _Behavior<Message> {
             let hasDuplicatedIntercept = behavior.existsInStack { b in
@@ -601,7 +599,6 @@ extension _Behavior {
     ///
     /// Note: The returned behavior MUST be `_Behavior.canonicalize`-ed in the vast majority of cases.
     // Implementation note: We don't do so here automatically in order to keep interpretations transparent and testable.
-    @inlinable
     public func interpretMessage(context: _ActorContext<Message>, message: Message, file: StaticString = #file, line: UInt = #line) throws -> _Behavior<Message> {
         switch self.underlying {
         case .receiveMessage(let recv): return try recv(message)
@@ -648,7 +645,6 @@ extension _Behavior {
     }
 
     /// Attempts interpreting signal using the current behavior, or returns `_Behavior.unhandled` if no `_Behavior.signalHandling` was found.
-    @inlinable
     public func interpretSignal(context: _ActorContext<Message>, signal: _Signal) throws -> _Behavior<Message> {
         // This switch does not use a `default:` clause on purpose!
         // This is to enforce having to consider consider how a signal should be interpreted if a new behavior case is added.
@@ -723,7 +719,6 @@ extension _Behavior {
     }
 
     /// Applies `interpretMessage` to an iterator of messages, while canonicalizing the behavior after every reduction.
-    @inlinable
     internal func interpretMessages<Iterator: IteratorProtocol>(context: _ActorContext<Message>, messages: inout Iterator) throws -> _Behavior<Message> where Iterator.Element == Message {
         var currentBehavior: _Behavior<Message> = self
         while currentBehavior.isStillAlive {
@@ -740,7 +735,6 @@ extension _Behavior {
 
     /// Validate if a _Behavior is legal to be used as "initial" behavior (when an Actor is spawned),
     /// since certain behaviors do not make sense as initial behavior.
-    @inlinable
     internal func validateAsInitial() throws {
         switch self.underlying {
         case .same: throw IllegalBehaviorError.notAllowedAsInitial(self)
@@ -750,7 +744,6 @@ extension _Behavior {
     }
 
     /// Same as `validateAsInitial`, however useful in chaining expressions as it returns itself when the validation has passed successfully.
-    @inlinable
     internal func validatedAsInitial() throws -> _Behavior<Message> {
         try self.validateAsInitial()
         return self
@@ -837,7 +830,6 @@ extension _Behavior {
     ///
     /// - Throws: `IllegalBehaviorError.tooDeeplyNestedBehavior` when a too deeply nested behavior is found,
     ///           in order to avoid attempting to start an possibly infinitely deferred behavior.
-    @inlinable
     internal func canonicalize(_ context: _ActorContext<Message>, next: _Behavior<Message>) throws -> _Behavior<Message> {
         guard self.isStillAlive else {
             return self // ignore, we're already dead and cannot become any other behavior
@@ -910,7 +902,6 @@ extension _Behavior {
     /// - Throws: `IllegalBehaviorError.tooDeeplyNestedBehavior` when a too deeply nested behavior is found,
     ///           in order to avoid attempting to start an possibly infinitely deferred behavior.
     // TODO: make not recursive perhaps since could blow up on large chain?
-    @inlinable
     internal func start(context: _ActorContext<Message>) throws -> _Behavior<Message> {
         let failAtDepth = context.system.settings.actor.maxBehaviorNestingDepth
 

Sources/DistributedActors/StashBuffer.swift

@@ -72,7 +72,6 @@ public final class _StashBuffer<Message: Codable> {
     ///              requires the context to be passed in.
     /// - Throws: When any of the behavior reductions throws
     /// - Returns: The last behavior returned from processing the unstashed messages
-    @inlinable
     public func unstashAll(context: _ActorContext<Message>, behavior: _Behavior<Message>) throws -> _Behavior<Message> {
         // TODO: can we make this honor the run length like `Mailbox` does?
         var iterator = self.buffer.iterator

Sources/DistributedActors/Supervision.swift

@@ -412,39 +412,33 @@ internal class Supervisor<Message: Codable> {
     @usableFromInline
     typealias Directive = SupervisionDirective<Message>
 
-    @inlinable
     internal final func interpretSupervised(target: _Behavior<Message>, context: _ActorContext<Message>, message: Message) throws -> _Behavior<Message> {
         traceLog_Supervision("CALL WITH \(target) @@@@ [\(message)]:\(type(of: message))")
         return try self.interpretSupervised0(target: target, context: context, processingAction: .message(message))
     }
 
-    @inlinable
     internal final func interpretSupervised(target: _Behavior<Message>, context: _ActorContext<Message>, signal: _Signal) throws -> _Behavior<Message> {
         traceLog_Supervision("INTERCEPT SIGNAL APPLY: \(target) @@@@ \(signal)")
         return try self.interpretSupervised0(target: target, context: context, processingAction: .signal(signal))
     }
 
-    @inlinable
     internal final func interpretSupervised(target: _Behavior<Message>, context: _ActorContext<Message>, closure: ActorClosureCarry) throws -> _Behavior<Message> {
         traceLog_Supervision("CALLING CLOSURE: \(target)")
         return try self.interpretSupervised0(target: target, context: context, processingAction: .closure(closure))
     }
 
-    @inlinable
     internal final func interpretSupervised(target: _Behavior<Message>, context: _ActorContext<Message>, subMessage: SubMessageCarry) throws -> _Behavior<Message> {
         traceLog_Supervision("INTERPRETING SUB MESSAGE: \(target)")
         return try self.interpretSupervised0(target: target, context: context, processingAction: .subMessage(subMessage))
     }
 
-    @inlinable
     internal final func interpretSupervised(target: _Behavior<Message>, context: _ActorContext<Message>, closure: @escaping () throws -> _Behavior<Message>) throws -> _Behavior<Message> {
         traceLog_Supervision("CALLING CLOSURE: \(target)")
         return try self.interpretSupervised0(
             target: target, context: context, processingAction: .continuation(closure)
         )
     }
 
-    @inlinable
     internal final func startSupervised(target: _Behavior<Message>, context: _ActorContext<Message>) throws -> _Behavior<Message> {
         traceLog_Supervision("CALLING START")
         return try self.interpretSupervised0(
@@ -454,7 +448,6 @@ internal class Supervisor<Message: Codable> {
     }
 
     /// Implements all directives, which supervisor implementations may yield to instruct how we should (if at all) restart an actor.
-    @inlinable
     @inline(__always)
     final func interpretSupervised0(target: _Behavior<Message>, context: _ActorContext<Message>, processingAction: ProcessingAction<Message>) throws -> _Behavior<Message> {
         try self.interpretSupervised0(
@@ -463,7 +456,6 @@ internal class Supervisor<Message: Codable> {
         ) // 1 since we already have "one failure"
     }
 
-    @inlinable
     @inline(__always)
     final func interpretSupervised0(
         target: _Behavior<Message>,

Sources/DistributedActors/_ActorShell.swift

@@ -273,7 +273,6 @@ public final class _ActorShell<Message: Codable>: _ActorContext<Message>, Abstra
     ///
     /// Warning: Mutates the cell's behavior.
     /// Returns: `true` if the actor remains alive, and `false` if it now is becoming `.stop`
-    @inlinable
     func interpretMessage(message: Message) throws -> ActorRunResult {
         do {
             let next: _Behavior<Message> = try self.supervisor.interpretSupervised(target: self.behavior, context: self, message: message)
@@ -481,7 +480,7 @@ public final class _ActorShell<Message: Codable>: _ActorContext<Message>, Abstra
     /// MUST be preceded by an invocation of `restartPrepare`.
     /// The two steps MAY be performed in different point in time; reason being: backoff restarts,
     /// which need to suspend the actor, and NOT start it just yet, until the system message awakens it again.
-    @inlinable public func _restartComplete(with behavior: _Behavior<Message>) throws -> _Behavior<Message> {
+    public func _restartComplete(with behavior: _Behavior<Message>) throws -> _Behavior<Message> {
         try behavior.validateAsInitial()
         self.behavior = behavior
         try self.interpretStart()
@@ -492,13 +491,11 @@ public final class _ActorShell<Message: Codable>: _ActorContext<Message>, Abstra
     /// Always invoke `becomeNext` rather than assigning to `self.behavior` manually.
     ///
     /// Returns: `true` if next behavior is .stop and appropriate actions will be taken
-    @inlinable
     internal func becomeNext(behavior next: _Behavior<Message>) throws {
         // TODO: handling "unhandled" would be good here... though I think type wise this won't fly, since we care about signal too
         self.behavior = try self.behavior.canonicalize(self, next: next)
     }
 
-    @inlinable
     internal func interpretStart() throws {
         // start means we need to evaluate all `setup` blocks, since they need to be triggered eagerly
         traceLog_Cell("START with behavior: \(self.behavior)")
@@ -509,7 +506,6 @@ public final class _ActorShell<Message: Codable>: _ActorContext<Message>, Abstra
 
     /// Interpret a `resume` with the passed in result, potentially waking up the actor from `suspended` state.
     /// Interpreting a resume NOT in suspended state is an error and should never happen.
-    @inlinable
     internal func interpretResume(_ result: Result<Any, Error>) throws -> ActorRunResult {
         switch self.behavior.underlying {
         case .suspended(let previousBehavior, let handler):
@@ -796,7 +792,7 @@ extension _ActorShell {
     ///
     /// Mutates actor cell behavior.
     /// May cause actor to terminate upon error or returning .stop etc from `.signalHandling` user code.
-    @inlinable func interpretTerminatedSignal(who dead: ActorID, terminated: _Signals.Terminated) throws {
+    func interpretTerminatedSignal(who dead: ActorID, terminated: _Signals.Terminated) throws {
         #if SACT_TRACE_ACTOR_SHELL
         self.log.info("Received terminated: \(dead)")
         #endif
@@ -852,7 +848,6 @@ extension _ActorShell {
 
     /// Interpret a carried signal directly -- those are potentially delivered by plugins or custom transports.
     /// They MAY share semantics with `Signals.Terminated`, in which case they would be interpreted accordingly.
-    @inlinable
     func interpretCarrySignal(_ signal: _Signal) throws {
         #if SACT_TRACE_ACTOR_SHELL
         self.log.info("Received carried signal: \(signal)")
@@ -867,13 +862,11 @@ extension _ActorShell {
         }
     }
 
-    @inlinable
     func interpretStop() throws {
         self.children.stopAll()
         try self.becomeNext(behavior: .stop(reason: .stopByParent))
     }
 
-    @inlinable
     func interpretChildTerminatedSignal(who terminatedRef: _AddressableActorRef, terminated: _Signals._ChildTerminated) throws {
         #if SACT_TRACE_ACTOR_SHELL
         self.log.info("Received \(terminated)")

Sources/DistributedActors/_BehaviorTimers.swift

@@ -114,7 +114,6 @@ public final class _BehaviorTimers<Message: Codable> {
     /// Cancels timer associated with the given key.
     ///
     /// - Parameter key: key of the timer to cancel
-    @inlinable
     public func cancel(for key: TimerKey) {
         if let timer = self.installedTimers.removeValue(forKey: key) {
             if context.system.settings.logging.verboseTimers {