Use get_type_info(•, throw_if_missing = true) to throw on unknown type

Author: rhaschke

include/pybind11/detail/smart_holder_type_casters.h

@@ -623,11 +623,8 @@ struct smart_holder_type_caster<std::shared_ptr<T>> : smart_holder_type_caster_l
     static constexpr auto name = _<std::shared_ptr<T>>();
 
     static handle cast(const std::shared_ptr<T> &src, return_value_policy policy, handle parent) {
-        auto src_raw_ptr = src.get();
-        auto st          = type_caster_base<T>::src_and_type(src_raw_ptr);
-        if (st.first == nullptr)
-            throw error_already_set();
-
+        auto src_raw_ptr               = src.get();
+        auto st                        = type_caster_base<T>::src_and_type(src_raw_ptr);
         void *src_raw_void_ptr         = static_cast<void *>(src_raw_ptr);
         const detail::type_info *tinfo = st.second;
         if (handle existing_inst = find_registered_python_instance(src_raw_void_ptr, tinfo))
@@ -688,11 +685,8 @@ struct smart_holder_type_caster<std::unique_ptr<T, D>> : smart_holder_type_caste
             throw cast_error("Invalid return_value_policy for unique_ptr.");
         }
 
-        auto src_raw_ptr = src.get();
-        auto st          = type_caster_base<T>::src_and_type(src_raw_ptr);
-        if (st.first == nullptr)
-            return none().release(); // PyErr was set already.
-
+        auto src_raw_ptr               = src.get();
+        auto st                        = type_caster_base<T>::src_and_type(src_raw_ptr);
         void *src_raw_void_ptr         = static_cast<void *>(src_raw_ptr);
         const detail::type_info *tinfo = st.second;
         if (handle existing_inst = find_registered_python_instance(src_raw_void_ptr, tinfo)) {

include/pybind11/detail/type_caster_base.h

@@ -739,16 +739,9 @@ class type_caster_generic {
     // isn't needed or can't be used.  If the type is unknown, sets the error and returns a pair
     // with .second = nullptr.  (p.first = nullptr is not an error: it becomes None).
     PYBIND11_NOINLINE static std::pair<const void *, const type_info *> src_and_type(
-            const void *src, const std::type_info &cast_type, const std::type_info *rtti_type = nullptr) {
-        if (auto *tpi = get_type_info(cast_type))
-            return {src, const_cast<const type_info *>(tpi)};
-
-        // Not found, set error:
-        std::string tname = rtti_type ? rtti_type->name() : cast_type.name();
-        detail::clean_type_id(tname);
-        std::string msg = "Unregistered type : " + tname;
-        PyErr_SetString(PyExc_TypeError, msg.c_str());
-        return {nullptr, nullptr};
+            const void *src, const std::type_info &cast_type) {
+        auto *tpi = get_type_info(cast_type, true);
+        return {src, const_cast<const type_info *>(tpi)};
     }
 
     const type_info *typeinfo = nullptr;
@@ -895,7 +888,7 @@ template <typename type> class type_caster_base : public type_caster_generic {
         }
         // Otherwise we have either a nullptr, an `itype` pointer, or an unknown derived pointer, so
         // don't do a cast
-        return type_caster_generic::src_and_type(src, cast_type, instance_type);
+        return type_caster_generic::src_and_type(src, cast_type);
     }
 
     static handle cast(const itype *src, return_value_policy policy, handle parent) {