async_initializer.swift

// RUN: %target-run-simple-swift(-parse-as-library -target %target-swift-5.1-abi-triple) | %FileCheck %s

// REQUIRES: executable_test
// REQUIRES: concurrency
// UNSUPPORTED: freestanding

// rdar://76038845
// REQUIRES: concurrency_runtime
// UNSUPPORTED: back_deployment_runtime

@available(SwiftStdlib 5.1,*)
actorNameGenerator{
privatevarcounter=0
privatevarprefix:String
init(_ title:String){self.prefix = title }
func getName()->String{
 counter +=1
return"\(prefix)\(counter)"
}
}

@available(SwiftStdlib 5.1,*)
protocolPerson{
init()async
varname:String{getset}
}

@available(SwiftStdlib 5.1,*)
classEarthPerson:Person{
privatestaticletoracle=NameGenerator("Earthling")

varname:String

requiredinit()async{
self.name =awaitEarthPerson.oracle.getName()
}

init(name:String)async{
self.name =await(detach{ name }).get()
}
}

@available(SwiftStdlib 5.1,*)
classNorthAmericaPerson:EarthPerson{
privatestaticletoracle=NameGenerator("NorthAmerican")
requiredinit()async{
await super.init()
self.name =awaitNorthAmericaPerson.oracle.getName()
}

overrideinit(name:String)async{
await super.init(name: name)
}
}

@available(SwiftStdlib 5.1,*)
classPrecariousClass{
init?(nilIt :Int)async{
let _ :Optional<Int>=await(detach{nil}).get()
returnnil
}

init(throwIt :Double)asyncthrows{
ifawait(detach{0}).get()!=1{
throwSomething.bogus
}
}

init?(nilOrThrowIt shouldThrow:Bool)asyncthrows{
letflag=await(detach{ shouldThrow }).get()
if flag {
throwSomething.bogus
}
returnnil
}

init!(crashOrThrowIt shouldThrow:Bool)asyncthrows{
letflag=await(detach{ shouldThrow }).get()
if flag {
throwSomething.bogus
}
returnnil
}
}

enumSomething:Error{
case bogus
}

@available(SwiftStdlib 5.1,*)
structPrecariousStruct{
init?(nilIt :Int)async{
let _ :Optional<Int>=await(detach{nil}).get()
returnnil
}

init(throwIt :Double)asyncthrows{
ifawait(detach{0}).get()!=1{
throwSomething.bogus
}
}
}



// CHECK: Earthling 1
// CHECK-NEXT: Alice
// CHECK-NEXT: Earthling 2
// CHECK-NEXT: Bob
// CHECK-NEXT: Earthling 3
// CHECK-NEXT: Alex
// CHECK-NEXT: NorthAmerican 1
// CHECK-NEXT: NorthAmerican 2
// CHECK-NEXT: Earthling 6

// CHECK-NEXT: class was nil
// CHECK-NEXT: class threw
// CHECK-NEXT: nilOrThrowIt init was nil
// CHECK-NEXT: nilOrThrowIt init threw
// CHECK-NEXT: crashOrThrowIt init threw
// CHECK-NEXT: struct was nil
// CHECK-NEXT: struct threw
// CHECK: done

@available(SwiftStdlib 5.1,*)
@mainstructRunIt{
staticfunc main()async{
letpeople:[Person]=[
awaitEarthPerson(),
awaitNorthAmericaPerson(name:"Alice"),
awaitEarthPerson(),
awaitNorthAmericaPerson(name:"Bob"),
awaitEarthPerson(),
awaitNorthAmericaPerson(name:"Alex"),
awaitNorthAmericaPerson(),
awaitNorthAmericaPerson(),
awaitEarthPerson()
]

forpin people {
print("\(p.name)")
}

 // ----

ifawaitPrecariousClass(nilIt:0)==nil{
print("class was nil")
}

do{let _ =tryawaitPrecariousClass(throwIt:0.0)}catch{
print("class threw")
}

iftry!awaitPrecariousClass(nilOrThrowIt:false)==nil{
print("nilOrThrowIt init was nil")
}

do{let _ =tryawaitPrecariousClass(nilOrThrowIt:true)}catch{
print("nilOrThrowIt init threw")
}

do{let _ =tryawaitPrecariousClass(crashOrThrowIt:true)}catch{
print("crashOrThrowIt init threw")
}

ifawaitPrecariousStruct(nilIt:0)==nil{
print("struct was nil")
}

do{let _ =tryawaitPrecariousStruct(throwIt:0.0)}catch{
print("struct threw")
}

print("done")
}
}