renamed parameter in tp_dealloc functions for clarity

lostmsu · lostmsu · commit 7deebd4eddf9 · 2021-10-18T23:37:20.000-07:00
diff --git a/src/runtime/classbase.cs b/src/runtime/classbase.cs
@@ -337,12 +337,12 @@ public static NewReference tp_repr(BorrowedReference ob)
         /// <summary>
         /// Standard dealloc implementation for instances of reflected types.
         /// </summary>
-        public static void tp_dealloc(NewReference ob)
+        public static void tp_dealloc(NewReference lastRef)
         {
-            ManagedType self = GetManagedObject(ob.Borrow())!;
-            tp_clear(ob.Borrow());
-            Runtime.PyObject_GC_UnTrack(ob.Borrow());
-            Runtime.PyObject_GC_Del(ob.Steal());
+            ManagedType self = GetManagedObject(lastRef.Borrow())!;
+            tp_clear(lastRef.Borrow());
+            Runtime.PyObject_GC_UnTrack(lastRef.Borrow());
+            Runtime.PyObject_GC_Del(lastRef.Steal());
             self?.FreeGCHandle();
         }
 
diff --git a/src/runtime/extensiontype.cs b/src/runtime/extensiontype.cs
@@ -86,11 +86,11 @@ public static int tp_setattro(BorrowedReference ob, BorrowedReference key, Borro
             return -1;
         }
 
-        public static void tp_dealloc(NewReference ob)
+        public static void tp_dealloc(NewReference lastRef)
         {
             // Clean up a Python instance of this extension type. This
             // frees the allocated Python object and decrefs the type.
-            var self = (ExtensionType?)GetManagedObject(ob.Borrow());
+            var self = (ExtensionType?)GetManagedObject(lastRef.Borrow());
             self?.Clear();
             self?.Dealloc();
         }
diff --git a/src/runtime/metatype.cs b/src/runtime/metatype.cs
@@ -285,22 +285,22 @@ public static NewReference mp_subscript(BorrowedReference tp, BorrowedReference
         /// Dealloc implementation. This is called when a Python type generated
         /// by this metatype is no longer referenced from the Python runtime.
         /// </summary>
-        public static void tp_dealloc(NewReference tp)
+        public static void tp_dealloc(NewReference lastRef)
         {
             // Fix this when we dont cheat on the handle for subclasses!
 
-            var flags = (TypeFlags)Util.ReadCLong(tp.Borrow(), TypeOffset.tp_flags);
+            var flags = (TypeFlags)Util.ReadCLong(lastRef.Borrow(), TypeOffset.tp_flags);
             if ((flags & TypeFlags.Subclass) == 0)
             {
-                GetGCHandle(tp.Borrow()).Free();
+                GetGCHandle(lastRef.Borrow()).Free();
 #if DEBUG
                 // prevent ExecutionEngineException in debug builds in case we have a bug
                 // this would allow using managed debugger to investigate the issue
-                SetGCHandle(tp.Borrow(), Runtime.CLRMetaType, default);
+                SetGCHandle(lastRef.Borrow(), Runtime.CLRMetaType, default);
 #endif
             }
 
-            var op = Util.ReadIntPtr(tp.Borrow(), TypeOffset.ob_type);
+            var op = Util.ReadIntPtr(lastRef.Borrow(), TypeOffset.ob_type);
             // We must decref our type.
             // type_dealloc from PyType will use it to get tp_free so we must keep the value
             Runtime.XDecref(StolenReference.DangerousFromPointer(op));
@@ -311,7 +311,7 @@ public static void tp_dealloc(NewReference tp)
             // case our CLR metatype. That is why we implement tp_free.
 
             IntPtr tp_dealloc = Util.ReadIntPtr(Runtime.PyTypeType, TypeOffset.tp_dealloc);
-            NativeCall.CallDealloc(tp_dealloc, tp.Steal());
+            NativeCall.CallDealloc(tp_dealloc, lastRef.Steal());
         }
 
         private static NewReference DoInstanceCheck(BorrowedReference tp, BorrowedReference args, bool checkType)

Original file line number	Diff line number	Diff line change
`@@ -86,11 +86,11 @@ public static int tp_setattro(BorrowedReference ob, BorrowedReference key, Borro`
`86`	`86`	`return -1;`
`87`	`87`	`}`
`88`	`88`
`89`		`- public static void tp_dealloc(NewReference ob)`
	`89`	`+ public static void tp_dealloc(NewReference lastRef)`
`90`	`90`	`{`
`91`	`91`	`// Clean up a Python instance of this extension type. This`
`92`	`92`	`// frees the allocated Python object and decrefs the type.`
`93`		`- var self = (ExtensionType?)GetManagedObject(ob.Borrow());`
	`93`	`+ var self = (ExtensionType?)GetManagedObject(lastRef.Borrow());`
`94`	`94`	`self?.Clear();`
`95`	`95`	`self?.Dealloc();`
`96`	`96`	`}`