Sync CustomPyTypes

Author: aaronj0

src/CustomPyTypes.cxx

@@ -6,12 +6,20 @@
 #include "ProxyWrappers.h"
 #include "PyStrings.h"
 
+// As of Python 3.12, we can't use the PyMethod_GET_FUNCTION and
+// PyMethod_GET_SELF macros anymore, as the contain asserts that check if the
+// Python type is actually PyMethod_Type. If the Python type is
+// CustomInstanceMethod_Type, we need our own macros. Technically they do they
+// same, because the actual C++ type of the PyObject is PyMethodObject anyway.
+#define CustomInstanceMethod_GET_SELF(meth) reinterpret_cast<PyMethodObject *>(meth)->im_self
+#define CustomInstanceMethod_GET_FUNCTION(meth) reinterpret_cast<PyMethodObject *>(meth)->im_func
 #if PY_VERSION_HEX >= 0x03000000
 // TODO: this will break functionality
-#define PyMethod_GET_CLASS(meth) Py_None
+#define CustomInstanceMethod_GET_CLASS(meth) Py_None
+#else
+#define CustomInstanceMethod_GET_CLASS(meth) PyMethod_GET_CLASS(meth)
 #endif
 
-
 namespace CPyCppyy {
 
 #if PY_VERSION_HEX < 0x03000000
@@ -156,6 +164,12 @@ PyTypeObject TypedefPointerToClass_Type = {
 #if PY_VERSION_HEX >= 0x03040000
     , 0                           // tp_finalize
 #endif
+#if PY_VERSION_HEX >= 0x03080000
+    , 0                           // tp_vectorcall
+#endif
+#if PY_VERSION_HEX >= 0x030c0000
+    , 0                           // tp_watched
+#endif
 };
 
 //= instancemethod object with a more efficient call function ================
@@ -237,13 +251,13 @@ static PyObject* im_call(PyObject* meth, PyObject* args, PyObject* kw)
 // into the list of arguments. However, the pythonized methods will then have
 // to undo that shuffling, which is inefficient. This method is the same as
 // the one for the instancemethod object, except for the shuffling.
-    PyObject* self = PyMethod_GET_SELF(meth);
+    PyObject* self = CustomInstanceMethod_GET_SELF(meth);
 
     if (!self) {
     // unbound methods must be called with an instance of the class (or a
     // derived class) as first argument
         Py_ssize_t argc = PyTuple_GET_SIZE(args);
-        PyObject* pyclass = PyMethod_GET_CLASS(meth);
+        PyObject* pyclass = CustomInstanceMethod_GET_CLASS(meth);
         if (1 <= argc && PyObject_IsInstance(PyTuple_GET_ITEM(args, 0), pyclass) == 1) {
             self = PyTuple_GET_ITEM(args, 0);
 
@@ -262,7 +276,7 @@ static PyObject* im_call(PyObject* meth, PyObject* args, PyObject* kw)
     } else
         Py_INCREF(args);
 
-    PyCFunctionObject* func = (PyCFunctionObject*)PyMethod_GET_FUNCTION(meth);
+    PyCFunctionObject* func = (PyCFunctionObject*)CustomInstanceMethod_GET_FUNCTION(meth);
 
 // the function is globally shared, so set and reset its "self" (ok, b/c of GIL)
     Py_INCREF(self);
@@ -279,10 +293,10 @@ static PyObject* im_descr_get(PyObject* meth, PyObject* obj, PyObject* pyclass)
 {
 // from instancemethod: don't rebind an already bound method, or an unbound method
 // of a class that's not a base class of pyclass
-    if (PyMethod_GET_SELF(meth)
+    if (CustomInstanceMethod_GET_SELF(meth)
 #if PY_VERSION_HEX < 0x03000000
-         || (PyMethod_GET_CLASS(meth) &&
-             !PyObject_IsSubclass(pyclass, PyMethod_GET_CLASS(meth)))
+         || (CustomInstanceMethod_GET_CLASS(meth) &&
+             !PyObject_IsSubclass(pyclass, CustomInstanceMethod_GET_CLASS(meth)))
 #endif
             ) {
         Py_INCREF(meth);
@@ -292,7 +306,7 @@ static PyObject* im_descr_get(PyObject* meth, PyObject* obj, PyObject* pyclass)
     if (obj == Py_None)
         obj = nullptr;
 
-    return CustomInstanceMethod_New(PyMethod_GET_FUNCTION(meth), obj, pyclass);
+    return CustomInstanceMethod_New(CustomInstanceMethod_GET_FUNCTION(meth), obj, pyclass);
 }
 
 //= CPyCppyy custom instance method type =====================================
@@ -321,6 +335,12 @@ PyTypeObject CustomInstanceMethod_Type = {
 #if PY_VERSION_HEX >= 0x03040000
     , 0                            // tp_finalize
 #endif
+#if PY_VERSION_HEX >= 0x03080000
+    , 0                           // tp_vectorcall
+#endif
+#if PY_VERSION_HEX >= 0x030c0000
+    , 0                           // tp_watched
+#endif
 };
 
 
@@ -372,6 +392,12 @@ PyTypeObject IndexIter_Type = {
 #if PY_VERSION_HEX >= 0x03040000
     , 0                           // tp_finalize
 #endif
+#if PY_VERSION_HEX >= 0x03080000
+    , 0                           // tp_vectorcall
+#endif
+#if PY_VERSION_HEX >= 0x030c0000
+    , 0                           // tp_watched
+#endif
 };
 
 
@@ -394,7 +420,10 @@ static PyObject* vectoriter_iternext(vectoriterobject* vi) {
     // that objects in vectors are simple and thus do not need to maintain object identity
     // (or at least not during the loop anyway). This gains 2x in performance.
         Cppyy::TCppObject_t cppobj = (Cppyy::TCppObject_t)((ptrdiff_t)vi->vi_data + vi->vi_stride * vi->ii_pos);
-        result = CPyCppyy::BindCppObjectNoCast(cppobj, vi->vi_klass, CPyCppyy::CPPInstance::kNoMemReg);
+        if (vi->vi_flags & vectoriterobject::kIsPolymorphic)
+            result = CPyCppyy::BindCppObject(*(void**)cppobj, vi->vi_klass, CPyCppyy::CPPInstance::kNoMemReg);
+        else
+            result = CPyCppyy::BindCppObjectNoCast(cppobj, vi->vi_klass, CPyCppyy::CPPInstance::kNoMemReg);
         if ((vi->vi_flags & vectoriterobject::kNeedLifeLine) && result)
             PyObject_SetAttr(result, PyStrings::gLifeLine, vi->ii_container);
     } else {
@@ -431,6 +460,12 @@ PyTypeObject VectorIter_Type = {
 #if PY_VERSION_HEX >= 0x03040000
     , 0                           // tp_finalize
 #endif
+#if PY_VERSION_HEX >= 0x03080000
+    , 0                           // tp_vectorcall
+#endif
+#if PY_VERSION_HEX >= 0x030c0000
+    , 0                           // tp_watched
+#endif
 };
 
 } // namespace CPyCppyy

src/CustomPyTypes.h

@@ -102,6 +102,7 @@ struct vectoriterobject : public indexiterobject {
     enum EFlags {
         kDefault        = 0x0000,
         kNeedLifeLine   = 0x0001,
+        kIsPolymorphic  = 0x0002,
     };
 };