Add shims and adjust availability to allow for swift 5.6 toolchains to build until source stability is achieved (apple#100)

* Add shims and adjust availability to allow for swift 5.6 toolchains to build until source stability is achieved

* Restore availability again

Author: phausler

Diff for: Package.swift

@@ -11,32 +11,25 @@ let package = Package(
     .watchOS("6.0")
   ],
   products: [
-    .library(
-      name: "AsyncAlgorithms",
-      targets: ["AsyncAlgorithms"]),
+    .library(name: "AsyncAlgorithms", targets: ["AsyncAlgorithms"]),
+    .library(name: "ClockShims", type: .static, targets: ["ClockShims"]),
     .library(name: "AsyncSequenceValidation", targets: ["AsyncSequenceValidation"]),
     .library(name: "_CAsyncSequenceValidationSupport", type: .static, targets: ["AsyncSequenceValidation"])
   ],
   dependencies: [],
   targets: [
-    .target(
-      name: "AsyncAlgorithms"),
+    .target(name: "AsyncAlgorithms", dependencies: ["ClockShims"]),
+    .target(name: "ClockShims"),
     .target(
       name: "AsyncSequenceValidation",
-      dependencies: ["_CAsyncSequenceValidationSupport"],
-      swiftSettings: [
-        .unsafeFlags([
-          "-Xfrontend", "-enable-experimental-pairwise-build-block"
-        ])
-      ]),
+      dependencies: ["_CAsyncSequenceValidationSupport", "AsyncAlgorithms"]),
     .systemLibrary(name: "_CAsyncSequenceValidationSupport"),
     .testTarget(
       name: "AsyncAlgorithmsTests",
       dependencies: ["AsyncAlgorithms", "AsyncSequenceValidation"],
       swiftSettings: [
         .unsafeFlags([
-          "-Xfrontend", "-disable-availability-checking",
-          "-Xfrontend", "-enable-experimental-pairwise-build-block"
+          "-Xfrontend", "-disable-availability-checking"
         ])
       ]),
   ]

Diff for: README.md

@@ -86,28 +86,27 @@ Finally, add `import AsyncAlgorithms` to your source code.
 
 ## Getting Started
 
