redundantSendable creates warning for recursive enums

[nicklockwood]

This might be a bug in the Swift compiler, but it's an issue regardless: The redundantSendable rule removes Sendable from the ValueType enum here, but without it I get a warning.

It only appears to be a problem for enums that contain a case that reference themselves.

enum ValueType: Hashable {
    case any
    indirect case list(ValueType)
}

extension ValueType {
    static let memberTypes: [String: ValueType] = [:] // <-- warns that ValueType is not Sendable
}

[nicklockwood]

cc @calda

[nicklockwood]

I found another case. Recursive references via an intermediate type also cause the warning, which will make it harder to detect this locally 😔

struct BlockType {
    let symbols: [Symbol]
}

enum Symbol {
    case any
    case block(BlockType)
}

extension Symbol {
    static let transform: Symbol = .any // <-- warning
}

[nicklockwood]

While it doesn't solve every scenario , preserving Sendable for indirect enums (or enums with indirect cases) fixes all the issues in my codebase.

Preserving Sendable for any enum with case values should fix every case (at the cost of a lot of false negatives).

[calda]

Unfortunate. I think preserving Sendable for indirect enums is probably the best fix, and disabling the rule by default.

[nicklockwood]

@calda thinking about this some more, maybe if we added an option, something like --remove-sendable always, indirect-enums, value-bearing-enums (default) then the rule could still be enabled by default. WDYT?

[calda]

If we want to keep it enabled by default I feel like a better solution than an option could just be to exclude enums with associated values. This feels like a pretty niche thing to have an option for given there will be edge cases that result in warnings/errors.