[libc++] Avoid using std::forward on things that aren't forwarding references. NFCI.

[ldionne]

Summary

Inspired by the recent Discord discussion on how to (speed up|stop generating debug symbols for) std::forward and std::move, I decided to investigate what happens if we mechanically replace all our std::forward<T>(t) with static_cast<decltype(t)>(t). In the process, I found these few places where we are using the std::forward syntax, but in fact we aren't forwarding anything — we're just using it as a more expensive/verbose static_cast. Regardless of what we do about std::forward itself, I'd like to adjust these places to reflect the fact that they're not forwarding.

In a few places you'll wonder why we do X& f(); ~~~ static_cast<X&&>(f()) instead of just X& f(); ~~~ std::move(f()). It's because sometimes X itself is an lvalue reference type, so moving-out-of its referent would be wrong, but static-casting to X&& will be a no-op.

In a few places in pair and tuple, one might be tempted to argue that we kinda are forwarding, from one member of a tuple/pair. I say sure, arguably; but IMNSHO it is vastly clearer to say static_cast<SpecificType&&>(std::get<I>(t)) than std::forward<SpecificType>(std::get<I>(t)) (when t is an lvalue reference to a tuple). Notice that in these cases, it would not be correct to write either static_cast<decltype(std::get<I>(t))>(std::get<I>(t)) or just std::get<I>(t); and also (per above) it wouldn't be correct to write std::move(std::get<I>(t)). I'm not sure if it would be correct to write std::get<I>(std::move(t)) in some cases, but I don't think that's clear either (and @Mordante has recently complained about apparent-use-after-move involving std::get, so he's probably happy not to introduce any more such cases).

After this patch, it will (at least for now) be possible to mechanically search-and-replace all std::forward<X>(y) into static_cast<decltype(y)>(y), and all the tests will still pass. I'm not saying we should land anything crazy like that, but it'll be handy to have the option for benchmarking.

[ldionne]

Regarding std::get<I>(std::move(tuple)), this provides a potentially relevant formal definition of when it's "okay" to do it: https://ldionne.com/2016/02/17/a-tentative-notion-of-move-independence/. In most places in this patch, my preference would be to use std::get<_I0>(std::move(__t)), since IMO that's the clearest form. In several places, we take the argument we're moving out of by value, so IMO using std::move on it makes a lot of sense.

Also -- you replaced all those places and a test failed for each of them? That's nice.

libcxx/include/__iterator/common_iterator.h

45

I don't understand why we're changing this one.

libcxx/include/__memory/unique_ptr.h

210

Can the deleter be a reference? If not, I don't understand why we're not std::moveing here (and below) instead.

libcxx/include/__utility/pair.h

224

std::move(__p).first?

libcxx/include/tuple

1591

Since the standard says this: http://eel.is/c++draft/pairs#pair-19, I think I'd rather leave it as-is. It would better if the Standard said static_cast, I think, but oh well.

[• Quuxplusone]

libcxx/include/__iterator/common_iterator.h

45

Somewhat cascading drive-by. I changed the forward on line 59; then noticed that __value should be __value_ down there; then noticed that the same thing applied up here; and finally, noticed that __proxy and __postfix_proxy were actually doing the same thing, except that __postfix_proxy was misusing forward to do its static_cast<X&&>, while __proxy was "misusing" move (a trick that wouldn't even have worked in general, as your blog post says — but worked here because the programmer happened to know something about iter_reference_t<_Iter>, but then they felt guilty about the cleverness and left a comment explaining their logic. BUT, if we remove the cleverness, then we can also remove the guilty comment. The new line 45 is correct by definition, even if iter_reference_t<_Iter> were someday to become a reference type.

(That said, I'm now wondering why both of these types aren't simply aggregates!)

libcxx/include/__memory/unique_ptr.h

210

Yes, deleter_type explicitly can be an lvalue reference type.

libcxx/include/__utility/pair.h

224

That would be correct AFAICT (per your blog post), but is it really more readable, or will it lead to people asking (as in your blog post) why not std::move(__p.first) or why isn't that a double-move bug? My attitude is, if we want to cast it to precisely the type _U1&&, for whatever metaprogrammy reasons, we should just say that, instead of trying to jenga a cast out of some clever call(s) to move or forward.

IOW, arguably, static_cast<X&&> means "Look out! This is subtle for some reason!", whereas std::move doesn't set off any alarm bells. And I'm claiming that if it matters for correctness whether you've written std::move(x).y or std::move(x.y), then that is subtle by definition, and some alarm bells are warranted.

libcxx/include/tuple

1591

TBF, it doesn't use this exact expression; it says it in English.

Initializes first with arguments of types Args1... obtained by forwarding the elements of first_­args and initializes second with arguments of types Args2... obtained by forwarding the elements of second_­args. (Here, forwarding an element x of type U within a tuple object means calling std​::​forward<U>(x).)

Also, maybe you'll change your mind when you see that this is not actually the ctor pair(piecewise_construct_t, tuple<Args1...>, tuple<Args2...>) defined in the standard. This is pair(piecewise_construct_t, tuple<_Args1...>&, tuple<_Args2...>&, __tuple_indices<_I1...>, __tuple_indices<_I2...>). So we've already messed with the types of first_args and second_args by ref-qualifying them. (Mind you, that doesn't change their value categories as far as the paragraph above is concerned.)

I strongly prefer not to use std::forward here, because std::forward<_Args1>(std::get<_I1>(__first_args)) is not equivalent to static_cast<decltype(std::get<_I1>(__first_args))&&>(std::get<_I1>(__first_args)), which means I can't (locally) turn it into _LIBCPP_FWD(std::get<_I1>(__first_args)). I want to permanently burninate any use of std::forward<X>(y) that can't be turned into _LIBCPP_FWD(y), because (by my definition at least) that is not forwarding.

Per your blog post, this is another place where we could use get<I>(move(x)):

:  first(std::get<_I1>(std::move(__first_args))...),

Physically correct, readability-wise-scary to me. But still, if you forced me to choose between forward<X>(get<I> or get<I>(move(, I would choose get<I>(move(. Because get<I>(move( is subtle, but forward<X>(get<I>( is just a flat-out lie AFAIC. It's not forwarding!

[ldionne]

[Github PRs transition cleanup]

I think the benefit of this isn't sufficient to justify going through the trouble of rebasing and figuring out what else needs to change, so I'll abandon this one.

libcxx/include/__functional/bind.h

__mu(reference_wrapper<_Tp> __t, _Uj&)
     return __t.get();
 }
 
 template <class _Ti, class ..._Uj, size_t ..._Indx>
 inline _LIBCPP_INLINE_VISIBILITY
 typename __invoke_of<_Ti&, _Uj...>::type
 __mu_expand(_Ti& __ti, tuple<_Uj...>& __uj, __tuple_indices<_Indx...>)
 {
-    return __ti(_VSTD::forward<_Uj>(_VSTD::get<_Indx>(__uj))...);
+    return __ti(static_cast<_Uj&&>(_VSTD::get<_Indx>(__uj))...);
 }
 
 template <class _Ti, class ..._Uj>
 inline _LIBCPP_INLINE_VISIBILITY
 typename __enable_if_t
 <
     is_bind_expression<_Ti>::value,
     __invoke_of<_Ti&, _Uj...>

 typename enable_if
 <
     0 < is_placeholder<_Ti>::value,
     typename __mu_return2<0 < is_placeholder<_Ti>::value, _Ti, _Uj>::type
 >::type
 __mu(_Ti&, _Uj& __uj)
 {
     const size_t _Indx = is_placeholder<_Ti>::value - 1;
-    return _VSTD::forward<typename tuple_element<_Indx, _Uj>::type>(_VSTD::get<_Indx>(__uj));
+    return static_cast<typename tuple_element<_Indx, _Uj>::type&&>(_VSTD::get<_Indx>(__uj));
 }
 
 template <class _Ti, class _Uj>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     !is_bind_expression<_Ti>::value &&
     is_placeholder<_Ti>::value == 0 &&

libcxx/include/__iterator/common_iterator.h

concept __can_use_postfix_proxy =
   move_constructible<iter_value_t<_Iter>>;
 
 template<input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent>
   requires (!same_as<_Iter, _Sent> && copyable<_Iter>)
 class common_iterator {
   class __proxy {
     friend common_iterator;
 
-    iter_value_t<_Iter> __value;
-    // We can move __x because the only caller verifies that __x is not a reference.
+    iter_value_t<_Iter> __value_;
     constexpr explicit __proxy(iter_reference_t<_Iter>&& __x)
-      : __value(_VSTD::move(__x)) {}
+      : __value_(static_cast<iter_reference_t<_Iter>&&>(__x)) {}
 
   public:
     constexpr const iter_value_t<_Iter>* operator->() const noexcept {
-      return _VSTD::addressof(__value);
+      return _VSTD::addressof(__value_);
     }
   };
 
   class __postfix_proxy {
     friend common_iterator;
 
-    iter_value_t<_Iter> __value;
+    iter_value_t<_Iter> __value_;
     constexpr explicit __postfix_proxy(iter_reference_t<_Iter>&& __x)
-      : __value(_VSTD::forward<iter_reference_t<_Iter>>(__x)) {}
+      : __value_(static_cast<iter_reference_t<_Iter>&&>(__x)) {}
 
   public:
     constexpr const iter_value_t<_Iter>& operator*() const noexcept {
-      return __value;
+      return __value_;
     }
   };
 
 public:
   variant<_Iter, _Sent> __hold_;
 
   common_iterator() requires default_initializable<_Iter> = default;
 

libcxx/include/__memory/compressed_pair.h

struct __compressed_pair_elem {
   template <class _Up, class = __enable_if_t<!is_same<__compressed_pair_elem, typename decay<_Up>::type>::value> >
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
   explicit __compressed_pair_elem(_Up&& __u) : __value_(std::forward<_Up>(__u)) {}
 
 #ifndef _LIBCPP_CXX03_LANG
   template <class... _Args, size_t... _Indices>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
   explicit __compressed_pair_elem(piecewise_construct_t, tuple<_Args...> __args, __tuple_indices<_Indices...>)
-      : __value_(std::forward<_Args>(std::get<_Indices>(__args))...) {}
+      : __value_(static_cast<_Args&&>(std::get<_Indices>(__args))...) {}
 #endif
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 reference __get() _NOEXCEPT { return __value_; }
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const_reference __get() const _NOEXCEPT { return __value_; }
 
 private:
   _Tp __value_;
 };
struct __compressed_pair_elem<_Tp, _Idx, true> : private _Tp {
   template <class _Up, class = __enable_if_t<!is_same<__compressed_pair_elem, typename decay<_Up>::type>::value> >
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
   explicit __compressed_pair_elem(_Up&& __u) : __value_type(std::forward<_Up>(__u)) {}
 
 #ifndef _LIBCPP_CXX03_LANG
   template <class... _Args, size_t... _Indices>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
   __compressed_pair_elem(piecewise_construct_t, tuple<_Args...> __args, __tuple_indices<_Indices...>)
-      : __value_type(std::forward<_Args>(std::get<_Indices>(__args))...) {}
+      : __value_type(static_cast<_Args&&>(std::get<_Indices>(__args))...) {}
 #endif
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11 reference __get() _NOEXCEPT { return *this; }
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const_reference __get() const _NOEXCEPT { return *this; }
 };
 
 template <class _T1, class _T2>
 class __compressed_pair : private __compressed_pair_elem<_T1, 0>,

libcxx/include/__memory/unique_ptr.h

public:
 
   template <bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_BadRValRefType<_Dummy> > >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(pointer __p, _BadRValRefType<_Dummy> __d) = delete;
 
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(unique_ptr&& __u) _NOEXCEPT
-      : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {
+      : __ptr_(__u.release(), static_cast<deleter_type&&>(__u.get_deleter())) {
   }
 
   template <class _Up, class _Ep,
       class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
       class = _EnableIfDeleterConvertible<_Ep>
   >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT
-      : __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) {}
+      : __ptr_(__u.release(), static_cast<_Ep&&>(__u.get_deleter())) {}
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
   template <class _Up>
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(auto_ptr<_Up>&& __p,
              typename enable_if<is_convertible<_Up*, _Tp*>::value &&
                                     is_same<_Dp, default_delete<_Tp> >::value,
                                 __nat>::type = __nat()) _NOEXCEPT
       : __ptr_(__p.release(), __value_init_tag()) {}
 #endif
 
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT {
     reset(__u.release());
-    __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter());
+    __ptr_.second() = static_cast<deleter_type&&>(__u.get_deleter());
     return *this;
   }
 
   template <class _Up, class _Ep,
       class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
       class = _EnableIfDeleterAssignable<_Ep>
   >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr& operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT {
     reset(__u.release());
-    __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter());
+    __ptr_.second() = static_cast<_Ep&&>(__u.get_deleter());
     return *this;
   }
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
   template <class _Up>
   _LIBCPP_INLINE_VISIBILITY
       typename enable_if<is_convertible<_Up*, _Tp*>::value &&
                              is_same<_Dp, default_delete<_Tp> >::value,
public:
   template <class _Pp, bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_BadRValRefType<_Dummy> >,
             class = _EnableIfPointerConvertible<_Pp> >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(_Pp __p, _BadRValRefType<_Dummy> __d) = delete;
 
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(unique_ptr&& __u) _NOEXCEPT
-      : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {
+      : __ptr_(__u.release(), static_cast<deleter_type&&>(__u.get_deleter())) {
   }
 
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT {
     reset(__u.release());
-    __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter());
+    __ptr_.second() = static_cast<deleter_type&&>(__u.get_deleter());
     return *this;
   }
 
   template <class _Up, class _Ep,
       class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
       class = _EnableIfDeleterConvertible<_Ep>
   >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT
-      : __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) {
+      : __ptr_(__u.release(), static_cast<_Ep&&>(__u.get_deleter())) {
   }
 
   template <class _Up, class _Ep,
       class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
       class = _EnableIfDeleterAssignable<_Ep>
   >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr&
   operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT {
     reset(__u.release());
-    __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter());
+    __ptr_.second() = static_cast<_Ep&&>(__u.get_deleter());
     return *this;
   }
 
 #ifdef _LIBCPP_CXX03_LANG
   unique_ptr(unique_ptr const&) = delete;
   unique_ptr& operator=(unique_ptr const&) = delete;
 #endif
 public:

libcxx/include/__utility/pair.h

pair(pair<_U1, _U2> const& __p)
         _NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value &&
                     is_nothrow_constructible<second_type, _U2 const&>::value))
         : first(__p.first), second(__p.second) {}
 
     template<class _U1, class _U2, typename enable_if<
             _CheckArgs::template __enable_explicit<_U1, _U2>()
     >::type* = nullptr>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
-    explicit pair(pair<_U1, _U2>&&__p)
+    explicit pair(pair<_U1, _U2>&& __p)
         _NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value &&
                     is_nothrow_constructible<second_type, _U2&&>::value))
-        : first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {}
+        : first(static_cast<_U1&&>(__p.first)), second(static_cast<_U2&&>(__p.second)) {}
 
     template<class _U1, class _U2, typename enable_if<
             _CheckArgs::template __enable_implicit<_U1, _U2>()
     >::type* = nullptr>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     pair(pair<_U1, _U2>&& __p)
         _NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value &&
                     is_nothrow_constructible<second_type, _U2&&>::value))
-        : first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {}
+        : first(static_cast<_U1&&>(__p.first)), second(static_cast<_U2&&>(__p.second)) {}
 
     template<class _Tuple, typename enable_if<
             _CheckTLC<_Tuple>::template __enable_explicit<_Tuple>()
     >::type* = nullptr>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     explicit pair(_Tuple&& __p)
         : first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))),
           second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {}
