Files
Franz Busch 6a92272e13 Fix a few new region isolation errors in nightly-main (#419)
* Rework `AsyncStreaming` protocols to use generic `RangeReplaceableContainer` buffers

Replace `InputSpan`/`OutputSpan` with generic `Buffer` associated types constrained to `RangeReplaceableContainer` across all four streaming protocols. This sidesteps the limitation that `OutputSpan` (and other `~Escapable` types) cannot be used in async contexts today, while still allowing conforming types to choose a buffer representation optimized for their use case (e.g. `UniqueArray` for heap-backed storage, or a future stack-allocated container for embedded).

Switch callee-owned protocols from `consuming` to `inout` closure semantics, rename `forEachChunk` to `forEachBuffer`, and move `forEach`/`collect` to future directions in the proposal.

Adds test coverage for `AsyncWriter`, `CallerAsyncReader`, and `EitherError`. Updates all documentation to reflect the new API surface.

* Fix a few new region isolation errors in `nightly-main`

Region isolation got smarter and started diagnosing more potential data races. This PR addresses the new errors. Importantly I had to introduce one `@unchecked Sendable` conformance since we can't yet use `UniqueDeque`
2026-05-14 23:22:27 +02:00

69 lines
1.7 KiB
Swift

//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Async Algorithms open source project
//
// Copyright (c) 2026 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
//
//===----------------------------------------------------------------------===//
#if UnstableAsyncStreaming && compiler(>=6.4)
import AsyncStreaming
import Testing
@Suite
struct EitherErrorTests {
enum FirstError: Error, Equatable, Hashable {
case one
case two
}
enum SecondError: Error, Equatable, Hashable {
case alpha
case beta
}
@Test
func unwrapFirst() throws {
let error: EitherError<FirstError, SecondError> = .first(.one)
#expect(throws: FirstError.one) {
try error.unwrap()
}
}
@Test
func unwrapSecond() throws {
let error: EitherError<FirstError, SecondError> = .second(.alpha)
#expect(throws: SecondError.alpha) {
try error.unwrap()
}
}
@Test
func equatable() {
let a: EitherError<FirstError, SecondError> = .first(.one)
let b: EitherError<FirstError, SecondError> = .first(.one)
let c: EitherError<FirstError, SecondError> = .first(.two)
let d: EitherError<FirstError, SecondError> = .second(.alpha)
#expect(a == b)
#expect(a != c)
#expect(a != d)
}
@Test
func hashable() {
let a: EitherError<FirstError, SecondError> = .first(.one)
let b: EitherError<FirstError, SecondError> = .first(.one)
let c: EitherError<FirstError, SecondError> = .second(.alpha)
#expect(a.hashValue == b.hashValue)
#expect(a.hashValue != c.hashValue)
}
}
#endif