[QUESTION]: BUG or FEATURE? overload_cast doesn't work for auto deduced return type functions templates

[junduck]

Required prerequisites

• Make sure you've read the documentation. Your issue may be addressed there.
• Search the issue tracker and Discussions to verify that this hasn't already been reported. +1 or comment there if it has.
• Consider asking first in the Gitter chat room or in a Discussion.

Problem description

When an overloaded member function's return type is auto deduced, and the class is a template, overload_cast fails to deduce return type.

  In file included from /tmp/pip-build-env-n9g56e9j/overlay/lib/python3.9/site-packages/pybind11/include/pybind11/pytypes.h:12,
                   from /tmp/pip-build-env-n9g56e9j/overlay/lib/python3.9/site-packages/pybind11/include/pybind11/cast.h:13,
                   from /tmp/pip-build-env-n9g56e9j/overlay/lib/python3.9/site-packages/pybind11/include/pybind11/attr.h:13,
                   from /tmp/pip-build-env-n9g56e9j/overlay/lib/python3.9/site-packages/pybind11/include/pybind11/pybind11.h:23,
                   from src/doublePet.cpp:1:
  /tmp/pip-build-env-n9g56e9j/overlay/lib/python3.9/site-packages/pybind11/include/pybind11/detail/common.h:843:20: note: candidate: ‘template<class Return, class Class> constexpr decltype (pmf) pybind11::detail::overload_cast_impl<Args>::operator()(Return (Class::*)(Args ...) const, std::true_type) const [with Return = Return; Class = Class; Args = {const std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&}]’
    843 |     constexpr auto operator()(Return (Class::*pmf)(Args...) const, std::true_type) const noexcept
        |                    ^~~~~~~~
  /tmp/pip-build-env-n9g56e9j/overlay/lib/python3.9/site-packages/pybind11/include/pybind11/detail/common.h:843:20: note:   template argument deduction/substitution failed:
  src/doublePet.cpp:37:59: note:   types ‘Return (Class::)(const std::__cxx11::basic_string<char>&) const’ and ‘double (Pet<double>::)(double)’ have incompatible cv-qualifiers
     37 |         .def("set", py::overload_cast<const std::string &>(&doublePet::set), "Set the pet's name");
        |                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~
  src/doublePet.cpp:37:59: note:   candidate expects 2 arguments, 1 provided

Reproducible example code

#include "pybind11/pybind11.h"
namespace py = pybind11;

template <typename T>
struct Pet
{
    Pet(const std::string &name, T age) : name(name), age(age) {}

    auto set(T age_)
    {
        age = age_;
        return age;
    }
    auto set(const std::string &name_)
    {
        name = name_;
        return name;
    }

    std::string name;
    T age;
};
using doublePet = Pet<double>;

void bind_pet(py::module &m)
{
    py::class_<doublePet>(m, "doublePet")
        .def("set", py::overload_cast<double>(&doublePet::set), "Set the pet's age")
        .def("set", py::overload_cast<const std::string &>(&doublePet::set), "Set the pet's name");
}

[henryiii]

No, this is incorrect, you are misusing auto. It should be decltype(auto) - this will correctly include the qualifiers on the type (const and &, I believe). Since you are not capturing those correctly, py::overload_cast<const std::string &> is not matching against anything, since there is no const std::string & function.

As a rule, never use auto, but always use decltype(auto) for automatic return type computation. They are either the same or decltype(auto) is correct.

[junduck]

Sorry, I know this is not a thread discussing C++ language, but in my provided code I was not doing any type forwading, instead was returning a COPY of a member variable. Anyway, using your suggested decltype(auto) still won't work (because in this example decltype(auto) does exactly same as auto)

template <typename T>
struct Pet
{
    Pet(const std::string &name, T age) : name(name), age(age) {}

    decltype(auto) set(T age_)
    {
        age = age_;
        return age;
    }
    decltype(auto) set(const std::string &name_)
    {
        name = name_;
        return name;
    }

    std::string name;
    T age;
};
using doublePet = Pet<double>;

void bind_pet(py::module &m)
{
    py::class_<doublePet>(m, "doublePet")
        .def("set", py::overload_cast<double>(&doublePet::set), "Set the pet's age")
        .def("set", py::overload_cast<const std::string &>(&doublePet::set), "Set the pet's name");
}

Same error message, py::overload_cast failed to deduce Return

  In file included from /tmp/pip-build-env-3gwjaqob/overlay/lib/python3.9/site-packages/pybind11/include/pybind11/pytypes.h:12,
                   from /tmp/pip-build-env-3gwjaqob/overlay/lib/python3.9/site-packages/pybind11/include/pybind11/cast.h:13,
                   from /tmp/pip-build-env-3gwjaqob/overlay/lib/python3.9/site-packages/pybind11/include/pybind11/attr.h:13,
                   from /tmp/pip-build-env-3gwjaqob/overlay/lib/python3.9/site-packages/pybind11/include/pybind11/pybind11.h:23,
                   from src/manano.cpp:1:
  /tmp/pip-build-env-3gwjaqob/overlay/lib/python3.9/site-packages/pybind11/include/pybind11/detail/common.h:843:20: note: candidate: ‘template<class Return, class Class> constexpr decltype (pmf) pybind11::detail::overload_cast_impl<Args>::operator()(Return (Class::*)(Args ...) const, std::true_type) const [with Return = Return; Class = Class; Args = {const std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&}]’
    843 |     constexpr auto operator()(Return (Class::*pmf)(Args...) const, std::true_type) const noexcept
        |                    ^~~~~~~~
  /tmp/pip-build-env-3gwjaqob/overlay/lib/python3.9/site-packages/pybind11/include/pybind11/detail/common.h:843:20: note:   template argument deduction/substitution failed:
  src/manano.cpp:39:59: note:   candidate expects 2 arguments, 1 provided
     39 |         .def("set", py::overload_cast<const std::string &>(&doublePet::set), "Set the pet's name");
        |                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~
  error: command '/usr/bin/gcc' failed with exit code 1

[henryiii]

return age; gets deduced as std::string then. So .def("set", py::overload_cast<std::string>(&double Pet::set), "Set the pet's name"); I think. Clang actually was happy with the const std::string&.

[junduck]

Thanks for your help. If Clang works fine with the example, then I guess it's a compiler specific problem. I looked into overload_cast_impl and couldn't figure out why GCC couldn't deduce return type (even vscode can prompt correct deduction!)