runtime: Marshal.SizeOf(Type) is throwing incorrectly on generic types

Description

Marshal.SizeOf(typeof(somegenericstruct)) throws ArgumentException when T is a closed generic type. It should only throw on open generic types.

Here’s the implementation

public static int SizeOf(Type t)
        {
            if (t is null)
            {
                throw new ArgumentNullException(nameof(t));
            }
            if (!t.IsRuntimeImplemented())
            {
                throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(t));
            }
            if (t.IsGenericType) // This should be changed to IsGenericTypeDefinition, I think
            {
                throw new ArgumentException(SR.Argument_NeedNonGenericType, nameof(t));
            }

            return SizeOfHelper(t, throwIfNotMarshalable: true);
        }

Configuration

Seen on .NET 5.0

Analysis

The documentation says that ArgumentException is thrown if t is a generic type definition. The implementation however throws when it is any generic type (including a closed one). The implementation of the similar method

public static int SizeOf<T>(T structure)

does not throw this exception - it can be used as workaround.

Here’s some test code:

    public class FrameworkBehaviorTests
    {
        [Fact]
        public void CannotGetSizeOfOpenGenericType()
        {
			// This exception is expected
            Assert.Throws<ArgumentException>(() =>
            {
                Marshal.SizeOf(typeof(GenericStruct<>));
            });
        }

        [Fact]
        public void CanGetSizeOfOpenGenericType()
        {
            // This test fails and throws as well
            Assert.Equal(8, Marshal.SizeOf(typeof(GenericStruct<short>)));
        }

        [Fact]
        public void CanGetSizeOfOpenGenericTypeViaInstance()
        {
			// This test passes, because it uses the SizeOf<T>(T object) overload
            GenericStruct<short> gs;
            gs._data1 = 2;
            gs._data2 = 10;
            Assert.Equal(8, Marshal.SizeOf(gs));
        }

        private struct GenericStruct<T>
        {
            public T _data1;
            public int _data2;
        }
    }