[DisallowNull] on delegate parameter

[Dersei]

I have an extension method that can be used to map a value to another value if the original one isn't null:

public static class Ext
{
    public delegate TResult NotNullMapping<in TInput, out TResult>([DisallowNull]TInput value);
    
    public static TResult MapIfNotNull<TInput, TResult>(this TInput value, NotNullMapping<TInput, TResult> mapping, TResult ifNull) {
        return value is not null ? mapping(value) : ifNull;
    }
}

So it can be used like this for example:

public class Test
{
    public int Run(IEnumerable<string> values)
    {
        return values.FirstOrDefault().MapIfNotNull(s => s.Length * 10, -1);
    }
}

What I expected was for the compiler to be able to detect that s isn't supposed to be null inside the lambda based on DisallowNull attribute. Interestingly enough, Rider and probably Resharper are able to do this and they don't show any warnings. However, that's not the case when building a project - in this situation, the compiler gives warning CS8602: Dereference of a possibly null reference. It's possible to fix that problem by changing MapIfNotNull to this:

    public static TResult MapIfNotNull<TInput, TResult>(this TInput? value, NotNullMapping<TInput, TResult> mapping,
        TResult ifNull)
        where TInput : notnull
    {
        return value is not null ? mapping(value) : ifNull;
    }

I understand why this code works after the change but I'm not sure why it doesn't before, especially since other tools are able to correctly identify that NotNullMapping parameter shouldn't be null.

Additionally when IEnumerable<string> is changed to IEnumerable<int?> the original version with DisallowNull works correctly in Rider but again the compiler gives CS8602 and now also CS8622 - Nullability of reference types in type of parameter doesn't match the target delegate (possibly because of nullability attributes). Unfortunately in that case the fix with notnull doesn't work anymore.

Obviously, the compiler doesn't need to work the same way Rider does but in that case Rider's behaviour seems to be more reasonable, though that might not be a correct impression.

The other way to have no warning is to explicitly declare the type of lambda parameter to be non-nullable:

return values.FirstOrDefault().MapIfNotNull((string s) => s.Length * 10, -1);

Unfortunately, it also means that this type is marked as redundant.

My question is: why doesn't original version work and is this something that could be improved or changed in the compiler? If not then I'd probably report that as a bug in Rider since those hidden warnings make working with NRT more cumbersome.

[RikkiGibson]

@jcouv do you recall if this behavior is by design? (whether nullability attributes on a delegate affect initial state of lambda parameters.)