// This doesn’t crash
enum SafeEnum: ConsumerHolder {
    case consume((ConcreteModel) -> Void)

    static func wrappedConsumer(_ event: @escaping (ConcreteModel) -> Void) -> SafeEnum {
        return .consume(event)
    }
}

performTest(SafeEnum.self) {
    if case .consume(let consumer) = $0 {
        print("Safe test starting")
        consumer(1)
        print("Safe test completed")
    }
}

// This crashes – note that the static func protocol constraint is fulfilled by an enum case
enum CrashingEnum: ConsumerHolder {
    case wrappedConsumer((ConcreteModel) -> Void)
}

performTest(CrashingEnum.self) {
    if case .wrappedConsumer(let consumer) = $0 {
        print("Crashing test starting")
        consumer(1)
        print("Crashing test completed")
    }
}

protocol ConsumerHolder {
    // If this associated type is replaced with a typealias, it no longer crashes
    #if true
    associatedtype Model
    #else
    typealias Model = ConcreteModel
    #endif
    static func wrappedConsumer(_: @escaping (Model) -> Void) -> Self
}

typealias ConcreteModel = Int
// If performTest is not generic, it no longer crashes
#if true
func performTest<Holder: ConsumerHolder> (
    _ type: Holder.Type,
    consume: @escaping (Holder) -> Void
) where Holder.Model == ConcreteModel {
    let wrapped = Holder.wrappedConsumer { _ in }
    consume(wrapped)
}
#else
func performTest(
    _ type: SafeEnum.Type,
    consume: @escaping (SafeEnum) -> Void
) {
    let wrapped = SafeEnum.wrappedConsumer { _ in }
    consume(wrapped)
}

func performTest(
    _ type: CrashingEnum.Type,
    consume: @escaping (CrashingEnum) -> Void
) {
    let wrapped = CrashingEnum.wrappedConsumer { _ in }
    consume(wrapped)
}
#endif