Do not double-return arrays to ArrayPool

[terrajobst]

The rule should flag cases where a buffer is potentially being returned to the shared pool multiple times, e.g. where a buffer is returned and then still used after the Return; where a method taking an array by ref returns the array but doesn't null out the ref; where there's a return call in a try block, where that same instance is also returned in a catch block, and where something after the return call in the try block could cause an exception that would trigger the same instance to be returned again in the catch; etc.

Category: Reliability

[jeffhandley]

Estimates:

• Analyzer: Large
• Fixer: Not Applicable

[buyaa-n]

@terrajobst it would be great if there were some examples of how it could happen, what the analyzer should look up, and what to flag for fix

[carlossanlop]

Cases the analyzer should detect:

static void DoubleReturn(int byteLength)
{
    byte[] rented = ArrayPool<byte>.Shared.Rent(byteLength);
    DoSomething(rented);
    ArrayPool<byte>.Shared.Return(rented);
    // Some more work here
    ArrayPool<byte>.Shared.Return(rented); // Analyzer should flag this second return as it is already returned
}

static void UsedAfterReturn(int byteLength)
{
    byte[] rented = ArrayPool<byte>.Shared.Rent(byteLength);
    DoSomething(rented);
    ArrayPool<byte>.Shared.Return(rented);
    DoSomething(rented); // Analyzer should flag this as it should not be used after return
}

static void PassAsRefReturnButNotNullsOutRef(int byteLength)
{
    byte[] rented = ArrayPool<byte>.Shared.Rent(byteLength);
    DoSomething(rented);
    LocalMethodReturns(ref rented);
    DoSomething(rented); // flag here if possible 

    static void LocalMethodReturns(ref byte[] rented)
    {
        ArrayPool<byte>.Shared.Return(rented);
        // Analyzer should flag that rented should be nulled out after return
    }
}

static byte[] TryCatch(int byteLength)
{
    byte[] rented = ArrayPool<byte>.Shared.Rent(byteLength);
    try
    {
        DoSomething(rented);
        ArrayPool<byte>.Shared.Return(rented);
        DoSomethingThatMayThrow();
    }
    catch
    {
        ArrayPool<byte>.Shared.Return(rented); // Analyzer should flag that here the array might be returned again
    }
}