Remove clock stubs and use the _Concurrency provided Clock APIs (apple#78)

* Remove the clock stubs

* Add default implementations using clocks

Author: phausler

Package.swift

@@ -14,20 +14,34 @@ let package = Package(
     .library(
       name: "AsyncAlgorithms",
       targets: ["AsyncAlgorithms"]),
-    .library(name: "ClockStub", type: .static, targets: ["ClockStub"]),
     .library(name: "AsyncSequenceValidation", targets: ["AsyncSequenceValidation"]),
     .library(name: "_CAsyncSequenceValidationSupport", type: .static, targets: ["AsyncSequenceValidation"])
   ],
   dependencies: [],
   targets: [
     .target(
       name: "AsyncAlgorithms",
-      dependencies: ["ClockStub"]),
-    .target(name: "ClockStub"),
-    .target(name: "AsyncSequenceValidation", dependencies: ["_CAsyncSequenceValidationSupport", "ClockStub"]),
+      swiftSettings: [
+        .unsafeFlags([
+          "-Xfrontend", "-disable-availability-checking"
+        ])
+      ]),
+    .target(
+      name: "AsyncSequenceValidation",
+      dependencies: ["_CAsyncSequenceValidationSupport"],
+      swiftSettings: [
+        .unsafeFlags([
+          "-Xfrontend", "-disable-availability-checking"
+        ])
+      ]),
     .systemLibrary(name: "_CAsyncSequenceValidationSupport"),
     .testTarget(
       name: "AsyncAlgorithmsTests",
-      dependencies: ["AsyncAlgorithms", "AsyncSequenceValidation"]),
+      dependencies: ["AsyncAlgorithms", "AsyncSequenceValidation"],
+      swiftSettings: [
+        .unsafeFlags([
+          "-Xfrontend", "-disable-availability-checking"
+        ])
+      ]),
   ]
 )

Sources/AsyncAlgorithms/AsyncDebounceSequence.swift

@@ -13,6 +13,10 @@ extension AsyncSequence {
   public func debounce<C: Clock>(for interval: C.Instant.Duration, tolerance: C.Instant.Duration? = nil, clock: C) -> AsyncDebounceSequence<Self, C> {
     AsyncDebounceSequence(self, interval: interval, tolerance: tolerance, clock: clock)
   }
+  
+  public func debounce(for interval: Duration, tolerance: Duration? = nil) -> AsyncDebounceSequence<Self, ContinuousClock> {
+    debounce(for: interval, tolerance: tolerance, clock: .continuous)
+  }
 }
 
 public struct AsyncDebounceSequence<Base: AsyncSequence, C: Clock>: Sendable

Sources/AsyncAlgorithms/AsyncThrottleSequence.swift

@@ -14,11 +14,9 @@ extension AsyncSequence {
     AsyncThrottleSequence(self, interval: interval, clock: clock, reducing: reducing)
   }
 
-  /*
   public func throttle<Reduced>(for interval: Duration, reducing: @Sendable @escaping (Reduced?, Element) async -> Reduced) -> AsyncThrottleSequence<Self, ContinuousClock, Reduced> {
     throttle(for: interval, clock: .continuous, reducing: reducing)
   }
-  */
 
   public func throttle<C: Clock>(for interval: C.Instant.Duration, clock: C, latest: Bool = true) -> AsyncThrottleSequence<Self, C, Element> {
     throttle(for: interval, clock: clock) { previous, element in
@@ -30,11 +28,9 @@ extension AsyncSequence {
     }
   }
 
-  /*
   public func throttle(for interval: Duration, latest: Bool = true) -> AsyncThrottleSequence<Self, ContinuousClock, Element> {
     throttle(for: interval, clock: .continuous, latest: latest)
   }
-   */
 }
 
 public struct AsyncThrottleSequence<Base: AsyncSequence, C: Clock, Reduced> {

Sources/AsyncAlgorithms/AsyncTimerSequence.swift

@@ -73,13 +73,12 @@ extension AsyncTimerSequence {
   }
 }
 
-/*
+
 extension AsyncTimerSequence where C == SuspendingClock {
   public static func repeating(every interval: Duration, tolerance: Duration? = nil) -> AsyncTimerSequence<SuspendingClock> {
     return AsyncTimerSequence(interval: interval, tolerance: tolerance, clock: SuspendingClock())
   }
 }
-*/
 
 extension AsyncTimerSequence: Sendable { }
 extension AsyncTimerSequence.Iterator: Sendable { }

Sources/AsyncAlgorithms/Reexport.swift

@@ -9,8 +9,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-import ClockStub
-
 extension AsyncSequenceValidationDiagram {
   public struct Clock {
     let queue: WorkQueue

Sources/AsyncSequenceValidation/Clock.swift

@@ -10,7 +10,6 @@
 //===----------------------------------------------------------------------===//
 
 import _CAsyncSequenceValidationSupport
-import ClockStub
 
 @_silgen_name("swift_job_run")
 @usableFromInline
@@ -23,7 +22,7 @@ public protocol AsyncSequenceValidationTest: Sendable {
   var inputs: [String] { get }
   var output: String { get }
 
-  func test<C: ClockStub.Clock>(with clock: C, activeTicks: [C.Instant], _ event: (String) -> Void) async throws
+  func test<C: Clock>(with clock: C, activeTicks: [C.Instant], _ event: (String) -> Void) async throws
 }
 
 extension AsyncSequenceValidationDiagram {
@@ -32,7 +31,7 @@ extension AsyncSequenceValidationDiagram {
     let sequence: Operation
     let output: String
 
-    func test<C: ClockStub.Clock>(with clock: C, activeTicks: [C.Instant], _ event: (String) -> Void) async throws {
+    func test<C: _Concurrency.Clock>(with clock: C, activeTicks: [C.Instant], _ event: (String) -> Void) async throws {
       var iterator = sequence.makeAsyncIterator()
       do {
         for tick in activeTicks {