PyROOT] Fix infinite loop in TMemoryRegulator::ClearProxiedObjects()

bindings/pyroot/pythonizations/CMakeLists.txt

@@ -112,7 +112,6 @@ set(cpp_sources
     src/TMemoryRegulator.cxx
     src/TObjectPyz.cxx
     src/TTreePyz.cxx
-    src/PyzCppHelpers.cxx
     src/CPPInstancePyz.cxx
     src/TPyDispatcher.cxx
     inc/TPyDispatcher.h

bindings/pyroot/pythonizations/src/CPPInstancePyz.cxx

@@ -17,7 +17,6 @@
 #include "../../cppyy/CPyCppyy/src/CustomPyTypes.h"
 
 #include "PyROOTPythonize.h"
-#include "PyzCppHelpers.hxx"
 #include "TBufferFile.h"
 
 using namespace CPyCppyy;
@@ -79,7 +78,7 @@ PyObject *op_reduce(PyObject *self, PyObject * /*args*/)
    if (selfClass == s_bfClass) {
       buff = (TBufferFile *)CPyCppyy::Instance_AsVoidPtr(self);
    } else {
-      auto className = GetScopedFinalNameFromPyObject(self);
+      auto className = Cppyy::GetScopedFinalName(selfClass);
       if (className.find("__cppyy_internal::Dispatcher") == 0) {
          PyErr_Format(PyExc_IOError, "generic streaming of Python objects whose class derives from a C++ class is not supported. "
                                      "Please refer to the Python pickle documentation for instructions on how to define "
@@ -94,7 +93,7 @@ PyObject *op_reduce(PyObject *self, PyObject * /*args*/)
       if (s_buff.WriteObjectAny(CPyCppyy::Instance_AsVoidPtr(self),
                                 TClass::GetClass(className.c_str())) != 1) {
          PyErr_Format(PyExc_IOError, "could not stream object of type %s",
-                      GetScopedFinalNameFromPyObject(self).c_str());
+                      Cppyy::GetScopedFinalName(selfClass).c_str());
          return 0;
       }
       buff = &s_buff;
@@ -104,7 +103,7 @@ PyObject *op_reduce(PyObject *self, PyObject * /*args*/)
    // on reading back in (see CPPInstanceExpand defined above)
    PyObject *res2 = PyTuple_New(2);
    PyTuple_SET_ITEM(res2, 0, PyBytes_FromStringAndSize(buff->Buffer(), buff->Length()));
-   PyTuple_SET_ITEM(res2, 1, PyBytes_FromString(GetScopedFinalNameFromPyObject(self).c_str()));
+   PyTuple_SET_ITEM(res2, 1, PyBytes_FromString(Cppyy::GetScopedFinalName(selfClass).c_str()));
 
    PyObject *result = PyTuple_New(2);
    Py_INCREF(s_expand);

bindings/pyroot/pythonizations/src/GenericPyz.cxx

@@ -14,17 +14,26 @@
 #include "CPyCppyy/API.h"
 
 #include "../../cppyy/CPyCppyy/src/CPyCppyy.h"
+#include "../../cppyy/CPyCppyy/src/CPPInstance.h"
 #include "../../cppyy/CPyCppyy/src/Utility.h"
 
 #include "PyROOTPythonize.h"
-#include "PyzCppHelpers.hxx"
 
 #include "TClass.h"
 #include "TInterpreter.h"
 #include "TInterpreterValue.h"
 
 #include <map>
 
+namespace {
+
+std::string GetScopedFinalNameFromPyObject(const PyObject *pyobj)
+{
+   return Cppyy::GetScopedFinalName(((CPyCppyy::CPPInstance *)pyobj)->ObjectIsA());
+}
+
+} // namespace
+
 using namespace CPyCppyy;
 
 // We take as unique identifier the declId of the class to

bindings/pyroot/pythonizations/src/TClassPyz.cxx

@@ -17,7 +17,6 @@
 #include "../../cppyy/CPyCppyy/src/Utility.h"
 
 #include "PyROOTPythonize.h"
-#include "PyzCppHelpers.hxx"
 
 // ROOT
 #include "TClass.h"
@@ -51,15 +50,11 @@ PyObject *TClassDynamicCastPyz(PyObject *self, PyObject *args)
       Utility::GetBuffer(pyobject, '*', 1, address, false);
    }
 
-   // Now use binding to return a usable class
-   TClass *klass = nullptr;
-   if (up) {
-      // Upcast: result is a base
-      klass = (TClass *)GetTClass(pyclass)->DynamicCast(TClass::Class(), CPyCppyy::Instance_AsVoidPtr(pyclass));
-   } else {
-      // Downcast: result is a derived
-      klass = (TClass *)GetTClass(self)->DynamicCast(TClass::Class(), cl1);
-   }
+   // Now use binding to return a usable class. Upcast: result is a base.
+   // Downcast: result is a derived.
+   Cppyy::TCppType_t cpptype = ((CPyCppyy::CPPInstance*)(up ? pyclass : self))->ObjectIsA();
+   TClass *tcl = TClass::GetClass(Cppyy::GetScopedFinalName(cpptype).c_str());
+   TClass *klass = (TClass *)tcl->DynamicCast(TClass::Class(), up ? CPyCppyy::Instance_AsVoidPtr(pyclass) : cl1);
 
    return CPyCppyy::Instance_FromVoidPtr(address, klass->GetName());
 }

bindings/pyroot/pythonizations/src/TMemoryRegulator.cxx

@@ -108,7 +108,10 @@ void PyROOT::TMemoryRegulator::ClearProxiedObjects()
       else {
          // Non-owning proxy, just unregister to clean tables.
          // The proxy deletion by Python will have no effect on C++, so all good
-         MemoryRegulator::UnregisterPyObject(pyobj, pyclass);
+         bool ret = MemoryRegulator::UnregisterPyObject(pyobj, pyclass);
+         if (!ret) {
+            fObjectMap.erase(elem);
+         }
       }
    }
 }

