Rename IsInterface to avoid Reflection issues

AaronRobinsonMSFT · AaronRobinsonMSFT · commit 005426df7b87 · 2025-08-14T12:41:49.000-07:00
This is a narrow change to address a user
reported issue on System.Runtime and the
common implementation detail, System.RuntimeType.
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeCustomAttributeData.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeCustomAttributeData.cs
@@ -170,7 +170,7 @@ internal static CustomAttributeEncoding TypeToCustomAttributeEncoding(RuntimeTyp
             if (type.IsClass)
                 return CustomAttributeEncoding.Object;
 
-            if (type.IsInterface)
+            if (type.IsActualInterface)
                 return CustomAttributeEncoding.Object;
 
             if (type.IsActualValueType)
@@ -2263,7 +2263,7 @@ internal static bool IsDefined(RuntimeFieldInfo field, RuntimeType? caType)
 
         internal static StructLayoutAttribute? GetStructLayoutCustomAttribute(RuntimeType type)
         {
-            if (type.IsInterface || type.HasElementType || type.IsGenericParameter)
+            if (type.IsActualInterface || type.HasElementType || type.IsGenericParameter)
                 return null;
 
             LayoutKind layoutKind = LayoutKind.Auto;
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeMethodInfo.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeMethodInfo.CoreCLR.cs
@@ -105,7 +105,7 @@ Signature LazyCreateSignature()
 
         internal RuntimeMethodInfo? GetParentDefinition()
         {
-            if (!IsVirtual || m_declaringType.IsInterface)
+            if (!IsVirtual || m_declaringType.IsActualInterface)
                 return null;
 
             RuntimeType? parent = (RuntimeType?)m_declaringType.BaseType;
@@ -323,7 +323,7 @@ internal void InvokePropertySetter(object? obj, BindingFlags invokeAttr, Binder?
 
         public override MethodInfo GetBaseDefinition()
         {
-            if (!IsVirtual || IsStatic || m_declaringType == null || m_declaringType.IsInterface)
+            if (!IsVirtual || IsStatic || m_declaringType == null || m_declaringType.IsActualInterface)
                 return this;
 
             int slot = RuntimeMethodHandle.GetSlot(this);
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/DynamicInterfaceCastableHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/DynamicInterfaceCastableHelpers.cs
@@ -30,7 +30,7 @@ internal static bool IsInterfaceImplemented(IDynamicInterfaceCastable castable,
                 throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, castable.GetType(), interfaceType));
 
             RuntimeType implType = handle.GetRuntimeType();
-            if (!implType.IsInterface)
+            if (!implType.IsActualInterface)
                 throw new InvalidOperationException(SR.Format(SR.IDynamicInterfaceCastable_NotInterface, implType.ToString()));
 
             if (!implType.IsDefined(typeof(DynamicInterfaceCastableImplementationAttribute), inherit: false))
diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs
@@ -579,7 +579,7 @@ private unsafe RuntimeMethodInfo[] PopulateMethods(Filter filter)
                     RuntimeType declaringType = ReflectedType;
                     Debug.Assert(declaringType != null);
 
-                    if (declaringType.IsInterface)
+                    if (declaringType.IsActualInterface)
                     {
                         #region IsInterface
 
@@ -998,7 +998,7 @@ private RuntimeType[] PopulateInterfaces(Filter filter)
                                     continue;
                             }
 
-                            Debug.Assert(interfaceType.IsInterface);
+                            Debug.Assert(interfaceType.IsActualInterface);
                             list.Add(interfaceType);
                         }
 
@@ -1028,7 +1028,7 @@ private RuntimeType[] PopulateInterfaces(Filter filter)
                         for (int i = 0; i < constraints.Length; i++)
                         {
                             RuntimeType constraint = (RuntimeType)constraints[i];
-                            if (constraint.IsInterface)
+                            if (constraint.IsActualInterface)
                                 al.Add(constraint);
 
                             Type[] temp = constraint.GetInterfaces();
@@ -1113,7 +1113,7 @@ private RuntimeEventInfo[] PopulateEvents(Filter filter)
                     RuntimeType declaringType = ReflectedType;
                     ListBuilder<RuntimeEventInfo> list = default;
 
-                    if (!declaringType.IsInterface)
+                    if (!declaringType.IsActualInterface)
                     {
                         while (RuntimeTypeHandle.IsGenericVariable(declaringType))
                             declaringType = declaringType.GetBaseType()!;
@@ -1206,7 +1206,7 @@ private RuntimePropertyInfo[] PopulateProperties(Filter filter)
 
                     ListBuilder<RuntimePropertyInfo> list = default;
 
-                    if (!declaringType.IsInterface)
+                    if (!declaringType.IsActualInterface)
                     {
                         while (RuntimeTypeHandle.IsGenericVariable(declaringType))
                             declaringType = declaringType.GetBaseType()!;
@@ -1258,8 +1258,8 @@ private void PopulateProperties(
 
                     int numVirtuals = RuntimeTypeHandle.GetNumVirtuals(declaringType);
 
-                    Debug.Assert((declaringType.IsInterface && isInterface && csPropertyInfos == null) ||
-                                 (!declaringType.IsInterface && !isInterface && usedSlots.Length >= numVirtuals));
+                    Debug.Assert((declaringType.IsActualInterface && isInterface && csPropertyInfos == null) ||
+                                 (!declaringType.IsActualInterface && !isInterface && usedSlots.Length >= numVirtuals));
 
                     for (int i = 0; i < tkProperties.Length; i++)
                     {
@@ -2697,7 +2697,7 @@ public override InterfaceMapping GetInterfaceMap([DynamicallyAccessedMembers(Dyn
 
             TypeHandle.VerifyInterfaceIsImplemented(ifaceRtTypeHandle);
             Debug.Assert(interfaceType.IsInterface);  // VerifyInterfaceIsImplemented enforces this invariant
-            Debug.Assert(!IsInterface); // VerifyInterfaceIsImplemented enforces this invariant
+            Debug.Assert(!IsActualInterface); // VerifyInterfaceIsImplemented enforces this invariant
 
             // SZArrays implement the methods on IList`1, IEnumerable`1, and ICollection`1 with
             // SZArrayHelper and some runtime magic. We don't have accurate interface maps for them.
@@ -2739,7 +2739,7 @@ public override InterfaceMapping GetInterfaceMap([DynamicallyAccessedMembers(Dyn
 
                 // If we resolved to an interface method, use the interface type as reflected type. Otherwise use `this`.
                 RuntimeType reflectedType = RuntimeMethodHandle.GetDeclaringType(classRtMethodHandle);
-                if (!reflectedType.IsInterface)
+                if (!reflectedType.IsActualInterface)
                     reflectedType = this;
 
                 // GetMethodBase will convert this to the instantiating/unboxing stub if necessary
@@ -3432,7 +3432,7 @@ internal unsafe bool IsActualEnum
             }
         }
 
-        internal new unsafe bool IsInterface
+        internal unsafe bool IsActualInterface
         {
             get
             {
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
@@ -186,7 +186,7 @@
     <Compile Include="System\MathF.NativeAot.cs" />
     <Compile Include="System\Object.NativeAot.cs" />
     <Compile Include="System\RuntimeArgumentHandle.cs" />
-    <Compile Include="System\RuntimeType.cs" />
+    <Compile Include="System\RuntimeType.NativeAot.cs" />
     <Compile Include="System\Runtime\ControlledExecution.NativeAot.cs" />
     <Compile Include="System\Runtime\DependentHandle.cs" />
     <Compile Include="System\Runtime\CompilerServices\EagerStaticClassConstructionAttribute.cs" />
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/RuntimeType.NativeAot.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/RuntimeType.NativeAot.cs
@@ -213,7 +213,7 @@ public override RuntimeTypeHandle TypeHandle
             }
         }
 
-        internal new unsafe bool IsInterface
+        internal unsafe bool IsActualInterface
         {
             get
             {
diff --git a/src/libraries/System.Private.CoreLib/src/System/Reflection/Emit/DynamicMethod.cs b/src/libraries/System.Private.CoreLib/src/System/Reflection/Emit/DynamicMethod.cs
@@ -269,7 +269,7 @@ private void Init(string name,
                     if (owner?.UnderlyingSystemType is RuntimeType rtOwner)
                     {
                         if (rtOwner.HasElementType || rtOwner.ContainsGenericParameters
-                            || rtOwner.IsGenericParameter || rtOwner.IsInterface)
+                            || rtOwner.IsGenericParameter || rtOwner.IsActualInterface)
                             throw new ArgumentException(SR.Argument_InvalidTypeForDynamicMethod);
 
                         _typeOwner = rtOwner;
diff --git a/src/libraries/System.Private.CoreLib/src/System/RuntimeType.cs b/src/libraries/System.Private.CoreLib/src/System/RuntimeType.cs
@@ -297,7 +297,7 @@ public override bool IsAssignableFrom([NotNullWhen(true)] Type? c)
                 if (c.IsSubclassOf(this))
                     return true;
 
-                if (IsInterface)
+                if (IsActualInterface)
                 {
                     return c.ImplementInterface(this);
                 }
@@ -711,7 +711,7 @@ public override bool IsAssignableFrom([NotNullWhen(true)] Type? c)
         // `class G3<T,U> where T:U where U:Stream`: typeof(G3<,>).GetGenericArguments()[0].BaseType is Object (!)
         private RuntimeType? GetBaseType()
         {
-            if (IsInterface)
+            if (IsActualInterface)
                 return null;
 
             if (RuntimeTypeHandle.IsGenericVariable(this))
@@ -724,7 +724,7 @@ public override bool IsAssignableFrom([NotNullWhen(true)] Type? c)
                 {
                     RuntimeType constraint = (RuntimeType)constraints[i];
 
-                    if (constraint.IsInterface)
+                    if (constraint.IsActualInterface)
                         continue;
 
                     if (constraint.IsGenericParameter)
diff --git a/src/libraries/System.Private.CoreLib/src/System/Type.cs b/src/libraries/System.Private.CoreLib/src/System/Type.cs
@@ -33,7 +33,7 @@ public bool IsInterface
             {
 #if !MONO
                 if (this is RuntimeType rt)
-                    return rt.IsInterface;
+                    return rt.IsActualInterface;
 #endif
                 return (GetAttributeFlagsImpl() & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Interface;
             }
diff --git a/src/mono/System.Private.CoreLib/src/System/RuntimeType.Mono.cs b/src/mono/System.Private.CoreLib/src/System/RuntimeType.Mono.cs
@@ -1321,6 +1321,8 @@ protected override bool IsValueTypeImpl()
             return res;
         }
 
+        internal bool IsActualInterface => IsInterface;
+
         // Returns true for actual value types only, ignoring generic parameter constraints.
         internal bool IsActualValueType => RuntimeTypeHandle.IsValueType(this);
 

Original file line number	Diff line number	Diff line change
`@@ -105,7 +105,7 @@ Signature LazyCreateSignature()`
`105`	`105`
`106`	`106`	`internal RuntimeMethodInfo? GetParentDefinition()`
`107`	`107`	`{`
`108`		`- if (!IsVirtual \|\| m_declaringType.IsInterface)`
	`108`	`+ if (!IsVirtual \|\| m_declaringType.IsActualInterface)`
`109`	`109`	`return null;`
`110`	`110`
`111`	`111`	`RuntimeType? parent = (RuntimeType?)m_declaringType.BaseType;`
`@@ -323,7 +323,7 @@ internal void InvokePropertySetter(object? obj, BindingFlags invokeAttr, Binder?`
`323`	`323`
`324`	`324`	`public override MethodInfo GetBaseDefinition()`
`325`	`325`	`{`
`326`		`- if (!IsVirtual \|\| IsStatic \|\| m_declaringType == null \|\| m_declaringType.IsInterface)`
	`326`	`+ if (!IsVirtual \|\| IsStatic \|\| m_declaringType == null \|\| m_declaringType.IsActualInterface)`
`327`	`327`	`return this;`
`328`	`328`
`329`	`329`	`int slot = RuntimeMethodHandle.GetSlot(this);`
Original file line number	Diff line number	Diff line change
`@@ -579,7 +579,7 @@ private unsafe RuntimeMethodInfo[] PopulateMethods(Filter filter)`
`579`	`579`	`RuntimeType declaringType = ReflectedType;`
`580`	`580`	`Debug.Assert(declaringType != null);`
`581`	`581`
`582`		`- if (declaringType.IsInterface)`
	`582`	`+ if (declaringType.IsActualInterface)`
`583`	`583`	`{`
`584`	`584`	`#region IsInterface`
`585`	`585`
`@@ -998,7 +998,7 @@ private RuntimeType[] PopulateInterfaces(Filter filter)`
`998`	`998`	`continue;`
`999`	`999`	`}`
`1000`	`1000`
`1001`		`- Debug.Assert(interfaceType.IsInterface);`
	`1001`	`+ Debug.Assert(interfaceType.IsActualInterface);`
`1002`	`1002`	`list.Add(interfaceType);`
`1003`	`1003`	`}`
`1004`	`1004`
`@@ -1028,7 +1028,7 @@ private RuntimeType[] PopulateInterfaces(Filter filter)`
`1028`	`1028`	`for (int i = 0; i < constraints.Length; i++)`
`1029`	`1029`	`{`
`1030`	`1030`	`RuntimeType constraint = (RuntimeType)constraints[i];`
`1031`		`- if (constraint.IsInterface)`
	`1031`	`+ if (constraint.IsActualInterface)`
`1032`	`1032`	`al.Add(constraint);`
`1033`	`1033`
`1034`	`1034`	`Type[] temp = constraint.GetInterfaces();`
`@@ -1113,7 +1113,7 @@ private RuntimeEventInfo[] PopulateEvents(Filter filter)`
`1113`	`1113`	`RuntimeType declaringType = ReflectedType;`
`1114`	`1114`	`ListBuilder<RuntimeEventInfo> list = default;`
`1115`	`1115`
`1116`		`- if (!declaringType.IsInterface)`
	`1116`	`+ if (!declaringType.IsActualInterface)`
`1117`	`1117`	`{`
`1118`	`1118`	`while (RuntimeTypeHandle.IsGenericVariable(declaringType))`
`1119`	`1119`	`declaringType = declaringType.GetBaseType()!;`
`@@ -1206,7 +1206,7 @@ private RuntimePropertyInfo[] PopulateProperties(Filter filter)`
`1206`	`1206`
`1207`	`1207`	`ListBuilder<RuntimePropertyInfo> list = default;`
`1208`	`1208`
`1209`		`- if (!declaringType.IsInterface)`
	`1209`	`+ if (!declaringType.IsActualInterface)`
`1210`	`1210`	`{`
`1211`	`1211`	`while (RuntimeTypeHandle.IsGenericVariable(declaringType))`
`1212`	`1212`	`declaringType = declaringType.GetBaseType()!;`
`@@ -1258,8 +1258,8 @@ private void PopulateProperties(`
`1258`	`1258`
`1259`	`1259`	`int numVirtuals = RuntimeTypeHandle.GetNumVirtuals(declaringType);`
`1260`	`1260`
`1261`		`- Debug.Assert((declaringType.IsInterface && isInterface && csPropertyInfos == null) \|\|`
`1262`		`- (!declaringType.IsInterface && !isInterface && usedSlots.Length >= numVirtuals));`
	`1261`	`+ Debug.Assert((declaringType.IsActualInterface && isInterface && csPropertyInfos == null) \|\|`
	`1262`	`+ (!declaringType.IsActualInterface && !isInterface && usedSlots.Length >= numVirtuals));`
`1263`	`1263`
`1264`	`1264`	`for (int i = 0; i < tkProperties.Length; i++)`
`1265`	`1265`	`{`
`@@ -2697,7 +2697,7 @@ public override InterfaceMapping GetInterfaceMap([DynamicallyAccessedMembers(Dyn`
`2697`	`2697`
`2698`	`2698`	`TypeHandle.VerifyInterfaceIsImplemented(ifaceRtTypeHandle);`
`2699`	`2699`	`Debug.Assert(interfaceType.IsInterface); // VerifyInterfaceIsImplemented enforces this invariant`
`2700`		`- Debug.Assert(!IsInterface); // VerifyInterfaceIsImplemented enforces this invariant`
	`2700`	`+ Debug.Assert(!IsActualInterface); // VerifyInterfaceIsImplemented enforces this invariant`
`2701`	`2701`
`2702`	`2702`	// SZArrays implement the methods on IList`1, IEnumerable`1, and ICollection`1 with
`2703`	`2703`	`// SZArrayHelper and some runtime magic. We don't have accurate interface maps for them.`
`@@ -2739,7 +2739,7 @@ public override InterfaceMapping GetInterfaceMap([DynamicallyAccessedMembers(Dyn`
`2739`	`2739`
`2740`	`2740`	// If we resolved to an interface method, use the interface type as reflected type. Otherwise use `this`.
`2741`	`2741`	`RuntimeType reflectedType = RuntimeMethodHandle.GetDeclaringType(classRtMethodHandle);`
`2742`		`- if (!reflectedType.IsInterface)`
	`2742`	`+ if (!reflectedType.IsActualInterface)`
`2743`	`2743`	`reflectedType = this;`
`2744`	`2744`
`2745`	`2745`	`// GetMethodBase will convert this to the instantiating/unboxing stub if necessary`
`@@ -3432,7 +3432,7 @@ internal unsafe bool IsActualEnum`
`3432`	`3432`	`}`
`3433`	`3433`	`}`
`3434`	`3434`
`3435`		`- internal new unsafe bool IsInterface`
	`3435`	`+ internal unsafe bool IsActualInterface`
`3436`	`3436`	`{`
`3437`	`3437`	`get`
`3438`	`3438`	`{`
Original file line number	Diff line number	Diff line change
`@@ -213,7 +213,7 @@ public override RuntimeTypeHandle TypeHandle`
`213`	`213`	`}`
`214`	`214`	`}`
`215`	`215`
`216`		`- internal new unsafe bool IsInterface`
	`216`	`+ internal unsafe bool IsActualInterface`
`217`	`217`	`{`
`218`	`218`	`get`
`219`	`219`	`{`
Original file line number	Diff line number	Diff line change
`@@ -269,7 +269,7 @@ private void Init(string name,`
`269`	`269`	`if (owner?.UnderlyingSystemType is RuntimeType rtOwner)`
`270`	`270`	`{`
`271`	`271`	`if (rtOwner.HasElementType \|\| rtOwner.ContainsGenericParameters`
`272`		`- \|\| rtOwner.IsGenericParameter \|\| rtOwner.IsInterface)`
	`272`	`+ \|\| rtOwner.IsGenericParameter \|\| rtOwner.IsActualInterface)`
`273`	`273`	`throw new ArgumentException(SR.Argument_InvalidTypeForDynamicMethod);`
`274`	`274`
`275`	`275`	`_typeOwner = rtOwner;`
Original file line number	Diff line number	Diff line change
`@@ -297,7 +297,7 @@ public override bool IsAssignableFrom([NotNullWhen(true)] Type? c)`
`297`	`297`	`if (c.IsSubclassOf(this))`
`298`	`298`	`return true;`
`299`	`299`
`300`		`- if (IsInterface)`
	`300`	`+ if (IsActualInterface)`
`301`	`301`	`{`
`302`	`302`	`return c.ImplementInterface(this);`
`303`	`303`	`}`
`@@ -711,7 +711,7 @@ public override bool IsAssignableFrom([NotNullWhen(true)] Type? c)`
`711`	`711`	// `class G3<T,U> where T:U where U:Stream`: typeof(G3<,>).GetGenericArguments()[0].BaseType is Object (!)
`712`	`712`	`private RuntimeType? GetBaseType()`
`713`	`713`	`{`
`714`		`- if (IsInterface)`
	`714`	`+ if (IsActualInterface)`
`715`	`715`	`return null;`
`716`	`716`
`717`	`717`	`if (RuntimeTypeHandle.IsGenericVariable(this))`
`@@ -724,7 +724,7 @@ public override bool IsAssignableFrom([NotNullWhen(true)] Type? c)`
`724`	`724`	`{`
`725`	`725`	`RuntimeType constraint = (RuntimeType)constraints[i];`
`726`	`726`
`727`		`- if (constraint.IsInterface)`
	`727`	`+ if (constraint.IsActualInterface)`
`728`	`728`	`continue;`
`729`	`729`
`730`	`730`	`if (constraint.IsGenericParameter)`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ public bool IsInterface`
`33`	`33`	`{`
`34`	`34`	`#if !MONO`
`35`	`35`	`if (this is RuntimeType rt)`
`36`		`- return rt.IsInterface;`
	`36`	`+ return rt.IsActualInterface;`
`37`	`37`	`#endif`
`38`	`38`	`return (GetAttributeFlagsImpl() & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Interface;`
`39`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1321,6 +1321,8 @@ protected override bool IsValueTypeImpl()`
`1321`	`1321`	`return res;`
`1322`	`1322`	`}`
`1323`	`1323`
	`1324`	`+ internal bool IsActualInterface => IsInterface;`
	`1325`	`+`
`1324`	`1326`	`// Returns true for actual value types only, ignoring generic parameter constraints.`
`1325`	`1327`	`internal bool IsActualValueType => RuntimeTypeHandle.IsValueType(this);`
`1326`	`1328`