Only root infrastructure and dependencies for IDynamicInterfaceCastable when IDIC is implemented (#116660)

jkoritzinsky · AustinWise · web-flow · commit 74076ee1b84f · 2025-07-02T01:13:56.000Z
Co-authored-by: Austin Wise &lt;AustinWise@gmail.com&gt;
diff --git a/src/coreclr/nativeaot/Bootstrap/main.cpp b/src/coreclr/nativeaot/Bootstrap/main.cpp
@@ -125,8 +125,6 @@ MANAGED_RUNTIME_EXPORT(AppendExceptionStackFrame)
 MANAGED_RUNTIME_EXPORT(GetSystemArrayEEType)
 MANAGED_RUNTIME_EXPORT(OnFirstChanceException)
 MANAGED_RUNTIME_EXPORT(OnUnhandledException)
-MANAGED_RUNTIME_EXPORT(IDynamicCastableIsInterfaceImplemented)
-MANAGED_RUNTIME_EXPORT(IDynamicCastableGetInterfaceImplementation)
 #ifdef FEATURE_OBJCMARSHAL
 MANAGED_RUNTIME_EXPORT(ObjectiveCMarshalTryGetTaggedMemory)
 MANAGED_RUNTIME_EXPORT(ObjectiveCMarshalGetIsTrackedReferenceCallback)
@@ -145,8 +143,6 @@ static const pfn c_classlibFunctions[] = {
     &MANAGED_RUNTIME_EXPORT_NAME(GetSystemArrayEEType),
     &MANAGED_RUNTIME_EXPORT_NAME(OnFirstChanceException),
     &MANAGED_RUNTIME_EXPORT_NAME(OnUnhandledException),
-    &MANAGED_RUNTIME_EXPORT_NAME(IDynamicCastableIsInterfaceImplemented),
-    &MANAGED_RUNTIME_EXPORT_NAME(IDynamicCastableGetInterfaceImplementation),
 #ifdef FEATURE_OBJCMARSHAL
     &MANAGED_RUNTIME_EXPORT_NAME(ObjectiveCMarshalTryGetTaggedMemory),
     &MANAGED_RUNTIME_EXPORT_NAME(ObjectiveCMarshalGetIsTrackedReferenceCallback),
diff --git a/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/CachedInterfaceDispatch.cs b/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/CachedInterfaceDispatch.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Runtime;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 
 using Internal.Runtime;
 
@@ -138,9 +139,7 @@ private static unsafe IntPtr RhResolveDispatchWorker(object pObject, void* cell,
                 {
                     // Dispatch not resolved through normal dispatch map, try using the IDynamicInterfaceCastable
                     // This will either give us the appropriate result, or throw.
-                    var pfnGetInterfaceImplementation = (delegate*<object, MethodTable*, ushort, IntPtr>)
-                        pInstanceType->GetClasslibFunction(ClassLibFunctionId.IDynamicCastableGetInterfaceImplementation);
-                    pTargetCode = pfnGetInterfaceImplementation(pObject, cellInfo.InterfaceType, cellInfo.InterfaceSlot);
+                    pTargetCode = IDynamicInterfaceCastable.GetDynamicInterfaceImplementation((IDynamicInterfaceCastable)pObject, cellInfo.InterfaceType, cellInfo.InterfaceSlot);
                     Diagnostics.Debug.Assert(pTargetCode != IntPtr.Zero);
                 }
                 return pTargetCode;
diff --git a/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/InternalCalls.cs b/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/InternalCalls.cs
@@ -44,12 +44,10 @@ internal enum ClassLibFunctionId
         GetSystemArrayEEType = 5,
         OnFirstChance = 6,
         OnUnhandledException = 7,
-        IDynamicCastableIsInterfaceImplemented = 8,
-        IDynamicCastableGetInterfaceImplementation = 9,
-        ObjectiveCMarshalTryGetTaggedMemory = 10,
-        ObjectiveCMarshalGetIsTrackedReferenceCallback = 11,
-        ObjectiveCMarshalGetOnEnteredFinalizerQueueCallback = 12,
-        ObjectiveCMarshalGetUnhandledExceptionPropagationHandler = 13,
+        ObjectiveCMarshalTryGetTaggedMemory = 8,
+        ObjectiveCMarshalGetIsTrackedReferenceCallback = 9,
+        ObjectiveCMarshalGetOnEnteredFinalizerQueueCallback = 10,
+        ObjectiveCMarshalGetUnhandledExceptionPropagationHandler = 11,
     }
 
     internal static class InternalCalls
diff --git a/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/TypeCast.cs b/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/TypeCast.cs
@@ -469,9 +469,7 @@ private static unsafe object CheckCastClassSpecial(MethodTable* pTargetType, obj
 
         private static unsafe bool IsInstanceOfInterfaceViaIDynamicInterfaceCastable(MethodTable* pTargetType, object obj, bool throwing)
         {
-            var pfnIsInterfaceImplemented = (delegate*<object, MethodTable*, bool, bool>)
-                pTargetType->GetClasslibFunction(ClassLibFunctionId.IDynamicCastableIsInterfaceImplemented);
-            return pfnIsInterfaceImplemented(obj, pTargetType, throwing);
+            return ((IDynamicInterfaceCastable)obj).IsInterfaceImplemented(new RuntimeTypeHandle(pTargetType), throwing);
         }
 
         internal static unsafe bool IsDerived(MethodTable* pDerivedType, MethodTable* pBaseType)
diff --git a/src/coreclr/nativeaot/Runtime.Base/src/System/ThrowHelpers.cs b/src/coreclr/nativeaot/Runtime.Base/src/System/ThrowHelpers.cs
@@ -57,5 +57,10 @@ private static void ThrowArgumentOutOfRangeException()
             // exception doesn't exist in MRT: throw PlatformNotSupportedException() instead
             throw new PlatformNotSupportedException();
         }
+
+        private static void ThrowFeatureBodyRemoved()
+        {
+            throw new NotSupportedException();
+        }
     }
 }
