Move tests into separate classes; other misc non-functional

src/coreclr/System.Private.CoreLib/src/System/Reflection/ModifiedType.CoreCLR.cs

@@ -15,7 +15,7 @@ internal Type GetTypeParameter(Type unmodifiedType, int index) =>
             Create(unmodifiedType, new TypeSignature()
             {
                 _signature = _typeSignature._signature,
-                _offset = _typeSignature._signature?.GetTypeParameterFromOffset(_typeSignature._offset, index) ?? 0
+                _offset = _typeSignature._signature?.GetTypeParameterOffset(_typeSignature._offset, index) ?? 0
             });
 
         internal SignatureCallingConvention GetCallingConventionFromFunctionPointer() =>

src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs

@@ -1641,7 +1641,7 @@ internal Type[] GetCustomModifiers(int parameterIndex, bool required) =>
         internal extern int GetParameterOffset(int parameterIndex);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal extern int GetTypeParameterFromOffset(int offset, int index);
+        internal extern int GetTypeParameterOffset(int offset, int index);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         internal extern SignatureCallingConvention GetCallingConventionFromFunctionPointerAtOffset(int offset);

src/coreclr/vm/ecalllist.h

@@ -206,7 +206,7 @@ FCFuncStart(gSignatureNative)
     FCFuncElement("GetSignature", SignatureNative::GetSignature)
     FCFuncElement("CompareSig", SignatureNative::CompareSig)
     FCFuncElement("GetParameterOffset", SignatureNative::GetParameterOffset)
-    FCFuncElement("GetTypeParameterFromOffset", SignatureNative::GetTypeParameterFromOffset)
+    FCFuncElement("GetTypeParameterOffset", SignatureNative::GetTypeParameterOffset)
     FCFuncElement("GetCustomModifiersAtOffset", SignatureNative::GetCustomModifiersAtOffset)
     FCFuncElement("GetCallingConventionFromFunctionPointerAtOffset", SignatureNative::GetCallingConventionFromFunctionPointerAtOffset)
 FCFuncEnd()

src/coreclr/vm/runtimehandles.cpp

@@ -1867,7 +1867,7 @@ FCIMPL2(INT32, SignatureNative::GetParameterOffset, SignatureNative* pSignatureU
 }
 FCIMPLEND
 
-FCIMPL3(INT32, SignatureNative::GetTypeParameterFromOffset, SignatureNative* pSignatureUNSAFE, INT32 offset, INT32 index)
+FCIMPL3(INT32, SignatureNative::GetTypeParameterOffset, SignatureNative* pSignatureUNSAFE, INT32 offset, INT32 index)
 {
     FCALL_CONTRACT;
 

src/coreclr/vm/runtimehandles.h

@@ -379,7 +379,7 @@ class SignatureNative : public Object
 
     static FCDECL2(INT32, GetParameterOffset, SignatureNative* pSig, INT32 parameterIndex);
 
-    static FCDECL3(INT32, GetTypeParameterFromOffset, SignatureNative* pSig, INT32 offset, INT32 index);
+    static FCDECL3(INT32, GetTypeParameterOffset, SignatureNative* pSig, INT32 offset, INT32 index);
 
     static FCDECL2(FC_INT8_RET, GetCallingConventionFromFunctionPointerAtOffset, SignatureNative* pSig, INT32 offset);
 

src/libraries/Common/tests/System/FunctionPointerTests.CallingConventions.cs → src/libraries/Common/tests/System/FunctionPointerCallingConventionTests.cs

@@ -8,8 +8,10 @@
 
 namespace System.Tests.Types
 {
-    public partial class FunctionPointerTests
+    public partial class FunctionPointerCallingConventionTests
     {
+        private const BindingFlags Bindings = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly;
+
         [Theory]
         [InlineData(true)]
         [InlineData(false)]
@@ -166,11 +168,31 @@ public static unsafe void UnmanagedCallConv_PhysicalModifiers_Modified(string me
             Assert.Equal(0, returnType.GetRequiredCustomModifiers().Length);
         }
 
-        public unsafe partial class FunctionPointerHolder
+        [Fact]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/71095", TestRuntimes.Mono)]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/71883", typeof(PlatformDetection), nameof(PlatformDetection.IsNativeAot))]
+        public static unsafe void GenericTypeParameter()
+        {
+            Type holder = typeof(FunctionPointerHolder).Project();
+            FieldInfo f = holder.GetField(nameof(FunctionPointerHolder._genericType), Bindings);
+            Type propType = f.FieldType.GetProperty("MyProp").GetModifiedPropertyType();
+
+            // Requires skipping past the return parameter metadata in order to get to the metadata for the first parameter.
+            Type paramType = propType.GetFunctionPointerParameterTypes()[1];
+            Type[] cc = paramType.GetFunctionPointerCallingConventions();
+            Assert.Equal(1, cc.Length);
+            Assert.Equal(typeof(CallConvCdecl).Project(), cc[0]);
+        }
+
+        private unsafe partial class FunctionPointerHolder
         {
             public delegate* unmanaged[Cdecl, MemberFunction]<int> MethodUnmanagedReturnValue_DifferentCallingConventions1() => default;
             public delegate* unmanaged[Stdcall, MemberFunction]<int> MethodUnmanagedReturnValue_DifferentCallingConventions2() => default;
 
+#pragma warning disable 0649
+            public MyGenericClass<delegate*<int, int, int>[]> _genericType;
+#pragma warning restore 0649
+
             // Methods to verify calling conventions and synthesized modopts.
             // The non-SuppressGCTransition variants are encoded with the CallKind byte.
             // The SuppressGCTransition variants are encoded as modopts (CallKind is "Unmananged").
@@ -183,6 +205,13 @@ public void MethodCallConv_Thiscall(delegate* unmanaged[Thiscall]<void> f) { }
             public void MethodCallConv_Thiscall_SuppressGCTransition(delegate* unmanaged[Thiscall, SuppressGCTransition]<void> f) { }
             public void MethodCallConv_Fastcall(delegate* unmanaged[Fastcall]<void> f) { }
             public void MethodCallConv_Fastcall_SuppressGCTransition(delegate* unmanaged[Fastcall, SuppressGCTransition]<void> f) { }
+
+            public class MyClass { }
+
+            public unsafe class MyGenericClass<T>
+            {
+                public delegate*<T, delegate* unmanaged[Cdecl]<void>, void> MyProp { get; }
+            }
         }
     }
 }