struct __get_pair<0>
     const _T1&
     get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}
 
 #ifndef _LIBCPP_CXX03_LANG
     template <class _T1, class _T2>
     static
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     _T1&&
-    get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T1>(__p.first);}
+    get(pair<_T1, _T2>&& __p) _NOEXCEPT {return static_cast<_T1&&>(__p.first);}
 
     template <class _T1, class _T2>
     static
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     const _T1&&
-    get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<const _T1>(__p.first);}
+    get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return static_cast<const _T1&&>(__p.first);}
 #endif // _LIBCPP_CXX03_LANG
 };
 
 template <>
 struct __get_pair<1>
 {
     template <class _T1, class _T2>
     static
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     _T2&
     get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}
 
     template <class _T1, class _T2>
     static
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     const _T2&
     get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}
 
 #ifndef _LIBCPP_CXX03_LANG
     template <class _T1, class _T2>
     static
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     _T2&&
-    get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T2>(__p.second);}
+    get(pair<_T1, _T2>&& __p) _NOEXCEPT {return static_cast<_T2&&>(__p.second);}
 
     template <class _T1, class _T2>
     static
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     const _T2&&
-    get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<const _T2>(__p.second);}
+    get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return static_cast<const _T2&&>(__p.second);}
 #endif // _LIBCPP_CXX03_LANG
 };
 
 template <size_t _Ip, class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 typename tuple_element<_Ip, pair<_T1, _T2> >::type&
 get(pair<_T1, _T2>& __p) _NOEXCEPT
 {

libcxx/include/tuple

template <class _Tuple,
               class = typename enable_if
                       <
                          __tuple_constructible<_Tuple, tuple<_Tp...> >::value
                       >::type
              >
         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
         __tuple_impl(_Tuple&& __t) _NOEXCEPT_((__all<is_nothrow_constructible<_Tp, typename tuple_element<_Indx,
                                        typename __make_tuple_types<_Tuple>::type>::type>::value...>::value))
-            : __tuple_leaf<_Indx, _Tp>(_VSTD::forward<typename tuple_element<_Indx,
-                                       typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
+            : __tuple_leaf<_Indx, _Tp>(static_cast<typename tuple_element<_Indx,
+                                       typename __make_tuple_types<_Tuple>::type>::type&&>(_VSTD::get<_Indx>(__t)))...
             {}
 
     template <class _Alloc, class _Tuple,
               class = typename enable_if
                       <
                          __tuple_constructible<_Tuple, tuple<_Tp...> >::value
                       >::type
              >
         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
         __tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
             : __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc, typename tuple_element<_Indx,
                                        typename __make_tuple_types<_Tuple>::type>::type>(), __a,
-                                       _VSTD::forward<typename tuple_element<_Indx,
-                                       typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
+                                       static_cast<typename tuple_element<_Indx,
+                                       typename __make_tuple_types<_Tuple>::type>::type&&>(_VSTD::get<_Indx>(__t)))...
             {}
 
     __tuple_impl(const __tuple_impl&) = default;
     __tuple_impl(__tuple_impl&&) = default;
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     void swap(__tuple_impl& __t)
         _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
     {
         _VSTD::__swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t))...);
     }
 };
 
 template<class _Dest, class _Source, size_t ..._Np>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 void __memberwise_copy_assign(_Dest& __dest, _Source const& __source, __tuple_indices<_Np...>) {
     _VSTD::__swallow(((_VSTD::get<_Np>(__dest) = _VSTD::get<_Np>(__source)), void(), 0)...);
 }
 
 template<class _Dest, class _Source, class ..._Up, size_t ..._Np>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 void __memberwise_forward_assign(_Dest& __dest, _Source&& __source, __tuple_types<_Up...>, __tuple_indices<_Np...>) {
     _VSTD::__swallow(((
-        _VSTD::get<_Np>(__dest) = _VSTD::forward<_Up>(_VSTD::get<_Np>(__source))
+        _VSTD::get<_Np>(__dest) = static_cast<_Up&&>(_VSTD::get<_Np>(__source))
     ), void(), 0)...);
 }
 
 template <class ..._Tp>
 class _LIBCPP_TEMPLATE_VIS tuple
 {
     typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> _BaseT;
 

 struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J0...> >
 {
     template <class _Tuple0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&>::type
     operator()(tuple<_Types...> __t, _Tuple0&& __t0)
     {
         return _VSTD::forward_as_tuple(
-            _VSTD::forward<_Types>(_VSTD::get<_I0>(__t))...,
+            static_cast<_Types&&>(_VSTD::get<_I0>(__t))...,
             _VSTD::get<_J0>(_VSTD::forward<_Tuple0>(__t0))...);
     }
 
     template <class _Tuple0, class _Tuple1, class ..._Tuples>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&, _Tuple1&&, _Tuples&&...>::type
     operator()(tuple<_Types...> __t, _Tuple0&& __t0, _Tuple1&& __t1, _Tuples&& ...__tpls)
     {
         typedef _LIBCPP_NODEBUG typename remove_reference<_Tuple0>::type _T0;
         typedef _LIBCPP_NODEBUG typename remove_reference<_Tuple1>::type _T1;
         return __tuple_cat<
             tuple<_Types...,
                   typename __apply_cv<_Tuple0, typename tuple_element<
                                                    _J0, _T0>::type>::type&&...>,
             typename __make_tuple_indices<sizeof...(_Types) +
                                           tuple_size<_T0>::value>::type,
             typename __make_tuple_indices<tuple_size<_T1>::value>::type>()(
             _VSTD::forward_as_tuple(
-                _VSTD::forward<_Types>(_VSTD::get<_I0>(__t))...,
+                static_cast<_Types&&>(_VSTD::get<_I0>(__t))...,
                 _VSTD::get<_J0>(_VSTD::forward<_Tuple0>(__t0))...),
             _VSTD::forward<_Tuple1>(__t1), _VSTD::forward<_Tuples>(__tpls)...);
     }
 };
 
 template <class _Tuple0, class... _Tuples>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 typename __tuple_cat_return<_Tuple0, _Tuples...>::type
struct _LIBCPP_TEMPLATE_VIS uses_allocator<tuple<_Tp...>, _Alloc>
     : true_type {};
 
 template <class _T1, class _T2>
 template <class... _Args1, class... _Args2, size_t ..._I1, size_t ..._I2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 pair<_T1, _T2>::pair(piecewise_construct_t,
                      tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
                      __tuple_indices<_I1...>, __tuple_indices<_I2...>)
-    :  first(_VSTD::forward<_Args1>(_VSTD::get<_I1>( __first_args))...),
-      second(_VSTD::forward<_Args2>(_VSTD::get<_I2>(__second_args))...)
+    :  first(static_cast<_Args1&&>(_VSTD::get<_I1>(__first_args))...),
+      second(static_cast<_Args2&&>(_VSTD::get<_I2>(__second_args))...)
 {
 }
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
 inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value;
 
 #define _LIBCPP_NOEXCEPT_RETURN(...) noexcept(noexcept(__VA_ARGS__)) { return __VA_ARGS__; }