diff --git a/src/coreclr/nativeaot/Runtime/ICodeManager.h b/src/coreclr/nativeaot/Runtime/ICodeManager.h
@@ -105,12 +105,10 @@ enum class ClasslibFunctionId
     GetSystemArrayEEType = 5,
     OnFirstChanceException = 6,
     OnUnhandledException = 7,
-    IDynamicCastableIsInterfaceImplemented = 8,
-    IDynamicCastableGetInterfaceImplementation = 9,
-    ObjectiveCMarshalTryGetTaggedMemory = 10,
-    ObjectiveCMarshalGetIsTrackedReferenceCallback = 11,
-    ObjectiveCMarshalGetOnEnteredFinalizerQueueCallback = 12,
-    ObjectiveCMarshalGetUnhandledExceptionPropagationHandler = 13,
+    ObjectiveCMarshalTryGetTaggedMemory = 8,
+    ObjectiveCMarshalGetIsTrackedReferenceCallback = 9,
+    ObjectiveCMarshalGetOnEnteredFinalizerQueueCallback = 10,
+    ObjectiveCMarshalGetUnhandledExceptionPropagationHandler = 11,
 };
 
 enum class AssociatedDataFlags : unsigned char
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System.Private.CoreLib.csproj b/src/coreclr/nativeaot/System.Private.CoreLib/src/System.Private.CoreLib.csproj
@@ -113,7 +113,6 @@
     <Compile Include="Internal\IntrinsicSupport\ComparerHelpers.cs" />
     <Compile Include="Internal\IntrinsicSupport\EqualityComparerHelpers.cs" />
     <Compile Include="Internal\Reflection\Augments\ReflectionAugments.cs" />
-    <Compile Include="Internal\Runtime\IDynamicInterfaceCastableSupport.cs" />
     <Compile Include="Internal\Runtime\MethodTable.Runtime.cs" />
     <Compile Include="Internal\Runtime\CompilerHelpers\ThrowHelpers.cs" />
     <Compile Include="Internal\Runtime\CompilerServices\FunctionPointerOps.cs" />
