averello/swift-mirror
1
0
Fork 0
mirror of https://github.com/apple/swift.git synced 2025-12-14 20:36:38 +01:00
Code Issues Packages Projects Releases Wiki Activity

Always infer AsyncSequence.Failure from AsyncIteratorProtocol.Failure

Browse Source 
The newly-introduced associated type `AsyncSequence.Failure` must
always be equivalent to the `Failure` type of the
`AsyncIteratorProtocol`. If the `AsyncSequence` type itself defines a
nested `Failure` type (say, for another purpose), associated type inference
would pick it and reject the `AsyncSequence`, causing a source compatibility
problem.

Work around the issue in two ways. First, always infer the type
witness for `AsyncSequence.Failure` from the type witness for
`AsyncIteratorProtocol.Failure`, so they can't be out of sync. This
means that we'll never even consider a nested `Failure` type in the
`AsyncSequence`-conforming type. This hack only applies prior to Swift 6.

Second, when we have inferred a `Failure` type and there is already
something else called `Failure` within that same nominal type, don't
print the inferred typelias into a module interface because it will
cause a conflict.

Fixes rdar://123543633.
This commit is contained in:
Doug Gregor
2024-02-28 13:40:23 -08:00
parent 34dd632889
commit 0652bb7abe
4 changed files with 124 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
test/ModuleInterface/async_sequence_conformance.swift
View File

@@ -25,3 +25,30 @@ public struct SequenceAdapter<Base: AsyncSequence>: AsyncSequence {
// CHECK: @available(
// CHECK-NEXT: public typealias Failure = Base.Failure
}
// CHECK: @available(
// CHECK-NEXT: public struct OtherSequenceAdapte
@available(SwiftStdlib 5.1, *)
public struct OtherSequenceAdapter<Base: AsyncSequence>: AsyncSequence {
// CHECK: public typealias Element = Base.Element
// CHECK-NOT: public typealias Failure
// CHECK: public struct Failure
// CHECK-LABEL: public struct AsyncIterator
// CHECK: @available{{.*}}macOS 10.15
// CHECK: @available(
// CHECK-NEXT: public typealias Failure = Base.Failure
public typealias Element = Base.Element
public struct Failure: Error { }
// CHECK-NOT: public typealias Failure
public struct AsyncIterator: AsyncIteratorProtocol {
public mutating func next() async rethrows -> Base.Element? { nil }
}
// CHECK: public func makeAsyncIterator
public func makeAsyncIterator() -> AsyncIterator { AsyncIterator() }
// CHECK-NOT: public typealias Failure
}