C++/Python shared object crash fix

C.f. pybind#1546 (comment)

Author: asadchev

include/pybind11/cast.h

@@ -33,6 +33,10 @@
 #endif
 
 NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+class gil_scoped_acquire;
+class gil_scoped_release;
+
 NAMESPACE_BEGIN(detail)
 
 /// A life support system for temporary objects created by `type_caster::load()`.
@@ -1510,9 +1514,55 @@ struct copyable_holder_caster : public type_caster_base<type> {
     holder_type holder;
 };
 
+/// Shared object crash fix: https://github.com/pybind/pybind11/issues/1546#issuecomment-526712704
+
+// /// Specialize for the common std::shared_ptr, so users don't need to
+// template <typename T>
+// class type_caster<std::shared_ptr<T>> : public copyable_holder_caster<T, std::shared_ptr<T>> { };
+
 /// Specialize for the common std::shared_ptr, so users don't need to
 template <typename T>
-class type_caster<std::shared_ptr<T>> : public copyable_holder_caster<T, std::shared_ptr<T>> { };
+class type_caster<std::shared_ptr<T>> {
+
+    PYBIND11_TYPE_CASTER (std::shared_ptr<T>, _(PYBIND11_STRING_NAME));
+
+    using BaseCaster = copyable_holder_caster<T, std::shared_ptr<T>>;
+
+    bool load (pybind11::handle src, bool b)
+    {
+        BaseCaster bc;
+        bool success = bc.load (src, b);
+        if (!success)
+        {
+            return false;
+        }
+
+	auto base_ptr = static_cast<std::shared_ptr<T>> (bc);
+	auto h = BaseCaster::cast(base_ptr, return_value_policy(), handle());
+	auto py_obj = reinterpret_borrow<object>(h);
+
+        auto py_obj_ptr = std::shared_ptr<object>{
+            new object{py_obj},
+            [](auto py_object_ptr) {
+                // It's possible that when the shared_ptr dies we won't have the
+                // gil (if the last holder is in a non-Python thread), so we
+                // make sure to acquire it in the deleter.
+                gil_scoped_acquire gil;
+                delete py_object_ptr;
+           }
+        };
+
+        value = std::shared_ptr<T> (py_obj_ptr, base_ptr.get ());
+        return true;
+    }
+
+    static handle cast (std::shared_ptr<T> sp,
+                        return_value_policy rvp,
+                        handle h)
+    {
+        return BaseCaster::cast (sp, rvp, h);
+    }
+};
 
 template <typename type, typename holder_type>
 struct move_only_holder_caster {
@@ -1554,6 +1604,11 @@ template <typename base, typename holder> struct is_holder_type :
 template <typename base, typename deleter> struct is_holder_type<base, std::unique_ptr<base, deleter>> :
     std::true_type {};
 
+// Specialization for shared_ptr:
+template <typename base> struct is_holder_type<base, std::shared_ptr<base>> :
+    std::true_type {};
+
+
 template <typename T> struct handle_type_name { static constexpr auto name = _<T>(); };
 template <> struct handle_type_name<bytes> { static constexpr auto name = _(PYBIND11_BYTES_NAME); };
 template <> struct handle_type_name<args> { static constexpr auto name = _("*args"); };
@@ -1901,7 +1956,7 @@ class argument_loader {
     static constexpr bool has_kwargs = kwargs_pos < 0;
     static constexpr bool has_args = args_pos < 0;
 
-    static constexpr auto arg_names = detail::concat(type_descr(make_caster<Args>::name)...);
+    static constexpr auto arg_names = concat(type_descr(make_caster<Args>::name)...);
 
     bool load_args(function_call &call) {
         return load_impl_sequence(call, indices{});