Suboptimal code for matching nullable value to constant pattern

[gafter]

See https://sharplab.io/#v2:EYLgZgpghgLgrgJwgZwLQAdYwggdsgZgB8ABARgDYACEgJhrIHYBYAKAG82ruaCHrgAe0EAbKgElkAQQDG8KCIAUAS1wwA/FQAeASioBeAHzaqy5FTIBuKlx4k+5AcLGSAolvQQ5EACYq1mroGxloG+haWbAC+bGxAA=

This issue is extracted from https://github.com/dotnet/roslyn/issues/31494

For source

static class Program
{
    public static bool IsActual(int? x) => x is 1; 
    public static bool IsExpected(int? x) => x == 1;
}

The generated code is

internal static class Program
{
    public static bool IsActual(int? x)
    {
        if (x.HasValue)
        {
            return x.GetValueOrDefault() == 1;
        }
        return false;
    }

    public static bool IsExpected(int? x)
    {
        int? num = x;
        int num2 = 1;
        return (num.GetValueOrDefault() == num2) & num.HasValue;
    }
}

The point is that we optimized == to avoid control-flow. We should do the same for the pattern-matching operations.

[sharwell]

Here's another case:

public bool IsDefaultOrEmpty => _dictionary?.Count is null or 0;

Expected:

int? num = _dictionary?.Count;
return num.GetValueOrDefault() == 0;

Actual:

int? num = _dictionary?.Count;
return !num.HasValue || num.GetValueOrDefault() == 0;