Delete Type.GetTypeHandleInternal (#59459)

Never-overriden virtual method forwarding to virtual property.

diff --git a/src/coreclr/System.Private.CoreLib/src/System/Enum.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Enum.CoreCLR.cs
index 3808942..bdf3a71 100644 (file)
--- a/src/coreclr/System.Private.CoreLib/src/System/Enum.CoreCLR.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Enum.CoreCLR.cs
@@ -36,7 +36,7 @@ namespace System
             {
                 ulong[]? values = null;
                 string[]? names = null;
-                RuntimeTypeHandle enumTypeHandle = enumType.GetTypeHandleInternal();
+                RuntimeTypeHandle enumTypeHandle = enumType.TypeHandle;
                 GetEnumValuesAndNames(
                     new QCallTypeHandle(ref enumTypeHandle),
                     ObjectHandleOnStack.Create(ref values),

diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Associates.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Associates.cs
index 6a39fad..cef6b99 100644 (file)
--- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Associates.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Associates.cs
@@ -52,14 +52,14 @@ namespace System.Reflection
 
             IntPtr[]? genericArgumentHandles = null;
             int genericArgumentCount = 0;
-            RuntimeType[] genericArguments = declaredType.GetTypeHandleInternal().GetInstantiationInternal();
+            RuntimeType[] genericArguments = declaredType.TypeHandle.GetInstantiationInternal();
             if (genericArguments != null)
             {
                 genericArgumentCount = genericArguments.Length;
                 genericArgumentHandles = new IntPtr[genericArguments.Length];
                 for (int i = 0; i < genericArguments.Length; i++)
                 {
-                    genericArgumentHandles[i] = genericArguments[i].GetTypeHandleInternal().Value;
+                    genericArgumentHandles[i] = genericArguments[i].TypeHandle.Value;
                 }
             }
 

diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicILGenerator.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicILGenerator.cs
index ca5acd0..fbbeaa5 100644 (file)
--- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicILGenerator.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicILGenerator.cs
@@ -820,7 +820,7 @@ namespace System.Reflection.Emit
                 if (vaMeth.m_dynamicMethod == null)
                 {
                     methodHandle = vaMeth.m_method!.MethodHandle.Value;
-                    typeHandle = vaMeth.m_method.GetDeclaringTypeInternal().GetTypeHandleInternal().Value;
+                    typeHandle = vaMeth.m_method.GetDeclaringTypeInternal().TypeHandle.Value;
                 }
                 else
                 {

diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/ModuleBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/ModuleBuilder.cs
index 65066ab..6559b2e 100644 (file)
--- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/ModuleBuilder.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/ModuleBuilder.cs
@@ -1464,12 +1464,12 @@ namespace System.Reflection.Emit
                 {
                     byte[] sig = SignatureHelper.GetTypeSigToken(this, field.DeclaringType).InternalGetSignature(out int length);
                     tr = GetTokenFromTypeSpec(sig, length);
-                    mr = GetMemberRefOfFieldInfo(tr, field.DeclaringType.GetTypeHandleInternal(), rtField);
+                    mr = GetMemberRefOfFieldInfo(tr, field.DeclaringType.TypeHandle, rtField);
                 }
                 else
                 {
                     tr = GetTypeTokenInternal(field.DeclaringType!);
-                    mr = GetMemberRefOfFieldInfo(tr, field.DeclaringType!.GetTypeHandleInternal(), rtField);
+                    mr = GetMemberRefOfFieldInfo(tr, field.DeclaringType!.TypeHandle, rtField);
                 }
             }
             else if (field is FieldOnTypeBuilderInstantiation fOnTB)

diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/SignatureHelper.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/SignatureHelper.cs
index 6bc5be5..9dd3a2f 100644 (file)
--- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/SignatureHelper.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/SignatureHelper.cs
@@ -553,7 +553,7 @@ namespace System.Reflection.Emit
 
             AddElementType(CorElementType.ELEMENT_TYPE_INTERNAL);
 
-            IntPtr handle = type.GetTypeHandleInternal().Value;
+            IntPtr handle = type.TypeHandle.Value;
 
             // Internal types must have their pointer written into the signature directly (we don't
             // want to convert to little-endian format on big-endian machines because the value is

diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdFieldInfo.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdFieldInfo.cs
index 7d5a8f9..fcc1845 100644 (file)
--- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdFieldInfo.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdFieldInfo.cs
@@ -33,8 +33,8 @@ namespace System.Reflection
             return
                 o is MdFieldInfo m &&
                 m.m_tkField == m_tkField &&
-                m_declaringType.GetTypeHandleInternal().GetModuleHandle().Equals(
-                    m.m_declaringType.GetTypeHandleInternal().GetModuleHandle());
+                m_declaringType.TypeHandle.GetModuleHandle().Equals(
+                    m.m_declaringType.TypeHandle.GetModuleHandle());
         }
         #endregion
 
@@ -80,7 +80,7 @@ namespace System.Reflection
         {
             // Cannot cache these because they could be user defined non-agile enumerations
 
-            object? value = MdConstant.GetValue(GetRuntimeModule().MetadataImport, m_tkField, FieldType.GetTypeHandleInternal(), raw);
+            object? value = MdConstant.GetValue(GetRuntimeModule().MetadataImport, m_tkField, FieldType.TypeHandle, raw);
 
             if (value == DBNull.Value)
                 throw new NotSupportedException(SR.Arg_EnumLitValueNotFound);

diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeModule.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeModule.cs
index 6c755ed..74849de 100644 (file)
--- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeModule.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeModule.cs
@@ -53,7 +53,7 @@ namespace System.Reflection
                     throw new ArgumentException(SR.Argument_InvalidGenericInstArray);
                 if (!(typeArg is RuntimeType))
                     throw new ArgumentException(SR.Argument_InvalidGenericInstArray);
-                typeHandleArgs[i] = typeArg.GetTypeHandleInternal();
+                typeHandleArgs[i] = typeArg.TypeHandle;
             }
             return typeHandleArgs;
         }

diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeParameterInfo.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeParameterInfo.cs
index 7f81cec..173caf6 100644 (file)
--- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeParameterInfo.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeParameterInfo.cs
@@ -338,7 +338,7 @@ namespace System.Reflection
             if (!MdToken.IsNullToken(m_tkParamDef))
             {
                 // This will return DBNull.Value if no constant value is defined on m_tkParamDef in the metadata.
-                defaultValue = MdConstant.GetValue(m_scope, m_tkParamDef, ParameterType.GetTypeHandleInternal(), raw);
+                defaultValue = MdConstant.GetValue(m_scope, m_tkParamDef, ParameterType.TypeHandle, raw);
             }
             #endregion
 

diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimePropertyInfo.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimePropertyInfo.cs
index 7300afa..a768a98 100644 (file)
--- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimePropertyInfo.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimePropertyInfo.cs
@@ -199,7 +199,7 @@ namespace System.Reflection
 
         internal object GetConstantValue(bool raw)
         {
-            object? defaultValue = MdConstant.GetValue(GetRuntimeModule().MetadataImport, m_token, PropertyType.GetTypeHandleInternal(), raw);
+            object? defaultValue = MdConstant.GetValue(GetRuntimeModule().MetadataImport, m_token, PropertyType.TypeHandle, raw);
 
             if (defaultValue == DBNull.Value)
                 // Arg_EnumLitValueNotFound -> "Literal value was not found."

diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs
index 653af42..e753b47 100644 (file)
--- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs
@@ -206,7 +206,7 @@ namespace System
             IntPtr[] outHandles = new IntPtr[inHandles.Length];
             for (int i = 0; i < inHandles.Length; i++)
             {
-                outHandles[i] = inHandles[i].GetTypeHandleInternal().Value;
+                outHandles[i] = inHandles[i].TypeHandle.Value;
             }
             length = outHandles.Length;
             return outHandles;
@@ -221,7 +221,7 @@ namespace System
 
             object? instantiatedObject = null;
 
-            IntPtr typeHandle = genericParameter.GetTypeHandleInternal().Value;
+            IntPtr typeHandle = genericParameter.TypeHandle.Value;
             CreateInstanceForAnotherGenericParameter(
                 new QCallTypeHandle(ref type),
                 &typeHandle,
@@ -244,8 +244,8 @@ namespace System
 
             IntPtr* pTypeHandles = stackalloc IntPtr[]
             {
-                genericParameter1.GetTypeHandleInternal().Value,
-                genericParameter2.GetTypeHandleInternal().Value
+                genericParameter1.TypeHandle.Value,
+                genericParameter2.TypeHandle.Value
             };
 
             CreateInstanceForAnotherGenericParameter(
@@ -673,7 +673,7 @@ namespace System
 
             if (HasInstantiation(retType) && !IsGenericTypeDefinition(retType))
             {
-                RuntimeTypeHandle nativeHandle = retType.GetTypeHandleInternal();
+                RuntimeTypeHandle nativeHandle = retType.TypeHandle;
                 GetGenericTypeDefinition(new QCallTypeHandle(ref nativeHandle), ObjectHandleOnStack.Create(ref retType));
             }
 

diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs
index c31be88..13ea8bf 100644 (file)
--- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs
@@ -980,7 +980,7 @@ namespace System
                             #endregion
 
                             RuntimeFieldInfo runtimeFieldInfo =
-                            new MdFieldInfo(tkField, fieldAttributes, declaringType.GetTypeHandleInternal(), m_runtimeTypeCache, bindingFlags);
+                            new MdFieldInfo(tkField, fieldAttributes, declaringType.TypeHandle, m_runtimeTypeCache, bindingFlags);
 
                             list.Add(runtimeFieldInfo);
                         }
@@ -1967,7 +1967,7 @@ namespace System
                 RuntimeType? declaringType = (RuntimeType?)genericMethodDefinition.DeclaringType;
                 if (declaringType != null)
                 {
-                    typeContext = declaringType.GetTypeHandleInternal().GetInstantiationInternal();
+                    typeContext = declaringType.TypeHandle.GetInstantiationInternal();
                 }
             }
 
@@ -1976,8 +1976,8 @@ namespace System
                 Type genericArgument = genericArguments[i];
                 Type genericParameter = genericParameters[i];
 
-                if (!RuntimeTypeHandle.SatisfiesConstraints(genericParameter.GetTypeHandleInternal().GetTypeChecked(),
-                    typeContext, methodContext, genericArgument.GetTypeHandleInternal().GetTypeChecked()))
+                if (!RuntimeTypeHandle.SatisfiesConstraints(genericParameter.TypeHandle.GetTypeChecked(),
+                    typeContext, methodContext, genericArgument.TypeHandle.GetTypeChecked()))
                 {
                     throw new ArgumentException(
                         SR.Format(SR.Argument_GenConstraintViolation, i.ToString(), genericArgument, definition, genericParameter), e);
@@ -2679,9 +2679,9 @@ namespace System
             if (ifaceRtType == null)
                 throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(ifaceType));
 
-            RuntimeTypeHandle ifaceRtTypeHandle = ifaceRtType.GetTypeHandleInternal();
+            RuntimeTypeHandle ifaceRtTypeHandle = ifaceRtType.TypeHandle;
 
-            GetTypeHandleInternal().VerifyInterfaceIsImplemented(ifaceRtTypeHandle);
+            TypeHandle.VerifyInterfaceIsImplemented(ifaceRtTypeHandle);
             Debug.Assert(ifaceType.IsInterface);  // VerifyInterfaceIsImplemented enforces this invariant
             Debug.Assert(!IsInterface); // VerifyInterfaceIsImplemented enforces this invariant
 
@@ -2708,7 +2708,7 @@ namespace System
                 im.InterfaceMethods[i] = (MethodInfo)ifaceMethodBase;
 
                 // If the impl is null, then virtual stub dispatch is active.
-                RuntimeMethodHandleInternal classRtMethodHandle = GetTypeHandleInternal().GetInterfaceMethodImplementation(ifaceRtTypeHandle, ifaceRtMethodHandle);
+                RuntimeMethodHandleInternal classRtMethodHandle = TypeHandle.GetInterfaceMethodImplementation(ifaceRtTypeHandle, ifaceRtMethodHandle);
 
                 if (classRtMethodHandle.IsNullHandle())
                     continue;
@@ -3344,12 +3344,12 @@ namespace System
         #region Generics
         internal RuntimeType[] GetGenericArgumentsInternal()
         {
-            return GetRootElementType().GetTypeHandleInternal().GetInstantiationInternal();
+            return GetRootElementType().TypeHandle.GetInstantiationInternal();
         }
 
         public override Type[] GetGenericArguments()
         {
-            Type[] types = GetRootElementType().GetTypeHandleInternal().GetInstantiationPublic();
+            Type[] types = GetRootElementType().TypeHandle.GetInstantiationPublic();
             return types ?? Type.EmptyTypes;
         }
 
@@ -3440,7 +3440,7 @@ namespace System
         }
 
         public override bool ContainsGenericParameters =>
-            GetRootElementType().GetTypeHandleInternal().ContainsGenericVariables();
+            GetRootElementType().TypeHandle.ContainsGenericVariables();
 
         public override Type[] GetGenericParameterConstraints()
         {

diff --git a/src/coreclr/System.Private.CoreLib/src/System/Type.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Type.CoreCLR.cs
index adeed9c..e5b379d 100644 (file)
--- a/src/coreclr/System.Private.CoreLib/src/System/Type.CoreCLR.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Type.CoreCLR.cs
@@ -81,11 +81,6 @@ namespace System
             return TypeNameParser.GetType(typeName, assemblyResolver, typeResolver, throwOnError, ignoreCase, ref stackMark);
         }
 
-        internal virtual RuntimeTypeHandle GetTypeHandleInternal()
-        {
-            return TypeHandle;
-        }
-
         // Given a class handle, this will return the class for that handle.
         [MethodImpl(MethodImplOptions.InternalCall)]
         internal static extern RuntimeType GetTypeFromHandleUnsafe(IntPtr handle);