Sync CPPOverload

Author: aaronj0

src/CPPOverload.cxx

@@ -342,8 +342,15 @@ static PyObject* mp_func_closure(CPPOverload* /* pymeth */, void*)
     Py_RETURN_NONE;
 }
 
+// To declare a variable as unused only when compiling for Python 3.
+#if PY_VERSION_HEX < 0x03000000
+#define CPyCppyy_Py3_UNUSED(name) name
+#else
+#define CPyCppyy_Py3_UNUSED(name)
+#endif
+
 //----------------------------------------------------------------------------
-static PyObject* mp_func_code(CPPOverload* pymeth, void*)
+static PyObject* mp_func_code(CPPOverload* CPyCppyy_Py3_UNUSED(pymeth), void*)
 {
 // Code details are used in module inspect to fill out interactive help()
 #if PY_VERSION_HEX < 0x03000000
@@ -410,7 +417,6 @@ static PyObject* mp_func_code(CPPOverload* pymeth, void*)
     return code;
 #else
 // not important for functioning of most code, so not implemented for p3 for now (TODO)
-    pymeth = 0;
     Py_RETURN_NONE;
 #endif
 }
@@ -821,7 +827,7 @@ static CPPOverload* mp_descr_get(CPPOverload* pymeth, CPPInstance* pyobj, PyObje
     }
 
 // vector calls don't get here, unless a method is looked up on an instance, for
-// e.g. class mathods (C++ static); notify downstream to expect a 'self'
+// e.g. class methods (C++ static); notify downstream to expect a 'self'
     newPyMeth->fFlags |= CallContext::kFromDescr;
 
 #else
@@ -925,13 +931,22 @@ static PyObject* mp_overload(CPPOverload* pymeth, PyObject* args)
 {
 // Select and call a specific C++ overload, based on its signature.
     const char* sigarg = nullptr;
+    PyObject* sigarg_tuple = nullptr;
     int want_const = -1;
-    if (PyTuple_GET_SIZE(args) && \
-            !PyArg_ParseTuple(args, const_cast<char*>("s|i:__overload__"), &sigarg, &want_const))
+    Py_ssize_t args_size = PyTuple_GET_SIZE(args);
+    if (args_size &&
+        PyArg_ParseTuple(args, const_cast<char*>("s|i:__overload__"), &sigarg, &want_const)) {
+        want_const = args_size == 1 ? -1 : want_const;
+        return pymeth->FindOverload(sigarg ? sigarg : "", want_const);
+    } else if (args_size &&
+               PyArg_ParseTuple(args, const_cast<char*>("O|i:__overload__"), &sigarg_tuple, &want_const)) {
+        PyErr_Clear();
+        want_const = args_size == 1 ? -1 : want_const;
+        return pymeth->FindOverload(sigarg_tuple, want_const);
+    } else {
+        PyErr_Format(PyExc_TypeError, "Unexpected arguments to __overload__");
         return nullptr;
-    want_const = PyTuple_GET_SIZE(args) == 1 ? -1 : want_const;
-
-    return pymeth->FindOverload(sigarg ? sigarg : "", want_const);
+    }
 }
 
 static PyObject* mp_add_overload(CPPOverload* pymeth, PyObject* new_overload)
@@ -1034,6 +1049,12 @@ PyTypeObject CPPOverload_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
@@ -1095,7 +1116,6 @@ PyObject* CPyCppyy::CPPOverload::FindOverload(const std::string& signature, int
 
     CPPOverload::Methods_t& methods = fMethodInfo->fMethods;
     for (auto& meth : methods) {
-
         bool found = accept_any;
         if (!found) {
             PyObject* pysig2 = meth->GetSignature(false);
@@ -1144,6 +1164,67 @@ PyObject* CPyCppyy::CPPOverload::FindOverload(const std::string& signature, int
     return (PyObject*)newmeth;
 }
 
+PyObject* CPyCppyy::CPPOverload::FindOverload(PyObject *args_tuple, int want_const)
+{
+    Py_ssize_t n = PyTuple_Size(args_tuple);
+
+    CPPOverload::Methods_t& methods = fMethodInfo->fMethods;
+
+    // This value is set based on the maximum penalty in Cppyy::CompareMethodArgType
+    Py_ssize_t min_score = INT_MAX;
+    bool found = false;
+    size_t best_method = 0, method_index = 0;
+
+    for (auto& meth : methods) {
+        if (0 <= want_const) {
+            bool isconst = meth->IsConst();
+            if (!((want_const && isconst) || (!want_const && !isconst)))
+                continue;
+        }
+
+        int score = meth->GetArgMatchScore(args_tuple);
+
+        if (score < min_score) {
+            found = true;
+            min_score = score;
+            best_method = method_index;
+        }
+
+        method_index++;
+    }
+
+    if (!found) {
+        std::string sigargs("(");
+
+        for (int i = 0; i < n; i++) {
+            PyObject *pItem = PyTuple_GetItem(args_tuple, i);
+            if(!CPyCppyy_PyText_Check(pItem)) {
+                PyErr_Format(PyExc_LookupError, "argument types should be in string format");
+                return (PyObject*) nullptr;
+            }
+            std::string arg_type(CPyCppyy_PyText_AsString(pItem));
+            sigargs += arg_type + ", ";
+        }
+        sigargs += ")";
+
+        PyErr_Format(PyExc_LookupError, "signature with arguments \"%s\" not found", sigargs.c_str());
+        return (PyObject*) nullptr;
+    }
+
+    CPPOverload* newmeth = mp_new(nullptr, nullptr, nullptr);
+    CPPOverload::Methods_t vec;
+    vec.push_back(methods[best_method]->Clone());
+    newmeth->Set(fMethodInfo->fName, vec);
+
+    if (fSelf) {
+        Py_INCREF(fSelf);
+        newmeth->fSelf = fSelf;
+    }
+    newmeth->fMethodInfo->fFlags = fMethodInfo->fFlags;
+
+    return (PyObject*) newmeth;
+}
+
 //----------------------------------------------------------------------------
 CPyCppyy::CPPOverload::MethodInfo_t::~MethodInfo_t()
 {

src/CPPOverload.h

@@ -67,6 +67,7 @@ class CPPOverload {
 
 // find a method based on the provided signature
     PyObject* FindOverload(const std::string& signature, int want_const = -1);
+    PyObject* FindOverload(PyObject *args_tuple, int want_const = -1);
 
 public:                 // public, as the python C-API works with C structs
     PyObject_HEAD