src/libraries/Common/tests/System/FunctionPointerTests.Identity.cs → src/libraries/Common/tests/System/FunctionPointerEqualityTests.cs

@@ -10,12 +10,14 @@ namespace System.Tests.Types
     // Also see ModifiedTypeTests which tests custom modifiers.
     // Unmodified Type instances are cached and keyed by the runtime.
     // Modified Type instances are created for each member.
-    public partial class FunctionPointerTests
+    public partial class FunctionPointerEqualityTests
     {
+        private const BindingFlags Bindings = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly;
+
         [Fact]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/71095", TestRuntimes.Mono)]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/71883", typeof(PlatformDetection), nameof(PlatformDetection.IsNativeAot))]
-        public static unsafe void FunctionUnmanagedPointerReturn_DifferentReturnValue()
+        public static unsafe void DifferentReturnValue()
         {
             Type t = typeof(FunctionPointerHolder).Project();
 
@@ -34,7 +36,7 @@ public static unsafe void FunctionUnmanagedPointerReturn_DifferentReturnValue()
         [InlineData(nameof(FunctionPointerHolder.Field_DateOnly), nameof(FunctionPointerHolder.Field_Int))]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/71095", TestRuntimes.Mono)]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/71883", typeof(PlatformDetection), nameof(PlatformDetection.IsNativeAot))]
-        public static unsafe void SigEqualityInDifferentModule_Field(string name, string otherName)
+        public static unsafe void SigInDifferentModule_Field(string name, string otherName)
         {
             Type fph1 = typeof(FunctionPointerHolder).Project();
             Type fph2 = typeof(FunctionPointerHolderSeparateModule).Project();
@@ -54,7 +56,7 @@ public static unsafe void SigEqualityInDifferentModule_Field(string name, string
         [InlineData(nameof(FunctionPointerHolder.Prop_DateOnly), nameof(FunctionPointerHolder.Prop_Int))]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/71095", TestRuntimes.Mono)]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/71883", typeof(PlatformDetection), nameof(PlatformDetection.IsNativeAot))]
-        public static unsafe void SigEqualityInDifferentModule_Property(string name, string otherName)
+        public static unsafe void SigInDifferentModule_Property(string name, string otherName)
         {
             Type fph1 = typeof(FunctionPointerHolder).Project();
             Type fph2 = typeof(FunctionPointerHolderSeparateModule).Project();
@@ -74,7 +76,7 @@ public static unsafe void SigEqualityInDifferentModule_Property(string name, str
         [InlineData(nameof(FunctionPointerHolder.MethodReturnValue_DateOnly), nameof(FunctionPointerHolder.MethodReturnValue_Int))]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/71095", TestRuntimes.Mono)]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/71883", typeof(PlatformDetection), nameof(PlatformDetection.IsNativeAot))]
-        public static unsafe void SigEqualityInDifferentModule_MethodReturn(string name, string otherName)
+        public static unsafe void SigInDifferentModule_MethodReturn(string name, string otherName)
         {
             Type fph1 = typeof(FunctionPointerHolder).Project();
             Type fph2 = typeof(FunctionPointerHolderSeparateModule).Project();
@@ -96,7 +98,7 @@ public static unsafe void SigEqualityInDifferentModule_MethodReturn(string name,
         [InlineData(nameof(FunctionPointerHolder.MethodCallConv_Cdecl), nameof(FunctionPointerHolder.MethodCallConv_Fastcall))]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/71095", TestRuntimes.Mono)]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/71883", typeof(PlatformDetection), nameof(PlatformDetection.IsNativeAot))]
