[libc++] Make a few standard types trivially equality comparable

[philnik]

Summary

This allows std::equal and other algorithms be optimized better.

[ldionne]

I think this LGTM w/ comments applied, but I'd like to see it one last time w/ green CI and comments applied before we ship this.

libcxx/include/__exception/exception_ptr.h

1

libcxx/test/std/language.support/support.exception/propagation/exception_ptr.pass.cpp is very very light, it doesn't even test for != -- can you add a test for that?

39

Please add a comment explaining that this allows making the class trivially equality comparable.

libcxx/include/__expected/unexpected.h

111

Please add a comment like:

// conforming extension: this is not observable beyond SFINAE but it allows making `unexpected` trivially comparable

libcxx/include/array

266

Same thing, please add a comment throughout whenever it's a public API. For example not in __wrap_iter.

libcxx/include/forward_list

395

No need for public:, we're already in public. Please check throughout.

libcxx/include/tuple

1333

Can you please ensure that we have tests for comparing tuples that contain reference types?

[philnik]

Address comments

[philnik]

Try to fix CI

[philnik]

Try to fix CI

[ldionne]

libcxx/include/array

266

libcxx/include/tuple

1362

Conforming extension comment?

libcxx/test/libcxx/types_are_trivially_equality_comparable.compile.pass.cpp

38

Per your comment, you might be able to uncomment this now.

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp

17

About your CI issues, I think this might be a compiler bug:

Works with all compilers: https://godbolt.org/z/Pc8bqczvo
Works with GCC but not Clang/MSVC: https://godbolt.org/z/j68j4Ezcn

I think they should both work on all compilers.

Edit: The problem seems to be that Clang and MSVC will instantiate operator== a bit too eagerly: https://godbolt.org/z/5hMKWzoMs, which triggers ADL on Holder<Incomplete>.

[philnik]

Abandoning for now, since this requires some sort of compiler fix to work properly and this won't happen within the next month or so.

libcxx/include/__exception/exception_ptr.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___EXCEPTION_EXCEPTION_PTR_H
public:
   _LIBCPP_HIDE_FROM_ABI exception_ptr(nullptr_t) _NOEXCEPT : __ptr_() {}
 
   exception_ptr(const exception_ptr&) _NOEXCEPT;
   exception_ptr& operator=(const exception_ptr&) _NOEXCEPT;
   ~exception_ptr() _NOEXCEPT;
 
   _LIBCPP_HIDE_FROM_ABI explicit operator bool() const _NOEXCEPT { return __ptr_ != nullptr; }
 
+#  if _LIBCPP_STD_VER < 20
   friend _LIBCPP_HIDE_FROM_ABI bool operator==(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT {
     return __x.__ptr_ == __y.__ptr_;
   }
 
   friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT {
     return !(__x == __y);
   }
+#  else
+  // This makes exception_ptr __trivially_equality_comparable
+  _LIBCPP_HIDE_FROM_ABI bool operator==(const exception_ptr&) const = default;
+#  endif
 
   friend _LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT;
   friend _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr);
 };
 
 template <class _Ep>
 _LIBCPP_HIDE_FROM_ABI exception_ptr make_exception_ptr(_Ep __e) _NOEXCEPT {
 #  ifndef _LIBCPP_HAS_NO_EXCEPTIONS

libcxx/include/__expected/unexpected.h

_LIBCPP_HIDE_FROM_ABI friend constexpr void swap(unexpected& __x, unexpected& __y) noexcept(noexcept(__x.swap(__y)))
     __x.swap(__y);
   }
 
   template <class _Err2>
   _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const unexpected& __x, const unexpected<_Err2>& __y) {
     return __x.__unex_ == __y.__unex_;
   }
 
+  // conforming extension: This is not observable other than through SFINAE on `u.operator==`
+  // This makes unexpected trivially equality comparable if _Err is trivially equality comparable
+  _LIBCPP_HIDE_FROM_ABI bool operator==(const unexpected&) const
+    requires is_object_v<_Err>
+  = default;
+
 private:
   _Err __unex_;
 };
 
 template <class _Err>
 unexpected(_Err) -> unexpected<_Err>;
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 23
 
 #endif // _LIBCPP___EXPECTED_UNEXPECTED_H

libcxx/include/__iterator/wrap_iter.h

