fixed thunk loading for slots, that use new reference types

pythonnet · lostmsu · Dec 14, 2021 · Oct 17, 2021 · Oct 17, 2021 · Oct 17, 2021
commit 14949fbedfaf197ed8b47c0aca186eaf4f11b4cf
diff --git a/src/runtime/Reflection/ParameterHelper.cs b/src/runtime/Reflection/ParameterHelper.cs
@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+namespace Python.Runtime.Reflection;
+
+[Serializable]
+struct ParameterHelper : IEquatable<ParameterInfo>
+{
+    public readonly string TypeName;
+    public readonly ParameterModifier Modifier;
+
+    public ParameterHelper(ParameterInfo tp)
+    {
+        TypeName = tp.ParameterType.AssemblyQualifiedName;
+        Modifier = ParameterModifier.None;
+
+        if (tp.IsIn && tp.ParameterType.IsByRef)
+        {
+            Modifier = ParameterModifier.In;
+        }
+        else if (tp.IsOut && tp.ParameterType.IsByRef)
+        {
+            Modifier = ParameterModifier.Out;
+        }
+        else if (tp.ParameterType.IsByRef)
+        {
+            Modifier = ParameterModifier.Ref;
+        }
+    }
+
+    public bool Equals(ParameterInfo other)
+    {
+        return this.Equals(new ParameterHelper(other));
+    }
+
+    public bool Matches(ParameterInfo other) => this.Equals(other);
+}
+
+enum ParameterModifier
+{
+    None,
+    In,
+    Out,
+    Ref
+}
diff --git a/src/runtime/StateSerialization/MaybeMethodBase.cs b/src/runtime/StateSerialization/MaybeMethodBase.cs
@@ -3,6 +3,8 @@
 using System.Runtime.Serialization;
 using System.Linq;
 
