Wrapping a call with [MaybeNullWhen] results in incorrect compiler warnings

[johncrim]

Version Used:
dotnet sdk 3.0.100

Steps to Reproduce:

1. dotnet new console
2. Add <Nullable>enable to the .csproj file:

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp3</TargetFramework>
    <Nullable>enable</Nullable>
  </PropertyGroup>

3. Add a method with a [MaybeNullWhen] attribute that wraps a call to another method using a [MaybeNullWhen] attribute. Eg:

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;

namespace MaybeNullWhen_Propagation
{
    class Program
    {
        private Dictionary<int, Process> _processes = new Dictionary<int, Process>();

        public bool TryGetProcessById(int processId, [MaybeNullWhen(false)] out Process process)
        {
            return _processes.TryGetValue(processId, out process);
        }

        public static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

4. dotnet build

Expected Behavior:
No warnings

Actual Behavior:
Received warning CS8601

Program.cs(14,58): warning CS8601: Possible null reference assignment. [C:\src\cc\test-cases\MaybeNullWhen-Propagation\MaybeNullWhen-Propagation.csproj]
    1 Warning(s)
    0 Error(s)

I'm not able to find a good workaround without disabling a warning. Using an additional local variable, and then assigning null to the out param when returning false, results in a different warning:

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;

namespace MaybeNullWhen_Propagation
{
    class Program
    {
        private Dictionary<int, Process> _processes = new Dictionary<int, Process>();

        public bool TryGetProcessById(int processId, [MaybeNullWhen(false)] out Process process)
        {
            if (_processes.TryGetValue(processId, out Process? p))
            {
                process = p;
                return true;
            }
            else
            {
                process = null;
                return false;
            }
        }

        public static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

Results in:

Program.cs(21,27): warning CS8625: Cannot convert null literal to non-nullable reference type. [C:\src\cc\test-cases\MaybeNullWhen-Propagation\MaybeNullWhen-Propagation.csproj]
    1 Warning(s)
    0 Error(s)

[RikkiGibson]

I think this is a symptom of #36039. Inside the TryGetProcessById implementation, the compiler currently isn't taking the attribute on out Process process into account. It's only at the call sites that the attribute is actually considered in the analysis.

I hope this gets addressed at some point, but my recommendation for the short term is to just change the implementation to _processes.TryGetValue(processId, out process!);

[joshwyant]

My workaround currently is using

#nullable disable
...
#nullable enable

[jcouv]

Duplicate of #39656 (also about wrapping a TryGetValue call in a TryGetValue method with [MaybeNullWhen(...)]).
I'll go ahead and close this one. Thanks

Attributes are known to only affect callers at the moment. They are not respected in method bodies. The scenario you describe is particularly tricky though, as it is conditional...