#ifdef _LIBCPP_ENABLE_DEBUG_MODE
         __get_db()->__insert_ic(this, __p);
 #endif
     }
 
     template <class _Up> friend class __wrap_iter;
     template <class _CharT, class _Traits, class _Alloc> friend class basic_string;
     template <class _Tp, class _Alloc> friend class _LIBCPP_TEMPLATE_VIS vector;
     template <class _Tp, size_t> friend class _LIBCPP_TEMPLATE_VIS span;
+
+#if _LIBCPP_STD_VER >= 20
+public:
+    // This makes __wrap_iter trivially equality comparable if _Iter is trivially equality comparable
+    bool operator==(const __wrap_iter&) const = default;
+#endif
 };
 
 template <class _Iter1>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
 bool operator==(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT
 {
     return __x.base() == __y.base();
 }

libcxx/include/__utility/pair.h

 #include <__type_traits/is_implicitly_default_constructible.h>
 #include <__type_traits/is_move_assignable.h>
 #include <__type_traits/is_nothrow_assignable.h>
 #include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/is_nothrow_copy_assignable.h>
 #include <__type_traits/is_nothrow_copy_constructible.h>
 #include <__type_traits/is_nothrow_default_constructible.h>
 #include <__type_traits/is_nothrow_move_assignable.h>
+#include <__type_traits/is_object.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/is_swappable.h>
 #include <__type_traits/nat.h>
 #include <__type_traits/remove_cvref.h>
 #include <__type_traits/unwrap_ref.h>
 #include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>

 
 #ifndef _LIBCPP_CXX03_LANG
     template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     pair(piecewise_construct_t,
          tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
          __tuple_indices<_I1...>, __tuple_indices<_I2...>);
 #endif
+
+#if _LIBCPP_STD_VER >= 20
+public:
+    // conforming extension: This is not observable other than through SFINAE on `u.operator==`
+    // This makes pair trivially equality comparable if _T1 and _T2 are trivially equality comparable
+    bool operator==(const pair&) const requires (is_object_v<_T1> && is_object_v<_T2>) = default;
+#endif
 };
 
 #if _LIBCPP_STD_VER >= 17
 template<class _T1, class _T2>
 pair(_T1, _T2) -> pair<_T1, _T2>;
 #endif
 
 // [pairs.spec], specialized algorithms

libcxx/include/array

struct _LIBCPP_TEMPLATE_VIS array
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference front() const _NOEXCEPT {return (*this)[0];}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 reference back()              _NOEXCEPT {return (*this)[_Size - 1];}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference back() const  _NOEXCEPT {return (*this)[_Size - 1];}
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
     value_type* data() _NOEXCEPT {return __elems_;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
     const value_type* data() const _NOEXCEPT {return __elems_;}
+
+#if _LIBCPP_STD_VER >= 20
+    // conforming extension: This is not observable other than through SFINAE on `u.operator==`
+    // This makes pair trivially equality comparable if _Tp is trivially equality comparable
+    _LIBCPP_HIDE_FROM_ABI bool operator==(const array&) const = default;
+#endif
 };
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS array<_Tp, 0>
 {
     // types:
     typedef array __self;
     typedef _Tp                                   value_type;

libcxx/include/complex

template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(const complex<_Xp>& __c)
             *this = *this * complex(__c.real(), __c.imag());
             return *this;
         }
     template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const complex<_Xp>& __c)
         {
             *this = *this / complex(__c.real(), __c.imag());
             return *this;
         }