-        public static unsafe void CallingConventionIdentity_Unmodified(string methodName1, string methodName2)
+        public static unsafe void CallingConvention_Unmodified(string methodName1, string methodName2)
         {
             Type t = typeof(FunctionPointerHolder).Project();
             MethodInfo m1 = t.GetMethod(methodName1, Bindings);
@@ -115,7 +117,7 @@ public static unsafe void CallingConventionIdentity_Unmodified(string methodName
         [InlineData(nameof(FunctionPointerHolder.MethodCallConv_Cdecl), nameof(FunctionPointerHolder.MethodCallConv_Fastcall))]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/71095", TestRuntimes.Mono)]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/71883", typeof(PlatformDetection), nameof(PlatformDetection.IsNativeAot))]
-        public static unsafe void CallingConventionIdentity_Modified(string methodName1, string methodName2)
+        public static unsafe void CallingConvention_Modified(string methodName1, string methodName2)
         {
             Type t = typeof(FunctionPointerHolder).Project();
             MethodInfo m1 = t.GetMethod(methodName1, Bindings);
@@ -126,5 +128,30 @@ public static unsafe void CallingConventionIdentity_Modified(string methodName1,
 
             Assert.True(fnPtrType1.IsFunctionPointerNotEqual(fnPtrType2));
         }
+
+        private unsafe class FunctionPointerHolder
+        {
+#pragma warning disable 0649
+            public delegate* managed<int> Field_Int;
+            public delegate* managed<DateOnly> Field_DateOnly; // Verify non-primitive
+#pragma warning restore 0649
+
+            public delegate* managed<int> Prop_Int { get; }
+            public delegate* managed<DateOnly> Prop_DateOnly { get; }
+            public delegate* managed<int> MethodReturnValue_Int() => default;
+            public delegate* managed<DateOnly> MethodReturnValue_DateOnly() => default;
+
+            public delegate* unmanaged<int> MethodUnmanagedReturnValue1() => default;
+            public delegate* unmanaged<bool> MethodUnmanagedReturnValue2() => default;
+
+            // Methods to verify calling conventions and synthesized modopts.
+            // The non-SuppressGCTransition variants are encoded with the CallKind byte.
+            // The SuppressGCTransition variants are encoded as modopts (CallKind is "Unmananged").
+            public void MethodCallConv_Cdecl(delegate* unmanaged[Cdecl]<void> f) { }
+            public void MethodCallConv_Cdecl_SuppressGCTransition(delegate* unmanaged[Cdecl, SuppressGCTransition]<void> f) { }
+            public void MethodCallConv_Stdcall(delegate* unmanaged[Stdcall]<void> f) { }
+            public void MethodCallConv_Thiscall(delegate* unmanaged[Thiscall]<void> f) { }
+            public void MethodCallConv_Fastcall(delegate* unmanaged[Fastcall]<void> f) { }
+        }
     }
 }

src/libraries/Common/tests/System/FunctionPointerTests.cs

@@ -279,8 +279,9 @@ private static void VerifyFieldOrProperty(Type fnPtrType, bool isModified)
             Assert.Equal<Type>(Type.EmptyTypes, fnPtrType.GetFunctionPointerReturnType().GetRequiredCustomModifiers());
         }
 
-        public unsafe partial class FunctionPointerHolder
+        private unsafe class FunctionPointerHolder
         {
+#pragma warning disable 0649
             public delegate*<void> ToString_1;
             public delegate*unmanaged<void> ToString_2;
             public delegate*<int> ToString_3;
@@ -292,20 +293,14 @@ public unsafe partial class FunctionPointerHolder
             public delegate*<delegate*<int, string>, bool> ToString_9;
 
             public delegate* managed<int> Field_Int;
-            public delegate* managed<DateOnly> Field_DateOnly; // Verify non-primitive
             public delegate* managed<MyClass> Field_MyClass;
+#pragma warning restore 0649
+
             public delegate* managed<int> Prop_Int { get; }
-            public delegate* managed<DateOnly> Prop_DateOnly { get; }
             public delegate* managed<MyClass> Prop_MyClass { get; }
-            public delegate* managed<int> MethodReturnValue_Int() => default;
-            public delegate* managed<DateOnly> MethodReturnValue_DateOnly() => default;
-            public delegate* unmanaged<int> MethodUnmanagedReturnValue_Int() => default;
-            public delegate* unmanaged<DateOnly> MethodUnmanagedReturnValue_DateOnly() => default;
 
             public delegate* managed<int> MethodReturnValue1() => default;
             public delegate* managed<int> MethodReturnValue2() => default;
-            public delegate* unmanaged<int> MethodUnmanagedReturnValue1() => default;
-            public delegate* unmanaged<bool> MethodUnmanagedReturnValue2() => default;
 
             public delegate* unmanaged[Stdcall, MemberFunction]<string, ref bool*, MyClass, in MyStruct, double> SeveralArguments() => default;
             public delegate*<in int, out int, void> RequiredModifiers() => default;