Changed constructor override order in Pybind11 3.1.0

[neworderofjamie]

First of all, thanks for the amazing library! I have just isolated an issue that occurs when building our project with Pybind11 3.1.0 vs 3.0.4 and I was hoping for a suggestion for a workaround.

We have a class called NumericValue, the relevant parts of which look like:

class NumericValue
{
public:
    NumericValue(double value) : m_Value(value){}
    NumericValue(int64_t value) : m_Value(value){}

    const std::variant<double, uint64_t, int64_t> &get() const{ return m_Value; }

private:
    std::variant<double, uint64_t, int64_t> m_Value;
};

This is wrapped for use in Python with:

pybind11::class_<NumericValue>(m, "NumericValue")
        .def(pybind11::init<double>())
        .def(pybind11::init<int64_t>())

        .def_property_readonly("value", &Type::NumericValue::get);

With Pybind11 3.0.4, if you constructed a NumericValue with a Python integer, the int64_t constructor was called but, with Pybind11 3.1.0, the double constructor gets called instead. At the suggestion of copilot, I have tried:

1. Adding noconvert to the int64_t constructor:

   .def(pybind11::init<int64_t>(), pybind11::arg("value").noconvert())

2. Making a pybind11::int_val constructor with a lambda function:

   .def(pybind11::init([](pybind11::int_ val){ return new Type::NumericValue(static_cast<int64_t>(val)); }),
                           pybind11::arg("value").noconvert())

Neither of which solve the problem! I am guessing this is related to #5879 but what's the correct solution here?

[henryiii]

🤖 AI text below 🤖

Yes, this comes from #5879. The change is intentional (it follows the PEP 484 numeric tower), but the overload order now matters.

pybind11 tries overloads in two passes. The first pass does not allow conversion. Since 3.1.0, a double argument accepts a Python int in that first pass. Because init<double> is registered first, it matches before init<int64_t> is tried. Adding .noconvert() to the int64_t overload does not help, because the double overload still matches first in the same pass.

The fix is to register the int64_t constructor first:

pybind11::class_<NumericValue>(m, "NumericValue")
    .def(pybind11::init<int64_t>())
    .def(pybind11::init<double>())
    .def_property_readonly("value", &NumericValue::get);

A Python int then matches int64_t. A Python float is never accepted by the integer caster, so it still goes to double. This order works on both 3.0.x and 3.1.x.