[CPyCppyy] Remove Eval() and classes redundant with TPython

The `TPython::Eval()` method was removed some time ago, and replaced
with the `Exec()` overload that uses `std::any` for data transfer.
So for ROOT, there is no reason to keep the fragile `Eval()`
functionality in the future CppJIT. If CppJIT users would need such
functionality, we should instead port the `std::any` mechanism to the
CPyCppyy API.

Remove PyResult, TPyArg and TPyClassGenerator in CPyCppyy, as they are
copies of TPython classes.

The corresponding TPython class for PyResult is the TPyReturn, and to
implement it without forwarding to the former PyResult class, the
CPyCppyy API needs to be extended with setters for ownership flags.

Author: guitargeek

bindings/pyroot/cppyy/CPyCppyy/CMakeLists.txt

@@ -7,7 +7,6 @@
 set(headers
     include/CPyCppyy/API.h
     include/CPyCppyy/Reflex.h
-    include/CPyCppyy/PyResult.h
     include/CPyCppyy/CommonDefs.h
     include/CPyCppyy/PyException.h
     include/CPyCppyy/DispatchPtr.h
@@ -38,7 +37,6 @@ set(sources
     src/MemoryRegulator.cxx
     src/ProxyWrappers.cxx
     src/PyException.cxx
-    src/PyResult.cxx
     src/PyStrings.cxx
     src/Pythonize.cxx
     src/TemplateProxy.cxx

bindings/pyroot/cppyy/CPyCppyy/include/CPyCppyy/API.h

@@ -40,7 +40,6 @@ namespace Cppyy {
 } // namespace Cppyy
 
 // Bindings
-#include "CPyCppyy/PyResult.h"
 #include "CPyCppyy/CommonDefs.h"
 
 // Standard
@@ -193,6 +192,10 @@ CPYCPPYY_EXTERN bool Scope_CheckExact(PyObject* pyobject);
 CPYCPPYY_EXTERN bool Instance_Check(PyObject* pyobject);
 CPYCPPYY_EXTERN bool Instance_CheckExact(PyObject* pyobject);
 
+// memory management: ownership of the underlying C++ object
+CPYCPPYY_EXTERN void Instance_SetPythonOwns(PyObject* pyobject);
+CPYCPPYY_EXTERN void Instance_SetCppOwns(PyObject* pyobject);
+
 // type verifier for sequences
 CPYCPPYY_EXTERN bool Sequence_Check(PyObject* pyobject);
 
@@ -217,9 +220,6 @@ CPYCPPYY_EXTERN bool Import(const std::string& name);
 // execute a python statement (e.g. "import sys")
 CPYCPPYY_EXTERN bool Exec(const std::string& cmd);
 
-// evaluate a python expression (e.g. "1+1")
-CPYCPPYY_EXTERN const PyResult Eval(const std::string& expr);
-
 // execute a python stand-alone script, with argv CLI arguments
 CPYCPPYY_EXTERN void ExecScript(const std::string& name, const std::vector<std::string>& args);
 

bindings/pyroot/cppyy/CPyCppyy/include/CPyCppyy/PyResult.h

@@ -196,6 +196,32 @@ bool CPyCppyy::Instance_CheckExact(PyObject* pyobject)
     return CPPInstance_CheckExact(pyobject);
 }
 
+//-----------------------------------------------------------------------------
+void CPyCppyy::Instance_SetPythonOwns(PyObject* pyobject)
+{
+    if (!Initialize())
+        return;
+
+// check validity of cast
+    if (!CPPInstance_Check(pyobject))
+        return;
+
+    ((CPPInstance *)pyobject)->PythonOwns();
+}
+
+//-----------------------------------------------------------------------------
+void CPyCppyy::Instance_SetCppOwns(PyObject* pyobject)
+{
+    if (!Initialize())
+        return;
+
+// check validity of cast
+    if (!CPPInstance_Check(pyobject))
+        return;
+
+    ((CPPInstance *)pyobject)->CppOwns();
+}
+
 //-----------------------------------------------------------------------------
 bool CPyCppyy::Sequence_Check(PyObject* pyobject)
 {
@@ -313,10 +339,6 @@ bool CPyCppyy::Import(const std::string& mod_name)
             fullname += ".";
             fullname += CPyCppyy_PyText_AsString(pyClName);
 
-      // force class creation (this will eventually call TPyClassGenerator)
-      // TODO: the following is broken (and should live in Cppyy.cxx) to
-      //         TClass::GetClass(fullname.c_str(), true);
-
             Py_XDECREF(pyClName);
         }
 
@@ -430,61 +452,6 @@ bool CPyCppyy::Exec(const std::string& cmd)
     return false;
 }
 
-//-----------------------------------------------------------------------------
-const CPyCppyy::PyResult CPyCppyy::Eval(const std::string& expr)
-{
-// Evaluate a python expression.
-//
-// Caution: do not hold on to the return value: either store it in a builtin
-// type (implicit casting will work), or in a pointer to a cppyy object (explicit
-// casting to a void* is required).
-    if (!Initialize())
-        return PyResult();
-
-// evaluate the expression
-    PyObject* result =
-        PyRun_String(const_cast<char*>(expr.c_str()), Py_eval_input, gMainDict, gMainDict);
-
-// report errors as appropriate; return void
-    if (!result) {
-        PyErr_Print();
-        return PyResult();
-    }
-
-// results that require no conversion
-    if (result == Py_None || CPPInstance_Check(result) ||
-            PyBytes_Check(result) ||
-            PyFloat_Check(result) || PyLong_Check(result) || PyInt_Check(result))
-        return PyResult(result);
-
-// explicit conversion for python type required
-    PyObject* pyclass = (PyObject*)Py_TYPE(result);
-
-// retrieve class name and the module in which it resides
-    PyObject* name = PyObject_GetAttr(pyclass, PyStrings::gName);
-    PyObject* module = PyObject_GetAttr(pyclass, PyStrings::gModule);
-
- // concat name
-    std::string qname =
-        std::string(CPyCppyy_PyText_AsString(module)) + \
-                    '.' + CPyCppyy_PyText_AsString(name);
-    Py_DECREF(module);
-    Py_DECREF(name);
-
-// locate cppyy style class with this name
-    // TODO: use Cppyy.cxx ...
-    //TClass* klass = TClass::GetClass(qname.c_str());
-    void* klass = nullptr;
-
-// construct general cppyy python object that pretends to be of class 'klass'
-    if (klass)
-        return PyResult(result);
-
-// no conversion, return null pointer object
-    Py_DECREF(result);
-    return PyResult();
-}
-
 //-----------------------------------------------------------------------------
 void CPyCppyy::Prompt() {
 // Enter an interactive python session (exit with ^D). State is preserved