[libcxx] LWG2485: get() should be overloaded for const tuple&&

[K-ballo]

Summary

Implement LWG2485, get() should be overloaded for const tuple&&.

[EricWF]

Added initial review comments.

I need to look a little more into how we form the rvalue reference to the returned element in the case where the element is an lvalue reference. I think it's currently correct but I just want to double check. I think the new language is a bit vague when it says get returns a reference to the element.

test/std/containers/sequences/array/array.tuple/get_const_rv.pass.cpp

33

1. Please test the constexprness of this function in C++14 and beyond.
2. Please static_assert the return type using decltype. The assignment to the expected type might hide conversions (though I doubt it in this case).

test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.fail.cpp

31

Add // expected-error {{call to deleted function 'cref'}} to the end of this line to make the test use clang verify.

test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.pass.cpp

27

Same note as on the array test.

test/std/utilities/utility/pairs/pair.astuple/get_const_rv.pass.cpp

25

I prefer using // UNSUPPORTED: c++98, c++03 instead of conditional compilation. That way LIT can report that the test was not run.

26

Same note as the array and tuple tests.

test/std/utilities/utility/pairs/pair.astuple/pairs.by.type.pass.cpp

70

This test seems wrong to me. The name of the file suggests we are testing the "by-type" overloads but your tests use indexes with get. It seems like the test above yours does the same thing as well.

Also please add constexpr tests and tests for the second type as well.

[EricWF]

To expand on my concerns about lvalue elements, I would like to see tests something like this:

int x = 42;
int const y = 43;
std::pair<int&, int const&> const p(x, y);
static_assert(std::is_same<int const&, decltype(std::get<0>(std::move(p)))>::value, "");
static_assert(std::is_same<int const&, decltype(std::get<1>(std::move(p)))>::value, "");

I assume you agree that this test has the correct behavior?

[K-ballo]

In D14839#306306, @EricWF wrote:

int x = 42;
int const y = 43;
std::pair<int&, int const&> const p(x, y);
static_assert(std::is_same<int const&, decltype(std::get<0>(std::move(p)))>::value, "");
static_assert(std::is_same<int const&, decltype(std::get<1>(std::move(p)))>::value, "");

I assume you agree that this test has the correct behavior?

I believe the first static_assert is incorrect, const is shallow so it should be just int&.

[K-ballo]

Addressed review comments

[EricWF]

Pair and array look good. Still have to look at tuple.

Could you add test that check the overloads are actually noexcept as well?

include/utility

139

Can you add the by-type overloads to the synopsis? I noticed the current overloads are missing as well, so if your feeling kind can you add those?

test/std/containers/sequences/array/array.tuple/get_const_rv.pass.cpp

21

#include "test_macros.h"

test/std/utilities/utility/pairs/pair.astuple/get_const_rv.pass.cpp

24

This needs #include "test_macros.h" to get TEST_STD_VER

test/std/utilities/utility/pairs/pair.astuple/pairs.by.type.pass.cpp

19

Can you TEST_STD_VER this while your here?

[EricWF]

LGTM after the requested changes. Thanks.

test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.fail.cpp

30

Could you add a comment about why this test is important? On it's face it looks a little silly but it's really the rational for this entire change.

test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.pass.cpp

25

#include "test_macros.h"

50

Test for int&& and int const&& as well please.

test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.pass.cpp

21

You can remove this guard. The test is already supported for C++11 and earlier.

71

Same as above: Rvalue ref tests.

test/std/utilities/utility/pairs/pair.astuple/get_const_rv.pass.cpp

38

Same as above: Rvalue ref tests.

test/std/utilities/utility/pairs/pair.astuple/pairs.by.type.pass.cpp

59

rvalue ref tests please.

[EricWF]

In D14839#307171, @K-ballo wrote:

In D14839#306306, @EricWF wrote:

int x = 42;
int const y = 43;
std::pair<int&, int const&> const p(x, y);
static_assert(std::is_same<int const&, decltype(std::get<0>(std::move(p)))>::value, "");
static_assert(std::is_same<int const&, decltype(std::get<1>(std::move(p)))>::value, "");

I assume you agree that this test has the correct behavior?

I believe the first static_assert is incorrect, const is shallow so it should be just int&.

BTW your correct.

[K-ballo]

Addressed review comments. Use UNSUPPORTED in pairs.by.type.pass.

[EricWF]

LGTM. Thanks.

[EricWF]

r255941.

