added a workaround for tp_clear implementations, that do not check, that they are not the first in tp_clear's MRO

lostmsu · lostmsu · commit 197689e07e5c · 2021-09-22T12:36:00.000-07:00
https://bugs.python.org/issue45266
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));

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ internal class CLRObject : ManagedType`
`12`	`12`
`13`	`13`	`internal CLRObject(object ob, IntPtr tp)`
`14`	`14`	`{`
`15`		`- System.Diagnostics.Debug.Assert(tp != IntPtr.Zero);`
	`15`	`+ Debug.Assert(tp != IntPtr.Zero);`
`16`	`16`	`IntPtr py = Runtime.PyType_GenericAlloc(tp, 0);`
`17`	`17`
`18`	`18`	`tpHandle = tp;`
Original file line number	Diff line number	Diff line change
`@@ -28,6 +28,8 @@ internal enum TrackTypes`
`28`	`28`	`internal IntPtr pyHandle; // PyObject *`
`29`	`29`	`internal IntPtr tpHandle; // PyType *`
`30`	`30`
	`31`	`+ internal bool clearReentryGuard;`
	`32`	`+`
`31`	`33`	`internal BorrowedReference ObjectReference => new(pyHandle);`
`32`	`34`	`internal BorrowedReference TypeReference => new(tpHandle);`
`33`	`35`
`@@ -145,7 +147,7 @@ internal static bool IsInstanceOfManagedType(IntPtr ob)`
`145`	`147`
`146`	`148`	`internal static bool IsManagedType(BorrowedReference type)`
`147`	`149`	`{`
`148`		`- var flags = (TypeFlags)Util.ReadCLong(type.DangerousGetAddress(), TypeOffset.tp_flags);`
	`150`	`+ var flags = PyType.GetFlags(type);`
`149`	`151`	`return (flags & TypeFlags.HasClrInstance) != 0;`
`150`	`152`	`}`
`151`	`153`
Original file line number	Diff line number	Diff line change
`@@ -103,6 +103,12 @@ internal IntPtr GetSlot(TypeSlotID slot)`
`103`	`103`	`return Exceptions.ErrorCheckIfNull(result);`
`104`	`104`	`}`
`105`	`105`
	`106`	`+ internal static TypeFlags GetFlags(BorrowedReference type)`
	`107`	`+ {`
	`108`	`+ Debug.Assert(TypeOffset.tp_flags > 0);`
	`109`	`+ return (TypeFlags)Util.ReadCLong(type.DangerousGetAddress(), TypeOffset.tp_flags);`
	`110`	`+ }`
	`111`	`+`
`106`	`112`	`internal static BorrowedReference GetBase(BorrowedReference type)`
`107`	`113`	`{`
`108`	`114`	`Debug.Assert(IsType(type));`