@@ -200,6 +199,7 @@
     <Compile Include="System\Runtime\InteropServices\ComEventsHelper.NativeAot.cs" Condition="'$(FeatureCominterop)' == 'true'" />
     <Compile Include="System\Runtime\InteropServices\ComWrappers.NativeAot.cs" Condition="'$(FeatureComWrappers)' == 'true'" />
     <Compile Include="System\Runtime\InteropServices\GCHandle.NativeAot.cs" />
+    <Compile Include="System\Runtime\InteropServices\IDynamicInterfaceCastable.cs" />
     <Compile Include="System\Runtime\InteropServices\NativeFunctionPointerWrapper.cs" />
     <Compile Include="System\Runtime\InteropServices\NativeLibrary.NativeAot.cs" />
     <Compile Include="System\Runtime\InteropServices\PInvokeMarshal.cs" />
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/InteropServices/IDynamicInterfaceCastable.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/InteropServices/IDynamicInterfaceCastable.cs
@@ -3,28 +3,22 @@
 
 using System;
 using System.Runtime;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using System.Threading;
 
+using Internal.Runtime;
 using Internal.Runtime.Augments;
 using Internal.TypeSystem;
 
 using Debug = System.Diagnostics.Debug;
 
-namespace Internal.Runtime
+namespace System.Runtime.InteropServices
 {
-    internal static unsafe class IDynamicCastableSupport
+    public unsafe partial interface IDynamicInterfaceCastable
     {
-        [RuntimeExport("IDynamicCastableIsInterfaceImplemented")]
-        internal static bool IDynamicCastableIsInterfaceImplemented(IDynamicInterfaceCastable instance, MethodTable* interfaceType, bool throwIfNotImplemented)
-        {
-            return instance.IsInterfaceImplemented(new RuntimeTypeHandle(interfaceType), throwIfNotImplemented);
-        }
-
         private static readonly object s_thunkPoolHeap = RuntimeAugments.CreateThunksHeap(RuntimeImports.GetInteropCommonStubAddress());
 
-        [RuntimeExport("IDynamicCastableGetInterfaceImplementation")]
-        internal static IntPtr IDynamicCastableGetInterfaceImplementation(IDynamicInterfaceCastable instance, MethodTable* interfaceType, ushort slot)
+        internal static nint GetDynamicInterfaceImplementation(IDynamicInterfaceCastable instance, MethodTable* interfaceType, ushort slot)
         {
             RuntimeTypeHandle handle = instance.GetInterfaceImplementation(new RuntimeTypeHandle(interfaceType));
             MethodTable* implType = handle.ToMethodTable();
@@ -38,10 +32,10 @@ internal static IntPtr IDynamicCastableGetInterfaceImplementation(IDynamicInterf
             }
 
             MethodTable* genericContext = null;
-            IntPtr result = RuntimeImports.RhResolveDynamicInterfaceCastableDispatchOnType(implType, interfaceType, slot, &genericContext);
-            if (result == IntPtr.Zero)
+            nint result = RuntimeImports.RhResolveDynamicInterfaceCastableDispatchOnType(implType, interfaceType, slot, &genericContext);
+            if (result == nint.Zero)
             {
-                IDynamicCastableGetInterfaceImplementationFailure(instance, interfaceType, implType);
+                GetInterfaceImplementationFailure(instance, interfaceType, implType);
             }
 
             if (genericContext != null)
@@ -73,7 +67,7 @@ private static void ThrowInvalidOperationException(MethodTable* resolvedImplType
             throw new InvalidOperationException(SR.Format(SR.IDynamicInterfaceCastable_NotInterface, Type.GetTypeFromMethodTable(resolvedImplType)));
         }
 
-        private static void IDynamicCastableGetInterfaceImplementationFailure(object instance, MethodTable* interfaceType, MethodTable* resolvedImplType)
+        private static void GetInterfaceImplementationFailure(object instance, MethodTable* interfaceType, MethodTable* resolvedImplType)
         {
             if (resolvedImplType->DispatchMap == null)
                 throw new InvalidOperationException(SR.Format(SR.IDynamicInterfaceCastable_MissingImplementationAttribute, Type.GetTypeFromMethodTable(resolvedImplType), nameof(DynamicInterfaceCastableImplementationAttribute)));
diff --git a/src/coreclr/nativeaot/Test.CoreLib/src/Internal/Runtime/IDynamicInterfaceCastableSupport.cs b/src/coreclr/nativeaot/Test.CoreLib/src/Internal/Runtime/IDynamicInterfaceCastableSupport.cs
diff --git a/src/coreclr/nativeaot/Test.CoreLib/src/System/Runtime/CompilerServices/RuntimeFeature.cs b/src/coreclr/nativeaot/Test.CoreLib/src/System/Runtime/CompilerServices/RuntimeFeature.cs
@@ -0,0 +1,48 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Runtime.CompilerServices
+{
+    public static partial class RuntimeFeature
+    {
+        /// <summary>
+        /// Name of the Portable PDB feature.
+        /// </summary>
+        public const string PortablePdb = nameof(PortablePdb);
+
+        /// <summary>
+        /// Indicates that this version of runtime supports default interface method implementations.
+        /// </summary>
+        public const string DefaultImplementationsOfInterfaces = nameof(DefaultImplementationsOfInterfaces);
+
+        /// <summary>
+        /// Indicates that this version of runtime supports the Unmanaged calling convention value.
+        /// </summary>
+        public const string UnmanagedSignatureCallingConvention = nameof(UnmanagedSignatureCallingConvention);
+
+        /// <summary>
+        /// Indicates that this version of runtime supports covariant returns in overrides of methods declared in classes.
+        /// </summary>
+        public const string CovariantReturnsOfClasses = nameof(CovariantReturnsOfClasses);
+
+        /// <summary>
+        /// Represents a runtime feature where types can define ref fields.
+        /// </summary>
+        public const string ByRefFields = nameof(ByRefFields);
+
+        /// <summary>
+        /// Represents a runtime feature where byref-like types can be used in Generic parameters.
+        /// </summary>
+        public const string ByRefLikeGenerics = nameof(ByRefLikeGenerics);
+
+        /// <summary>
+        /// Indicates that this version of runtime supports virtual static members of interfaces.
+        /// </summary>
+        public const string VirtualStaticsInInterfaces = nameof(VirtualStaticsInInterfaces);
+
+        /// <summary>
+        /// Indicates that this version of runtime supports <see cref="System.IntPtr" /> and <see cref="System.UIntPtr" /> as numeric types.
+        /// </summary>
+        public const string NumericIntPtr = nameof(NumericIntPtr);
+    }
+}
diff --git a/src/coreclr/nativeaot/Test.CoreLib/src/System/Runtime/InteropServices/IDynamicInterfaceCastable.cs b/src/coreclr/nativeaot/Test.CoreLib/src/System/Runtime/InteropServices/IDynamicInterfaceCastable.cs
@@ -0,0 +1,16 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Internal.Runtime;
+
+namespace System.Runtime.InteropServices
+{
+    public unsafe partial interface IDynamicInterfaceCastable
+    {
+        internal static IntPtr GetDynamicInterfaceImplementation(object instance, MethodTable* interfaceType, ushort slot)
+        {
+            RuntimeImports.RhpFallbackFailFast();
+            return default;
+        }
+    }
+}
diff --git a/src/coreclr/nativeaot/Test.CoreLib/src/System/RuntimeTypeHandle.cs b/src/coreclr/nativeaot/Test.CoreLib/src/System/RuntimeTypeHandle.cs
@@ -5,6 +5,8 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
+using Internal.Runtime;
+
 namespace System
 {
     [StructLayout(LayoutKind.Sequential)]
@@ -17,6 +19,11 @@ internal RuntimeTypeHandle(IntPtr value)
             _value = value;
         }
 
+        unsafe internal RuntimeTypeHandle(MethodTable* value)
+            :this((IntPtr)value)
+        {
+        }
+
         [Intrinsic]
         internal static unsafe IntPtr ToIntPtr(RuntimeTypeHandle handle)
         {
diff --git a/src/coreclr/nativeaot/Test.CoreLib/src/Test.CoreLib.csproj b/src/coreclr/nativeaot/Test.CoreLib/src/Test.CoreLib.csproj
@@ -209,11 +209,14 @@
     <Compile Include="..\..\Runtime.Base\src\System\Runtime\CompilerServices\Unsafe.cs">
       <Link>System\Runtime\CompilerServices\Unsafe.cs</Link>
     </Compile>
-    <Compile Include="Internal\Runtime\IDynamicInterfaceCastableSupport.cs" />
+    <Compile Include="$(LibrariesProjectRoot)\System.Private.CoreLib\src\System\Runtime\InteropServices\IDynamicInterfaceCastable.cs">
+      <Link>Common\System\Runtime\InteropServices\IDynamicInterfaceCastable.cs</Link>
+    </Compile>
     <Compile Include="Internal\Runtime\MethodTable.Runtime.cs" />
     <Compile Include="System\Runtime\CompilerServices\CastCache.cs" />
     <Compile Include="System\Runtime\CompilerServices\ClassConstructorRunner.cs" />
     <Compile Include="System\Runtime\CompilerServices\InlineArrayAttribute.cs" />
+    <Compile Include="System\Runtime\CompilerServices\RuntimeFeature.cs" />
     <Compile Include="System\Runtime\CompilerServices\StaticClassConstructionContext.cs" />
     <Compile Include="System\Runtime\ExceptionServices\ExceptionHandling.cs" />
     <Compile Include="System\Runtime\InteropServices\InAttribute.cs" />
@@ -222,6 +225,7 @@
     <Compile Include="System\Diagnostics\CodeAnalysis\DoesNotReturnIfAttribute.cs" />
     <Compile Include="System\Diagnostics\Debug.cs" />
     <Compile Include="System\Runtime\InteropServices\MemoryMarshal.cs" />
+    <Compile Include="System\Runtime\InteropServices\IDynamicInterfaceCastable.cs" />
     <Compile Include="System\Runtime\RuntimeImports.cs" />
     <Compile Include="System\Runtime\RuntimeHelpers.cs" />
     <Compile Include="System\Threading\Interlocked.cs" />
diff --git a/src/coreclr/tools/Common/Compiler/DevirtualizationManager.cs b/src/coreclr/tools/Common/Compiler/DevirtualizationManager.cs
@@ -218,6 +218,8 @@ protected virtual MethodDesc ResolveVirtualMethod(MethodDesc declMethod, DefType
         public virtual bool CanReferenceConstructedTypeOrCanonicalFormOfType(TypeDesc type) => true;
 
         public virtual TypeDesc[] GetImplementingClasses(TypeDesc type) => null;
+
+        public virtual bool CanHaveDynamicInterfaceImplementations(TypeDesc type) => true;
 #endif
     }
 }
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Compilation.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Compilation.cs
@@ -308,11 +308,20 @@ public ISymbolNode ComputeConstantLookup(ReadyToRunHelperId lookupKind, object t
                     {
                         var type = (TypeDesc)targetOfLookup;
 
-                        // We counter-intuitively ask for a constructed type symbol. This is needed due to IDynamicInterfaceCastable.
-                        // If this cast happens with an object that implements IDynamicIntefaceCastable, user code will
-                        // see a RuntimeTypeHandle representing this interface.
                         if (type.IsInterface)
-                            return NodeFactory.MaximallyConstructableType(type);
+                        {
+                            // We counter-intuitively ask for a constructed type symbol. This is needed due to IDynamicInterfaceCastable.
+                            // If this cast happens with an object that implements IDynamicInterfaceCastable, user code will
+                            // see a RuntimeTypeHandle representing this interface.
+                            if (NodeFactory.DevirtualizationManager.CanHaveDynamicInterfaceImplementations(type))
+                            {
+                                return NodeFactory.MaximallyConstructableType(type);
+                            }
+                            else
+                            {
+                                return NecessaryTypeSymbolIfPossible(type);
+                            }
+                        }
 
                         if (type.IsNullable)
                             type = type.Instantiation[0];
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/InterfaceDispatchCellNode.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/InterfaceDispatchCellNode.cs
@@ -50,6 +50,20 @@ public void AppendMangledName(NameMangler nameMangler, Utf8StringBuilder sb)
 
         public override bool StaticDependenciesAreComputed => true;
 
+        private IEETypeNode GetInterfaceTypeNode(NodeFactory factory)
+        {
+            // If this dispatch cell is ever used with an object that implements IDynamicIntefaceCastable, user code will
+            // see a RuntimeTypeHandle representing this interface.
+            if (factory.DevirtualizationManager.CanHaveDynamicInterfaceImplementations(_targetMethod.OwningType))
+            {
+                return factory.ConstructedTypeSymbol(_targetMethod.OwningType);
+            }
+            else
+            {
+                return factory.NecessaryTypeSymbol(_targetMethod.OwningType);
+            }
+        }
+
         public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory)
         {
             DependencyList result = new DependencyList();
@@ -63,10 +77,7 @@ public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFacto
 
             result.Add(factory.InitialInterfaceDispatchStub, "Initial interface dispatch stub");
 
-            // We counter-intuitively ask for a constructed type symbol. This is needed due to IDynamicInterfaceCastable.
-            // If this dispatch cell is ever used with an object that implements IDynamicIntefaceCastable, user code will
-            // see a RuntimeTypeHandle representing this interface.
-            result.Add(factory.ConstructedTypeSymbol(_targetMethod.OwningType), "Interface type");
+            result.Add(GetInterfaceTypeNode(factory), "Interface type");
 
             return result;
         }
@@ -75,10 +86,7 @@ public override void EncodeData(ref ObjectDataBuilder objData, NodeFactory facto
         {
             objData.EmitPointerReloc(factory.InitialInterfaceDispatchStub);
 
-            // We counter-intuitively ask for a constructed type symbol. This is needed due to IDynamicInterfaceCastable.
-            // If this dispatch cell is ever used with an object that implements IDynamicIntefaceCastable, user code will
-            // see a RuntimeTypeHandle representing this interface.
-            IEETypeNode interfaceType = factory.ConstructedTypeSymbol(_targetMethod.OwningType);
+            IEETypeNode interfaceType = GetInterfaceTypeNode(factory);
             if (factory.Target.SupportsRelativePointers)
             {
                 if (interfaceType.RepresentsIndirectionCell)
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ILScanner.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ILScanner.cs
diff --git a/src/coreclr/tools/aot/ILCompiler/Program.cs b/src/coreclr/tools/aot/ILCompiler/Program.cs
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/IDynamicInterfaceCastable.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/IDynamicInterfaceCastable.cs

Original file line number	Diff line number	Diff line change
`@@ -469,9 +469,7 @@ private static unsafe object CheckCastClassSpecial(MethodTable* pTargetType, obj`
`469`	`469`
`470`	`470`	`private static unsafe bool IsInstanceOfInterfaceViaIDynamicInterfaceCastable(MethodTable* pTargetType, object obj, bool throwing)`
`471`	`471`	`{`
`472`		`- var pfnIsInterfaceImplemented = (delegate<object, MethodTable, bool, bool>)`
`473`		`- pTargetType->GetClasslibFunction(ClassLibFunctionId.IDynamicCastableIsInterfaceImplemented);`
`474`		`- return pfnIsInterfaceImplemented(obj, pTargetType, throwing);`
	`472`	`+ return ((IDynamicInterfaceCastable)obj).IsInterfaceImplemented(new RuntimeTypeHandle(pTargetType), throwing);`
`475`	`473`	`}`
`476`	`474`
`477`	`475`	`internal static unsafe bool IsDerived(MethodTable* pDerivedType, MethodTable* pBaseType)`
Original file line number	Diff line number	Diff line change
`@@ -57,5 +57,10 @@ private static void ThrowArgumentOutOfRangeException()`
`57`	`57`	`// exception doesn't exist in MRT: throw PlatformNotSupportedException() instead`
`58`	`58`	`throw new PlatformNotSupportedException();`
`59`	`59`	`}`
	`60`	`+`
	`61`	`+ private static void ThrowFeatureBodyRemoved()`
	`62`	`+ {`
	`63`	`+ throw new NotSupportedException();`
	`64`	`+ }`
`60`	`65`	`}`
`61`	`66`	`}`