bindings/pyroot/pythonizations/src/TObjectPyz.cxx

@@ -17,11 +17,32 @@
 #include "../../cppyy/CPyCppyy/src/Utility.h"
 
 #include "PyROOTPythonize.h"
-#include "PyzCppHelpers.hxx"
 
 // ROOT
 #include "TObject.h"
 
+namespace {
+
+// Convert generic python object into a boolean value
+PyObject *BoolNot(PyObject *value)
+{
+   if (PyObject_IsTrue(value) == 1) {
+      Py_DECREF(value);
+      Py_RETURN_FALSE;
+   } else {
+      Py_XDECREF(value);
+      Py_RETURN_TRUE;
+   }
+}
+
+// Call method with signature: obj->meth(arg1)
+PyObject *CallPyObjMethod(PyObject *obj, const char *meth, PyObject *arg1)
+{
+   return PyObject_CallMethod(obj, meth, "O", arg1);
+}
+
+} // namespace
+
 using namespace CPyCppyy;
 
 // Implement Python's __eq__ with TObject::IsEqual

bindings/pyroot/pythonizations/src/TTreePyz.cxx

@@ -24,7 +24,6 @@
 #include "CPyCppyy/API.h"
 
 #include "PyROOTPythonize.h"
-#include "PyzCppHelpers.hxx"
 
 // ROOT
 #include "TClass.h"
@@ -38,6 +37,16 @@
 #include "TStreamerElement.h"
 #include "TStreamerInfo.h"
 
+namespace {
+
+// Get the TClass of the C++ object proxied by pyobj
+TClass *GetTClass(const PyObject *pyobj)
+{
+   return TClass::GetClass(Cppyy::GetScopedFinalName(((CPyCppyy::CPPInstance*)pyobj)->ObjectIsA()).c_str());
+}
+
+} // namespace
+
 using namespace CPyCppyy;
 
 static TBranch *SearchForBranch(TTree *tree, const char *name)