GIVE UP capability to automatically trigger move-construction for foo(T&&)

Author: rhaschke

include/pybind11/cast.h

@@ -771,13 +771,6 @@ using cast_op_type =
         typename std::add_pointer<intrinsic_t<T>>::type,
         typename std::add_lvalue_reference<intrinsic_t<T>>::type>;
 
-template <typename T> using cast_op_type_for_moving =
-    conditional_t<std::is_move_constructible<intrinsic_t<T>>::value,
-        // return an rvalue ref via T(std::move(value)) which triggers a move construction
-        intrinsic_t<T>,
-        // this doesn't work for abstract types: cast these to an rvalue reference
-        typename std::add_rvalue_reference<intrinsic_t<T>>::type >;
-
 // A by-value argument will use lvalue references by default (triggering copy construction)
 // except the type is move-only and thus should use move semantics.
 template <typename T> using cast_op_type_for_byvalue =
@@ -811,7 +804,7 @@ using movable_cast_op_type =
     conditional_t<std::is_pointer<typename std::remove_reference<T>::type>::value,
         typename std::add_pointer<intrinsic_t<T>>::type,
         conditional_t<std::is_rvalue_reference<T>::value,
-            cast_op_type_for_moving<T>,
+            typename std::add_rvalue_reference<intrinsic_t<T>>::type,
             conditional_t<std::is_lvalue_reference<T>::value,
                 typename std::add_lvalue_reference<intrinsic_t<T>>::type,
                 cast_op_type_for_byvalue<T> > > >;
@@ -951,8 +944,6 @@ template <typename type> class type_caster_base : public type_caster_generic {
     operator itype&() { if (!value) throw reference_cast_error(); return *((itype *) value); }
     // move-forward caster, just forwarding an rvalue reference
     operator itype&&() { if (!value) throw reference_cast_error(); return std::move(*((itype *) value)); }
-    // move caster, actually triggering a move construction from value
-    operator itype() { if (!value) throw reference_cast_error(); return std::move(*((itype *) value)); }
 
 protected:
     using Constructor = void *(*)(const void *);
@@ -1028,7 +1019,6 @@ template <typename type> class type_caster<std::reference_wrapper<type>> {
         operator type*() { return &value; } \
         operator type&() { return value; } \
         operator type&&() { return std::move(value); } \
-        operator type() { return std::move(value); } \
         template <typename T_> using cast_op_type = pybind11::detail::movable_cast_op_type<T_>
 
 

include/pybind11/eigen.h

@@ -347,7 +347,6 @@ struct type_caster<Type, enable_if_t<is_eigen_dense_plain<Type>::value>> {
     operator Type*() { return &value; }
     operator Type&() { return value; }
     operator Type&&() { return std::move(value); }
-    operator Type() { return std::move(value); }
     template <typename T> using cast_op_type = movable_cast_op_type<T>;
 
 private:

tests/test_copy_move.cpp

@@ -75,11 +75,6 @@ static_assert(std::is_same<movable_cast_op_type<MoveOrCopyInt&>, MoveOrCopyInt&>
 static_assert(std::is_same<movable_cast_op_type<MoveOnlyInt&>, MoveOnlyInt&>::value, "lvalue reference requested");
 static_assert(std::is_same<movable_cast_op_type<CopyOnlyInt&>, CopyOnlyInt&>::value, "lvalue reference requested");
 
-// move semantics is explicitly requested by an rvalue argument (T&&)
-static_assert(std::is_same<movable_cast_op_type<MoveOrCopyInt&&>, MoveOrCopyInt>::value, "requesting move semantics");
-static_assert(std::is_same<movable_cast_op_type<MoveOnlyInt&&>, MoveOnlyInt>::value, "requesting move semantics");
-static_assert(std::is_same<movable_cast_op_type<CopyOnlyInt&&>, CopyOnlyInt>::value, "requesting move semantics");
-
 // casting type for by-value arguments is chosen to yield copy semantics by default, but move semantics for move-only types
 static_assert(std::is_same<movable_cast_op_type<MoveOrCopyInt>, MoveOrCopyInt&>::value, "default to copy semantics");
 static_assert(std::is_same<movable_cast_op_type<MoveOnlyInt>, MoveOnlyInt&&>::value, "only move semantics supported");

tests/test_copy_move.py

@@ -66,7 +66,7 @@ def test_move_and_copy_loads():
     assert c_mc.copy_assignments == 0
     assert c_mc.copy_constructions == 5
     assert c_mc.move_assignments == 6
-    assert c_mc.move_constructions == 4
+    assert c_mc.move_constructions == 3
     assert c_c.copy_assignments == 4
     assert c_c.copy_constructions == 6
     assert c_m.alive() + c_mc.alive() + c_c.alive() == 0
@@ -78,27 +78,27 @@ def test_move_copy_class_loads():
     cs = m.move_and_copy_cstats()["MoveOnlyInt"]
     o = m.MoveOnlyInt(3)
     assert m.MoveOnlyInt.move_explicit(o) == 3
-    assert o.value == -1  # value becomes -1 after moving
+    # assert o.value == -1  # value becomes -1 after moving
     o = m.MoveOnlyInt(4)
     assert m.MoveOnlyInt.move_implicit(o) == 4
     assert o.value == -1  # value becomes -1 after moving
-    assert (cs.copy_constructions, cs.move_constructions) == (0, 2)
+    assert (cs.copy_constructions, cs.move_constructions) == (0, 1)
 
     cs = m.move_and_copy_cstats()["MoveOrCopyInt"]
     o = m.MoveOrCopyInt(3)
     assert m.MoveOrCopyInt.ref(o) == 3
     assert m.MoveOrCopyInt.copy(o) == 3
     assert m.MoveOrCopyInt.move(o) == 3
-    assert o.value == -1  # value becomes -1 after moving
-    assert (cs.copy_constructions, cs.move_constructions) == (1, 1)
+    # assert o.value == -1  # value becomes -1 after moving
+    assert (cs.copy_constructions, cs.move_constructions) == (1, 0)
 
     cs = m.move_and_copy_cstats()["CopyOnlyInt"]
     o = m.CopyOnlyInt(3)
     assert m.CopyOnlyInt.lref(o) == 3
     assert m.CopyOnlyInt.copy(o) == 3
     assert m.CopyOnlyInt.rref(o) == 3  # copies as well
     assert o.value == 3  # value hasn't change
-    assert (cs.copy_constructions, cs.move_constructions) == (2, 0)
+    assert (cs.copy_constructions, cs.move_constructions) == (1, 0)
 
 
 @pytest.mark.skipif(not m.has_optional, reason="no <optional>")
@@ -123,11 +123,11 @@ def test_move_and_copy_load_optional():
 
     assert c_m.copy_assignments + c_m.copy_constructions == 0
     assert c_m.move_assignments == 2
-    assert c_m.move_constructions == 6
+    assert c_m.move_constructions >= 5
     assert c_mc.copy_assignments == 0
     assert c_mc.copy_constructions == 2
     assert c_mc.move_assignments == 3
-    assert c_mc.move_constructions == 7
+    assert c_mc.move_constructions >= 4
     assert c_c.copy_assignments == 2
     assert c_c.copy_constructions == 5
     assert c_m.alive() + c_mc.alive() + c_c.alive() == 0