-⚠️ Please note that this package currently requires a recent [Swift Trunk Development toolchain](https://www.swift.org/download/#trunk-development-main). More information on how to use custom toolchains with Xcode can be viewed [here](https://developer.apple.com/library/archive/documentation/ToolsLanguages/Conceptual/Xcode_Overview/AlternativeToolchains.html).
-
 ### Building/Testing Using Xcode on macOS
 
-  1. Download the most recent development Xcode toolchain.
-  2. Install the package
-  4. Select the development toolchain in Xcode
-  4. Open the `swift-async-algorithms` package directory in Xcode
-  5. Build or Test in Xcode as normal
+  1. Open the `swift-async-algorithms` package directory in Xcode
+  2. Build or Test in Xcode as normal
+  
+### Building/Testing Using Swift Package Manager
 
-⚠️ Note: `swift test` does not currently work properly with custom toolchains for this package.
+  1. In the `swift-async-algorithms` directory run `swift build` or `swift test` accordingly 
 
 ### Building/Testing on Linux
 
-  1. Download the most recent development toolchain for your Linux distribution
+  1. Download the most recent toolchain for your Linux distribution
   2. Decompress the archive to a path in which the `swift` executable is in the binary search path environment variable (`$PATH`)
   3. In the `swift-async-algorithms` directory run `swift build` or `swift test` accordingly
 
 ## Source Stability
 
 The Swift Async Algorithms package has a goal of being source stable as soon as possible; version numbers will follow [Semantic Versioning](https://semver.org/). Source breaking changes to public API can only land in a new major version.
 
+Before the version 1.0 the `swift-async-algorithms` package will not be source or ABI stable. Particularly the shims associated with `Clock`, `Instant` and `Duration` are present just to provide backwards compatability to older toolchains. As soon as this is available widely the shims will be removed; which will be an ABI breaking change. 
+
 The public API of version 1.0 of the `swift-async-algorithms` package will consist of non-underscored declarations that are marked `public` in the `AsyncAlgorithms` module. Interfaces that aren't part of the public API may continue to change in any release, including patch releases.
 
 Future minor versions of the package may introduce changes to these rules as needed.

Diff for: Sources/AsyncAlgorithms/Reexport.swift

@@ -0,0 +1,12 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift Async Algorithms open source project
+//
+// Copyright (c) 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+//
+//===----------------------------------------------------------------------===//
+
+@_exported import ClockShims

Diff for: Sources/AsyncSequenceValidation/AsyncSequenceValidationDiagram.swift

@@ -56,6 +56,46 @@ public struct AsyncSequenceValidationDiagram : Sendable {
     return Test(inputs: accumulated.inputs, sequence: accumulated.operation, output: Specification(specification: output.component, location: output.location))
   }
 
+  public static func buildBlock<Operation: AsyncSequence>(_ sequence: Component<Operation>, _ output: Component<String>) -> some AsyncSequenceValidationTest where Operation.Element == String {
+    let part1 = buildPartialBlock(first: sequence)
+    let part2 = buildPartialBlock(accumulated: part1, next: output)
+    return part2
+  }
+  
+  public static func buildBlock<Operation: AsyncSequence>(_ input1: Component<String>, _ sequence: Component<Operation>, _ output: Component<String>) -> some AsyncSequenceValidationTest where Operation.Element == String {
+    let part1 = buildPartialBlock(first: input1)
+    let part2 = buildPartialBlock(accumulated: part1, next: sequence)
+    let part3 = buildPartialBlock(accumulated: part2, next: output)
+    return part3
+  }
+  
+  public static func buildBlock<Operation: AsyncSequence>(_ input1: Component<String>, _ input2: Component<String>, _ sequence: Component<Operation>, _ output: Component<String>) -> some AsyncSequenceValidationTest where Operation.Element == String {
+    let part1 = buildPartialBlock(first: input1)
+    let part2 = buildPartialBlock(accumulated: part1, next: input2)
+    let part3 = buildPartialBlock(accumulated: part2, next: sequence)
+    let part4 = buildPartialBlock(accumulated: part3, next: output)
+    return part4
+  }
+  
+  public static func buildBlock<Operation: AsyncSequence>(_ input1: Component<String>, _ input2: Component<String>, _ input3: Component<String>, _ sequence: Component<Operation>, _ output: Component<String>) -> some AsyncSequenceValidationTest where Operation.Element == String {
+    let part1 = buildPartialBlock(first: input1)
+    let part2 = buildPartialBlock(accumulated: part1, next: input2)
+    let part3 = buildPartialBlock(accumulated: part2, next: input3)
+    let part4 = buildPartialBlock(accumulated: part3, next: sequence)
+    let part5 = buildPartialBlock(accumulated: part4, next: output)
+    return part5
+  }
+  
+  public static func buildBlock<Operation: AsyncSequence>(_ input1: Component<String>, _ input2: Component<String>, _ input3: Component<String>, _ input4: Component<String>, _ sequence: Component<Operation>, _ output: Component<String>) -> some AsyncSequenceValidationTest where Operation.Element == String {
+    let part1 = buildPartialBlock(first: input1)
+    let part2 = buildPartialBlock(accumulated: part1, next: input2)
+    let part3 = buildPartialBlock(accumulated: part2, next: input3)
+    let part4 = buildPartialBlock(accumulated: part3, next: input3)
+    let part5 = buildPartialBlock(accumulated: part4, next: sequence)
+    let part6 = buildPartialBlock(accumulated: part5, next: output)
+    return part6
+  }
+  
   let queue: WorkQueue
 
   public var inputs: InputList

Diff for: Sources/AsyncSequenceValidation/Clock.swift

@@ -9,6 +9,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+import AsyncAlgorithms
+
 @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 extension AsyncSequenceValidationDiagram {
   public struct Clock {

Diff for: Sources/AsyncSequenceValidation/Test.swift

@@ -10,6 +10,7 @@
 //===----------------------------------------------------------------------===//
 
 import _CAsyncSequenceValidationSupport
+import AsyncAlgorithms
 
 @_silgen_name("swift_job_run")
 @usableFromInline
@@ -33,7 +34,7 @@ extension AsyncSequenceValidationDiagram {
     let sequence: Operation
     let output: Specification
 
-    func test<C: _Concurrency.Clock>(with clock: C, activeTicks: [C.Instant], output: Specification, _ event: (String) -> Void) async throws {
+    func test<C: ClockShims.Clock>(with clock: C, activeTicks: [C.Instant], output: Specification, _ event: (String) -> Void) async throws {
       var iterator = sequence.makeAsyncIterator()
       do {
         for tick in activeTicks {

Diff for: Sources/ClockShims/Clock.swift

@@ -0,0 +1,76 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2021 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+import Swift
+
+/// A mechanism in which to measure time, and delay work until a given point 
+/// in time.
+///
+/// Types that conform to the `Clock` protocol define a concept of "now" which 
+/// is the specific instant in time that property is accessed. Any pair of calls
+/// to the `now` property may have a minimum duration between them - this
+/// minimum resolution is exposed by the `minimumResolution` property to inform
+/// any user of the type the expected granularity of accuracy. 
+///
+/// One of the primary uses for clocks is to schedule task sleeping. This method
+/// resumes the calling task after a given deadline has been met or passed with
+/// a given tolerance value. The tolerance is expected as a leeway around the 
+/// deadline. The clock may reschedule tasks within the tolerance to ensure 
+/// efficient execution of resumptions by reducing potential operating system
+/// wake-ups. If no tolerance is specified (i.e. nil is passed in) the sleep
+/// function is expected to schedule with a default tolerance strategy. 
+///
+/// For more information about specific clocks see `ContinuousClock` and 
+/// `SuspendingClock`.
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
+public protocol Clock: Sendable {
+  associatedtype Instant: InstantProtocol
+
+  var now: Instant { get }
+  var minimumResolution: Instant.Duration { get }
+
+  func sleep(until deadline: Instant, tolerance: Instant.Duration?) async throws
+}
+
+
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
+extension Clock {
+  /// Measure the elapsed time to execute a closure.
+  ///
+  ///       let clock = ContinuousClock()
+  ///       let elapsed = clock.measure {
+  ///          someWork()
+  ///       }
+  @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
+  public func measure(_ work: () throws -> Void) rethrows -> Instant.Duration {
+    let start = now
+    try work()
+    let end = now
+    return start.duration(to: end)
+  }
+
+  /// Measure the elapsed time to execute an asynchronous closure.
+  ///
+  ///       let clock = ContinuousClock()
+  ///       let elapsed = await clock.measure {
+  ///          await someWork()
+  ///       }
+  @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
+  public func measure(
+    _ work: () async throws -> Void
+  ) async rethrows -> Instant.Duration {
+    let start = now
+    try await work()
+    let end = now
+    return start.duration(to: end)
+  }
+}
+