error_self_conformance.swift

// RUN: %target-run-simple-swift | %FileCheck %s
// REQUIRES: executable_test

structBoxedError<T:Error>{
varcontents:T
}

enumMyError:Error{
case nothingImportant
case reallyImportant(String)
}

// CHECK: start
print("start")

letvalue=MyError.reallyImportant("hello")

// CHECK-NEXT: reallyImportant("hello")
print(value)

func takeBoxedError<T>(error:BoxedError<T>)->Error{
return error.contents
}

func makeBoxedError<T:Error>(error:T)->BoxedError<Error>{
returnBoxedError(contents: error)
}

letunboxedValue=takeBoxedError(error:makeBoxedError(error: value))

// CHECK-NEXT: reallyImportant("hello")
print(unboxedValue)

leterrorValue:Error=MyError.reallyImportant("goodbye")

func castValueToError<T>(error:T)->Error?{
return error as?Error
}

// CHECK-NEXT: reallyImportant("goodbye")
print(castValueToError(error: errorValue)?? value)

structCarrier<T>{
varname:String
}
protocolErrorCarrier{}
extensionCarrier:ErrorCarrierwhere T:Error{}

func castValueToErrorCarrier<T>(_ value:T)->ErrorCarrier?{
return value as?ErrorCarrier
}

// CHECK-NEXT: nil
print(castValueToErrorCarrier(Carrier<Int>(name:"A carrier of numbers")))

// CHECK-NEXT: A carrier of my errors
print(castValueToErrorCarrier(Carrier<MyError>(name:"A carrier of my errors")))

// CHECK-NEXT: A carrier of all errors
print(castValueToErrorCarrier(Carrier<Error>(name:"A carrier of all errors")))

// CHECK-NEXT: nil
protocolErrorRefinement:Error{}
print(castValueToErrorCarrier(Carrier<ErrorRefinement>(name:"A carrier of refined errors")))

// CHECK-NEXT: nil
protocolOtherProtocol{}
print(castValueToErrorCarrier(Carrier<Error&OtherProtocol>(name:"A carrier of composed errors")))

// CHECK-NEXT: nil
classC{}
print(castValueToErrorCarrier(Carrier<Error&C>(name:"A carrier of classic composed errors")))

// CHECK-NEXT: end
print("end")