NullabilityInfoContext returns incorrect NullabilityInfo values for Generics

[ShawnOwczarzak]

Description

When using the NullabilityInfoContext to fetch NullabilityInfo for a generic property, the ReadState and WriteState are always Nullable, even when the defined generic has the type as NotNull.

Reproduction Steps

using System.Reflection;

#nullable enable
namespace NullabilityInfoWithGenerics
{
    internal class Program
    {
        static void Main(string[] args)
        {
            PropertyInfo valueProperty = typeof(MyGenericClass<string>).GetProperty("Value")!;
            NullabilityInfo NullabilityInfo = new NullabilityInfoContext().Create(valueProperty);

            // Expect NotNull
            Console.WriteLine(NullabilityInfo.ReadState);
        }
    }
    public record MyGenericClass<T>(T Value);   
}
#nullable restore

Expected behavior

The resulting NullabilityInfo's ReadState and WriteState should match the implemented generic type. string == NotNull. string? == Nullable

Actual behavior

When genaric T is a reference type, NullablityInfo has the ReadState Nullable.

Regression?

No response

Known Workarounds

Not using generics works fine (see below). But it's not really a work around.

Configuration

Dotnet 8.0
Nullable enabled

Other information

More Expected/Actual

Type                             | Expected   | Actual
-------------------------------------------------------
MyGenericClass`1<String>         | NotNull    | Nullable
MyGenericClass`1<String>         | Nullable   | Nullable
MyGenericClass`1<Int32>          | NotNull    | NotNull
MyGenericClass`1<Int32?>         | Nullable   | Nullable
MyGenericClass`1<TestClass>      | NotNull    | Nullable
MyGenericClass`1<TestClass?>     | Nullable   | Nullable
MyStringClass                    | NotNull    | NotNull
MyNullableStringClass            | Nullable   | Nullable
MyIntClass                       | NotNull    | NotNull
MyNullableIntClass               | Nullable   | Nullable
MyTestClassClass                 | NotNull    | NotNull
MyNullableTestClassClass         | Nullable   | Nullable

using System.Reflection;

#nullable enable
namespace NullabilityInfoWithGenerics
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("{0, -30} | {1, -10} | {2} ", "Type", "Expected", "Actual");
            Console.WriteLine("-------------------------------------------------------");

            CheckNullability<MyGenericClass<string>>(NullabilityState.NotNull);  // Mismatch
            CheckNullability<MyGenericClass<string?>>(NullabilityState.Nullable);
            
            CheckNullability<MyGenericClass<int>>(NullabilityState.NotNull);
            CheckNullability<MyGenericClass<int?>>(NullabilityState.Nullable);
            
            CheckNullability<MyGenericClass<TestClass?>>(NullabilityState.NotNull);  // Mismatch
            CheckNullability<MyGenericClass<TestClass?>>(NullabilityState.Nullable);

            CheckNullability<MyStringClass>(NullabilityState.NotNull);
            CheckNullability<MyNullableStringClass>(NullabilityState.Nullable);

            CheckNullability<MyIntClass>(NullabilityState.NotNull);
            CheckNullability<MyNullableIntClass>(NullabilityState.Nullable);

            CheckNullability<MyTestClassClass>(NullabilityState.NotNull);
            CheckNullability<MyNullableTestClassClass>(NullabilityState.Nullable);
        }

        static void CheckNullability<T>(NullabilityState expected)
        {
            PropertyInfo valueProperty = typeof(T).GetProperty("Value")!;
            NullabilityInfo NullabilityInfo = new NullabilityInfoContext().Create(valueProperty);

            if(expected != NullabilityInfo.ReadState)
            {
                Console.BackgroundColor = ConsoleColor.Yellow;
                Console.ForegroundColor = ConsoleColor.Black;
            }

            Console.WriteLine(
                "{0, -30} | {1, -10} | {2} ", 
                string.Format("{0}<{1}>", typeof(T).Name, string.Join(',', typeof(T).GetGenericArguments().Select(x => x.Name))), 
                expected, 
                NullabilityInfo.ReadState);

            if (expected != NullabilityInfo.ReadState)
                Console.ResetColor();
        }
    }
    public record MyGenericClass<T>(T Value);    
    public record MyStringClass(string Value);
    public record MyNullableStringClass(string? Value);
    public record MyIntClass(int Value);
    public record MyNullableIntClass(int? Value);
    public record MyTestClassClass(TestClass Value);
    public record MyNullableTestClassClass(TestClass? Value);
    public record TestClass { }
}
#nullable restore

[elgonzo]

The desired result is impossible to get through reflection from the generic type itself unless MyGenericClass<ReferenceType> and MyGenericClass<ReferenceType?> would be distinguishable types at runtime, which however is not the case.

Note that MyGenericClass<string> is the same type as MyGenericClass<string?>. In other words, for reference type generic parameters ReferenceEquals(typeof(MyGenericClass<ReferenceType>), typeof(MyGenericClass<ReferenceType?>) is true.

If you need this at runtime without doing source code analysis/Roslyn, as far as reference types as generic arguments are concerned, one approach is finding some field/property/method that is using the type MyGenericClass<T>/MyGenericClass<T?> and then not inspect the type but rather the custom attributes of that field, property or the respective method parameter (or return parameter). That's how the nullability information for such generic reference type arguments is carried despite the generic type itself not being able to define the nullability of its generic reference type arguments. You don't query the generic type, you query users of the generic type to get this information. NullabilityInfoContext can help you also with that.

So, if you for example have some method somewhere like:

public class Bar
{
    public MyGenericClass<string> Foo() { ... }
}

then you can query the return parameter (not the generic type!) to see whether it is a generic type with nullable/non-nullable generic arguments. E.g.:

var returnParameter = typeof(Bar).GetMethod("Foo", BindingFlags.Public | BindingFlags.Instance).ReturnParameter;
NullabilityInfo ni = new NullabilityInfoContext().Create(returnParameter);
Console.WriteLine(ni.GenericTypeArguments[0].ReadState);

(Sharplab.io example)

[dotnet-policy-service]

Tagging subscribers to this area: @dotnet/area-system-reflection
See info in area-owners.md if you want to be subscribed.

[ShawnOwczarzak]

That explains everything I am seeing. 🙂👍

Unfortunate since I'm in a JsonConverter and needing the PropertyInfo of the property on the parent class means handling the deserialization there, instead of just needing the generic Type to convert. But the snippet you provided is a great starting point 💯

Thank you @elgonzo for the quick and very clear response!