Cases where an IDisposable may or may not be returned

Here’s a case that I don’t think is currently picked up by IDisposableAnalyzers but maybe would be a good candidate:

// Assume the caller will dispose what it receives
IDisposable GetSomething()
{
   var item = ProduceDisposableItem();

   if (condition) return item;
   return null;

   // oops, forgot to item.Dispose()
}

While that’s a simple example of the case I had in mind, a related situation is this (and where I actually had a problem in my code):

// Assume the caller will dispose what it receives
IEnumerable<IDisposable> GetStuff()
{
    foreach(var item in ProduceDisposableItems())
    {
        if (condition) yield return item;
        // should have disposed item here
    }
}

As far as I can tell these cases DO require manual disposal but aren’t picked up by the analyzer. The ‘asymmetry’ made it less obvious (to me) when the code was written that a disposal was missing.

[JohanLarsson]

Awesome that you write issues for where we fail to warn. Most issues are about where we warn where we should not, nothing wrong with that but we very much need this type of issues. Keep 'em coming!

[JohanLarsson]

Writing the first example like this is better for many reasons btw:

IDisposable GetSomething()
{
    if (condition)
    {
        var item = ProduceDisposableItem();
        return item;
    }
            
   return null;
   // oops, forgot to item.Dispose()
}

I get that there may be side effect reasons for writing it the other way and we can figure the case out.