Need an analyzer to warn about ignored Dispose method

[jcouv]

In C# 8.0, we're adding support for pattern-based disposal. Due to compatibility concerns, the feature is restricted to ref structs for foreach and using. But it not restricted for await foreach and await using.

This unfortunate situation could cause user confusion. It would be useful for an analyzer to warn on foreach or using where the user might hope an instance Dispose() method to be called but it is in fact not called.

Umbrella for enhanced-using feature: #28588

[sharwell]

@jcouv Why doesn't the compiler report a clear warning for this case (extension Dispose not available for use in foreach/using)?

[jcouv]

@sharwell We don't want to break existing code. You could have an existing Dispose method which was (and remains) ignored. Previously, no scenarios allowed such a Dispose method to contribute to a foreach, but now it could (in some limited scenarios).

To illustrate the purpose of this analyzer, consider someone who changes their ref struct enumerable/enumerator (with a Dispose method) to be a struct (Dispose will be ignored).
But the compiler cannot break someone who is already in the latter situation...

[sharwell]

@jcouv My understanding is existing code will not be broken. Code will fall into three cases:

1. The type supports pattern-based dispose, in which case this issue does not apply
2. The type implements IDisposable, in which case pattern-based dispose methods are irrelevant because the IDisposable implementation would take precedence
3. The type does not implement IDisposable in which case the code would not compile anyway so the error you report is at the discretion of the compiler (and could change)

This issue targets situation 3, reporting an error that a pattern-based dispose was not used instead of the current error saying the type must be disposable.

[jcouv]

A foreach works on a pattern-based enumerable/enumerator without IDisposable today, so situation 3 actually compiles. The lowered code for foreach does if (enumerator is IDisposable) ....
The analyzer would produce a warning in that case (since the compiler cannot, for compat reasons).

[jcouv]

@sharwell Did my reponse make sense? I still think this should be addressed by an analyzer warning rather than a compiler warning.