+
+#if _LIBCPP_STD_VER >= 20
+    // conforming extension: This is not observable other than through SFINAE on `u.operator==`
+    // This makes complex trivially equality comparable if _Tp is trivially equality comparable
+    bool operator==(const complex&) const = default;
+#endif
 };
 
 template<> class _LIBCPP_TEMPLATE_VIS complex<double>;
 template<> class _LIBCPP_TEMPLATE_VIS complex<long double>;
 
 template<>
 class _LIBCPP_TEMPLATE_VIS complex<float>
 {

libcxx/include/forward_list

public:
     _LIBCPP_INLINE_VISIBILITY
     __forward_list_iterator operator++(int)
     {
         __forward_list_iterator __t(*this);
         ++(*this);
         return __t;
     }
 
+#if _LIBCPP_STD_VER <= 20
     friend _LIBCPP_INLINE_VISIBILITY
     bool operator==(const __forward_list_iterator& __x,
                     const __forward_list_iterator& __y)
         {return __x.__ptr_ == __y.__ptr_;}
     friend _LIBCPP_INLINE_VISIBILITY
     bool operator!=(const __forward_list_iterator& __x,
                     const __forward_list_iterator& __y)
         {return !(__x == __y);}
+#else
+    // This makes __forward_list_iterator trivially equality comparable
+    _LIBCPP_HIDE_FROM_ABI bool operator==(const __forward_list_iterator&) const = default;
+#endif
 };
 
 template <class _NodeConstPtr>
 class _LIBCPP_TEMPLATE_VIS __forward_list_const_iterator
 {
     static_assert((!is_const<typename pointer_traits<_NodeConstPtr>::element_type>::value), "");
     typedef _NodeConstPtr _NodePtr;
 
public:
     _LIBCPP_INLINE_VISIBILITY
     __forward_list_const_iterator operator++(int)
     {
         __forward_list_const_iterator __t(*this);
         ++(*this);
         return __t;
     }
 
+#if _LIBCPP_STD_VER <= 20
     friend _LIBCPP_INLINE_VISIBILITY
     bool operator==(const __forward_list_const_iterator& __x,
                     const __forward_list_const_iterator& __y)
         {return __x.__ptr_ == __y.__ptr_;}
     friend _LIBCPP_INLINE_VISIBILITY
     bool operator!=(const __forward_list_const_iterator& __x,
                            const __forward_list_const_iterator& __y)
         {return !(__x == __y);}
+#else
+    // This makes __forward_list_iterator trivially equality comparable
+    _LIBCPP_HIDE_FROM_ABI bool operator==(const __forward_list_const_iterator&) const = default;
+#endif
 };
 
 template <class _Tp, class _Alloc>
 class __forward_list_base
 {
 protected:
     typedef _Tp    value_type;
     typedef _Alloc allocator_type;

libcxx/include/list

__list_iterator& operator--()
         _LIBCPP_DEBUG_ASSERT(__get_const_db()->__decrementable(this),
                              "Attempted to decrement a non-decrementable list::iterator");
         __ptr_ = __ptr_->__prev_;
         return *this;
     }
     _LIBCPP_INLINE_VISIBILITY
     __list_iterator operator--(int) {__list_iterator __t(*this); --(*this); return __t;}
 
+#if _LIBCPP_STD_VER <= 20
     friend _LIBCPP_INLINE_VISIBILITY
     bool operator==(const __list_iterator& __x, const __list_iterator& __y)
     {
         return __x.__ptr_ == __y.__ptr_;
     }
     friend _LIBCPP_INLINE_VISIBILITY
      bool operator!=(const __list_iterator& __x, const __list_iterator& __y)
         {return !(__x == __y);}
+#else
+    // This makes __list_iterator trivially equality comparable
+    _LIBCPP_HIDE_FROM_ABI bool operator==(const __list_iterator&) const = default;
+#endif
 };
 
 template <class _Tp, class _VoidPtr>
 class _LIBCPP_TEMPLATE_VIS __list_const_iterator
 {
     typedef __list_node_pointer_traits<_Tp, _VoidPtr> _NodeTraits;
     typedef typename _NodeTraits::__link_pointer __link_pointer;
 
__list_const_iterator& operator--()
         _LIBCPP_DEBUG_ASSERT(__get_const_db()->__decrementable(this),
                              "Attempted to decrement a non-decrementable list::const_iterator");
         __ptr_ = __ptr_->__prev_;
         return *this;
     }
     _LIBCPP_INLINE_VISIBILITY
     __list_const_iterator operator--(int) {__list_const_iterator __t(*this); --(*this); return __t;}
 
+#if _LIBCPP_STD_VER <= 20
     friend _LIBCPP_INLINE_VISIBILITY
     bool operator==(const __list_const_iterator& __x, const __list_const_iterator& __y)
     {
         return __x.__ptr_ == __y.__ptr_;
     }
     friend _LIBCPP_INLINE_VISIBILITY
     bool operator!=(const __list_const_iterator& __x, const __list_const_iterator& __y)
         {return !(__x == __y);}
