Make sure obj.cast<T>() works as expected when T is a Python type

`obj.cast<T>()` should be the same as `T(obj)`, i.e. it should convert
the given object to a different Python type. However, `obj.cast<T>()`
usually calls `type_caster::load()` which only checks the type without
doing any actual conversion. That causes a very unexpected `cast_error`.
This commit makes it so that `obj.cast<T>()` and `T(obj)` are the same
when T is a Python type.

Author: dean0x7d

include/pybind11/cast.h

@@ -1033,16 +1033,20 @@ template <typename T> make_caster<T> load_type(const handle &handle) {
 
 NAMESPACE_END(detail)
 
-template <typename T> T cast(const handle &handle) {
+template <typename T, detail::enable_if_t<!detail::is_pyobject<T>::value, int> = 0>
+T cast(const handle &handle) {
     static_assert(!detail::cast_is_temporary_value_reference<T>::value,
             "Unable to cast type to reference: value is local to type caster");
     using type_caster = detail::make_caster<T>;
     return detail::load_type<T>(handle).operator typename type_caster::template cast_op_type<T>();
 }
 
-template <typename T> object cast(const T &value,
-        return_value_policy policy = return_value_policy::automatic_reference,
-        handle parent = handle()) {
+template <typename T, detail::enable_if_t<detail::is_pyobject<T>::value, int> = 0>
+T cast(const handle &handle) { return {handle, true}; }
+
+template <typename T, detail::enable_if_t<!detail::is_pyobject<T>::value, int> = 0>
+object cast(const T &value, return_value_policy policy = return_value_policy::automatic_reference,
+            handle parent = handle()) {
     if (policy == return_value_policy::automatic)
         policy = std::is_pointer<T>::value ? return_value_policy::take_ownership : return_value_policy::copy;
     else if (policy == return_value_policy::automatic_reference)

tests/test_python_types.cpp

@@ -316,4 +316,19 @@ test_initializer python_types([](py::module &m) {
             "memoryview"_a=py::memoryview(d["memoryview"])
         );
     });
+
+    m.def("test_cast_functions", [](py::dict d) {
+        // When converting between Python types, obj.cast<T>() should be the same as T(obj)
+        return py::dict(
+            "str"_a=d["str"].cast<py::str>(),
+            "bool"_a=d["bool"].cast<py::bool_>(),
+            "int"_a=d["int"].cast<py::int_>(),
+            "float"_a=d["float"].cast<py::float_>(),
+            "tuple"_a=d["tuple"].cast<py::tuple>(),
+            "list"_a=d["list"].cast<py::list>(),
+            "dict"_a=d["dict"].cast<py::dict>(),
+            "set"_a=d["set"].cast<py::set>(),
+            "memoryview"_a=d["memoryview"].cast<py::memoryview>()
+        );
+    });
 });

tests/test_python_types.py

@@ -299,7 +299,8 @@ def func(self, x, *args):
 
 def test_constructors():
     """C++ default and converting constructors are equivalent to type calls in Python"""
-    from pybind11_tests import test_default_constructors, test_converting_constructors
+    from pybind11_tests import (test_default_constructors, test_converting_constructors,
+                                test_cast_functions)
 
     types = [str, bool, int, float, tuple, list, dict, set]
     expected = {t.__name__: t() for t in types}
@@ -319,3 +320,4 @@ def test_constructors():
     inputs = {k.__name__: v for k, v in data.items()}
     expected = {k.__name__: k(v) for k, v in data.items()}
     assert test_converting_constructors(inputs) == expected
+    assert test_cast_functions(inputs) == expected