Add comments and remove unused in operatormethod.cs

Also move fixupslots before pytype_ready. Also apply access violation fix in classderived.
pythonnet · lostmsu · Jan 5, 2021 · Dec 16, 2020 · Dec 17, 2020 · Dec 17, 2020
commit c26e5892996cf3463a5cd4512ef5d9fde118740f
diff --git a/src/runtime/classderived.cs b/src/runtime/classderived.cs
@@ -66,7 +66,12 @@ internal ClassDerivedObject(Type tp) : base(tp)
         public new static void tp_dealloc(IntPtr ob)
         {
             var self = (CLRObject)GetManagedObject(ob);
-
+            // Amos's fix https://github.com/pythonnet/pythonnet/pull/1260#issuecomment-726719595
+            if (self.tpHandle == IntPtr.Zero)
+            {
+                ClassBase.tp_dealloc(ob);
+                return;
+            }
             // don't let the python GC destroy this object
             Runtime.PyObject_GC_UnTrack(self.pyHandle);
 

diff --git a/src/runtime/operatormethod.cs b/src/runtime/operatormethod.cs
@@ -9,9 +9,11 @@ namespace Python.Runtime
 {
     internal static class OperatorMethod
     {
+        // Maps the compiled method name in .NET CIL (e.g. op_Addition) to
+        // the equivalent Python operator (e.g. __add__) as well as the offset
+        // that identifies that operator's slot (e.g. nb_add) in heap space.
         public static Dictionary<string, Tuple<string, int>> OpMethodMap { get; private set; }
 
-        private static Dictionary<string, string> _pyOpNames;
         private static PyObject _opType;
 
         static OperatorMethod()
@@ -35,12 +37,6 @@ static OperatorMethod()
                 ["op_Modulus"] = Tuple.Create("__mod__", TypeOffset.nb_remainder),
                 ["op_OneComplement"] = Tuple.Create("__invert__", TypeOffset.nb_invert)
             };
-
-            _pyOpNames = new Dictionary<string, string>();
-            foreach (string name in OpMethodMap.Keys)
-            {
-                _pyOpNames.Add(GetPyMethodName(name), name);
-            }
         }
 
         public static void Initialize()
@@ -62,11 +58,6 @@ public static bool IsOperatorMethod(string methodName)
             return OpMethodMap.ContainsKey(methodName);
         }
 
-        public static bool IsPyOperatorMethod(string pyMethodName)
-        {
-            return _pyOpNames.ContainsKey(pyMethodName);
-        }
-
         public static bool IsOperatorMethod(MethodBase method)
         {
             if (!method.IsSpecialName)
@@ -75,7 +66,12 @@ public static bool IsOperatorMethod(MethodBase method)
             }
             return OpMethodMap.ContainsKey(method.Name);
         }
-
+        /// <summary>
+        /// For the operator methods of a CLR type, set the special slots of the
+        /// corresponding Python type's operator methods.
+        /// </summary>
+        /// <param name="pyType"></param>
+        /// <param name="clrType"></param>
         public static void FixupSlots(IntPtr pyType, Type clrType)
         {
             const BindingFlags flags = BindingFlags.Public | BindingFlags.Static;
@@ -86,10 +82,16 @@ public static void FixupSlots(IntPtr pyType, Type clrType)
                 {
                     continue;
                 }
-                var slotdef = OpMethodMap[method.Name];
-                int offset = slotdef.Item2;
+                int offset = OpMethodMap[method.Name].Item2;
+                // Copy the default implementation of e.g. the nb_add slot,
+                // which simply calls __add__ on the type.
                 IntPtr func = Marshal.ReadIntPtr(_opType.Handle, offset);
+                // Write the slot definition of the target Python type, so
+                // that we can later modify __add___ and it will be called
+                // when used with a Python operator.
+                // https://tenthousandmeters.com/blog/python-behind-the-scenes-6-how-python-object-system-works/
                 Marshal.WriteIntPtr(pyType, offset, func);
+
             }
         }
 
@@ -116,7 +118,9 @@ private static PyObject GetOperatorType()
             {
                 // A hack way for getting typeobject.c::slotdefs
                 string code = GenerateDummyCode();
+                // The resulting OperatorMethod class is stored in a PyDict.
                 PythonEngine.Exec(code, null, locals.Handle);
+                // Return the class itself, which is a type.
                 return locals.GetItem("OperatorMethod");
             }
         }

diff --git a/src/runtime/typemanager.cs b/src/runtime/typemanager.cs
@@ -273,6 +273,7 @@ internal static IntPtr CreateType(ManagedType impl, Type clrType)
                             | TypeFlags.HaveGC;
             Util.WriteCLong(type, TypeOffset.tp_flags, flags);
 
+            OperatorMethod.FixupSlots(type, clrType);
             // Leverage followup initialization from the Python runtime. Note
             // that the type of the new type must PyType_Type at the time we
             // call this, else PyType_Ready will skip some slot initialization.
@@ -281,7 +282,6 @@ internal static IntPtr CreateType(ManagedType impl, Type clrType)
             {
                 throw new PythonException();
             }
-            OperatorMethod.FixupSlots(type, clrType);
 
             IntPtr dict = Marshal.ReadIntPtr(type, TypeOffset.tp_dict);
             string mn = clrType.Namespace ?? "";