indirect public enum SwiftType {
    case nested(NestedSwiftType)
    case nominal(NominalSwiftType)
    case optional(SwiftType)
}

public enum NominalSwiftType {
    case typeName(String)
    case generic(String, parameters: GenericArgumentSwiftType)
}

public enum ProtocolCompositionComponent {
    case nominal(NominalSwiftType)
    case nested(NestedSwiftType)
}

public enum TupleSwiftType {
    case types(TwoOrMore<SwiftType>)
    case empty
}

public typealias NestedSwiftType = TwoOrMore<NominalSwiftType>
public typealias GenericArgumentSwiftType = OneOrMore<SwiftType>

// MARK: - Building structures
public enum OneOrMore<T> {
    indirect case list(T, OneOrMore)
    case tail(T)
}

public enum TwoOrMore<T> {
    indirect case list(T, TwoOrMore)
    case tail(T, T)
}

func crashMe() {
    
    let unaliasedType = SwiftType.nominal(.typeName("TypeA"))
    let unaliasedBaseType = SwiftType.optional(.nominal(.typeName("TypeB")))
    
    // No complaints about non-exhaustive switch here!
    switch (unaliasedType, unaliasedBaseType) {
    case (.nominal, .nominal):
        break
        // Uncomment to fix crash
//    default:
//        break
    }
    
}

crashMe()