[BUG]: Supplying `nb::arg()`s changes implicit conversion behavior for `self`

[inducer]

Problem description

The self argument to a function appears to undergo implicit conversion if a method is wrapped without supplying any nb::args, but as soon as they are supplied, implicit conversion no longer takes place.

To reproduce: Within nanobind_example, use this as nanobind_example_ext.cpp:

#include <nanobind/nanobind.h>

namespace nb = nanobind;

using namespace nb::literals;

struct a {};
struct b {
    b(a const &inst_a)
    {}
};

void f(b const &inst_b, int i)
{ }

NB_MODULE(nanobind_example_ext, m) {
    nb::class_<a> wrap_a(m, "A");
    nb::class_<b> wrap_b(m, "B");

    wrap_a.def(nb::init<>());
    wrap_b.def(nb::init_implicit<a const &>());
    wrap_a.def("f_no_args", f);
    wrap_a.def("f_with_args", f, nb::arg("i"));
}

Use this as __init__.py:

from .nanobind_example_ext import A, B

And run the following script:

import nanobind_example as nbex

a = nbex.A()
a.f_no_args(0)
a.f_with_args(0)

Observe the following output:

$ python nbex.py
Traceback (most recent call last):
  File "/home/andreas/tmp/nbex.py", line 5, in <module>
    a.f_with_args(0)
    ~~~~~~~~~~~~~^^^
TypeError: f_with_args(): incompatible function arguments. The following argument types are supported:
    1. f_with_args(self, i: int) -> None

Invoked with types: nanobind_example.nanobind_example_ext.A, int

Observe that the call to f_no_args has succeeded, but the call to f_with_args is failing.

I've chased this down to a point where I think supplying args must be clearing the cast_flags::convert on the self argument. But I wasn't able to pinpoint how/where that happens.

Observed with nanobind 2.7.0, Python 3.13.3.

[wjakob]

I am curious: what is actually the expected behavior here? I find the implicit conversion for self to be potentially dangerous and just wrote a patch to fix this behavior (see below). But then I noticed that this actually causes one of the test cases to fail.

diff --git a/src/nb_func.cpp b/src/nb_func.cpp
index 915b2fc..c76eb53 100644
--- a/src/nb_func.cpp
+++ b/src/nb_func.cpp
@@ -917,6 +917,8 @@ static PyObject *nb_func_vectorcall_simple(PyObject *self,
 
         if (is_constructor)
             args_flags[0] = (uint8_t) cast_flags::construct;
+        else if (is_method)
+            args_flags[0] = 0;
 
         for (size_t k = 0; k < count; ++k) {
             const func_data *f = fr + k;
@@ -1017,7 +1019,8 @@ static PyObject *nb_func_vectorcall_simple_1(PyObject *self,
                                              PyObject *kwargs_in) noexcept {
     func_data *fr = nb_func_data(self);
     const size_t nargs_in = (size_t) NB_VECTORCALL_NARGS(nargsf);
-    bool is_constructor = fr->flags & (uint32_t) func_flags::is_constructor;
+    bool is_constructor = fr->flags & (uint32_t) func_flags::is_constructor,
+         is_method      = fr->flags & (uint32_t) func_flags::is_method;
 
     // Handler routine that will be invoked in case of an error condition
     PyObject *(*error_handler)(PyObject *, PyObject *const *, size_t,
@@ -1029,7 +1032,9 @@ static PyObject *nb_func_vectorcall_simple_1(PyObject *self,
         PyObject *arg = args_in[0];
         cleanup_list cleanup(arg);
         uint8_t args_flags[1] = {
-            (uint8_t) (is_constructor ? (1 | (uint8_t) cast_flags::construct) : 1)
+            (uint8_t)
+            ((is_constructor ?  cast_flags::construct : 0) |
+             (is_method ? 1 : 0))
         };
 
         try {
diff --git a/tests/test_classes.cpp b/tests/test_classes.cpp
index caaa9ec..26b4f7d 100644
--- a/tests/test_classes.cpp
+++ b/tests/test_classes.cpp
@@ -349,6 +349,9 @@ NB_MODULE(test_classes_ext, m) {
         .def(nb::init_implicit<const B *>())
         .def(nb::init_implicit<int>())
         .def(nb::init_implicit<float>())
+        .def("method_1", [](D&){})
+        .def("method_2", [](D&, int){})
+        .def("method_3", [](D&, int, int){}, "b"_a, "c"_a)
         .def_rw("value", &D::value);
 
     m.def("get_d", [](const D &d) { return d.value; });
diff --git a/tests/test_classes.py b/tests/test_classes.py
index a34fa65..2075a82 100644
--- a/tests/test_classes.py
+++ b/tests/test_classes.py
@@ -316,6 +316,14 @@ def test13_implicitly_convertible():
     assert t.get_d_via_cast(c) == (-1, -1, -1, -1)
     assert t.get_d_via_try_cast(c) == (-1, -1, -1, -1)
 
+    with pytest.raises(TypeError, match='incompatible function arguments'):
+        t.D.method_1(1)
+
+    with pytest.raises(TypeError, match='incompatible function arguments'):
+        t.D.method_2(1, 2)
+
+    with pytest.raises(TypeError, match='incompatible function arguments'):
+        t.D.method_3(1, 2, 3)
 
 def test14_operators():
     a = t.Int(1)

[inducer]

I am curious: what is actually the expected behavior here?

islpy wraps isl, which exposes (among other things) operations on subsets of $\mathbb Z^n$, specifically BasicSets, which are (quasi-)convex, and Sets, which are unions of those. BasicSets can be converted to Sets without loss of information. isl itself makes many useful operations only available on Sets (e.g. finding a lower bound along a dimension). With implicit conversion, I can simply take the existing wrapper function (taking a Set) and expose it as a method on a BasicSet. Pybind11 allowed this practice, so I was not surprised when nanobind did, too.

In this instance, safety of the implicit conversion is not a concern; all objects are immutable.

As a matter of full disclosure, more-recent me is a little less impressed with this pattern than I maybe once was, but we might be contending with two layers of Hyrum's law in this case.