include/__tuple

 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 const typename tuple_element<_Ip, tuple<_Tp...> >::type&
 get(const tuple<_Tp...>&) _NOEXCEPT;
 
 template <size_t _Ip, class ..._Tp>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 typename tuple_element<_Ip, tuple<_Tp...> >::type&&
 get(tuple<_Tp...>&&) _NOEXCEPT;
+
+template <size_t _Ip, class ..._Tp>
+_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+const typename tuple_element<_Ip, tuple<_Tp...> >::type&&
+get(const tuple<_Tp...>&&) _NOEXCEPT;
 #endif
 
 // pair specializations
 
 template <class _T1, class _T2> struct _LIBCPP_TYPE_VIS_ONLY pair;
 
 template <class _T1, class _T2> struct __tuple_like<pair<_T1, _T2> > : true_type {};
 
 template <size_t _Ip, class _T1, class _T2>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 typename tuple_element<_Ip, pair<_T1, _T2> >::type&
 get(pair<_T1, _T2>&) _NOEXCEPT;
 
 template <size_t _Ip, class _T1, class _T2>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
 get(const pair<_T1, _T2>&) _NOEXCEPT;
 
 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
 template <size_t _Ip, class _T1, class _T2>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
 get(pair<_T1, _T2>&&) _NOEXCEPT;
+
+template <size_t _Ip, class _T1, class _T2>
+_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+const typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
+get(const pair<_T1, _T2>&&) _NOEXCEPT;
 #endif
 
 // array specializations
 
 template <class _Tp, size_t _Size> struct _LIBCPP_TYPE_VIS_ONLY array;
 
 template <class _Tp, size_t _Size> struct __tuple_like<array<_Tp, _Size> > : true_type {};
 
 template <size_t _Ip, class _Tp, size_t _Size>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 _Tp&
 get(array<_Tp, _Size>&) _NOEXCEPT;
 
 template <size_t _Ip, class _Tp, size_t _Size>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 const _Tp&
 get(const array<_Tp, _Size>&) _NOEXCEPT;
 
 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
 template <size_t _Ip, class _Tp, size_t _Size>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 _Tp&&
 get(array<_Tp, _Size>&&) _NOEXCEPT;
+
+template <size_t _Ip, class _Tp, size_t _Size>
+_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+const _Tp&&
+get(const array<_Tp, _Size>&&) _NOEXCEPT;
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_VARIADICS)
 
 // __make_tuple_indices
 
 template <size_t...> struct __tuple_indices {};
 

include/array

 
 template <class T> class tuple_size;
 template <size_t I, class T> class tuple_element;
 template <class T, size_t N> struct tuple_size<array<T, N>>;
 template <size_t I, class T, size_t N> struct tuple_element<I, array<T, N>>;
 template <size_t I, class T, size_t N> T& get(array<T, N>&) noexcept; // constexpr in C++14
 template <size_t I, class T, size_t N> const T& get(const array<T, N>&) noexcept; // constexpr in C++14
 template <size_t I, class T, size_t N> T&& get(array<T, N>&&) noexcept; // constexpr in C++14
+template <size_t I, class T, size_t N> const T&& get(const array<T, N>&&) noexcept; // constexpr in C++14
 
 }  // std
 
 */
 
 #include <__config>
 #include <__tuple>
 #include <type_traits>

 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 _Tp&&
 get(array<_Tp, _Size>&& __a) _NOEXCEPT
 {
     static_assert(_Ip < _Size, "Index out of bounds in std::get<> (std::array &&)");
     return _VSTD::move(__a.__elems_[_Ip]);
 }
 
+template <size_t _Ip, class _Tp, size_t _Size>
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+const _Tp&&
+get(const array<_Tp, _Size>&& __a) _NOEXCEPT
+{
+    static_assert(_Ip < _Size, "Index out of bounds in std::get<> (const std::array &&)");
+    return _VSTD::move(__a.__elems_[_Ip]);
+}
+
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_ARRAY

include/tuple

template <size_t I, class... T>
     typename tuple_element<I, tuple<T...>>::type&
     get(tuple<T...>&) noexcept; // constexpr in C++14
 template <size_t I, class... T>
     const typename tuple_element<I, tuple<T...>>::type&
     get(const tuple<T...>&) noexcept; // constexpr in C++14
 template <size_t I, class... T>
     typename tuple_element<I, tuple<T...>>::type&&
     get(tuple<T...>&&) noexcept; // constexpr in C++14
