Change moves to forwards where appropriate.

Addresses the same issues as PR #276.

Author: tzlaine

include/boost/parser/detail/text/detail/all_t.hpp

@@ -126,7 +126,7 @@ namespace boost::parser::detail::text::detail {
             else if constexpr (can_ref_view<R>)
                 return ref_view(r);
             else
-                return owning_view<T>(std::move(r));
+                return owning_view<T>((R &&)r);
         }
     };
 

include/boost/parser/parser.hpp

@@ -1362,7 +1362,7 @@ namespace boost { namespace parser {
                 auto const r = cps | text::as_utf8;
                 c.insert(c.end(), r.begin(), r.end());
             } else {
-                detail::insert(c, std::move(x));
+                detail::insert(c, (T &&)x);
             }
         }
 
@@ -1951,9 +1951,9 @@ namespace boost { namespace parser {
         template<typename T, typename Tuple, int... Is>
         auto
         make_from_tuple_impl(Tuple && tup, std::integer_sequence<int, Is...>)
-            -> decltype(T(parser::get(std::move(tup), llong<Is>{})...))
+            -> decltype(T(parser::get((Tuple &&)tup, llong<Is>{})...))
         {
-            return T(parser::get(std::move(tup), llong<Is>{})...);
+            return T(parser::get((Tuple &&)tup, llong<Is>{})...);
         }
 
         template<typename T, typename... Args>
@@ -1987,7 +1987,7 @@ namespace boost { namespace parser {
                 auto const r = cps | text::as_utf8;
                 c.insert(c.end(), r.begin(), r.end());
             } else if constexpr (std::is_convertible_v<just_u &&, just_t>) {
-                detail::insert(c, std::move(x));
+                detail::insert(c, (U &&)x);
             } else if constexpr (
                 !is_tuple<just_t>::value && is_tuple<just_u>::value &&
                 std::is_aggregate_v<just_t> &&
@@ -1996,8 +1996,7 @@ namespace boost { namespace parser {
                 auto int_seq =
                     std::make_integer_sequence<int, tuple_size_<just_u>>();
                 detail::insert(
-                    c,
-                    detail::tuple_to_aggregate<just_t>(std::move(x), int_seq));
+                    c, detail::tuple_to_aggregate<just_t>((U &&)x, int_seq));
             } else if constexpr (
                 is_tuple<just_t>::value && !is_tuple<just_u>::value &&
                 std::is_aggregate_v<just_u> &&
@@ -2013,8 +2012,7 @@ namespace boost { namespace parser {
             } else if constexpr (is_constructible_from_tuple_v<
                                      just_t,
                                      just_u>) {
-                detail::insert(
-                    c, detail::make_from_tuple<just_t>(std::move(x)));
+                detail::insert(c, detail::make_from_tuple<just_t>((U &&)x));
             } else {
                 static_assert(
                     sizeof(U) && false,
@@ -2029,7 +2027,7 @@ namespace boost { namespace parser {
         {
             if (!gen_attrs)
                 return;
-            detail::move_back_impl(c, std::move(x));
+            detail::move_back_impl(c, (T &&)x);
         }
 
         template<typename Container>
@@ -2098,15 +2096,15 @@ namespace boost { namespace parser {
                     "is almost certainly not what you meant to write, so "
                     "Boost.Parser disallows it.  If you want to do this, write "
                     "a semantic action and do it explicitly.");
-                t = std::move(u);
+                t = (U &&)u;
             } else if constexpr (
                 !is_tuple<just_t>::value && is_tuple<just_u>::value &&
                 std::is_aggregate_v<just_t> &&
                 !std::is_convertible_v<just_u &&, just_t> &&
                 is_struct_assignable_v<just_t, just_u>) {
                 auto int_seq =
                     std::make_integer_sequence<int, tuple_size_<just_u>>();
-                t = detail::tuple_to_aggregate<just_t>(std::move(u), int_seq);
+                t = detail::tuple_to_aggregate<just_t>((U &&)u, int_seq);
             } else if constexpr (
                 is_tuple<just_t>::value && !is_tuple<just_u>::value &&
                 std::is_aggregate_v<just_u> &&
@@ -2120,7 +2118,7 @@ namespace boost { namespace parser {
             } else if constexpr (is_constructible_from_tuple_v<
                                      just_t,
                                      just_u>) {
-                t = detail::make_from_tuple<just_t>(std::move(u));
+                t = detail::make_from_tuple<just_t>((U &&)u);
             } else {
                 static_assert(
                     sizeof(T) && false,