+#else
+    // This makes __list_const_iterator trivially equality comparable
+    _LIBCPP_HIDE_FROM_ABI bool operator==(const __list_const_iterator&) const = default;
+#endif
 };
 
 template <class _Tp, class _Alloc>
 class __list_imp
 {
     __list_imp(const __list_imp&);
     __list_imp& operator=(const __list_imp&);
 public:

libcxx/include/tuple

public:
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
     int swap(const __tuple_leaf& __t) const _NOEXCEPT_(__is_nothrow_swappable<const __tuple_leaf>::value) {
         _VSTD::swap(*this, __t);
         return 0;
     }
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14       _Hp& get()       _NOEXCEPT {return __value_;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Hp& get() const _NOEXCEPT {return __value_;}
+
+#if _LIBCPP_STD_VER >= 20
+    // This makes __tuple_leaf trivially equality comparable if _Hp is trivially equality comparable
+    _LIBCPP_HIDE_FROM_ABI bool operator==(const __tuple_leaf&) const requires (is_object_v<_Hp>) = default;
+#endif
 };
 
 template <size_t _Ip, class _Hp>
 class __tuple_leaf<_Ip, _Hp, true>
     : private _Hp
 {
     _LIBCPP_CONSTEXPR_SINCE_CXX14
     __tuple_leaf& operator=(const __tuple_leaf&);
public:
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
     int swap(const __tuple_leaf& __rhs) const _NOEXCEPT_(__is_nothrow_swappable<const __tuple_leaf>::value) {
         _VSTD::swap(*this, __rhs);
         return 0;
     }
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14       _Hp& get()       _NOEXCEPT {return static_cast<_Hp&>(*this);}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Hp& get() const _NOEXCEPT {return static_cast<const _Hp&>(*this);}
+
+#if _LIBCPP_STD_VER >= 20
+    // This makes __tuple_leaf trivially equality comparable if _Hp is trivially equality comparable
+    _LIBCPP_HIDE_FROM_ABI bool operator==(const __tuple_leaf&) const requires (is_object_v<_Hp>) = default;
+#endif
 };
 
 template <class ..._Tp>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
 void __swallow(_Tp&&...) _NOEXCEPT {}
 
 template <class _Tp>
 struct __all_default_constructible;
struct _LIBCPP_DECLSPEC_EMPTY_BASES __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
     }
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
     void swap(const __tuple_impl& __t) const
         _NOEXCEPT_(__all<__is_nothrow_swappable<const _Tp>::value...>::value)
     {
         _VSTD::__swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<const __tuple_leaf<_Indx, _Tp>&>(__t))...);
     }
+
+#if _LIBCPP_STD_VER >= 20
+    // This makes __tuple_impl trivially equality comparable if all _Tp are trivially equality comparable
+    _LIBCPP_HIDE_FROM_ABI bool operator==(const __tuple_impl&) const
+      requires(__all<is_object_v<_Tp>...>::value)
+    = default;
+#  endif
 };
 
 template<class _Dest, class _Source, size_t ..._Np>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
 void __memberwise_copy_assign(_Dest& __dest, _Source const& __source, __tuple_indices<_Np...>) {
     _VSTD::__swallow(((_VSTD::get<_Np>(__dest) = _VSTD::get<_Np>(__source)), void(), 0)...);
 }
 
void swap(tuple& __t) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
         {__base_.swap(__t.__base_);}
 
 #if _LIBCPP_STD_VER >= 23
     _LIBCPP_HIDE_FROM_ABI constexpr
     void swap(const tuple& __t) const noexcept(__all<is_nothrow_swappable_v<const _Tp&>...>::value) {
         __base_.swap(__t.__base_);
     }
 #endif // _LIBCPP_STD_VER >= 23