+template <size_t I, class... T>
+    const typename tuple_element<I, tuple<T...>>::type&&
+    get(const tuple<T...>&&) noexcept; // constexpr in C++14
 
 template <class T1, class... T>
     constexpr T1& get(tuple<T...>&) noexcept;  // C++14
 template <class T1, class... T>
     constexpr const T1& get(const tuple<T...>&) noexcept;   // C++14
 template <class T1, class... T>
     constexpr T1&& get(tuple<T...>&&) noexcept;   // C++14
+template <class T1, class... T>
+    constexpr const T1&& get(const tuple<T...>&&) noexcept;   // C++14
 
 // 20.4.1.6, relational operators:
 template<class... T, class... U> bool operator==(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
 template<class... T, class... U> bool operator<(const tuple<T...>&, const tuple<U...>&);  // constexpr in C++14
 template<class... T, class... U> bool operator!=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
 template<class... T, class... U> bool operator>(const tuple<T...>&, const tuple<U...>&);  // constexpr in C++14
 template<class... T, class... U> bool operator<=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
 template<class... T, class... U> bool operator>=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
class _LIBCPP_TYPE_VIS_ONLY tuple
     base base_;
 
     template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
         typename tuple_element<_Jp, tuple<_Up...> >::type& get(tuple<_Up...>&) _NOEXCEPT;
     template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
         const typename tuple_element<_Jp, tuple<_Up...> >::type& get(const tuple<_Up...>&) _NOEXCEPT;
     template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
         typename tuple_element<_Jp, tuple<_Up...> >::type&& get(tuple<_Up...>&&) _NOEXCEPT;
+    template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
+        const typename tuple_element<_Jp, tuple<_Up...> >::type&& get(const tuple<_Up...>&&) _NOEXCEPT;
 public:
 
     template <bool _Dummy = true, class = typename enable_if<
         __all<__dependent_type<is_default_constructible<_Tp>, _Dummy>::value...>::value
     >::type>
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR tuple()
         _NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}

 typename tuple_element<_Ip, tuple<_Tp...> >::type&&
 get(tuple<_Tp...>&& __t) _NOEXCEPT
 {
     typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
     return static_cast<type&&>(
              static_cast<__tuple_leaf<_Ip, type>&&>(__t.base_).get());
 }
 
+template <size_t _Ip, class ..._Tp>
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+const typename tuple_element<_Ip, tuple<_Tp...> >::type&&
+get(const tuple<_Tp...>&& __t) _NOEXCEPT
+{
+    typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
+    return static_cast<const type&&>(
+             static_cast<const __tuple_leaf<_Ip, type>&&>(__t.base_).get());
+}
+
 #if _LIBCPP_STD_VER > 11
 // get by type
 template <typename _T1, size_t _Idx, typename... _Args>
 struct __find_exactly_one_t_helper;
 
 // -- find exactly one
 template <typename _T1, size_t _Idx, typename... _Args>
 struct __find_exactly_one_t_checker {

 
 template <class _T1, class... _Args>
 inline _LIBCPP_INLINE_VISIBILITY
 constexpr _T1&& get(tuple<_Args...>&& __tup) noexcept
 {
     return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(_VSTD::move(__tup));
 }
 
+template <class _T1, class... _Args>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr _T1 const&& get(tuple<_Args...> const&& __tup) noexcept
+{
+    return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(_VSTD::move(__tup));
+}
+
 #endif
 
 // tie
 
 template <class ..._Tp>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 tuple<_Tp&...>
 tie(_Tp&... __t) _NOEXCEPT

include/utility

 template<size_t I, class T1, class T2>
     const typename tuple_element<I, pair<T1, T2> >::type&
     get(const pair<T1, T2>&) noexcept; // constexpr in C++14
 
 template<size_t I, class T1, class T2>
     typename tuple_element<I, pair<T1, T2> >::type&&
     get(pair<T1, T2>&&) noexcept; // constexpr in C++14
 
+template<size_t I, class T1, class T2>
+    const typename tuple_element<I, pair<T1, T2> >::type&&
+    get(const pair<T1, T2>&&) noexcept; // constexpr in C++14
+
 template<class T1, class T2>
     constexpr T1& get(pair<T1, T2>&) noexcept; // C++14
 
 template<size_t I, class T1, class T2>
     constexpr const T1& get(const pair<T1, T2>&) noexcept; // C++14
 
 template<size_t I, class T1, class T2>
     constexpr T1&& get(pair<T1, T2>&&) noexcept; // C++14
 
+template<size_t I, class T1, class T2>
+    constexpr const T1&& get(const pair<T1, T2>&&) noexcept; // C++14
+
 // C++14
 
 template<class T, T... I>
 struct integer_sequence
 {
     typedef T value_type;
 
     static constexpr size_t size() noexcept;
 };

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     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);}
 