+using Python.Runtime.Reflection;
+
 namespace Python.Runtime
 {
     [Serializable]
@@ -17,43 +19,6 @@ internal struct MaybeMethodBase<T> : ISerializable where T: MethodBase
         const string SerializationIsCtor = "c";
         const string SerializationMethodName = "n";
 
-        [Serializable]
-        struct ParameterHelper : IEquatable<ParameterInfo>
-        {
-            public enum TypeModifier
-            {
-                None,
-                In,
-                Out,
-                Ref
-            }
-            public readonly string Name;
-            public readonly TypeModifier Modifier;
-
-            public ParameterHelper(ParameterInfo tp)
-            {
-                Name = tp.ParameterType.AssemblyQualifiedName;
-                Modifier = TypeModifier.None;
-
-                if (tp.IsIn && tp.ParameterType.IsByRef)
-                {
-                    Modifier = TypeModifier.In;
-                }
-                else if (tp.IsOut && tp.ParameterType.IsByRef)
-                {
-                    Modifier = TypeModifier.Out;
-                }
-                else if (tp.ParameterType.IsByRef)
-                {
-                    Modifier = TypeModifier.Ref;
-                }
-            }
-
-            public bool Equals(ParameterInfo other)
-            {
-                return this.Equals(new ParameterHelper(other));
-            }
-        }
         public static implicit operator MaybeMethodBase<T> (T ob) => new MaybeMethodBase<T>(ob);
 
         string name;
@@ -119,7 +84,7 @@ internal MaybeMethodBase(SerializationInfo serializationInfo, StreamingContext c
                 bool hasRefType = false;
                 for (int i = 0; i < param.Length; i++)
                 {
-                    var paramTypeName = param[i].Name;
+                    var paramTypeName = param[i].TypeName;
                     types[i] = Type.GetType(paramTypeName);
                     if (types[i] == null)
                     {

diff --git a/src/runtime/interop.cs b/src/runtime/interop.cs
@@ -1,10 +1,10 @@
 using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Linq;
 using System.Runtime.InteropServices;
+using Python.Runtime.Reflection;
 using System.Reflection;
-using System.Text;
 
 namespace Python.Runtime
 {
@@ -120,110 +120,38 @@ public enum TypeFlags: int
 
     internal class Interop
     {
-        private static Hashtable pmap;
+        static readonly Dictionary<MethodInfo, Type> delegateTypes = new();
 
-        static Interop()
+        internal static Type GetPrototype(MethodInfo method)
         {
-            // Here we build a mapping of PyTypeObject slot names to the
-            // appropriate prototype (delegate) type to use for the slot.
+            if (delegateTypes.TryGetValue(method, out var delegateType))
+                return delegateType;
 
-            Type[] items = typeof(Interop).GetNestedTypes();
-            Hashtable p = new Hashtable();
+            var parameters = method.GetParameters().Select(p => new ParameterHelper(p)).ToArray();
 
-            for (int i = 0; i < items.Length; i++)
+            foreach (var candidate in typeof(Interop).GetNestedTypes())
             {
-                Type item = items[i];
-                p[item.Name] = item;
-            }
+                if (!typeof(Delegate).IsAssignableFrom(candidate))
+                    continue;
 
-            pmap = new Hashtable();
-
-            pmap["tp_dealloc"] = p["DestructorFunc"];
-            pmap["tp_print"] = p["PrintFunc"];
-            pmap["tp_getattr"] = p["BinaryFunc"];
-            pmap["tp_setattr"] = p["ObjObjArgFunc"];
-            pmap["tp_compare"] = p["ObjObjFunc"];
-            pmap["tp_repr"] = p["UnaryFunc"];
-            pmap["tp_hash"] = p["UnaryFunc"];
-            pmap["tp_call"] = p["TernaryFunc"];
-            pmap["tp_str"] = p["UnaryFunc"];
-            pmap["tp_getattro"] = p["BinaryFunc"];
-            pmap["tp_setattro"] = p["ObjObjArgFunc"];
-            pmap["tp_traverse"] = p["ObjObjArgFunc"];
-            pmap["tp_clear"] = p["InquiryFunc"];
-            pmap["tp_richcompare"] = p["RichCmpFunc"];
-            pmap["tp_iter"] = p["UnaryFunc"];
-            pmap["tp_iternext"] = p["UnaryFunc"];
-            pmap["tp_descr_get"] = p["TernaryFunc"];
-            pmap["tp_descr_set"] = p["ObjObjArgFunc"];
-            pmap["tp_init"] = p["ObjObjArgFunc"];
-            pmap["tp_alloc"] = p["IntArgFunc"];
-            pmap["tp_new"] = p["TernaryFunc"];
-            pmap["tp_free"] = p["DestructorFunc"];
-            pmap["tp_is_gc"] = p["InquiryFunc"];
-
-            pmap["nb_add"] = p["BinaryFunc"];
-            pmap["nb_subtract"] = p["BinaryFunc"];
-            pmap["nb_multiply"] = p["BinaryFunc"];
-            pmap["nb_remainder"] = p["BinaryFunc"];
-            pmap["nb_divmod"] = p["BinaryFunc"];
-            pmap["nb_power"] = p["TernaryFunc"];
-            pmap["nb_negative"] = p["UnaryFunc"];
-            pmap["nb_positive"] = p["UnaryFunc"];
-            pmap["nb_absolute"] = p["UnaryFunc"];
-            pmap["nb_nonzero"] = p["InquiryFunc"];
-            pmap["nb_invert"] = p["UnaryFunc"];
-            pmap["nb_lshift"] = p["BinaryFunc"];
-            pmap["nb_rshift"] = p["BinaryFunc"];
-            pmap["nb_and"] = p["BinaryFunc"];
-            pmap["nb_xor"] = p["BinaryFunc"];
-            pmap["nb_or"] = p["BinaryFunc"];
-            pmap["nb_coerce"] = p["ObjObjFunc"];
-            pmap["nb_int"] = p["UnaryFunc"];
-            pmap["nb_long"] = p["UnaryFunc"];
-            pmap["nb_float"] = p["UnaryFunc"];
-            pmap["nb_oct"] = p["UnaryFunc"];
-            pmap["nb_hex"] = p["UnaryFunc"];
-            pmap["nb_inplace_add"] = p["BinaryFunc"];
-            pmap["nb_inplace_subtract"] = p["BinaryFunc"];
-            pmap["nb_inplace_multiply"] = p["BinaryFunc"];
-            pmap["nb_inplace_remainder"] = p["BinaryFunc"];
-            pmap["nb_inplace_power"] = p["TernaryFunc"];
-            pmap["nb_inplace_lshift"] = p["BinaryFunc"];
-            pmap["nb_inplace_rshift"] = p["BinaryFunc"];
-            pmap["nb_inplace_and"] = p["BinaryFunc"];
-            pmap["nb_inplace_xor"] = p["BinaryFunc"];
-            pmap["nb_inplace_or"] = p["BinaryFunc"];
-            pmap["nb_floor_divide"] = p["BinaryFunc"];
-            pmap["nb_true_divide"] = p["BinaryFunc"];
-            pmap["nb_inplace_floor_divide"] = p["BinaryFunc"];
-            pmap["nb_inplace_true_divide"] = p["BinaryFunc"];
-            pmap["nb_index"] = p["UnaryFunc"];
-
-            pmap["sq_length"] = p["InquiryFunc"];
-            pmap["sq_concat"] = p["BinaryFunc"];
-            pmap["sq_repeat"] = p["IntArgFunc"];
-            pmap["sq_item"] = p["IntArgFunc"];
-            pmap["sq_slice"] = p["IntIntArgFunc"];
-            pmap["sq_ass_item"] = p["IntObjArgFunc"];
-            pmap["sq_ass_slice"] = p["IntIntObjArgFunc"];
-            pmap["sq_contains"] = p["ObjObjFunc"];
-            pmap["sq_inplace_concat"] = p["BinaryFunc"];
-            pmap["sq_inplace_repeat"] = p["IntArgFunc"];
-
-            pmap["mp_length"] = p["InquiryFunc"];
-            pmap["mp_subscript"] = p["BinaryFunc"];
-            pmap["mp_ass_subscript"] = p["ObjObjArgFunc"];
-
-            pmap["bf_getreadbuffer"] = p["IntObjArgFunc"];
-            pmap["bf_getwritebuffer"] = p["IntObjArgFunc"];
-            pmap["bf_getsegcount"] = p["ObjObjFunc"];
-            pmap["bf_getcharbuffer"] = p["IntObjArgFunc"];
-        }
+                MethodInfo invoke = candidate.GetMethod("Invoke");
+                var candiateParameters = invoke.GetParameters();
+                if (candiateParameters.Length != parameters.Length)
+                    continue;
 
-        internal static Type GetPrototype(string name)
-        {
-            return pmap[name] as Type;
+                var parametersMatch = parameters.Zip(candiateParameters,
+                    (expected, actual) => expected.Matches(actual))
+                    .All(matches => matches);
+
+                if (!parametersMatch) continue;
+
+                if (invoke.ReturnType != method.ReturnType) continue;
+
+                delegateTypes.Add(method, candidate);
+                return candidate;
+            }
+
+            throw new NotImplementedException(method.ToString());
         }
 
 
@@ -235,7 +163,7 @@ internal static ThunkInfo GetThunk(MethodInfo method, string funcType = null)
             if (funcType != null)
                 dt = typeof(Interop).GetNestedType(funcType) as Type;
             else
-                dt = GetPrototype(method.Name);
+                dt = GetPrototype(method);
 
             if (dt == null)
             {
@@ -252,53 +180,38 @@ internal static ThunkInfo GetThunk(Delegate @delegate)
             return info;
         }
 
-
-        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-        public delegate IntPtr UnaryFunc(IntPtr ob);
-
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-        public delegate IntPtr BinaryFunc(IntPtr ob, IntPtr arg);
+        public delegate NewReference B_N(BorrowedReference ob);
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-        public delegate IntPtr TernaryFunc(IntPtr ob, IntPtr a1, IntPtr a2);
+        public delegate NewReference BB_N(BorrowedReference ob, BorrowedReference a);
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate NewReference BBB_N(BorrowedReference ob, BorrowedReference a1, BorrowedReference a2);
-        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-        public delegate int BBB_I32(BorrowedReference ob, BorrowedReference a1, BorrowedReference a2);
-
-        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-        public delegate int InquiryFunc(IntPtr ob);
-
-        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-        public delegate IntPtr IntArgFunc(IntPtr ob, int arg);
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-        public delegate IntPtr IntIntArgFunc(IntPtr ob, int a1, int a2);
+        public delegate int B_I32(BorrowedReference ob);
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-        public delegate int IntObjArgFunc(IntPtr ob, int a1, IntPtr a2);
-
-        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-        public delegate int IntIntObjArgFunc(IntPtr o, int a, int b, IntPtr c);
+        public delegate int BBB_I32(BorrowedReference ob, BorrowedReference a1, BorrowedReference a2);
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-        public delegate int ObjObjArgFunc(IntPtr o, IntPtr a, IntPtr b);
+        public delegate int BP_I32(BorrowedReference ob, IntPtr arg);
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-        public delegate int ObjObjFunc(IntPtr ob, IntPtr arg);
+        public delegate IntPtr B_P(BorrowedReference ob);
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-        public delegate int BP_I32(BorrowedReference ob, IntPtr arg);
+        public delegate NewReference BBI32_N(BorrowedReference ob, BorrowedReference a1, int a2);
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-        public delegate void DestructorFunc(IntPtr ob);
+        public delegate NewReference BP_N(BorrowedReference ob, IntPtr arg);
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-        public delegate int PrintFunc(IntPtr ob, IntPtr a, int b);
+        public delegate void N_V(NewReference ob);
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-        public delegate IntPtr RichCmpFunc(IntPtr ob, IntPtr a, int b);
+        public delegate int BPP_I32(BorrowedReference ob, IntPtr a1, IntPtr a2);
     }
 
 

diff --git a/src/runtime/metatype.cs b/src/runtime/metatype.cs
@@ -178,7 +178,7 @@ public static NewReference tp_new(BorrowedReference tp, BorrowedReference args,
         }
 
 
-        public static NewReference tp_alloc(BorrowedReference mt, int n)
+        public static NewReference tp_alloc(BorrowedReference mt, nint n)
             => Runtime.PyType_GenericAlloc(mt, n);
-Original file line number
+Diff line change
@@ Expand Up @@
             }
-            public static NewReference tp_alloc(BorrowedReference mt, int n)
+            public static NewReference tp_alloc(BorrowedReference mt, nint n)
                 => Runtime.PyType_GenericAlloc(mt, n);
@@ Expand Down @@