+
+#if _LIBCPP_STD_VER >= 20
+    // This makes tuple trivially equality comparable if all _Tp are trivially equality comparable
+    _LIBCPP_HIDE_FROM_ABI bool operator==(const tuple&) const requires (__all<is_object_v<_Tp>...>::value) = default;
+#endif
 };
 
 template <>
 class _LIBCPP_TEMPLATE_VIS tuple<>
 {
 public:
     constexpr tuple() _NOEXCEPT = default;
     template <class _Alloc>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
         tuple(allocator_arg_t, const _Alloc&) _NOEXCEPT {}
     template <class _Alloc>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
         tuple(allocator_arg_t, const _Alloc&, const tuple&) _NOEXCEPT {}
     template <class _Up>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
         tuple(array<_Up, 0>) _NOEXCEPT {}
     template <class _Alloc, class _Up>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
         tuple(allocator_arg_t, const _Alloc&, array<_Up, 0>) _NOEXCEPT {}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
     void swap(tuple&) _NOEXCEPT {}
 #if _LIBCPP_STD_VER >= 23
     _LIBCPP_HIDE_FROM_ABI constexpr void swap(const tuple&) const noexcept {}
 #endif
+
+#if _LIBCPP_STD_VER >= 20
+public:
+    bool operator==(const tuple&) const = default;
+#endif
 };
 
 #if _LIBCPP_STD_VER >= 23
 template <class... _TTypes, class... _UTypes, template<class> class _TQual, template<class> class _UQual>
     requires requires { typename tuple<common_reference_t<_TQual<_TTypes>, _UQual<_UTypes>>...>; }
 struct basic_common_reference<tuple<_TTypes...>, tuple<_UTypes...>, _TQual, _UQual> {
     using type = tuple<common_reference_t<_TQual<_TTypes>, _UQual<_UTypes>>...>;
 };

libcxx/test/libcxx/types_are_trivially_equality_comparable.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: clang
+// UNSUPPORTED: clang-15, clang-16
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// ADDITIONAL_COMPILE_FLAGS: -Wno-private-header
+
+#include <__iterator/wrap_iter.h>
+#include <__type_traits/is_equality_comparable.h>
+
+#include <array>
+#include <complex>
+#include <expected>
+#include <forward_list>
+#include <list>
+#include <optional>
+#include <tuple>
+#include <utility>
+
+#include "test_macros.h"
+
+template <class T>
+constexpr bool is_tec = std::__libcpp_is_trivially_equality_comparable<T, T>::value;
+
+static_assert(is_tec<std::array<int, 1>>);
+static_assert(is_tec<std::complex<int>>);
+static_assert(is_tec<std::forward_list<int>::iterator>);
+static_assert(is_tec<std::forward_list<int>::const_iterator>);
+static_assert(is_tec<std::list<int>::iterator>);
+static_assert(is_tec<std::list<int>::const_iterator>);
+// These are currently false because of a compiler bug
+// static_assert(is_tec<std::pair<int, int>>);
+// static_assert(is_tec<std::tuple<int>>);
+// static_assert(is_tec<std::tuple<int, int>>);
+static_assert(is_tec<std::__wrap_iter<int*>>);
+
+#if TEST_STD_VER >= 23
+static_assert(is_tec<std::unexpected<int>>);
+#endif
+
+// TODO: Make these types trivially equality comparable:
+// - std::chrono types
+// - std::coroutine_handle<void>
+// - std::filesystem::space_info
+// - std::unique_ptr
+// - iterator_t<elements_view>
+// - iterator_t<iota_view>
+// - iterator_t<zip_view>
+// - error_code
+// - error_condition
+// - set, map, unordered_set, etc. iterators

libcxx/test/std/language.support/support.exception/propagation/exception_ptr.pass.cpp

 #include <type_traits>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::exception_ptr p;
     assert(p == nullptr);
+    assert(!(p != nullptr));
     std::exception_ptr p2 = p;
     assert(nullptr == p);
+    assert(!(nullptr != p));
     assert(!p);
     assert(p2 == p);
+    assert(!(p2 != p));
     p2 = p;
     assert(p2 == p);
+    assert(!(p2 != p));
     assert(p2 == nullptr);
+    assert(!(p2 != nullptr));
     std::exception_ptr p3 = nullptr;
     assert(p3 == nullptr);
+    assert(!(p3 != nullptr));
     p3 = nullptr;
     assert(p3 == nullptr);
