[Freestanding] Disable Task.sleep.

Author: nate-chandler

stdlib/public/Concurrency/Clock.swift

@@ -38,7 +38,9 @@ public protocol Clock<Duration>: Sendable {
   var now: Instant { get }
   var minimumResolution: Instant.Duration { get }
 
+#if !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
   func sleep(until deadline: Instant, tolerance: Instant.Duration?) async throws
+#endif
 }
 
 

stdlib/public/Concurrency/ContinuousClock.swift

@@ -75,6 +75,7 @@ extension ContinuousClock: Clock {
       .seconds(seconds) + .nanoseconds(nanoseconds))
   }
 
+#if !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
   /// Suspend task execution until a given deadline within a tolerance.
   /// If no tolerance is specified then the system may adjust the deadline
   /// to coalesce CPU wake-ups to more efficiently process the wake-ups in
@@ -93,6 +94,15 @@ extension ContinuousClock: Clock {
       tolerance: tolerance,
       clock: .continuous)
   }
+#else
+  @available(SwiftStdlib 5.7, *)
+  @available(*, unavailable, message: "Unavailable in task-to-thread concurrency model")
+  public func sleep(
+    until deadline: Instant, tolerance: Swift.Duration? = nil
+  ) async throws {
+      fatalError("Unavailable in task-to-thread concurrency model")
+  }
+#endif
 }
 
 @available(SwiftStdlib 5.7, *)

stdlib/public/Concurrency/SuspendingClock.swift

@@ -77,6 +77,7 @@ extension SuspendingClock: Clock {
     return .seconds(seconds) + .nanoseconds(nanoseconds)
   }
 
+#if !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
   /// Suspend task execution until a given deadline within a tolerance.
   /// If no tolerance is specified then the system may adjust the deadline
   /// to coalesce CPU wake-ups to more efficiently process the wake-ups in
@@ -96,6 +97,15 @@ extension SuspendingClock: Clock {
       tolerance: tolerance,
       clock: .suspending)
   }
+#else
+  @available(SwiftStdlib 5.7, *)
+  @available(*, unavailable, message: "Unavailable in task-to-thread concurrency model")
+  public func sleep(
+    until deadline: Instant, tolerance: Swift.Duration? = nil
+  ) async throws {
+      fatalError("Unavailable in task-to-thread concurrency model")
+  }
+#endif
 }
 
 @available(SwiftStdlib 5.7, *)

stdlib/public/Concurrency/TaskSleep.swift

@@ -12,6 +12,7 @@
 import Swift
 @_implementationOnly import _SwiftConcurrencyShims
 
+#if !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
 @available(SwiftStdlib 5.1, *)
 extension Task where Success == Never, Failure == Never {
   @available(*, deprecated, renamed: "Task.sleep(nanoseconds:)")
@@ -295,3 +296,19 @@ extension Task where Success == Never, Failure == Never {
     }
   }
 }
+#else
+@available(SwiftStdlib 5.1, *)
+@available(*, unavailable, message: "Unavailable in task-to-thread concurrency model")
+extension Task where Success == Never, Failure == Never {
+  @available(SwiftStdlib 5.1, *)
+  @available(*, unavailable, message: "Unavailable in task-to-thread concurrency model")
+  public static func sleep(_ duration: UInt64) async {
+    fatalError("Unavailable in task-to-thread concurrency model")
+  }
+  @available(SwiftStdlib 5.1, *)
+  @available(*, unavailable, message: "Unavailable in task-to-thread concurrency model")
+  public static func sleep(nanoseconds duration: UInt64) async throws {
+    fatalError("Unavailable in task-to-thread concurrency model")
+  }
+}
+#endif

stdlib/public/Concurrency/TaskSleepDuration.swift

@@ -12,6 +12,7 @@
 import Swift
 @_implementationOnly import _SwiftConcurrencyShims
 
+#if !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
 @available(SwiftStdlib 5.7, *)
 extension Task where Success == Never, Failure == Never {
   @available(SwiftStdlib 5.7, *)
@@ -159,3 +160,23 @@ extension Task where Success == Never, Failure == Never {
     try await sleep(until: .now + duration, clock: .continuous)
   }
 }
+#else
+@available(SwiftStdlib 5.7, *)
+@available(*, unavailable, message: "Unavailable in task-to-thread concurrency model")
+extension Task where Success == Never, Failure == Never {
+  @available(SwiftStdlib 5.7, *)
+  @available(*, unavailable, message: "Unavailable in task-to-thread concurrency model")
+  public static func sleep<C: Clock>(
+    until deadline: C.Instant,
+    tolerance: C.Instant.Duration? = nil,
+    clock: C
+  ) async throws {
+    fatalError("Unavailable in task-to-thread concurrency model")
+  }
+  @available(SwiftStdlib 5.7, *)
+  @available(*, unavailable, message: "Unavailable in task-to-thread concurrency model")
+  public static func sleep(for duration: Duration) async throws {
+    fatalError("Unavailable in task-to-thread concurrency model")
+  }
+}
+#endif

test/stdlib/freestanding_diags_stdlib.swift

@@ -11,7 +11,8 @@ func chowMein() async {
 @MainActor // expected-error{{not permitted within task-to-thread concurrency model}}
 class ChowMein {}
 
-func foo() async {
+@available(SwiftStdlib 5.1, *)
+func foo() async throws {
   Task<Void, Never> {} // expected-error{{Unavailable in task-to-thread concurrency model}}
   Task<Void, Error> {} // expected-error{{Unavailable in task-to-thread concurrency model}}
   Task<Void, Never>.detached {} // expected-error{{Unavailable in task-to-thread concurrency model}}
@@ -24,6 +25,22 @@ func foo() async {
   asyncDetached { () async -> () in } // expected-error{{Unavailable in task-to-thread concurrency model}}
   asyncDetached { () async throws -> () in } // expected-error{{Unavailable in task-to-thread concurrency model}}
   _ = MainActor.self // expected-error{{Unavailable in task-to-thread concurrency model}}
+  await Task.sleep(1 as UInt64) // expected-error{{Unavailable in task-to-thread concurrency model}}
+  try await Task.sleep(nanoseconds: 1 as UInt64) // expected-error{{Unavailable in task-to-thread concurrency model}}
+}
+
+@available(SwiftStdlib 5.7, *)
+func bar() async {
+  func withContinuousClock(_ clock: ContinuousClock) async throws { try await clock.sleep(until: { fatalError() }()) } // expected-error{{Unavailable in task-to-thread concurrency model}}
+  func withSuspendingClock(_ clock: SuspendingClock) async throws { try await clock.sleep(until: { fatalError() }()) } // expected-error{{Unavailable in task-to-thread concurrency model}}
+  func withClock<C : Clock>(
+    until deadline: C.Instant,
+    tolerance: C.Instant.Duration? = nil,
+    clock: C
+  ) async throws {
+    try await Task.sleep(until: deadline, tolerance: tolerance, clock: clock) // expected-error{{Unavailable in task-to-thread concurrency model}}
+  }
+  func withDuration(_ duration: Duration) async throws { try await Task.sleep(for: duration) } // expected-error{{Unavailable in task-to-thread concurrency model}}
 }
 
 func foo2(