[stdlib] Distributed: Mark all new protocol requirements as available starting from stdlib 5.11

Author: xedin

stdlib/public/Distributed/DistributedActorSystem.swift

@@ -382,6 +382,7 @@ public protocol DistributedActorSystem<SerializationRequirement>: Sendable {
   /// ## Errors
   /// This method is allowed to throw because of underlying transport or serialization errors,
   /// as well as by re-throwing the error received from the remote callee (if able to).
+  @available(SwiftStdlib 5.11, *)
   func remoteCall<Act, Err, Res>(
       on actor: Act,
       target: RemoteCallTarget,
@@ -798,6 +799,7 @@ public protocol DistributedTargetInvocationEncoder<SerializationRequirement> {
 
   /// Record an argument of `Argument` type.
   /// This will be invoked for every argument of the target, in declaration order.
+  @available(SwiftStdlib 5.11, *)
   mutating func recordArgument<Value/*: SerializationRequirement*/>(
     _ argument: RemoteCallArgument<Value>
   ) throws
@@ -810,6 +812,7 @@ public protocol DistributedTargetInvocationEncoder<SerializationRequirement> {
 
   /// Record the return type of the distributed method.
   /// This method will not be invoked if the target is returning `Void`.
+  @available(SwiftStdlib 5.11, *)
   mutating func recordReturnType<R/*: SerializationRequirement*/>(_ type: R.Type) throws
 
   /// Invoked to signal to the encoder that no further `record...` calls will be made on it.
@@ -948,6 +951,7 @@ public protocol DistributedTargetInvocationDecoder<SerializationRequirement> {
   /// buffer for all the arguments and their expected types. The 'pointer' passed here is a pointer
   /// to a "slot" in that pre-allocated buffer. That buffer will then be passed to a thunk that
   /// performs the actual distributed (local) instance method invocation.
+  @available(SwiftStdlib 5.11, *)
   mutating func decodeNextArgument<Argument/*: SerializationRequirement*/>() throws -> Argument
 
   /// Decode the specific error type that the distributed invocation target has recorded.
@@ -996,6 +1000,7 @@ public protocol DistributedTargetInvocationResultHandler<SerializationRequiremen
 
   /// Invoked when the distributed target execution returns successfully.
   /// The `value` is the return value of the executed distributed invocation target.
+  @available(SwiftStdlib 5.11, *)
   func onReturn<Success/*: SerializationRequirement*/>(value: Success) async throws
 
   /// Invoked when the distributed target execution of a `Void` returning

test/Distributed/Runtime/distributed_actor_localSystem_generic.swift

@@ -1,5 +1,5 @@
 // RUN: %empty-directory(%t)
-// RUN: %target-build-swift -module-name main -Xfrontend -disable-availability-checking -j2 -parse-as-library -I %t %s -o %t/a.out
+// RUN: %target-build-swift -module-name main -j2 -parse-as-library -I %t %s -o %t/a.out
 // RUN: %target-codesign %t/a.out
 // RUN: %target-run %t/a.out | %FileCheck %s --color
 
@@ -16,6 +16,7 @@
 
 import Distributed
 
+@available(SwiftStdlib 5.11, *)
 distributed actor Worker<ActorSystem> where ActorSystem: DistributedActorSystem<any Codable>, ActorSystem.ActorID: Codable {
   distributed func hi(name: String) {
     print("Hi, \(name)!")
@@ -27,6 +28,7 @@ distributed actor Worker<ActorSystem> where ActorSystem: DistributedActorSystem<
 }
 
 // ==== Execute ----------------------------------------------------------------
+@available(SwiftStdlib 5.11, *)
 @main struct Main {
   static func main() async throws {
     let system = LocalTestingDistributedActorSystem()