async_sequence_rethrows.swift

// RUN: %target-swift-frontend -disable-availability-checking %s -emit-sil -o /dev/null -verify

// REQUIRES: concurrency

// Tests for the use of 'rethrows' on generic functions that have AsyncSequence
// and AsyncIteratorProtocol requirements.

func f1(_ seq:someAsyncSequence)asyncrethrows{
fortryawait_in seq {}
}

func f2(_ seq:someAsyncSequence, body:()throws->Void)asyncrethrows{
fortryawait_in seq {
trybody()
}
}

func f3(_ seq:someAsyncSequence, _ seq2:someAsyncSequence)asyncrethrows{
fortryawait_in seq {
}

fortryawait_in seq2 {
}
}

enumHomeworkError:Error{
case dogAteIt
}

func testCalls(x:someAsyncSequence<Int,Never>, y:anyAsyncSequence<Int,anyError>)asyncthrows{
awaitf1(x)
tryawaitf1(y)

awaitf2(x){print("Hello")}
tryawaitf2(y){print("Hello")}

tryawaitf2(x){throwHomeworkError.dogAteIt }
tryawaitf2(y){throwHomeworkError.dogAteIt }

awaitf3(x, x)
tryawaitf3(x, y)
}

// Treat @rethrows protocols that inherit AsyncSequence like they are
// AsyncSequence for the purpose of rethrowing methods.
@rethrows
protocolInheritsAsyncSequence:AsyncSequence{}

extensionInheritsAsyncSequence{
func blah()asyncrethrows->[Element]{
tryawaitself.reduce(into:[Element]()){ $0.append($1)}
}
}

// Ensure that we can get the thrown error type from next().
structData{}

structErrorSequence<Element, Failure:Error>:AsyncSequence,AsyncIteratorProtocol{
letthrowError:Failure

func makeAsyncIterator()->ErrorSequence<Element,Failure>{
self
}

mutatingfunc next()asyncthrows(Failure)->Element?{
throw throwError
}
}

enumMyError:Error{
case foo
}


func getASequence()->anyAsyncSequence<Data,MyError>{
returnErrorSequence<Data,_>(throwError:MyError.foo) // ERROR: Cannot convert return expression of type 'any Error' to return type 'MyError'
}

// Test the default implementation of next() in terms of next(isolation:).
structAsyncIteratorWithOnlyNextIsolation:AsyncIteratorProtocol{
publicmutatingfunc next(isolation:(anyActor)?)throws(MyError)->Int?{0}
}

// Test the default implementation of next(isolation:) in terms of next().
structAsyncIteratorWithOnlyNext:AsyncIteratorProtocol{
publicmutatingfunc next()throws(MyError)->Int?{0}
}