async_sequence_syntax.swift

// RUN: %target-swift-frontend -target %target-swift-5.1-abi-triple %s -emit-sil -o /dev/null -verify
// RUN: %target-swift-frontend -target %target-swift-5.1-abi-triple %s -emit-sil -o /dev/null -verify -strict-concurrency=targeted
// RUN: %target-swift-frontend -target %target-swift-5.1-abi-triple %s -emit-sil -o /dev/null -verify -strict-concurrency=complete

// REQUIRES: concurrency
// REQUIRES: asserts

// expected-note@+2{{add 'async' to function 'missingAsync' to make it asynchronous}}
@available(SwiftStdlib 5.1,*)
func missingAsync<T :AsyncSequence>(_ seq:T)throws{
fortryawait_in seq {} // expected-error{{'async' in a function that does not support concurrency}}
}

@available(SwiftStdlib 5.1,*)
func missingThrows<T :AsyncSequence>(_ seq:T)async{
fortryawait_in seq {}
 // expected-error@-1 {{errors thrown from here are not handled}}
}

@available(SwiftStdlib 5.1,*)
func executeAsync(_ work:()async->Void){}
@available(SwiftStdlib 5.1,*)
func execute(_ work:()->Void){}

@available(SwiftStdlib 5.1,*)
func missingThrowingInBlock<T :AsyncSequence>(_ seq:T){
executeAsync{ // expected-error{{invalid conversion from throwing function of type '() async throws -> Void' to non-throwing function type '() async -> Void'}}
fortryawait_in seq {}
}
}

@available(SwiftStdlib 5.1,*)
func missingTryInBlock<T :AsyncSequence>(_ seq:T){
executeAsync{
forawait_in seq {}
 // expected-error@-1{{call can throw, but the error is not handled}}
 // expected-error@-2{{errors thrown from here are not handled}}
}
}

@available(SwiftStdlib 5.1,*)
func missingAsyncInBlock<T :AsyncSequence>(_ seq:T){
execute{ // expected-error{{cannot pass function of type '() async -> Void' to parameter expecting synchronous function type}}
do{
fortryawait_in seq {} // expected-note {{'async' inferred from asynchronous operation used here}}
}catch{}
}
}

@available(SwiftStdlib 5.1,*)
func doubleDiagCheckGeneric<T :AsyncSequence>(_ seq:T)async{
varit= seq.makeAsyncIterator()
 // expected-error@+1{{call can throw, but it is not marked with 'try' and the error is not handled}}
let _ =await it.next()
}

@available(SwiftStdlib 5.1,*)
structThrowingAsyncSequence:AsyncSequence,AsyncIteratorProtocol{
typealiasElement=Int
typealiasAsyncIterator=Self
mutatingfunc next()asyncthrows->Int?{
returnnil
}

func makeAsyncIterator()->Self{returnself}
}

@available(SwiftStdlib 5.1,*)
func doubleDiagCheckConcrete(_ seq:ThrowingAsyncSequence)async{
varit= seq.makeAsyncIterator()
 // expected-error@+1{{call can throw, but it is not marked with 'try' and the error is not handled}}
let _ =await it.next()
}

// rdar://75274975
@available(SwiftStdlib 5.1,*)
func forAwaitInsideDoCatch<Source:AsyncSequence>(_ source:Source)async{
do{
fortryawaititemin source {
print(item)
}
}catch{} // no-warning
}

@available(SwiftStdlib 5.1,*)
func forAwaitWithConcreteType(_ seq:ThrowingAsyncSequence)throws{ // expected-note {{add 'async' to function 'forAwaitWithConcreteType' to make it asynchronous}}
fortryawaiteltin seq { // expected-error {{'async' in a function that does not support concurrency}}
 _ = elt
}
}

@available(SwiftStdlib 5.1,*)
func forTryAwaitReturningExistentialType()asyncthrows{
structS{
func seq()->anyAsyncSequence{fatalError()}
}

fortryawait_inS().seq(){ // Ok
}
}

@available(SwiftStdlib 5.1,*)
publicstructReaderSeq:AsyncSequence,Sendable{
publicenumFailure:Error{
case x
}

publictypealiasElement=Int

publicfunc makeAsyncIterator()->Reader{}

publicactorReader:AsyncIteratorProtocol{
publicfunc next()asyncthrows->Element?{}
}
}

@available(SwiftStdlib 5.1,*)
func test1()->Error{
returnReaderSeq.Failure.x
}

@available(SwiftStdlib 5.1,*)
publicstructMineOwnIterator<Element>:AsyncSequence,AsyncIteratorProtocol{
publicmutatingfunc next()async->Element?{nil}
publicfunc makeAsyncIterator()->Self{self}

@_implements(AsyncIteratorProtocol, Failure)
publictypealias__AsyncIteratorProtocol_Failure=Never

@_implements(AsyncSequence, Failure)
publictypealias__AsyncSequence_Failure=Never
}