fix: do not run keep_alive for an overload that failed argument conversion

[jturney]

Description

Calling an overloaded function bound with py::keep_alive<0, N> segfaults whenever the call is not matched by the first overload tried. Minimal reproducer:

struct Tensor {};
struct Holder {
    Tensor t;
    Tensor &from_int(int)            { return t; }
    Tensor &from_string(std::string) { return t; }
};

PYBIND11_MODULE(min, m) {
    py::class_<Tensor>(m, "Tensor");
    py::class_<Holder>(m, "Holder")
        .def(py::init<>())
        .def("make", &Holder::from_int,    py::return_value_policy::reference, py::keep_alive<0, 1>())
        .def("make", &Holder::from_string, py::return_value_policy::reference, py::keep_alive<0, 1>());
}

>>> h.make(1)     # <min.Tensor object at 0x...>
>>> h.make("x")   # Segmentation fault

The crash is EXC_BAD_ACCESS in _Py_TYPE(ob=0x1). Swapping the registration order swaps which call crashes, so it is always the call that reaches an overload after an earlier one failed argument conversion. return_value_policy::reference is not required to trigger it, and removing keep_alive makes it go away.

Cause

The dispatch lambda in cpp_function::initialize runs the post-call hook unconditionally (pybind11.h:596-603):

auto result = call_impl<...>(call, ...);
process_attributes<Extra...>::postcall(call, result);

call_impl bails out at pybind11.h:504 when argument loading fails:

if (!args_converter.load_args(call)) { return PYBIND11_TRY_NEXT_OVERLOAD; }

and that sentinel is ((PyObject *) 1) (detail/common.h:367). For a keep_alive whose nurse or patient is index 0 the work happens in postcall, so keep_alive_impl receives the sentinel as ret, get_arg(0) returns it, and _Py_TYPE dereferences it.

The existing guards do not catch this. The sentinel is neither null nor Py_None, so it passes straight through the checks added in #341.

Fix

A single guard inside keep_alive_impl, beside those checks.

On scope: only the Nurse == 0 || Patient == 0 specialization does its work in postcall. The other specialization runs in precall, against a fully populated call.args, and I verified that keep_alive<1, 2> on the same setup is unaffected. keep_alive is also the only call policy with a non-trivial postcall; the other three in attr.h have empty bodies. So this guard covers every path that can observe the sentinel.

An alternative would be to guard the postcall call site so that no policy runs on the bail-out path. That may be more correct in general, since running a post-call hook for a call that never happened is questionable on its own terms, but it changes behaviour for call policies broadly. I went with the narrow fix and am happy to switch if you prefer the other.

Tests

Added to test_call_policies. The new test crashes the interpreter without the fix, which is rather the point: pybind11 currently has no test that exercises a call policy on a failing overload, and that gap is the likely reason this went unnoticed for so long.

Full suite on macOS/arm64, clang, Python 3.14, against master 5e9611a:

	result
master (baseline)	1326 passed, 23 skipped, 2 xfailed, 1 xpassed
this PR	1327 passed, 23 skipped, 2 xfailed, 1 xpassed

Notes

Reproduces on both v3.1.0 and current master. I could not find an existing issue or PR for this. I searched issues and PRs for keep_alive, postcall, and TRY_NEXT_OVERLOAD, and grepped the diffs of all 39 open PRs that touch pybind11.h.