In practice, type_caster_holder<T> demands T to be copy constructible

[andre-caldas]

I think it is a bug. But the "issue tracker" encouraged me to discuss it here, first. :-)

The type_caster_holder<T> type is defined like this:

template <typename type, typename holder_type>
using type_caster_holder = conditional_t<is_copy_constructible<holder_type>::value,
                                         copyable_holder_caster<type, holder_type>,
                                         move_only_holder_caster<type, holder_type>>;

I think that using the non STL is_copy_constructible is wrong, here. The correct would be std::is_copy_constructible, instead. The reason is that the former is a "recursive check" for copy constructiveness. That is, for example, std::shared_ptr<NoCopyType> will not be considered copyable if NoCopyType is not.

Maybe this is the reason std::shared_ptr<T> is treated specially in PYBIND11_DECLARE_HOLDER_TYPE.

My custom shared ptr was not compiling because it was being treated as "move only". By using std::is_copy_constructible, it now compiles.

Am I missing something? Shall I submit a PR?

[andre-caldas]

Just as an example, in the case of std::shared_ptr, the type caster is defined like this:

pybind11/include/pybind11/cast.h

Lines 831 to 833 in 86a6429

	/// 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>> {};

That is, even if T is not copyable, type_caster<std::shared_ptr<T>> inherits form copyable_holder_caster.

As the following comment explains, move_only_holder_caster is for non copyable holders, lie std::unique_ptr:

pybind11/include/pybind11/cast.h

Lines 835 to 849 in 86a6429

	/// Type caster for holder types like std::unique_ptr.
	/// Please consider the SFINAE hook an implementation detail, as explained
	/// in the comment for the copyable_holder_caster.
	template <typename type, typename holder_type, typename SFINAE = void>
	struct move_only_holder_caster {
	static_assert(std::is_base_of<type_caster_base<type>, type_caster<type>>::value,
	"Holder classes are only supported for custom types");
	static handle cast(holder_type &&src, return_value_policy, handle) {
	auto *ptr = holder_helper<holder_type>::get(src);
	return type_caster_base<type>::cast_holder(ptr, std::addressof(src));
	}
	static constexpr auto name = type_caster_base<type>::name;
	};

This comment is also relevant:

pybind11/include/pybind11/cast.h

Lines 750 to 756 in 86a6429

	/// Type caster for holder types like std::shared_ptr, etc.
	/// The SFINAE hook is provided to help work around the current lack of support
	/// for smart-pointer interoperability. Please consider it an implementation
	/// detail that may change in the future, as formal support for smart-pointer
	/// interoperability is added into pybind11.
	template <typename type, typename holder_type, typename SFINAE = void>
	struct copyable_holder_caster : public type_caster_base<type> {

All this, to support the fact that we should use STL's std::is_copy_constructible, here:

pybind11/include/pybind11/cast.h

Line 855 in 86a6429

using type_caster_holder = conditional_t<is_copy_constructible<holder_type>::value,