+    assert(!(p3 != nullptr));
 
     return 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.rel/eq.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <tuple>
 
 // template <class... Types> class tuple;
 
 // template<class... TTypes, class... UTypes>
 //   bool
 //   operator==(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
 
 // UNSUPPORTED: c++03
 
 #include <tuple>
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        typedef std::tuple<> T1;
-        typedef std::tuple<> T2;
-        const T1 t1;
-        const T2 t2;
-        assert(t1 == t2);
-        assert(!(t1 != t2));
-    }
-    {
-        typedef std::tuple<int> T1;
-        typedef std::tuple<double> T2;
-        const T1 t1(1);
-        const T2 t2(1.1);
-        assert(!(t1 == t2));
-        assert(t1 != t2);
-    }
-    {
-        typedef std::tuple<int> T1;
-        typedef std::tuple<double> T2;
-        const T1 t1(1);
-        const T2 t2(1);
-        assert(t1 == t2);
-        assert(!(t1 != t2));
-    }
-    {
-        typedef std::tuple<int, double> T1;
-        typedef std::tuple<double, long> T2;
-        const T1 t1(1, 2);
-        const T2 t2(1, 2);
-        assert(t1 == t2);
-        assert(!(t1 != t2));
-    }
-    {
-        typedef std::tuple<int, double> T1;
-        typedef std::tuple<double, long> T2;
-        const T1 t1(1, 2);
-        const T2 t2(1, 3);
-        assert(!(t1 == t2));
-        assert(t1 != t2);
-    }
-    {
-        typedef std::tuple<int, double> T1;
-        typedef std::tuple<double, long> T2;
-        const T1 t1(1, 2);
-        const T2 t2(1.1, 2);
-        assert(!(t1 == t2));
-        assert(t1 != t2);
-    }
-    {
-        typedef std::tuple<int, double> T1;
-        typedef std::tuple<double, long> T2;
-        const T1 t1(1, 2);
-        const T2 t2(1.1, 3);
-        assert(!(t1 == t2));
-        assert(t1 != t2);
-    }
-    {
-        typedef std::tuple<long, int, double> T1;
-        typedef std::tuple<double, long, int> T2;
-        const T1 t1(1, 2, 3);
-        const T2 t2(1, 2, 3);
-        assert(t1 == t2);
-        assert(!(t1 != t2));
-    }
-    {
-        typedef std::tuple<long, int, double> T1;
-        typedef std::tuple<double, long, int> T2;
-        const T1 t1(1, 2, 3);
-        const T2 t2(1.1, 2, 3);
-        assert(!(t1 == t2));
-        assert(t1 != t2);
-    }
-    {
-        typedef std::tuple<long, int, double> T1;
-        typedef std::tuple<double, long, int> T2;
-        const T1 t1(1, 2, 3);
-        const T2 t2(1, 3, 3);
-        assert(!(t1 == t2));
-        assert(t1 != t2);
-    }
-    {
-        typedef std::tuple<long, int, double> T1;
-        typedef std::tuple<double, long, int> T2;
-        const T1 t1(1, 2, 3);
-        const T2 t2(1, 2, 4);
-        assert(!(t1 == t2));
-        assert(t1 != t2);
-    }
-    {
-        typedef std::tuple<long, int, double> T1;
-        typedef std::tuple<double, long, int> T2;
-        const T1 t1(1, 2, 3);
-        const T2 t2(1, 3, 2);
-        assert(!(t1 == t2));
-        assert(t1 != t2);
-    }
-    {
-        typedef std::tuple<long, int, double> T1;
-        typedef std::tuple<double, long, int> T2;
-        const T1 t1(1, 2, 3);
-        const T2 t2(1.1, 2, 2);
-        assert(!(t1 == t2));
-        assert(t1 != t2);
-    }
-    {
-        typedef std::tuple<long, int, double> T1;
-        typedef std::tuple<double, long, int> T2;
-        const T1 t1(1, 2, 3);
-        const T2 t2(1.1, 3, 3);
-        assert(!(t1 == t2));
-        assert(t1 != t2);
-    }
-    {
-        typedef std::tuple<long, int, double> T1;
-        typedef std::tuple<double, long, int> T2;
-        const T1 t1(1, 2, 3);
-        const T2 t2(1.1, 3, 2);
-        assert(!(t1 == t2));
-        assert(t1 != t2);
-    }
-#if TEST_STD_VER > 11
-    {
-        typedef std::tuple<long, int, double> T1;
-        typedef std::tuple<double, long, int> T2;
-        constexpr T1 t1(1, 2, 3);
-        constexpr T2 t2(1.1, 3, 2);
-        static_assert(!(t1 == t2), "");
-        static_assert(t1 != t2, "");
-    }
-#endif
+TEST_CONSTEXPR_CXX14 bool test() {
+    int i = 1;
+    double d = 1.1;
+    std::tuple<int&, double&> lhs(i, d);
+    i = 2;
+    d = 2.2;
+    std::tuple<int&, double&> rhs(i, d);
+    assert(lhs == rhs);
+    assert(!(lhs != rhs));
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
 
   return 0;
 }