Avoid unnecessary Python type checks and conversions where appropriate

The pytype converting constructors are convenient and safe for user
code, but for library internals the additional type checks and possible
conversions are sometimes not desired.

This commit adds `reinterpret_borrow<T>()` and `reinterpret_steal<T>()`
which serve as the low-level unsafe counterparts of `cast<T>()`.

Author: dean0x7d

include/pybind11/cast.h

@@ -199,7 +199,7 @@ class type_caster_generic {
             auto const &type_dict = get_internals().registered_types_py;
             bool new_style_class = PyType_Check(tobj);
             if (type_dict.find(tobj) == type_dict.end() && new_style_class && tobj->tp_bases) {
-                tuple parents(tobj->tp_bases, true);
+                auto parents = reinterpret_borrow<tuple>(tobj->tp_bases);
                 for (handle parent : parents) {
                     bool result = load(src, convert, (PyTypeObject *) parent.ptr());
                     if (result)
@@ -868,7 +868,7 @@ template <typename type, typename holder_type> class type_caster_holder : public
             auto const &type_dict = get_internals().registered_types_py;
             bool new_style_class = PyType_Check(tobj);
             if (type_dict.find(tobj) == type_dict.end() && new_style_class && tobj->tp_bases) {
-                tuple parents(tobj->tp_bases, true);
+                auto parents = reinterpret_borrow<tuple>(tobj->tp_bases);
                 for (handle parent : parents) {
                     bool result = load(src, convert, (PyTypeObject *) parent.ptr());
                     if (result)
@@ -963,7 +963,7 @@ struct pyobject_caster {
     bool load(handle src, bool /* convert */) {
         if (!isinstance<type>(src))
             return false;
-        value = type(src, true);
+        value = reinterpret_borrow<type>(src);
         return true;
     }
 
@@ -1298,7 +1298,7 @@ class unpacking_collector {
     void process(list &/*args_list*/, detail::kwargs_proxy kp) {
         if (!kp)
             return;
-        for (const auto &k : dict(kp, true)) {
+        for (const auto &k : reinterpret_borrow<dict>(kp)) {
             if (m_kwargs.contains(k.first)) {
 #if defined(NDEBUG)
                 multiple_values_error();

include/pybind11/pybind11.h

@@ -379,7 +379,7 @@ class cpp_function : public function {
                result = PYBIND11_TRY_NEXT_OVERLOAD;
         try {
             for (; it != nullptr; it = it->next) {
-                tuple args_(args, true);
+                auto args_ = reinterpret_borrow<tuple>(args);
                 size_t kwargs_consumed = 0;
 
                 /* For each overload:
@@ -499,7 +499,7 @@ class cpp_function : public function {
                 msg += "\n";
             }
             msg += "\nInvoked with: ";
-            tuple args_(args, true);
+            auto args_ = reinterpret_borrow<tuple>(args);
             for (size_t ti = overloads->is_constructor ? 1 : 0; ti < args_.size(); ++ti) {
                 msg += static_cast<std::string>(pybind11::str(args_[ti]));
                 if ((ti + 1) != args_.size() )
@@ -764,7 +764,7 @@ class generic_type : public object {
 
     /// Helper function which tags all parents of a type using mult. inheritance
     void mark_parents_nonsimple(PyTypeObject *value) {
-        tuple t(value->tp_bases, true);
+        auto t = reinterpret_borrow<tuple>(value->tp_bases);
         for (handle h : t) {
             auto tinfo2 = get_type_info((PyTypeObject *) h.ptr());
             if (tinfo2)
@@ -932,7 +932,7 @@ class class_ : public detail::generic_type {
     static_assert(detail::all_of_t<is_valid_class_option, options...>::value,
             "Unknown/invalid class_ template parameters provided");
 
-    PYBIND11_OBJECT(class_, detail::generic_type, PyType_Check)
+    PYBIND11_OBJECT(class_, generic_type, PyType_Check)
 
     template <typename... Extra>
     class_(handle scope, const char *name, const Extra &... extra) {

include/pybind11/pytypes.h

@@ -41,6 +41,9 @@ using sequence_accessor = accessor<accessor_policies::sequence_item>;
 using list_accessor = accessor<accessor_policies::list_item>;
 using tuple_accessor = accessor<accessor_policies::tuple_item>;
 
+/// Tag for choosing the non-converting py::object constructor
+struct noconvert { };
+
 /// Tag and check to identify a class which implements the Python object API
 class pyobject_tag { };
 template <typename T> using is_pyobject = std::is_base_of<pyobject_tag, T>;
@@ -102,9 +105,11 @@ class handle : public detail::object_api<handle> {
 class object : public handle {
 public:
     object() = default;
+    // Derived classes may override this constructor for Python type conversions
+    object(handle h, bool borrowed) : handle(h) { if (borrowed) inc_ref(); }
+    // This one must be inherited as is -- it's always just a pure pointer assignment
+    object(handle h, bool borrowed, detail::noconvert) : object(h, borrowed) { }
     object(const object &o) : handle(o) { inc_ref(); }
-    object(const handle &h, bool borrowed) : handle(h) { if (borrowed) inc_ref(); }
-    object(PyObject *ptr, bool borrowed) : handle(ptr) { if (borrowed) inc_ref(); }
     object(object &&other) noexcept { m_ptr = other.m_ptr; other.m_ptr = nullptr; }
     ~object() { dec_ref(); }
 
@@ -137,6 +142,13 @@ class object : public handle {
     template <typename T> T cast() &&;
 };
 
+/** Python type casts of the form `obj.cast<pytype>()` and `pytype(obj)` are equivalent
+    and they do actual convertions, e.g. `list` -> `tuple`. In contrast, the following
+    functions don't do any kind of conversion, they simply declare that a PyObject is a
+    certain type and borrow or steal the reference. */
+template <typename T> T reinterpret_borrow(handle h) { return T(h, true, detail::noconvert()); }
+template <typename T> T reinterpret_steal(handle h) { return T(h, false, detail::noconvert()); }
+
 /// Check if `obj` is an instance of type `T`
 template <typename T, detail::enable_if_t<std::is_base_of<object, T>::value, int> = 0>
 bool isinstance(handle obj) { return T::_check(obj); }
@@ -392,6 +404,7 @@ NAMESPACE_END(detail)
 
 #define PYBIND11_OBJECT_COMMON(Name, Parent, CheckFun) \
     public: \
+        using Parent::Parent; \
         PYBIND11_DEPRECATED("Use py::isinstance<py::python_type>(obj) instead") \
         bool check() const { return m_ptr != nullptr && (bool) CheckFun(m_ptr); } \
         static bool _check(handle h) { return h.ptr() != nullptr && CheckFun(h.ptr()); }
@@ -404,7 +417,6 @@ NAMESPACE_END(detail)
 
 #define PYBIND11_OBJECT(Name, Parent, CheckFun) \
     PYBIND11_OBJECT_COMMON(Name, Parent, CheckFun) \
-    Name(handle h, bool borrowed) : Parent(h, borrowed) { } \
     /* This is deliberately not 'explicit' to allow implicit conversion from object: */ \
     Name(const object &o) : Parent(o) { }
 
@@ -833,7 +845,7 @@ inline str repr(handle h) {
     Py_XDECREF(str_value); str_value = unicode;
     if (!str_value) throw error_already_set();
 #endif
-    return {str_value, false};
+    return reinterpret_steal<str>(str_value);
 }
 
 NAMESPACE_BEGIN(detail)

include/pybind11/stl.h

@@ -32,7 +32,7 @@ template <typename Type, typename Key> struct set_caster {
     bool load(handle src, bool convert) {
         if (!isinstance<pybind11::set>(src))
             return false;
-        pybind11::set s(src, true);
+        auto s = reinterpret_borrow<pybind11::set>(src);
         value.clear();
         key_conv conv;
         for (auto entry : s) {
@@ -64,7 +64,7 @@ template <typename Type, typename Key, typename Value> struct map_caster {
     bool load(handle src, bool convert) {
         if (!isinstance<dict>(src))
             return false;
-        dict d(src, true);
+        auto d = reinterpret_borrow<dict>(src);
         key_conv kconv;
         value_conv vconv;
         value.clear();
@@ -99,7 +99,7 @@ template <typename Type, typename Value> struct list_caster {
     bool load(handle src, bool convert) {
         if (!isinstance<sequence>(src))
             return false;
-        sequence s(src, true);
+        auto s = reinterpret_borrow<sequence>(src);
         value_conv conv;
         value.clear();
         reserve_maybe(s, &value);
@@ -144,7 +144,7 @@ template <typename Type, size_t Size> struct type_caster<std::array<Type, Size>>
     bool load(handle src, bool convert) {
         if (!isinstance<list>(src))
             return false;
-        list l(src, true);
+        auto l = reinterpret_borrow<list>(src);
         if (l.size() != Size)
             return false;
         value_conv conv;