+    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);}
+
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 };
 
 template <>
 struct __get_pair<1>
 {
     template <class _T1, class _T2>
     static

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     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);}
 
+    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);}
+
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 };
 
 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
 {

 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
 {
     return __get_pair<_Ip>::get(_VSTD::move(__p));
 }
 
+template <size_t _Ip, class _T1, class _T2>
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+const typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
+get(const pair<_T1, _T2>&& __p) _NOEXCEPT
+{
+    return __get_pair<_Ip>::get(_VSTD::move(__p));
+}
+
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 #if _LIBCPP_STD_VER > 11
 template <class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY
 constexpr _T1 & get(pair<_T1, _T2>& __p) _NOEXCEPT
 {
     return __get_pair<0>::get(__p);

 inline _LIBCPP_INLINE_VISIBILITY
 constexpr _T1 && get(pair<_T1, _T2>&& __p) _NOEXCEPT
 {
     return __get_pair<0>::get(_VSTD::move(__p));
 }
 
 template <class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY
+constexpr _T1 const && get(pair<_T1, _T2> const&& __p) _NOEXCEPT
+{
+    return __get_pair<0>::get(_VSTD::move(__p));
+}
+
+template <class _T1, class _T2>
+inline _LIBCPP_INLINE_VISIBILITY
 constexpr _T1 & get(pair<_T2, _T1>& __p) _NOEXCEPT
 {
     return __get_pair<1>::get(__p);
 }
 
 template <class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY
 constexpr _T1 const & get(pair<_T2, _T1> const& __p) _NOEXCEPT
 {
     return __get_pair<1>::get(__p);
 }
 
 template <class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY
 constexpr _T1 && get(pair<_T2, _T1>&& __p) _NOEXCEPT
 {
     return __get_pair<1>::get(_VSTD::move(__p));
 }
 
+template <class _T1, class _T2>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr _T1 const && get(pair<_T2, _T1> const&& __p) _NOEXCEPT
+{
+    return __get_pair<1>::get(_VSTD::move(__p));
+}
+
 #endif
 
 #if _LIBCPP_STD_VER > 11
 
 template<class _Tp, _Tp... _Ip>
 struct _LIBCPP_TYPE_VIS_ONLY integer_sequence
 {
     typedef _Tp value_type;

test/std/containers/sequences/array/array.tuple/get_const_rv.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <array>
+
+// template <size_t I, class T, size_t N> const T&& get(const array<T, N>&& a);
+
+// UNSUPPORTED: c++98, c++03
+
+#include <array>
+#include <memory>
+#include <type_traits>
+#include <utility>
+#include <cassert>
+
+// std::array is explicitly allowed to be initialized with A a = { init-list };.
+// Disable the missing braces warning for this reason.
+#include "disable_missing_braces_warning.h"
+
+int main()
+{
+
+    {
+    typedef std::unique_ptr<double> T;
+    typedef std::array<T, 1> C;
+    const C c = {std::unique_ptr<double>(new double(3.5))};
+    static_assert(std::is_same<const T&&, decltype(std::get<0>(std::move(c)))>::value, "");
+    const T&& t = std::get<0>(std::move(c));
+    assert(*t == 3.5);
+    }
+
+#if TEST_STD_VER > 11
+    {
+    typedef double T;
+    typedef std::array<T, 3> C;
+    constexpr const C c = {1, 2, 3.5};
+    static_assert(std::get<0>(std::move(c)) == 1, "");
+    static_assert(std::get<1>(std::move(c)) == 2, "");
+    static_assert(std::get<2>(std::move(c)) == 3.5, "");
+    }
+#endif
+}

test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.fail.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template <size_t I, class... Types>
+//   const typename tuple_element<I, tuple<Types...> >::type&&
+//   get(const tuple<Types...>&& t);
+
+// UNSUPPORTED: c++98, c++03
+
+#include <tuple>
+
+template <class T> void cref(T const&) {};
+template <class T> void cref(T const&&) = delete;
+
+std::tuple<int> const tup4() { return std::make_tuple(4); }
+
+int main()
+{
+    {
+        cref(std::get<0>(tup4()));  // expected-error {{call to deleted function 'cref'}}
+    }
+}

test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template <size_t I, class... Types>
+//   const typename tuple_element<I, tuple<Types...> >::type&&
+//   get(const tuple<Types...>&& t);
+
+// UNSUPPORTED: c++98, c++03
+
+#include <tuple>
+#include <utility>
+#include <string>
+#include <type_traits>
+#include <cassert>
+
+int main()
+{
+    {
+    typedef std::tuple<int> T;
+    const T t(3);
+    static_assert(std::is_same<const int&&, decltype(std::get<0>(std::move(t)))>::value, "");
+    const int&& i = std::get<0>(std::move(t));
+    assert(i == 3);
+    }
+
+    {
+    typedef std::tuple<std::string, int> T;
+    const T t("high", 5);
+    static_assert(std::is_same<const std::string&&, decltype(std::get<0>(std::move(t)))>::value, "");
+    static_assert(std::is_same<const int&&, decltype(std::get<1>(std::move(t)))>::value, "");
+    const std::string&& s = std::get<0>(std::move(t));
+    const int&& i = std::get<1>(std::move(t));
+    assert(s == "high");
+    assert(i == 5);
+    }
+
+    {
+    int x = 42;
+    int const y = 43;
+    std::tuple<int&, int const&> const p(x, y);
+    static_assert(std::is_same<int&, decltype(std::get<0>(std::move(p)))>::value, "");
+    static_assert(std::is_same<int const&, decltype(std::get<1>(std::move(p)))>::value, "");
+    }
+
+#if TEST_STD_VER > 11
+    {
+    typedef std::tuple<double, int> T;
+    constexpr const T t(2.718, 5);
+    static_assert(std::get<0>(std::move(t)) == 2.718, "");
+    static_assert(std::get<1>(std::move(t)) == 5, "");
+    }
+#endif
+}

test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11
 
 #include <tuple>
 #include <string>
 #include <complex>
+#include <type_traits>
 
 #include <cassert>
 
 int main()
 {
 #if _LIBCPP_STD_VER > 11
     typedef std::complex<float> cf;
     {
     auto t1 = std::tuple<int, std::string, cf> { 42, "Hi", { 1,2 }};
-    assert ( std::get<int>(t1) == 42 ); // find at the beginning 
+    assert ( std::get<int>(t1) == 42 ); // find at the beginning
     assert ( std::get<std::string>(t1) == "Hi" ); // find in the middle
     assert ( std::get<cf>(t1).real() == 1 ); // find at the end
     assert ( std::get<cf>(t1).imag() == 2 );
     }
-    
     {
     auto t2 = std::tuple<int, std::string, int, cf> { 42, "Hi", 23, { 1,2 }};
 //  get<int> would fail!
     assert ( std::get<std::string>(t2) == "Hi" );
     assert (( std::get<cf>(t2) == cf{ 1,2 } ));
     }
-    
     {
     constexpr std::tuple<int, const int, double, double> p5 { 1, 2, 3.4, 5.6 };
     static_assert ( std::get<int>(p5) == 1, "" );
     static_assert ( std::get<const int>(p5) == 2, "" );
     }
 
     {
     const std::tuple<int, const int, double, double> p5 { 1, 2, 3.4, 5.6 };
     const int &i1 = std::get<int>(p5);
     const int &i2 = std::get<const int>(p5);
     assert ( i1 == 1 );
     assert ( i2 == 2 );
     }
 
     {
     typedef std::unique_ptr<int> upint;
     std::tuple<upint> t(upint(new int(4)));
     upint p = std::get<upint>(std::move(t)); // get rvalue
     assert(*p == 4);
-    assert(std::get<0>(t) == nullptr); // has been moved from
+    assert(std::get<upint>(t) == nullptr); // has been moved from
+    }
+
+    {
+    typedef std::unique_ptr<int> upint;
+    const std::tuple<upint> t(upint(new int(4)));
+    const upint&& p = std::get<upint>(std::move(t)); // get const rvalue
+    assert(*p == 4);
+    assert(std::get<upint>(t) != nullptr);
+    }
+
+    {
+    int x = 42;
+    int tuple y = 43;
+    std::tuple<int&, int const&> const t(x, y);
+    static_assert(std::is_same<int&, decltype(std::get<int&>(std::move(t)))>::value, "");
+    static_assert(std::is_same<int const&, decltype(std::get<int const&>(std::move(t)))>::value, "");
+    }
+
+    {
+    constexpr const std::tuple<int, const int, double, double> t { 1, 2, 3.4, 5.6 };
+    static_assert(std::get<int>(std::move(t)) == 1, "");
+    static_assert(std::get<const int>(std::move(t)) == 2, "");
     }
 
 #endif
 }

test/std/utilities/utility/pairs/pair.astuple/get_const_rv.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <utility>
+
+// template <class T1, class T2> struct pair
+
+// template<size_t I, class T1, class T2>
+//     const typename tuple_element<I, std::pair<T1, T2> >::type&&
+//     get(const pair<T1, T2>&&);
+
+// UNSUPPORTED: c++98, c++03
+
+#include <utility>
+#include <memory>
+#include <type_traits>
+#include <cassert>
+
+int main()
+{
+    {
+    typedef std::pair<std::unique_ptr<int>, short> P;
+    const P p(std::unique_ptr<int>(new int(3)), 4);
+    static_assert(std::is_same<const std::unique_ptr<int>&&, decltype(std::get<0>(std::move(p)))>::value, "");
+    const std::unique_ptr<int>&& ptr = std::get<0>(std::move(p));
+    assert(*ptr == 3);
+    }
+
+    {
+    int x = 42;
+    int const y = 43;
+    std::pair<int&, int const&> const p(x, y);
+    static_assert(std::is_same<int&, decltype(std::get<0>(std::move(p)))>::value, "");
+    static_assert(std::is_same<int const&, decltype(std::get<1>(std::move(p)))>::value, "");
+    }
+
+#if TEST_STD_VER > 11
+    {
+    typedef std::pair<int, short> P;
+    constexpr const P p1(3, 4);
+    static_assert(std::get<0>(std::move(p1)) == 3, "");
+    static_assert(std::get<1>(std::move(p1)) == 4, "");
+    }
+#endif
+}

test/std/utilities/utility/pairs/pair.astuple/pairs.by.type.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <utility>
 #include <string>
+#include <type_traits>
 #include <complex>
 
 #include <cassert>
 
 int main()
 {
 #if _LIBCPP_STD_VER > 11
     typedef std::complex<float> cf;
     {
     auto t1 = std::make_pair<int, cf> ( 42, { 1,2 } );
     assert ( std::get<int>(t1) == 42 );
     assert ( std::get<cf>(t1).real() == 1 );
     assert ( std::get<cf>(t1).imag() == 2 );
     }
-    
     {
     const std::pair<int, const int> p1 { 1, 2 };
     const int &i1 = std::get<int>(p1);
     const int &i2 = std::get<const int>(p1);
     assert ( i1 == 1 );
     assert ( i2 == 2 );
     }
 
     {
     typedef std::unique_ptr<int> upint;
     std::pair<upint, int> t(upint(new int(4)), 42);
-    upint p = std::get<0>(std::move(t)); // get rvalue
+    upint p = std::get<upint>(std::move(t)); // get rvalue
     assert(*p == 4);
-    assert(std::get<0>(t) == nullptr); // has been moved from
+    assert(std::get<upint>(t) == nullptr); // has been moved from
+    }
+
+    {
+    typedef std::unique_ptr<int> upint;
+    const std::pair<upint, int> t(upint(new int(4)), 42);
+    static_assert(std::is_same<const upint&&, decltype(std::get<upint>(std::move(t)))>::value, "");
+    static_assert(std::is_same<const int&&, decltype(std::get<int>(std::move(t)))>::value, "");
+    auto&& p = std::get<upint>(std::move(t)); // get const rvalue
+    auto&& i = std::get<int>(std::move(t)); // get const rvalue
+    assert(*p == 4);
+    assert(i == 42);
+    assert(std::get<upint>(t) != nullptr);
+    }
+
+    {
+    int x = 42;
+    int const y = 43;
+    std::pair<int&, int const&> const p(x, y);
+    static_assert(std::is_same<int&, decltype(std::get<int&>(std::move(p)))>::value, "");
+    static_assert(std::is_same<int const&, decltype(std::get<int const&>(std::move(p)))>::value, "");
+    }
+
+    {
+    constexpr const std::pair<int, const int> p { 1, 2 };
+    static_assert(std::get<int>(std::move(p)) == 1, "");
+    static_assert(std::get<const int>(std::move(p)) == 2, "");
     }
 
 #endif
 }