test it

Author: EthanSteinberg

include/pybind11/detail/class.h

@@ -165,21 +165,6 @@ extern "C" inline int pybind11_meta_setattro(PyObject *obj, PyObject *name, PyOb
     }
 }
 
-/**
- * Python 3's PyInstanceMethod_Type hides itself via its tp_descr_get, which prevents aliasing
- * methods via cls.attr("m2") = cls.attr("m1"): instead the tp_descr_get returns a plain function,
- * when called on a class, or a PyMethod, when called on an instance.  Override that behaviour here
- * to do a special case bypass for PyInstanceMethod_Types.
- */
-extern "C" inline PyObject *pybind11_meta_getattro(PyObject *obj, PyObject *name) {
-    PyObject *descr = _PyType_Lookup((PyTypeObject *) obj, name);
-    if (descr && PyInstanceMethod_Check(descr)) {
-        Py_INCREF(descr);
-        return descr;
-    }
-    return PyType_Type.tp_getattro(obj, name);
-}
-
 /// metaclass `__call__` function that is used to create all pybind11 objects.
 extern "C" inline PyObject *pybind11_meta_call(PyObject *type, PyObject *args, PyObject *kwargs) {
 
@@ -274,7 +259,6 @@ inline PyTypeObject *make_default_metaclass() {
     type->tp_call = pybind11_meta_call;
 
     type->tp_setattro = pybind11_meta_setattro;
-    type->tp_getattro = pybind11_meta_getattro;
 
     type->tp_dealloc = pybind11_meta_dealloc;
 

include/pybind11/detail/common.h

@@ -274,9 +274,6 @@
 //               behavior.
 
 /// Compatibility macros for Python 2 / Python 3 versions TODO: remove
-#define PYBIND11_INSTANCE_METHOD_NEW(ptr, class_) PyInstanceMethod_New(ptr)
-#define PYBIND11_INSTANCE_METHOD_CHECK PyInstanceMethod_Check
-#define PYBIND11_INSTANCE_METHOD_GET_FUNCTION PyInstanceMethod_GET_FUNCTION
 #define PYBIND11_BYTES_CHECK PyBytes_Check
 #define PYBIND11_BYTES_FROM_STRING PyBytes_FromString
 #define PYBIND11_BYTES_FROM_STRING_AND_SIZE PyBytes_FromStringAndSize

include/pybind11/detail/function_record.h

@@ -602,53 +602,22 @@ inline handle create_pybind_function_overload_set(handle existing_function) {
     return create_pybind_function<function_overload_set>(existing_function);
 }
 
-inline handle
-combine_functions(handle existing_function, handle new_function, bool prepend, bool is_method) {
-    // TODO: InstanceMethod here is very inefficient
+inline handle combine_functions(handle existing_function, handle new_function, bool prepend) {
     pybind_function *new_wrapper = (pybind_function *) new_function.ptr();
 
-    bool pulled_from_instance_method = false;
-    if (PyInstanceMethod_Check(existing_function.ptr())) {
-        pulled_from_instance_method = true;
-        existing_function = PyInstanceMethod_GET_FUNCTION(existing_function.ptr());
-    }
-
     if (!PyObject_TypeCheck(existing_function.ptr(), pybind_function_type())) {
         if (!existing_function.is_none() && new_wrapper->name[0] != '_') {
             pybind11_fail(std::string("Found an existing object when trying to defined function ")
                           + new_wrapper->name);
         }
 
-        if (is_method) {
-            return PyInstanceMethod_New(new_function.ptr());
-        }
         return new_function.ptr();
     }
 
-    if (is_method != pulled_from_instance_method) {
-        pybind11_fail(
-            "overloading a method with both static and instance methods is not supported; "
-#if !defined(PYBIND11_DETAILED_ERROR_MESSAGES)
-            "#define PYBIND11_DETAILED_ERROR_MESSAGES or compile in debug mode for more "
-            "details"
-#else
-            "error while attempting to bind "
-            + std::string(is_method ? "instance" : "static") + " method "
-            + std::string(pybind11::str(
-                ((handle) ((PyObject *) new_wrapper->current_scope)).attr("__name__")))
-            + "." + std::string(new_wrapper->name) + new_wrapper->signature
-#endif
-        );
-    }
-
     pybind_function *wrapper = (pybind_function *) existing_function.ptr();
 
     if (wrapper->current_scope != new_wrapper->current_scope) {
-        if (is_method) {
-            return PyInstanceMethod_New(new_function.ptr());
-        } else {
-            return new_function.ptr();
-        }
+        return new_function.ptr();
     }
 
     if (!wrapper->is_overload_set) {
@@ -663,10 +632,6 @@ combine_functions(handle existing_function, handle new_function, bool prepend, b
 
     wrapper->doc = wrapped->doc.c_str();
 
-    if (is_method) {
-        return PyInstanceMethod_New(existing_function.ptr());
-    }
-
     return existing_function;
 }
 

include/pybind11/detail/internal_pytypes.h

@@ -6,6 +6,7 @@
 #include "vendor/optional.h"
 
 #include <array>
+#include <iostream>
 
 PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
 PYBIND11_NAMESPACE_BEGIN(detail)
@@ -207,11 +208,20 @@ struct pybind_function_type_data {
 
         set_vectorcall_set_offset(type, offsetof(pybind_function, vectorcall));
 
-        type.tp_flags = Py_TPFLAGS_DEFAULT | pybind_vectorcall_flag;
+        type.tp_flags = Py_TPFLAGS_METHOD_DESCRIPTOR | Py_TPFLAGS_DEFAULT | pybind_vectorcall_flag;
 
-        type.tp_descr_get = [](PyObject *, PyObject *, PyObject *) -> PyObject * {
-            printf("Shouldn't be calling this\n");
-            abort();
+        type.tp_descr_get = [](PyObject *self, PyObject *obj, PyObject *) -> PyObject * {
+            // std::cout << "Ideally shouldn't be calling tp_descr_get ... " << obj << std::endl;
+            if (obj == nullptr) {
+                Py_INCREF(self);
+                return self;
+            } else {
+                PyObject *result_method = PyMethod_New(self, obj);
+                if (result_method == nullptr) {
+                    pybind11_fail("Could not create method binder");
+                }
+                return result_method;
+            }
         };
 
         int ret = PyType_Ready(&type);
@@ -245,20 +255,6 @@ handle create_pybind_function(Args &&...args) {
     return (PyObject *) om;
 }
 
-inline bool is_pybind_function(handle func) {
-    if (!func) {
-        return false;
-    }
-    if (PyMethod_Check(func.ptr())) {
-        func = PyMethod_Function(func.ptr());
-    }
-    if (PyInstanceMethod_Check(func.ptr())) {
-        func = PyInstanceMethod_GET_FUNCTION(func.ptr());
-    }
-
-    return PyObject_TypeCheck(func.ptr(), pybind_function_type());
-}
-
 inline void append_note_if_missing_header_is_suspected(std::string &msg) {
     if (msg.find("std::") != std::string::npos) {
         msg += "\n\n"

include/pybind11/pybind11.h

@@ -128,12 +128,10 @@ class cpp_function : public function {
         sibling sib = std::get<sibling_index>(std::forward_as_tuple(extra..., sibling(none())));
 
         bool has_prepend = detail::any_of<std::is_same<prepend, Extra>...>::value;
-        bool has_is_method = detail::any_of<std::is_same<is_method, Extra>...>::value;
 
         handle new_function
             = detail::create_pybind_function_wrapper(std::forward<Func>(f), a, extra...);
-        m_ptr
-            = detail::combine_functions(sib.value, new_function, has_prepend, has_is_method).ptr();
+        m_ptr = detail::combine_functions(sib.value, new_function, has_prepend).ptr();
     }
 };
 
@@ -1665,6 +1663,22 @@ inline const char *error_already_set::what() const noexcept {
 
 PYBIND11_NAMESPACE_BEGIN(detail)
 
+inline bool is_pybind11_function(const function &func) {
+    PyObject *ptr = func.ptr();
+    if (ptr == nullptr) {
+        return false;
+    }
+
+    if (PyMethod_Check(ptr)) {
+        ptr = PyMethod_GET_FUNCTION(ptr);
+        if (ptr == nullptr) {
+            return false;
+        }
+    }
+
+    return PyObject_TypeCheck(ptr, pybind_function_type());
+}
+
 inline function
 get_type_override(const void *this_ptr, const type_info *this_type, const char *name) {
     handle self = get_object_handle(this_ptr, this_type);
@@ -1683,14 +1697,14 @@ get_type_override(const void *this_ptr, const type_info *this_type, const char *
 
     function override = getattr(self, name, function());
 
-    if (detail::is_pybind_function(override)) {
+    if (is_pybind11_function(override)) {
         // TODO: Fix this
         cache.insert(std::move(key));
         return function();
     }
 
-    /* Don't call dispatch code if invoked from overridden function.
-       Unfortunately this doesn't work on PyPy. */
+/* Don't call dispatch code if invoked from overridden function.
+   Unfortunately this doesn't work on PyPy. */
 #if !defined(PYPY_VERSION)
 #    if PY_VERSION_HEX >= 0x03090000
     PyFrameObject *frame = PyThreadState_GetFrame(PyThreadState_Get());

include/pybind11/pytypes.h

@@ -824,16 +824,6 @@ inline ssize_t hash(handle obj) {
 /// @} python_builtins
 
 PYBIND11_NAMESPACE_BEGIN(detail)
-inline handle get_function(handle value) {
-    if (value) {
-        if (PyInstanceMethod_Check(value.ptr())) {
-            value = PyInstanceMethod_GET_FUNCTION(value.ptr());
-        } else if (PyMethod_Check(value.ptr())) {
-            value = PyMethod_GET_FUNCTION(value.ptr());
-        }
-    }
-    return value;
-}
 
 // Reimplementation of python's dict helper functions to ensure that exceptions
 // aren't swallowed (see #2862)

tests/test_methods_and_attributes.py

@@ -227,33 +227,6 @@ def test_metaclass_override():
     assert isinstance(m.MetaclassOverride.__dict__["readonly"], int)
 
 
-def test_no_mixed_overloads():
-    from pybind11_tests import detailed_error_messages_enabled
-
-    with pytest.raises(RuntimeError) as excinfo:
-        m.ExampleMandA.add_mixed_overloads1()
-    assert str(
-        excinfo.value
-    ) == "overloading a method with both static and instance methods is not supported; " + (
-        "#define PYBIND11_DETAILED_ERROR_MESSAGES or compile in debug mode for more details"
-        if not detailed_error_messages_enabled
-        else "error while attempting to bind static method ExampleMandA.overload_mixed1"
-        "(arg0: float) -> str"
-    )
-
-    with pytest.raises(RuntimeError) as excinfo:
-        m.ExampleMandA.add_mixed_overloads2()
-    assert str(
-        excinfo.value
-    ) == "overloading a method with both static and instance methods is not supported; " + (
-        "#define PYBIND11_DETAILED_ERROR_MESSAGES or compile in debug mode for more details"
-        if not detailed_error_messages_enabled
-        else "error while attempting to bind instance method ExampleMandA.overload_mixed2"
-        "(self: pybind11_tests.methods_and_attributes.ExampleMandA, arg0: int, arg1: int)"
-        " -> str"
-    )
-
-
 @pytest.mark.parametrize("access", ["ro", "rw", "static_ro", "static_rw"])
 def test_property_return_value_policies(access):
     if not access.startswith("static"):