`typeof(object).IsAssignableFrom(typeof(RefStruct))` returns true, but it's not casteable to that type

[Enderlook]

Description

The behavior of refStructValue is object and typeof(object).IsAssignableFrom(typeof(RefStruct)) (where ref struct RefStruct {}) don't match.

I'm not 100% sure if this is a bug since technically, all types inherit from System.Object, so the reflection approach is technically correct.

However, in practice, instances can't be cast to that type, as that would box which is against the rules of ref struct.
Also, Type.IsAssignableFrom(Type) documentation says:

Determines whether an instance of a specified type c can be assigned to a variable of the current type.

An instance of type RefStruct can't be assigned to variables of object, so using the API summary is wrong.

Checking pointers, which can't also be cast to object, the operation typeof(object).IsAssignableTo(typeof(void*)) returns false (unlike with ref struct which is true), a value that I would expect as pointers can't be cast to objects.

So, from my point of view, either the API has a bug or the documentation is outdated.

By the way, this also applies to Type.IsAssignableTo(Type).

Reproduction Steps

using System;
Console.WriteLine(typeof(object).IsAssignableFrom(typeof(RefStruct)));
Console.WriteLine(new RefStruct() is object);
Console.WriteLine(typeof(object).IsAssignableFrom(typeof(void*)));
ref struct RefStruct { }

Expected behavior

using System;
Console.WriteLine(typeof(object).IsAssignableFrom(typeof(RefStruct))); // false
Console.WriteLine(new RefStruct() is object);  // false
Console.WriteLine(typeof(object).IsAssignableFrom(typeof(void*))); // false
ref struct RefStruct { }

Actual behavior

using System;
Console.WriteLine(typeof(object).IsAssignableFrom(typeof(RefStruct))); // true
Console.WriteLine(new RefStruct() is object);  // false
Console.WriteLine(typeof(object).IsAssignableFrom(typeof(void*))); // false
ref struct RefStruct { }

Regression?

No idea, though I guess the discrepancy appeared exactly after the invention of ref struct types.

Known Workarounds

I could check for typeof(RefStruct).IsByRefLike before using Type.IsAssignableFrom(Type).

Configuration

.NET 9
Windows 10 Pro Version 2009 Compilation of OS 19045.5608
X64
Probably happens in all configurations. It also happens in Sharplab.

Other information

No response

[dotnet-policy-service]

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

[jkotas]

The behavior of refStructValue is object and typeof(object).IsAssignableFrom(typeof(RefStruct)) (where ref struct RefStruct {}) don't match.

This is not the only situation where C# is operator and reflection IsAssignableFrom API differ. For example, they produce different result for Nullable<int> too:

Console.WriteLine(typeof(object).IsAssignableFrom(typeof(Nullable<int>))); // True
Console.WriteLine(new Nullable<int>() is object); // False

Unfortunately, C# and reflection type system behaviors were not designed to match.

[mikernet]

@jkotas That makes complete sense in the nullable situation though. This is fundamentally different - there are exactly 0 ref struct values that can be assigned to object at a runtime level.

[jkotas]

Reflection IsAssignableFrom API operates on (conceptually) boxed values. It is answering a question: If you were able to obtain a boxed value of the given type, would that value be assignable to the target type? It is not trying to answer whether it is possible to obtain such boxed value.

Here is another example of a behavior difference between C# is operator and reflection:

Console.WriteLine(typeof(IDisposable).IsAssignableFrom(typeof(MyStruct))); // True
Console.WriteLine(new MyStruct() is IDisposable); // False

ref struct MyStruct : IDisposable
{
    public void Dispose() { }
}

If we were to change the behavior of the reflection IsAssignableFrom to return false for byreflike types, we would have to change the interface case to return false too to maintain transitivity. It would break code that uses IsAssignableFrom to check whether the given type implements an interface. There are likely other 2nd and 3rd order breaking effects that I cannot think about at the moment.

the documentation is outdated.

How would you like to see the documentation updated? The documentation for IsAssignableFrom has a precise definition of the behavior https://learn.microsoft.com/en-us/dotnet/api/system.type.isassignablefrom?view=net-9.0#returns

[Enderlook]

How would you like to see the documentation updated? The documentation for IsAssignableFrom has a precise definition of the behavior https://learn.microsoft.com/en-us/dotnet/api/system.type.isassignablefrom?view=net-9.0#returns

The top level documentation of the API states:

Determines whether an instance of a specified type c can be assigned to a variable of the current type.

That part seems sort of outdated. After all, it returns true, but an instance of a ref struct type can't be assigned to a variable of type object. I don't know, maybe it should specify that operates conceptually at boxed values, otherwise, the statement isn't entirely accurate.

[jkotas]

The doc update should be submitted to https://github.com/dotnet/dotnet-api-docs repo.