fix: crash on pre 1.2

Author: stefanomondino

Sources/AsyncAlgorithms/AsyncFailureBackportable.swift

@@ -129,6 +129,10 @@ where Base.Element: Sendable, Base: _SendableMetatype, Base.AsyncIterator: _Send
   //   **Usage**: Tracks buffer position and manages async continuations
   //   **Cleanup**: Automatically unregisters and cancels pending operations on deinit
   final class Side {
+    // Due to a runtime crash in 1.0 compatible versions, it's not possible to handle
+    // a generic failure constrained to Base.Failure. We handle inner failure with a `any Error`
+    // and force unwrap it to the generic 1.2 generic type on the outside Iterator.
+    typealias Failure = any Error
     // Tracks the state of a single consumer's iteration.
     //
     // - `continuation`: The continuation waiting for the next element (nil if not waiting)
@@ -180,6 +184,7 @@ where Base.Element: Sendable, Base: _SendableMetatype, Base.AsyncIterator: _Send
   // All operations are synchronized using a `Mutex` to ensure thread-safe access
   // to the shared state across multiple concurrent consumers.
   final class Iteration: Sendable {
+    typealias Failure = Side.Failure
     // Represents the state of the background task that consumes the source sequence.
     //
     // The iteration task goes through several states during its lifecycle:
@@ -586,7 +591,7 @@ where Base.Element: Sendable, Base: _SendableMetatype, Base.AsyncIterator: _Send
           }
         }
       } catch {
-        emit(.failure(error as! Failure))
+        emit(.failure(error))
       }
     }
 
@@ -695,8 +700,10 @@ where Base.Element: Sendable, Base: _SendableMetatype, Base.AsyncIterator: _Send
 }
 
 @available(AsyncAlgorithms 1.1, *)
-extension AsyncShareSequence: AsyncSequence, AsyncFailureBackportable {
+extension AsyncShareSequence: AsyncSequence {
   public typealias Element = Base.Element
+  @available(AsyncAlgorithms 1.2, *)
+  public typealias Failure = Base.Failure
   public struct Iterator: AsyncIteratorProtocol, _SendableMetatype {
     let side: Side
 
@@ -707,21 +714,23 @@ extension AsyncShareSequence: AsyncSequence, AsyncFailureBackportable {
     mutating public func next() async rethrows -> Element? {
       try await side.next(isolation: nil)
     }
-  
-//    mutating public func next(isolation actor: isolated (any Actor)?) async throws(Self.BackportableFailure) -> Element? {
-//      try await side.next(isolation: actor)
-//    }
+    
+    @available(AsyncAlgorithms 1.2, *)
+    mutating public func next(isolation actor: isolated (any Actor)?) async throws(Failure) -> Element? {
+      do {
+        return try await side.next(isolation: actor)
+      } catch {
+        // It's guaranteed to match `Failure` but we are keeping the internal `Side` and `Iteration`
+        // constrained to `any Error` to prevent a compiler bug visible at runtime
+        // on pre 1.2 operating systems
+        throw error as! Failure
+      }
+    }
   }
 
   public func makeAsyncIterator() -> Iterator {
     Iterator(extent.iteration)
   }
 }
 
-@available(AsyncAlgorithms 1.2, *)
-extension AsyncShareSequence.Iterator {
-  mutating public func next(isolation actor: isolated (any Actor)?) async throws(Base.Failure) -> Base.Element? {
-    try await side.next(isolation: actor)
-  }
-}
 #endif

Sources/AsyncAlgorithms/AsyncShareSequence.swift

@@ -0,0 +1,26 @@
+//
+//  FailingSequence.swift
+//  swift-async-algorithms
+//
+//  Created by Stefano Mondino on 15/10/25.
+//
+
+@available(AsyncAlgorithms 1.2, *)
+struct FailingSequence<Failure: Error>: AsyncSequence, Sendable {
+  typealias Element = Void
+  let error: Failure
+  init(_ error: Failure) {
+    self.error = error
+  }
+  func makeAsyncIterator() -> AsyncIterator { AsyncIterator(error: error) }
+  
+  struct AsyncIterator: AsyncIteratorProtocol, Sendable {
+    let error: Failure
+    func next() async throws(Failure) -> Void? {
+      throw error
+    }
+    mutating func next(completion: @escaping (Result<Element?, Failure>) -> Void) async throws(Failure) -> Element? {
+      throw error
+    }
+  }
+}

Tests/AsyncAlgorithmsTests/Support/FailingSequence.swift

@@ -589,18 +589,19 @@ final class TestShare: XCTestCase {
 
   func test_share_rethrows_failure_type_without_falling_back_to_any_error() async {
     if #available(AsyncAlgorithms 1.2, *) {
+      
+ 
       // Ensure - at compile time - that error is effectively a TestError
-      let shared: some AsyncSequence<Void, TestError> = AlwaysFailingSequence().share()
-    do {
-      for try await _ in shared {
-        XCTFail("Expected to not get here")
-      }
-    } catch {
-     
-      XCTAssertEqual(error, TestError.failure)
+      let shared: some AsyncSequence<Void, TestError> = FailingSequence(TestError.failure).share()
+      do {
+        for try await _ in shared {
+          XCTFail("Expected to not get here")
+        }
+      } catch {
+        XCTAssertEqual(error, TestError.failure)
       }
     } else {
-      // not available
+      _ = XCTSkip("This test is not available before 1.2")
     }
   }
 }
@@ -611,21 +612,4 @@ private enum TestError: Error, Equatable {
   case failure
 }
 
-@available(AsyncAlgorithms 1.2, *)
-/// A sequence used to properly test concrete error on 1.2
-private struct AlwaysFailingSequence: AsyncSequence, Sendable {
-  init() {}
-  
-  func makeAsyncIterator() -> AsyncIterator { AsyncIterator() }
-  
-  struct AsyncIterator: AsyncIteratorProtocol, Sendable {
-    
-    func next() async throws(TestError) -> Void? {
-      throw TestError.failure
-    }
-    mutating func next(completion: @escaping (Result<Element?, TestError>) -> Void) async throws(TestError) -> Element? {
-      throw TestError.failure
-    }
-  }
-}
 #endif