[NativeAOT] Miscellaneous cleanup (#93446)

jkotas · MichalStrehovsky · web-flow · commit 765798c49d5d · 2023-10-13T22:18:12.000-07:00
* [NativeAOT] Miscellaneous cleanup

- Delete unnecessary abstractions
- Simplify ifdefs
- Use more derived types

* Apply suggestions from code review

Co-authored-by: Michal Strehovský &lt;MichalStrehovsky@users.noreply.github.com&gt;
diff --git a/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/MethodTable.Runtime.cs b/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/MethodTable.Runtime.cs
@@ -11,42 +11,29 @@ namespace Internal.Runtime
     // Extensions to MethodTable that are specific to the use in Runtime.Base.
     internal unsafe partial struct MethodTable
     {
-#pragma warning disable CA1822
+#if !INPLACE_RUNTIME
         internal MethodTable* GetArrayEEType()
         {
-#if INPLACE_RUNTIME
-            return MethodTable.Of<Array>();
-#else
             MethodTable* pThis = (MethodTable*)Unsafe.Pointer(ref this);
             void* pGetArrayEEType = InternalCalls.RhpGetClasslibFunctionFromEEType(pThis, ClassLibFunctionId.GetSystemArrayEEType);
             return ((delegate* <MethodTable*>)pGetArrayEEType)();
-#endif
         }
 
         internal Exception GetClasslibException(ExceptionIDs id)
         {
-#if INPLACE_RUNTIME
-            return RuntimeExceptionHelpers.GetRuntimeException(id);
-#else
             if (IsParameterizedType)
             {
                 return RelatedParameterType->GetClasslibException(id);
             }
 
             return EH.GetClasslibExceptionFromEEType(id, (MethodTable*)Unsafe.AsPointer(ref this));
-#endif
         }
-#pragma warning restore CA1822
+#endif
 
         internal IntPtr GetClasslibFunction(ClassLibFunctionId id)
         {
             return (IntPtr)InternalCalls.RhpGetClasslibFunctionFromEEType((MethodTable*)Unsafe.AsPointer(ref this), id);
         }
-
-        internal static bool AreSameType(MethodTable* mt1, MethodTable* mt2)
-        {
-            return mt1 == mt2;
-        }
     }
 
     internal static class WellKnownEETypes
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Reflection/Core/Execution/ExecutionDomain.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Reflection/Core/Execution/ExecutionDomain.cs
@@ -117,27 +117,27 @@ public Type GetNamedTypeForHandle(RuntimeTypeHandle typeHandle)
 
         public Type GetArrayTypeForHandle(RuntimeTypeHandle typeHandle)
         {
-            RuntimeTypeHandle elementTypeHandle = ExecutionEnvironment.GetArrayTypeElementType(typeHandle);
+            RuntimeTypeHandle elementTypeHandle = RuntimeAugments.GetRelatedParameterTypeHandle(typeHandle);
             return elementTypeHandle.GetTypeForRuntimeTypeHandle().GetArrayType(typeHandle);
         }
 
         public Type GetMdArrayTypeForHandle(RuntimeTypeHandle typeHandle, int rank)
         {
-            RuntimeTypeHandle elementTypeHandle = ExecutionEnvironment.GetArrayTypeElementType(typeHandle);
+            RuntimeTypeHandle elementTypeHandle = RuntimeAugments.GetRelatedParameterTypeHandle(typeHandle);
             return elementTypeHandle.GetTypeForRuntimeTypeHandle().GetMultiDimArrayType(rank, typeHandle);
         }
 
         public Type GetPointerTypeForHandle(RuntimeTypeHandle typeHandle)
         {
-            RuntimeTypeHandle targetTypeHandle = ExecutionEnvironment.GetPointerTypeTargetType(typeHandle);
+            RuntimeTypeHandle targetTypeHandle = RuntimeAugments.GetRelatedParameterTypeHandle(typeHandle);
             return targetTypeHandle.GetTypeForRuntimeTypeHandle().GetPointerType(typeHandle);
         }
 
         public Type GetFunctionPointerTypeForHandle(RuntimeTypeHandle typeHandle)
         {
-            ExecutionEnvironment.GetFunctionPointerTypeComponents(typeHandle, out RuntimeTypeHandle returnTypeHandle,
-                                                                              out RuntimeTypeHandle[] parameterHandles,
-                                                                              out bool isUnmanaged);
+            RuntimeTypeHandle returnTypeHandle = RuntimeAugments.GetFunctionPointerReturnType(typeHandle);
+            RuntimeTypeHandle[] parameterHandles = RuntimeAugments.GetFunctionPointerParameterTypes(typeHandle);
+            bool isUnmanaged = RuntimeAugments.IsUnmanagedFunctionPointerType(typeHandle);
 
             RuntimeTypeInfo returnType = returnTypeHandle.GetTypeForRuntimeTypeHandle();
             int count = parameterHandles.Length;
@@ -152,7 +152,7 @@ public Type GetFunctionPointerTypeForHandle(RuntimeTypeHandle typeHandle)
 
         public Type GetByRefTypeForHandle(RuntimeTypeHandle typeHandle)
         {
-            RuntimeTypeHandle targetTypeHandle = ExecutionEnvironment.GetByRefTypeTargetType(typeHandle);
+            RuntimeTypeHandle targetTypeHandle = RuntimeAugments.GetRelatedParameterTypeHandle(typeHandle);
             return targetTypeHandle.GetTypeForRuntimeTypeHandle().GetByRefType(typeHandle);
         }
 
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Reflection/Core/Execution/ExecutionEnvironment.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Reflection/Core/Execution/ExecutionEnvironment.cs
@@ -53,18 +53,14 @@ public abstract class ExecutionEnvironment
         public abstract bool TryGetNamedTypeForMetadata(QTypeDefinition qTypeDefinition, out RuntimeTypeHandle runtimeTypeHandle);
 
         public abstract bool TryGetArrayTypeForElementType(RuntimeTypeHandle elementTypeHandle, out RuntimeTypeHandle arrayTypeHandle);
-        public abstract RuntimeTypeHandle GetArrayTypeElementType(RuntimeTypeHandle arrayTypeHandle);
 
         public abstract bool TryGetMultiDimArrayTypeForElementType(RuntimeTypeHandle elementTypeHandle, int rank, out RuntimeTypeHandle arrayTypeHandle);
 
         public abstract bool TryGetFunctionPointerTypeForComponents(RuntimeTypeHandle returnTypeHandle, RuntimeTypeHandle[] parameterHandles, bool isUnmanaged, out RuntimeTypeHandle functionPointerTypeHandle);
-        public abstract void GetFunctionPointerTypeComponents(RuntimeTypeHandle functionPointerHandle, out RuntimeTypeHandle returnTypeHandle, out RuntimeTypeHandle[] parameterHandles, out bool isUnmanaged);
 
         public abstract bool TryGetPointerTypeForTargetType(RuntimeTypeHandle targetTypeHandle, out RuntimeTypeHandle pointerTypeHandle);
-        public abstract RuntimeTypeHandle GetPointerTypeTargetType(RuntimeTypeHandle pointerTypeHandle);
 
         public abstract bool TryGetByRefTypeForTargetType(RuntimeTypeHandle targetTypeHandle, out RuntimeTypeHandle byRefTypeHandle);
-        public abstract RuntimeTypeHandle GetByRefTypeTargetType(RuntimeTypeHandle byRefTypeHandle);
 
         public abstract bool TryGetConstructedGenericTypeForComponents(RuntimeTypeHandle genericTypeDefinitionHandle, RuntimeTypeHandle[] genericTypeArgumentHandles, out RuntimeTypeHandle runtimeTypeHandle);
         public abstract bool TryGetConstructedGenericTypeForComponentsNoConstraintCheck(RuntimeTypeHandle genericTypeDefinitionHandle, RuntimeTypeHandle[] genericTypeArgumentHandles, out RuntimeTypeHandle runtimeTypeHandle);
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Reflection/Core/NonPortable/RuntimeTypeUnifier.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Reflection/Core/NonPortable/RuntimeTypeUnifier.cs
@@ -7,6 +7,7 @@
 using System.Collections.Concurrent;
 using System.Runtime.CompilerServices;
 
+using Internal.Runtime;
 using Internal.Runtime.Augments;
 
 namespace Internal.Reflection.Core.NonPortable
@@ -42,12 +43,12 @@ internal static partial class RuntimeTypeUnifier
         //
         // Retrieves the unified Type object for given RuntimeTypeHandle (this is basically the Type.GetTypeFromHandle() api without the input validation.)
         //
-        internal static Type GetRuntimeTypeForEEType(EETypePtr eeType)
+        internal static unsafe RuntimeType GetRuntimeTypeForMethodTable(MethodTable* eeType)
         {
             // If writable data is supported, we shouldn't be using the hashtable - the runtime type
-            // is accessible through a couple indirections from the EETypePtr which is much faster.
+            // is accessible through a couple indirections from the MethodTable which is much faster.
             Debug.Assert(!Internal.Runtime.MethodTable.SupportsWritableData);
-            return RuntimeTypeHandleToTypeCache.Table.GetOrAdd(eeType.RawValue);
+            return RuntimeTypeHandleToTypeCache.Table.GetOrAdd((IntPtr)eeType);
         }
 
         //
@@ -59,14 +60,14 @@ internal static Type GetRuntimeTypeForEEType(EETypePtr eeType)
         // does a second lookup in the true unifying tables rather than creating the Type itself.
         // Thus, the one-to-one relationship between Type reference identity and Type semantic identity is preserved.
         //
-        private sealed class RuntimeTypeHandleToTypeCache : ConcurrentUnifierW<IntPtr, Type>
+        private sealed class RuntimeTypeHandleToTypeCache : ConcurrentUnifierW<IntPtr, RuntimeType>
         {
             private RuntimeTypeHandleToTypeCache() { }
 
-            protected sealed override Type Factory(IntPtr rawRuntimeTypeHandleKey)
+            protected sealed override RuntimeType Factory(IntPtr rawRuntimeTypeHandleKey)
             {
                 EETypePtr eeType = new EETypePtr(rawRuntimeTypeHandleKey);
-                return GetRuntimeTypeBypassCache(eeType);
+                return (RuntimeType)GetRuntimeTypeBypassCache(eeType);
             }
 
             public static readonly RuntimeTypeHandleToTypeCache Table = new RuntimeTypeHandleToTypeCache();
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/Augments/RuntimeAugments.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/Augments/RuntimeAugments.cs
@@ -602,7 +602,7 @@ public static bool IsFunctionPointerType(RuntimeTypeHandle typeHandle)
 
         public static unsafe RuntimeTypeHandle GetFunctionPointerReturnType(RuntimeTypeHandle typeHandle)
         {
-            return new RuntimeTypeHandle(new EETypePtr(typeHandle.ToMethodTable()->FunctionPointerReturnType));
+            return new RuntimeTypeHandle(typeHandle.ToMethodTable()->FunctionPointerReturnType);
         }
 
         public static unsafe int GetFunctionPointerParameterCount(RuntimeTypeHandle typeHandle)
@@ -613,7 +613,7 @@ public static unsafe int GetFunctionPointerParameterCount(RuntimeTypeHandle type
         public static unsafe RuntimeTypeHandle GetFunctionPointerParameterType(RuntimeTypeHandle typeHandle, int argumentIndex)
         {
             Debug.Assert(argumentIndex < GetFunctionPointerParameterCount(typeHandle));
-            return new RuntimeTypeHandle(new EETypePtr(typeHandle.ToMethodTable()->FunctionPointerParameters[argumentIndex]));
+            return new RuntimeTypeHandle(typeHandle.ToMethodTable()->FunctionPointerParameters[argumentIndex]);
         }
 
         public static unsafe RuntimeTypeHandle[] GetFunctionPointerParameterTypes(RuntimeTypeHandle typeHandle)
@@ -626,7 +626,7 @@ public static unsafe RuntimeTypeHandle[] GetFunctionPointerParameterTypes(Runtim
             MethodTableList parameters = typeHandle.ToMethodTable()->FunctionPointerParameters;
             for (int i = 0; i < result.Length; i++)
             {
-                result[i] = new RuntimeTypeHandle(new EETypePtr(parameters[i]));
+                result[i] = new RuntimeTypeHandle(parameters[i]);
             }
 
             return result;
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/LdTokenHelpers.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/LdTokenHelpers.cs
@@ -31,7 +31,7 @@ private static unsafe RuntimeFieldHandle GetRuntimeFieldHandle(IntPtr pHandleSig
             return returnValue;
         }
 
-        private static unsafe Type GetRuntimeType(MethodTable* pMT)
+        private static unsafe RuntimeType GetRuntimeType(MethodTable* pMT)
         {
             return Type.GetTypeFromMethodTable(pMT);
         }
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/SynchronizedMethodHelpers.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/SynchronizedMethodHelpers.cs
@@ -67,7 +67,7 @@ private static unsafe void MonitorExitStatic(MethodTable* pMT, ref bool lockTake
             lockTaken = false;
         }
 
-        private static unsafe Type GetStaticLockObject(MethodTable* pMT)
+        private static unsafe RuntimeType GetStaticLockObject(MethodTable* pMT)
         {
             return Type.GetTypeFromMethodTable(pMT);
         }
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/IDynamicInterfaceCastableSupport.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/IDynamicInterfaceCastableSupport.cs
@@ -12,13 +12,13 @@ static unsafe class IDynamicCastableSupport
         [RuntimeExport("IDynamicCastableIsInterfaceImplemented")]
         internal static bool IDynamicCastableIsInterfaceImplemented(IDynamicInterfaceCastable instance, MethodTable* interfaceType, bool throwIfNotImplemented)
         {
-            return instance.IsInterfaceImplemented(new RuntimeTypeHandle(new EETypePtr(interfaceType)), throwIfNotImplemented);
+            return instance.IsInterfaceImplemented(new RuntimeTypeHandle(interfaceType), throwIfNotImplemented);
         }
 
         [RuntimeExport("IDynamicCastableGetInterfaceImplementation")]
         internal static IntPtr IDynamicCastableGetInterfaceImplementation(IDynamicInterfaceCastable instance, MethodTable* interfaceType, ushort slot)
         {
-            RuntimeTypeHandle handle = instance.GetInterfaceImplementation(new RuntimeTypeHandle(new EETypePtr(interfaceType)));
+            RuntimeTypeHandle handle = instance.GetInterfaceImplementation(new RuntimeTypeHandle(interfaceType));
             MethodTable* implType = handle.ToMethodTable();
             if (implType == null)
             {
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/MethodTable.Runtime.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/MethodTable.Runtime.cs
@@ -11,17 +11,43 @@ namespace Internal.Runtime
     // Extensions to MethodTable that are specific to the use in the CoreLib.
     internal unsafe partial struct MethodTable
     {
-#if !INPLACE_RUNTIME
-        internal static MethodTable* GetArrayEEType()
+#pragma warning disable CA1822
+        internal MethodTable* GetArrayEEType()
         {
-
             return MethodTable.Of<Array>();
         }
 
+        internal Exception GetClasslibException(ExceptionIDs id)
+        {
+            return RuntimeExceptionHelpers.GetRuntimeException(id);
+        }
+#pragma warning restore CA1822
+
         internal static bool AreSameType(MethodTable* mt1, MethodTable* mt2)
         {
             return mt1 == mt2;
         }
-#endif
+
+        internal bool IsEnum
+        {
+            get
+            {
+                // Q: When is an enum type a constructed generic type?
+                // A: When it's nested inside a generic type.
+
+                // Generic type definitions that return true for IsPrimitive are type definitions of generic enums.
+                // Otherwise check the base type.
+                return IsPrimitive && (IsGenericTypeDefinition || NonArrayBaseType == MethodTable.Of<Enum>());
+            }
+        }
+
+        // Returns true for actual primitives only, returns false for enums
+        internal bool IsActualPrimitive
+        {
+            get
+            {
+                return IsPrimitive && NonArrayBaseType == MethodTable.Of<ValueType>();
+            }
+        }
     }
 }
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/EETypePtr.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/EETypePtr.cs
@@ -156,20 +156,11 @@ internal bool IsPrimitive
             }
         }
 
-        // WARNING: Never call unless the MethodTable came from an instanced object. Nested enums can be open generics (typeof(Outer<>).NestedEnum)
-        // and this helper has undefined behavior when passed such as a enum.
         internal bool IsEnum
         {
             get
             {
-                // Q: When is an enum type a constructed generic type?
-                // A: When it's nested inside a generic type.
-                if (!IsDefType)
-                    return false;
-
-                // Generic type definitions that return true for IsPrimitive are type definitions of generic enums.
-                // Otherwise check the base type.
-                return (IsGenericTypeDefinition && IsPrimitive) || this.BaseType == EETypePtr.EETypePtrOf<Enum>();
+                return _value->IsEnum;
             }
         }
 
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.NativeAot.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.NativeAot.cs
@@ -417,7 +417,7 @@ internal sealed unsafe class ManagedObjectWrapperHolder
             static ManagedObjectWrapperHolder()
             {
                 delegate* unmanaged<IntPtr, bool> callback = &IsRootedCallback;
-                if (!RuntimeImports.RhRegisterRefCountedHandleCallback((nint)callback, typeof(ManagedObjectWrapperHolder).GetEEType()))
+                if (!RuntimeImports.RhRegisterRefCountedHandleCallback((nint)callback, EETypePtr.EETypePtrOf<ManagedObjectWrapperHolder>()))
                 {
                     throw new OutOfMemoryException();
                 }
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/InteropServices/UnsafeGCHandle.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/InteropServices/UnsafeGCHandle.cs
@@ -41,7 +41,7 @@ private UnsafeGCHandle(object value, GCHandleType type)
             _handle = RuntimeImports.RhHandleAlloc(value, type);
         }
 
-        public static UnsafeGCHandle Alloc(object value, GCHandleType type)
+        public static UnsafeGCHandle Alloc(object value, GCHandleType type = GCHandleType.Normal)
         {
             return new UnsafeGCHandle(value, type);
         }
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/RuntimeImports.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/RuntimeImports.cs
@@ -391,10 +391,10 @@ internal static unsafe bool AreTypesAssignable(EETypePtr pSourceType, EETypePtr
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         [RuntimeImport(RuntimeLibrary, "RhTypeCast_IsInstanceOfAny")]
-        private static extern unsafe object IsInstanceOfAny(MethodTable* pTargetType, object obj);
+        internal static extern unsafe object IsInstanceOf(MethodTable* pTargetType, object obj);
 
         internal static unsafe object IsInstanceOf(EETypePtr pTargetType, object obj)
-            => IsInstanceOfAny(pTargetType.ToPointer(), obj);
+            => IsInstanceOf(pTargetType.ToPointer(), obj);
 
         //
         // calls to runtime for allocation
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/RuntimeTypeHandle.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/RuntimeTypeHandle.cs
@@ -18,15 +18,14 @@ public unsafe struct RuntimeTypeHandle : IEquatable<RuntimeTypeHandle>, ISeriali
     {
         private IntPtr _value;
 
+        internal unsafe RuntimeTypeHandle(MethodTable* pEEType)
+            => _value = (IntPtr)pEEType;
+
         internal RuntimeTypeHandle(EETypePtr pEEType)
-            : this(pEEType.RawValue)
-        {
-        }
+            => _value = pEEType.RawValue;
 
         private RuntimeTypeHandle(IntPtr value)
-        {
-            _value = value;
-        }
+            => _value = value;
 
         public override bool Equals(object? obj)
         {
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Type.NativeAot.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Type.NativeAot.cs
@@ -23,17 +23,17 @@ public abstract partial class Type : MemberInfo, IReflect
         public static unsafe Type? GetTypeFromHandle(RuntimeTypeHandle handle) => handle.IsNull ? null : GetTypeFromMethodTable(handle.ToMethodTable());
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static unsafe Type GetTypeFromMethodTable(MethodTable* pMT)
+        internal static unsafe RuntimeType GetTypeFromMethodTable(MethodTable* pMT)
         {
             // If we support the writable data section on MethodTables, the runtime type associated with the MethodTable
             // is cached there. If writable data is not supported, we need to do a lookup in the runtime type
             // unifier's hash table.
             if (MethodTable.SupportsWritableData)
             {
-                ref GCHandle handle = ref Unsafe.AsRef<GCHandle>(pMT->WritableData);
+                ref UnsafeGCHandle handle = ref Unsafe.AsRef<UnsafeGCHandle>(pMT->WritableData);
                 if (handle.IsAllocated)
                 {
-                    return Unsafe.As<Type>(handle.Target);
+                    return Unsafe.As<RuntimeType>(handle.Target);
                 }
                 else
                 {
@@ -42,26 +42,26 @@ internal static unsafe Type GetTypeFromMethodTable(MethodTable* pMT)
             }
             else
             {
-                return RuntimeTypeUnifier.GetRuntimeTypeForEEType(new EETypePtr(pMT));
+                return RuntimeTypeUnifier.GetRuntimeTypeForMethodTable(pMT);
             }
         }
 
         [MethodImpl(MethodImplOptions.NoInlining)]
-        private static unsafe Type GetTypeFromMethodTableSlow(MethodTable* pMT, ref GCHandle handle)
+        private static unsafe RuntimeType GetTypeFromMethodTableSlow(MethodTable* pMT, ref UnsafeGCHandle handle)
         {
             // Note: this is bypassing the "fast" unifier cache (based on a simple IntPtr
             // identity of MethodTable pointers). There is another unifier behind that cache
             // that ensures this code is race-free.
             Type result = RuntimeTypeUnifier.GetRuntimeTypeBypassCache(new EETypePtr(pMT));
-            GCHandle tempHandle = GCHandle.Alloc(result);
+            UnsafeGCHandle tempHandle = UnsafeGCHandle.Alloc(result);
 
             // We don't want to leak a handle if there's a race
-            if (Interlocked.CompareExchange(ref Unsafe.As<GCHandle, IntPtr>(ref handle), (IntPtr)tempHandle, default) != default)
+            if (Interlocked.CompareExchange(ref Unsafe.As<UnsafeGCHandle, IntPtr>(ref handle), Unsafe.As<UnsafeGCHandle, IntPtr>(ref tempHandle), default) != default)
             {
                 tempHandle.Free();
             }
 
-            return result;
+            return Unsafe.As<RuntimeType>(handle.Target);
         }
 
         internal EETypePtr GetEEType()
diff --git a/src/coreclr/nativeaot/System.Private.Reflection.Execution/src/Internal/Reflection/Execution/ExecutionEnvironmentImplementation.MappingTables.cs b/src/coreclr/nativeaot/System.Private.Reflection.Execution/src/Internal/Reflection/Execution/ExecutionEnvironmentImplementation.MappingTables.cs
diff --git a/src/coreclr/nativeaot/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/MethodTable.Runtime.cs b/src/coreclr/nativeaot/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/MethodTable.Runtime.cs
diff --git a/src/coreclr/nativeaot/Test.CoreLib/src/Internal/Runtime/MethodTable.Runtime.cs b/src/coreclr/nativeaot/Test.CoreLib/src/Internal/Runtime/MethodTable.Runtime.cs
diff --git a/src/libraries/System.Private.CoreLib/src/System/RuntimeType.cs b/src/libraries/System.Private.CoreLib/src/System/RuntimeType.cs

Original file line number	Diff line number	Diff line change
`@@ -11,42 +11,29 @@ namespace Internal.Runtime`
`11`	`11`	`// Extensions to MethodTable that are specific to the use in Runtime.Base.`
`12`	`12`	`internal unsafe partial struct MethodTable`
`13`	`13`	`{`
`14`		`-#pragma warning disable CA1822`
	`14`	`+#if !INPLACE_RUNTIME`
`15`	`15`	`internal MethodTable* GetArrayEEType()`
`16`	`16`	`{`
`17`		`-#if INPLACE_RUNTIME`
`18`		`- return MethodTable.Of<Array>();`
`19`		`-#else`
`20`	`17`	`MethodTable* pThis = (MethodTable*)Unsafe.Pointer(ref this);`
`21`	`18`	`void* pGetArrayEEType = InternalCalls.RhpGetClasslibFunctionFromEEType(pThis, ClassLibFunctionId.GetSystemArrayEEType);`
`22`	`19`	`return ((delegate* <MethodTable*>)pGetArrayEEType)();`
`23`		`-#endif`
`24`	`20`	`}`
`25`	`21`
`26`	`22`	`internal Exception GetClasslibException(ExceptionIDs id)`
`27`	`23`	`{`
`28`		`-#if INPLACE_RUNTIME`
`29`		`- return RuntimeExceptionHelpers.GetRuntimeException(id);`
`30`		`-#else`
`31`	`24`	`if (IsParameterizedType)`
`32`	`25`	`{`
`33`	`26`	`return RelatedParameterType->GetClasslibException(id);`
`34`	`27`	`}`
`35`	`28`
`36`	`29`	`return EH.GetClasslibExceptionFromEEType(id, (MethodTable*)Unsafe.AsPointer(ref this));`
`37`		`-#endif`
`38`	`30`	`}`
`39`		`-#pragma warning restore CA1822`
	`31`	`+#endif`
`40`	`32`
`41`	`33`	`internal IntPtr GetClasslibFunction(ClassLibFunctionId id)`
`42`	`34`	`{`
`43`	`35`	`return (IntPtr)InternalCalls.RhpGetClasslibFunctionFromEEType((MethodTable*)Unsafe.AsPointer(ref this), id);`
`44`	`36`	`}`
`45`		`-`
`46`		`- internal static bool AreSameType(MethodTable* mt1, MethodTable* mt2)`
`47`		`- {`
`48`		`- return mt1 == mt2;`
`49`		`- }`
`50`	`37`	`}`
`51`	`38`
`52`	`39`	`internal static class WellKnownEETypes`
Original file line number	Diff line number	Diff line change
`@@ -117,27 +117,27 @@ public Type GetNamedTypeForHandle(RuntimeTypeHandle typeHandle)`
`117`	`117`
`118`	`118`	`public Type GetArrayTypeForHandle(RuntimeTypeHandle typeHandle)`
`119`	`119`	`{`
`120`		`- RuntimeTypeHandle elementTypeHandle = ExecutionEnvironment.GetArrayTypeElementType(typeHandle);`
	`120`	`+ RuntimeTypeHandle elementTypeHandle = RuntimeAugments.GetRelatedParameterTypeHandle(typeHandle);`
`121`	`121`	`return elementTypeHandle.GetTypeForRuntimeTypeHandle().GetArrayType(typeHandle);`
`122`	`122`	`}`
`123`	`123`
`124`	`124`	`public Type GetMdArrayTypeForHandle(RuntimeTypeHandle typeHandle, int rank)`
`125`	`125`	`{`
`126`		`- RuntimeTypeHandle elementTypeHandle = ExecutionEnvironment.GetArrayTypeElementType(typeHandle);`
	`126`	`+ RuntimeTypeHandle elementTypeHandle = RuntimeAugments.GetRelatedParameterTypeHandle(typeHandle);`
`127`	`127`	`return elementTypeHandle.GetTypeForRuntimeTypeHandle().GetMultiDimArrayType(rank, typeHandle);`
`128`	`128`	`}`
`129`	`129`
`130`	`130`	`public Type GetPointerTypeForHandle(RuntimeTypeHandle typeHandle)`
`131`	`131`	`{`
`132`		`- RuntimeTypeHandle targetTypeHandle = ExecutionEnvironment.GetPointerTypeTargetType(typeHandle);`
	`132`	`+ RuntimeTypeHandle targetTypeHandle = RuntimeAugments.GetRelatedParameterTypeHandle(typeHandle);`
`133`	`133`	`return targetTypeHandle.GetTypeForRuntimeTypeHandle().GetPointerType(typeHandle);`
`134`	`134`	`}`
`135`	`135`
`136`	`136`	`public Type GetFunctionPointerTypeForHandle(RuntimeTypeHandle typeHandle)`
`137`	`137`	`{`
`138`		`- ExecutionEnvironment.GetFunctionPointerTypeComponents(typeHandle, out RuntimeTypeHandle returnTypeHandle,`
`139`		`- out RuntimeTypeHandle[] parameterHandles,`
`140`		`- out bool isUnmanaged);`
	`138`	`+ RuntimeTypeHandle returnTypeHandle = RuntimeAugments.GetFunctionPointerReturnType(typeHandle);`
	`139`	`+ RuntimeTypeHandle[] parameterHandles = RuntimeAugments.GetFunctionPointerParameterTypes(typeHandle);`
	`140`	`+ bool isUnmanaged = RuntimeAugments.IsUnmanagedFunctionPointerType(typeHandle);`
`141`	`141`
`142`	`142`	`RuntimeTypeInfo returnType = returnTypeHandle.GetTypeForRuntimeTypeHandle();`
`143`	`143`	`int count = parameterHandles.Length;`
`@@ -152,7 +152,7 @@ public Type GetFunctionPointerTypeForHandle(RuntimeTypeHandle typeHandle)`
`152`	`152`
`153`	`153`	`public Type GetByRefTypeForHandle(RuntimeTypeHandle typeHandle)`
`154`	`154`	`{`
`155`		`- RuntimeTypeHandle targetTypeHandle = ExecutionEnvironment.GetByRefTypeTargetType(typeHandle);`
	`155`	`+ RuntimeTypeHandle targetTypeHandle = RuntimeAugments.GetRelatedParameterTypeHandle(typeHandle);`
`156`	`156`	`return targetTypeHandle.GetTypeForRuntimeTypeHandle().GetByRefType(typeHandle);`
`157`	`157`	`}`
`158`	`158`
Original file line number	Diff line number	Diff line change
`@@ -602,7 +602,7 @@ public static bool IsFunctionPointerType(RuntimeTypeHandle typeHandle)`
`602`	`602`
`603`	`603`	`public static unsafe RuntimeTypeHandle GetFunctionPointerReturnType(RuntimeTypeHandle typeHandle)`
`604`	`604`	`{`
`605`		`- return new RuntimeTypeHandle(new EETypePtr(typeHandle.ToMethodTable()->FunctionPointerReturnType));`
	`605`	`+ return new RuntimeTypeHandle(typeHandle.ToMethodTable()->FunctionPointerReturnType);`
`606`	`606`	`}`
`607`	`607`
`608`	`608`	`public static unsafe int GetFunctionPointerParameterCount(RuntimeTypeHandle typeHandle)`
`@@ -613,7 +613,7 @@ public static unsafe int GetFunctionPointerParameterCount(RuntimeTypeHandle type`
`613`	`613`	`public static unsafe RuntimeTypeHandle GetFunctionPointerParameterType(RuntimeTypeHandle typeHandle, int argumentIndex)`
`614`	`614`	`{`
`615`	`615`	`Debug.Assert(argumentIndex < GetFunctionPointerParameterCount(typeHandle));`
`616`		`- return new RuntimeTypeHandle(new EETypePtr(typeHandle.ToMethodTable()->FunctionPointerParameters[argumentIndex]));`
	`616`	`+ return new RuntimeTypeHandle(typeHandle.ToMethodTable()->FunctionPointerParameters[argumentIndex]);`
`617`	`617`	`}`
`618`	`618`
`619`	`619`	`public static unsafe RuntimeTypeHandle[] GetFunctionPointerParameterTypes(RuntimeTypeHandle typeHandle)`
`@@ -626,7 +626,7 @@ public static unsafe RuntimeTypeHandle[] GetFunctionPointerParameterTypes(Runtim`
`626`	`626`	`MethodTableList parameters = typeHandle.ToMethodTable()->FunctionPointerParameters;`
`627`	`627`	`for (int i = 0; i < result.Length; i++)`
`628`	`628`	`{`
`629`		`- result[i] = new RuntimeTypeHandle(new EETypePtr(parameters[i]));`
	`629`	`+ result[i] = new RuntimeTypeHandle(parameters[i]);`
`630`	`630`	`}`
`631`	`631`
`632`	`632`	`return result;`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ private static unsafe RuntimeFieldHandle GetRuntimeFieldHandle(IntPtr pHandleSig`
`31`	`31`	`return returnValue;`
`32`	`32`	`}`
`33`	`33`
`34`		`- private static unsafe Type GetRuntimeType(MethodTable* pMT)`
	`34`	`+ private static unsafe RuntimeType GetRuntimeType(MethodTable* pMT)`
`35`	`35`	`{`
`36`	`36`	`return Type.GetTypeFromMethodTable(pMT);`
`37`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ private static unsafe void MonitorExitStatic(MethodTable* pMT, ref bool lockTake`
`67`	`67`	`lockTaken = false;`
`68`	`68`	`}`
`69`	`69`
`70`		`- private static unsafe Type GetStaticLockObject(MethodTable* pMT)`
	`70`	`+ private static unsafe RuntimeType GetStaticLockObject(MethodTable* pMT)`
`71`	`71`	`{`
`72`	`72`	`return Type.GetTypeFromMethodTable(pMT);`
`73`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,13 +12,13 @@ static unsafe class IDynamicCastableSupport`
`12`	`12`	`[RuntimeExport("IDynamicCastableIsInterfaceImplemented")]`
`13`	`13`	`internal static bool IDynamicCastableIsInterfaceImplemented(IDynamicInterfaceCastable instance, MethodTable* interfaceType, bool throwIfNotImplemented)`
`14`	`14`	`{`
`15`		`- return instance.IsInterfaceImplemented(new RuntimeTypeHandle(new EETypePtr(interfaceType)), throwIfNotImplemented);`
	`15`	`+ return instance.IsInterfaceImplemented(new RuntimeTypeHandle(interfaceType), throwIfNotImplemented);`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`[RuntimeExport("IDynamicCastableGetInterfaceImplementation")]`
`19`	`19`	`internal static IntPtr IDynamicCastableGetInterfaceImplementation(IDynamicInterfaceCastable instance, MethodTable* interfaceType, ushort slot)`
`20`	`20`	`{`
`21`		`- RuntimeTypeHandle handle = instance.GetInterfaceImplementation(new RuntimeTypeHandle(new EETypePtr(interfaceType)));`
	`21`	`+ RuntimeTypeHandle handle = instance.GetInterfaceImplementation(new RuntimeTypeHandle(interfaceType));`
`22`	`22`	`MethodTable* implType = handle.ToMethodTable();`
`23`	`23`	`if (implType == null)`
`24`	`24`	`{`
Original file line number	Diff line number	Diff line change
`@@ -156,20 +156,11 @@ internal bool IsPrimitive`
`156`	`156`	`}`
`157`	`157`	`}`
`158`	`158`
`159`		`- // WARNING: Never call unless the MethodTable came from an instanced object. Nested enums can be open generics (typeof(Outer<>).NestedEnum)`
`160`		`- // and this helper has undefined behavior when passed such as a enum.`
`161`	`159`	`internal bool IsEnum`
`162`	`160`	`{`
`163`	`161`	`get`
`164`	`162`	`{`
`165`		`- // Q: When is an enum type a constructed generic type?`
`166`		`- // A: When it's nested inside a generic type.`
`167`		`- if (!IsDefType)`
`168`		`- return false;`
`169`		`-`
`170`		`- // Generic type definitions that return true for IsPrimitive are type definitions of generic enums.`
`171`		`- // Otherwise check the base type.`
`172`		`- return (IsGenericTypeDefinition && IsPrimitive) \|\| this.BaseType == EETypePtr.EETypePtrOf<Enum>();`
	`163`	`+ return _value->IsEnum;`
`173`	`164`	`}`
`174`	`165`	`}`
`175`	`166`