optional reference_wrapper vector of uint8_t memory errors

[jlimaqti]

I'm having strange issues with trying to call this function from python. Argument a's size often seems to have weird values (often 16 or 2^64-1).

size_t myfunc(const std::optional<std::reference_wrapper<const std::vector<uint8_t>>>& a = std::nullopt,
                        const std::optional<std::vector<float>>& b = std::nullopt)

It seems to be the introduction of the 2nd argument that triggers the observation of the issue, but my intuition is it is a memory issue so it may only be exposed by the second argument.

Here is a small reproduceable snippet, also with examples of similar calls that work OK:

#include <cstdint>
#include <functional>
#include <optional>
#include <vector>
#include <memory>

#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
#include <pybind11/numpy.h>

class PybindTest
{
public:
    /* Problem case */
    size_t optrefwrap_uint8(const std::optional<std::reference_wrapper<const std::vector<uint8_t>>>& a = std::nullopt,
                            const std::optional<std::vector<float>>& b = std::nullopt)
    {
        if (a.has_value()) { return a->get().size(); }
        else { return 999; }
    }
    /* Similar, but OK cases */
    size_t optrefwrap_novec_uint8(const std::optional<std::reference_wrapper<uint8_t>>& a = std::nullopt,
                                  const std::optional<std::vector<float>>& b = std::nullopt)
    {
        if (a.has_value()) { return a->get(); }
        else { return 999; }
    }
    size_t opt_uint8(const std::optional<const std::vector<uint8_t>>& a = std::nullopt,
                     const std::optional<std::vector<float>>& b = std::nullopt)
    {
        if (a.has_value()) { return a->size(); }
        else { return 999; }
    }
    size_t refwrap_2ndopt_uint8(const std::reference_wrapper<const std::vector<uint8_t>>& a, const std::optional<std::vector<float>>& b = std::nullopt)
    {
        return a.get().size();
    }
    size_t optrefwrap_no2ndopt_uint8(const std::optional<std::reference_wrapper<const std::vector<uint8_t>>>& a = std::nullopt,
                                     const std::vector<float>& b = {})
    {
        if (a.has_value()) { return a->get().size(); }
        else { return 999; }
    }
    size_t optrefwrap_int32(const std::optional<std::reference_wrapper<const std::vector<int32_t>>>& a = std::nullopt,
                            const std::optional<std::vector<float>>& b = std::nullopt)
    {
        if (a.has_value()) { return a->get().size(); }
        else { return 999; }
    }
};

namespace py = pybind11;

PYBIND11_MODULE(PybindTest, m)
{
py::class_<PybindTest, std::shared_ptr<PybindTest>>(m, "PybindTest")
    .def(py::init<>())
    .def("optrefwrap_uint8", &PybindTest::optrefwrap_uint8, py::arg("a") = py::none(), py::arg("b") = py::none())
    .def("optrefwrap_no2ndopt_uint8", &PybindTest::optrefwrap_no2ndopt_uint8, py::arg("a") = py::none(), py::arg("b") = std::vector<float>())
    .def("opt_uint8", &PybindTest::opt_uint8, py::arg("a") = py::none(), py::arg("b") = py::none())
    .def("refwrap_2ndopt_uint8", &PybindTest::refwrap_2ndopt_uint8, py::arg("a"), py::arg("b"))
    .def("optrefwrap_int32", &PybindTest::optrefwrap_int32, py::arg("a") = py::none(), py::arg("b") = py::none())
    .def("optrefwrap_novec_uint8", &PybindTest::optrefwrap_novec_uint8, py::arg("a") = py::none(), py::arg("b") = py::none());
}

Python calls:

import numpy as np

import PybindTest

def test_foo():
    a = np.array([1, 2, 3, 4], dtype=np.uint8)
    b = np.array([10, 12, 14, 17], dtype=np.float32)
    t = PybindTest.PybindTest()

    assert 4 == t.opt_uint8(a,b) #OK
    assert 4 == t.refwrap_2ndopt_uint8(a,b) #OK
    assert 4 == t.optrefwrap_int32(a,b) #OK
    assert 4 == t.optrefwrap_no2ndopt_uint8(a,b) #OK
    assert 2 == t.optrefwrap_novec_uint8(a[1],b) #OK
    assert 999 == t.optrefwrap_uint8() #OK
    assert 4 == t.optrefwrap_uint8(a) #OK
    assert 4 == t.optrefwrap_uint8(a,b) #Fails with value 16

Code was built using the pybind cmake_example, ran on Ubuntu 22.04, Python 3.10.

I always hesitate to conclude that there is a bug in a well-used project like this, before I file a bug, am I doing anything obviously wrong here?