added a workaround for tp_clear implementations, that do not check, t…

…hat they are not the first in tp_clear's MRO https://bugs.python.org/issue45266
pythonnet · lostmsu · Sep 23, 2021 · May 24, 2020 · Jun 3, 2020 · Jun 17, 2020
commit 197689e07e5ce69dd73122371306cf4d69eb16ec
diff --git a/src/runtime/classbase.cs b/src/runtime/classbase.cs
@@ -360,18 +360,40 @@ public static void tp_dealloc(IntPtr ob)
 
         public static int tp_clear(IntPtr ob)
         {
-            ManagedType self = GetManagedObject(ob);
+            if (GetManagedObject(ob) is { } self)
+            {
+                if (self.clearReentryGuard) return 0;
+
+                // workaround for https://bugs.python.org/issue45266
+                self.clearReentryGuard = true;
+
+                try
+                {
+                    return ClearImpl(ob, self);
+                }
+                finally
+                {
+                    self.clearReentryGuard = false;
+                }
+            }
+            else
+            {
+                return ClearImpl(ob, null);
+            }
+        }
 
+        static int ClearImpl(IntPtr ob, ManagedType self)
+        {
             bool isTypeObject = Runtime.PyObject_TYPE(ob) == Runtime.PyCLRMetaType;
             if (!isTypeObject)
             {
-                ClearObjectDict(ob);
-
                 int baseClearResult = BaseUnmanagedClear(ob);
                 if (baseClearResult != 0)
                 {
                     return baseClearResult;
                 }
+
+                ClearObjectDict(ob);
             }
             if (self is not null) self.tpHandle = IntPtr.Zero;
             return 0;

diff --git a/src/runtime/clrobject.cs b/src/runtime/clrobject.cs
@@ -12,7 +12,7 @@ internal class CLRObject : ManagedType
 
         internal CLRObject(object ob, IntPtr tp)
         {
-            System.Diagnostics.Debug.Assert(tp != IntPtr.Zero);
+            Debug.Assert(tp != IntPtr.Zero);
             IntPtr py = Runtime.PyType_GenericAlloc(tp, 0);
 
             tpHandle = tp;

diff --git a/src/runtime/managedtype.cs b/src/runtime/managedtype.cs
@@ -28,6 +28,8 @@ internal enum TrackTypes
         internal IntPtr pyHandle; // PyObject *
         internal IntPtr tpHandle; // PyType *
 
+        internal bool clearReentryGuard;
+
         internal BorrowedReference ObjectReference => new(pyHandle);
         internal BorrowedReference TypeReference => new(tpHandle);
 
@@ -145,7 +147,7 @@ internal static bool IsInstanceOfManagedType(IntPtr ob)
 
         internal static bool IsManagedType(BorrowedReference type)
         {
-            var flags = (TypeFlags)Util.ReadCLong(type.DangerousGetAddress(), TypeOffset.tp_flags);
+            var flags = PyType.GetFlags(type);
             return (flags & TypeFlags.HasClrInstance) != 0;
         }
 

diff --git a/src/runtime/pytype.cs b/src/runtime/pytype.cs
@@ -103,6 +103,12 @@ internal IntPtr GetSlot(TypeSlotID slot)
             return Exceptions.ErrorCheckIfNull(result);
         }
 
+        internal static TypeFlags GetFlags(BorrowedReference type)
+        {
+            Debug.Assert(TypeOffset.tp_flags > 0);
+            return (TypeFlags)Util.ReadCLong(type.DangerousGetAddress(), TypeOffset.tp_flags);
+        }
+
         internal static BorrowedReference GetBase(BorrowedReference type)
         {
             Debug.Assert(IsType(type));