NativeAOT Unlock assignability comparison in reflection-free (#70726)

* NativeAOT Unlock assignability comparison in reflection-free
Closes #69960

* Document support for `IsAssignableFrom`

* Document support for `IsInstanceOfType`

* Document `IsAssignableTo`

* Add suggestion from Michal

* Update src/coreclr/nativeaot/System.Private.DisabledReflection/src/Internal/Reflection/RuntimeTypeInfo.cs

Co-authored-by: Michal Strehovský <[email protected]>

* Remove whitespaces

Co-authored-by: Michal Strehovský <[email protected]>

Author: kant2002

src/coreclr/nativeaot/System.Private.DisabledReflection/src/Internal/Reflection/RuntimeTypeInfo.cs

@@ -202,6 +202,36 @@ protected override bool IsPrimitiveImpl()
             return RuntimeAugments.IsPrimitive(_typeHandle);
         }
 
+        public override bool IsAssignableFrom([NotNullWhen(true)] Type c)
+        {
+            if (c == null)
+                return false;
+
+            if (object.ReferenceEquals(c, this))
+                return true;
+
+            c = c.UnderlyingSystemType;
+
+            Type typeInfo = c;
+            RuntimeTypeInfo toTypeInfo = this;
+
+            if (typeInfo is not RuntimeType)
+                return false;  // Desktop compat: If typeInfo is null, or implemented by a different Reflection implementation, return "false."
+
+            RuntimeTypeInfo fromTypeInfo = (RuntimeTypeInfo)typeInfo;
+
+            RuntimeTypeHandle toTypeHandle = toTypeInfo._typeHandle;
+            RuntimeTypeHandle fromTypeHandle = fromTypeInfo._typeHandle;
+
+            if (RuntimeAugments.IsGenericTypeDefinition(toTypeHandle) || RuntimeAugments.IsGenericTypeDefinition(fromTypeHandle))
+                throw new NotSupportedException(SR.Reflection_Disabled);
+
+            if (RuntimeAugments.IsAssignableFrom(toTypeHandle, fromTypeHandle))
+                return true;
+
+            return false;
+        }
+
         internal static RuntimeTypeInfo GetRuntimeTypeInfo(RuntimeTypeHandle typeHandle)
         {
             return RuntimeTypeTable.Table.GetOrAdd(new RuntimeTypeHandleKey(typeHandle));

src/coreclr/nativeaot/docs/reflection-free-mode.md

@@ -34,7 +34,7 @@ Think of:
 Reflection-free mode **supports a limited set of reflection APIs** that keep their expected semantics.
 
 * `typeof(SomeType)` will return a `System.Type` that can be compared with results of other `typeof` expressions or results of `Object.GetType()` calls. The patterns commonly used in perf optimizations of generic code (e.g. `typeof(T) == typeof(byte)`) will work fine, and so will `obj.GetType() == typeof(SomeType)`.
-* Following APIs on `System.Type` work: `TypeHandle`, `UnderlyingSystemType`, `BaseType`, `IsByRefLike`, `IsValueType`, `GetTypeCode`, `GetHashCode`, `GetElementType`, `GetInterfaces`, `HasElementType`, `IsArray`, `IsByRef`, `IsPointer`, `IsPrimitive`.
+* Following APIs on `System.Type` work: `TypeHandle`, `UnderlyingSystemType`, `BaseType`, `IsByRefLike`, `IsValueType`, `GetTypeCode`, `GetHashCode`, `GetElementType`, `GetInterfaces`, `HasElementType`, `IsArray`, `IsByRef`, `IsPointer`, `IsPrimitive`, `IsAssignableFrom`, `IsAssignableTo`, `IsInstanceOfType`.
 * `Activator.CreateInstance<T>()` will work. The compiler statically analyzes and expands this to efficient code at compile time. No reflection is involved at runtime.
 * `Assembly.GetExecutingAssembly()` will return a `System.Reflection.Assembly` that can be compared with other runtime `Assembly` instances. This is mostly to make it possible to use the `NativeLibrary.SetDllImportResolver` API.