[libcxx] adds concept `std::common_reference_with`

[cjdb]

Summary

Implements parts of:

• P0898R3 Standard Library Concepts
• P1754 Rename concepts to standard_case for C++20, while we still can

Depends on D96657

[cjdb]

corrects requirement

[Mordante]

libcxx/include/concepts

176

Minor nitpick the section is called [concept.commonref].

181

I know it behaves the same, but is there a reason you use common_reference_t<_Up, _Tp> instead of common_reference_t<_Tp, _Up> as specified in the standard?

libcxx/test/std/concepts/lang/commonreference.compile.pass.cpp

55

Can you guard this with #ifndef _LIBCPP_HAS_NO_INT128?

[cjdb]

applies @Mordante's feedback

[cjdb]

libcxx/include/concepts

181

I think this was a late night change from common_reference_t<_Up, _Up>.

[Mordante]

Thanks! Provided it passes CI, LGTM.

[miscco]

Do we need tests for indirections like std::reference_wrapper?

[cjdb]

Do we need tests for indirections like std::reference_wrapper?

@miscco what would that buy us?

[miscco]

As far as I can tell the last clause from common_reference is specifically made for something like reference_wrapper types

[CaseyCarter]

In D96660#2564818, @miscco wrote:

As far as I can tell the last clause from common_reference is specifically made for something like reference_wrapper types

It's specifically for "Pre-LWG-2993 reference_wrapper"-like types; modern reference_wrapper doesn't need it. In fact the only test case I know of for that last clause is to implement pre-LWG-2993 reference_wrapper and check common_reference_t<old_reference_wrapper<meow>, meow&>.

[cjdb]

rebases to active CI

[cjdb]

In D96660#2566031, @CaseyCarter wrote:

In D96660#2564818, @miscco wrote:

As far as I can tell the last clause from common_reference is specifically made for something like reference_wrapper types

It's specifically for "Pre-LWG-2993 reference_wrapper"-like types; modern reference_wrapper doesn't need it. In fact the only test case I know of for that last clause is to implement pre-LWG-2993 reference_wrapper and check common_reference_t<old_reference_wrapper<meow>, meow&>.

@CaseyCarter does MSVC test this? I couldn't find it when I looked for an example.

[CaseyCarter]

In D96660#2567420, @cjdb wrote:

In D96660#2566031, @CaseyCarter wrote:

In D96660#2564818, @miscco wrote:

As far as I can tell the last clause from common_reference is specifically made for something like reference_wrapper types

It's specifically for "Pre-LWG-2993 reference_wrapper"-like types; modern reference_wrapper doesn't need it. In fact the only test case I know of for that last clause is to implement pre-LWG-2993 reference_wrapper and check common_reference_t<old_reference_wrapper<meow>, meow&>.

@CaseyCarter does MSVC test this? I couldn't find it when I looked for an example.

https://github.com/microsoft/STL/blob/a31bd6ed6b4f1c18045bc329b38c08845ec0fc3d/tests/std/tests/VSO_0000000_type_traits/test.cpp#L1474-L1485

[EricWF]

I don't see any major issues with patch. It looks OK to me.

[ldionne]

Getting the easy stuff out of the way first, before I dive into common_reference proper. Thanks!

[ldionne]

(I assume we'll handle types behaving like the old reference_wrapper correctly in your common_reference patch)

[cjdb]

rebase to activate CI

[cjdb]

previous CI flaked, reactivating...

[cjdb]

rebases to activate CI

libcxx/include/concepts

 // [concept.convertible]
 template<class _From, class _To>
 concept convertible_to =
   is_convertible_v<_From, _To> &&
   requires(add_rvalue_reference_t<_From> (&__f)()) {
     static_cast<_To>(__f());
   };
 
+// [concept.commonreference]
+template<class _Tp, class _Up>
+concept common_reference_with =
+  same_as<common_reference_t<_Tp, _Up>, common_reference_t<_Up, _Tp>> &&
+  convertible_to<_Tp, common_reference_t<_Tp, _Up>> &&
+  convertible_to<_Up, common_reference_t<_Up, _Up>>;
+
 // [concepts.arithmetic], arithmetic concepts
 template<class _Tp>
 concept integral = is_integral_v<_Tp>;
 
 template<class _Tp>
 concept signed_integral = integral<_Tp> && is_signed_v<_Tp>;
 
 template<class _Tp>

libcxx/test/std/concepts/lang/commonreference.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class From, class To>
+// concept common_reference_with;
+
+#include <concepts>
+#include <type_traits>
+
+template <class T, class U>
+constexpr bool CheckCommonReferenceWith() noexcept {
+  static_assert(std::common_reference_with<T, U&>);
+  static_assert(std::common_reference_with<T, const U&>);
+  static_assert(std::common_reference_with<T, volatile U&>);
+  static_assert(std::common_reference_with<T, const volatile U&>);
+  static_assert(std::common_reference_with<T, U&&>);
+  static_assert(std::common_reference_with<T, const U&&>);
+  static_assert(std::common_reference_with<T, volatile U&&>);
+  static_assert(std::common_reference_with<T, const volatile U&&>);
+  static_assert(std::common_reference_with<T&, U&&>);
+  static_assert(std::common_reference_with<T&, const U&&>);
+  static_assert(std::common_reference_with<T&, volatile U&&>);
+  static_assert(std::common_reference_with<T&, const volatile U&&>);
+  static_assert(std::common_reference_with<const T&, U&&>);
+  static_assert(std::common_reference_with<const T&, const U&&>);
+  static_assert(std::common_reference_with<const T&, volatile U&&>);
+  static_assert(std::common_reference_with<const T&, const volatile U&&>);
+  static_assert(std::common_reference_with<volatile T&, U&&>);
+  static_assert(std::common_reference_with<volatile T&, const U&&>);
+  static_assert(std::common_reference_with<volatile T&, volatile U&&>);
+  static_assert(std::common_reference_with<volatile T&, const volatile U&&>);
+  static_assert(std::common_reference_with<const volatile T&, U&&>);
+  static_assert(std::common_reference_with<const volatile T&, const U&&>);
+  static_assert(std::common_reference_with<const volatile T&, volatile U&&>);
+  static_assert(
+      std::common_reference_with<const volatile T&, const volatile U&&>);
+
+  return std::common_reference_with<T, U>;
+}
+
+namespace BuiltinTypes {
+// fundamental types
+static_assert(std::common_reference_with<void, void>);
+static_assert(CheckCommonReferenceWith<int, int>());
+static_assert(CheckCommonReferenceWith<int, long>());
+static_assert(CheckCommonReferenceWith<int, unsigned char>());
+static_assert(CheckCommonReferenceWith<int, __int128_t>());
+static_assert(CheckCommonReferenceWith<int, double>());
+
+// arrays
+static_assert(CheckCommonReferenceWith<int[5], int[5]>());
+
+// pointers (common with void*)
+static_assert(CheckCommonReferenceWith<int*, void*>());
+static_assert(CheckCommonReferenceWith<int*, const void*>());
+static_assert(CheckCommonReferenceWith<int*, volatile void*>());
+static_assert(CheckCommonReferenceWith<int*, const volatile void*>());
+static_assert(CheckCommonReferenceWith<const int*, void*>());
+static_assert(CheckCommonReferenceWith<const int*, const void*>());
+static_assert(CheckCommonReferenceWith<const int*, volatile void*>());
+static_assert(CheckCommonReferenceWith<const int*, const volatile void*>());
+static_assert(CheckCommonReferenceWith<volatile int*, void*>());
+static_assert(CheckCommonReferenceWith<volatile int*, const void*>());
+static_assert(CheckCommonReferenceWith<volatile int*, volatile void*>());
+static_assert(CheckCommonReferenceWith<volatile int*, const volatile void*>());
+static_assert(CheckCommonReferenceWith<const volatile int*, void*>());
+static_assert(CheckCommonReferenceWith<const volatile int*, const void*>());
+static_assert(CheckCommonReferenceWith<const volatile int*, volatile void*>());
+static_assert(
+    CheckCommonReferenceWith<const volatile int*, const volatile void*>());
+
+static_assert(CheckCommonReferenceWith<int (*)(), int (*)()>());
+static_assert(CheckCommonReferenceWith<int (*)(), int (*)() noexcept>());
+struct S {};
+static_assert(CheckCommonReferenceWith<int S::*, int S::*>());
+static_assert(CheckCommonReferenceWith<int S::*, const int S::*>());
+static_assert(CheckCommonReferenceWith<int (S::*)(), int (S::*)()>());
+static_assert(CheckCommonReferenceWith<int (S::*)(), int (S::*)() noexcept>());
+static_assert(
+    CheckCommonReferenceWith<int (S::*)() const, int (S::*)() const>());
+static_assert(CheckCommonReferenceWith<int (S::*)() const,
+                                       int (S::*)() const noexcept>());
+static_assert(
+    CheckCommonReferenceWith<int (S::*)() volatile, int (S::*)() volatile>());
+static_assert(CheckCommonReferenceWith<int (S::*)() volatile,
+                                       int (S::*)() volatile noexcept>());
+static_assert(CheckCommonReferenceWith<int (S::*)() const volatile,
+                                       int (S::*)() const volatile>());
+static_assert(CheckCommonReferenceWith<int (S::*)() const volatile,
+                                       int (S::*)() const volatile noexcept>());
+
+// nonsense
+static_assert(!std::common_reference_with<double, float*>);
+static_assert(!std::common_reference_with<int, int[5]>);
+static_assert(!std::common_reference_with<int*, long*>);
+static_assert(!std::common_reference_with<int*, unsigned int*>);
+static_assert(!std::common_reference_with<int (*)(), int (*)(int)>);
+static_assert(!std::common_reference_with<int S::*, float S::*>);
+static_assert(!std::common_reference_with<int (S::*)(), int (S::*)() const>);
+static_assert(!std::common_reference_with<int (S::*)(), int (S::*)() volatile>);
+static_assert(
+    !std::common_reference_with<int (S::*)(), int (S::*)() const volatile>);
+static_assert(
+    !std::common_reference_with<int (S::*)() const, int (S::*)() volatile>);
+static_assert(!std::common_reference_with<int (S::*)() const,
+                                          int (S::*)() const volatile>);
+static_assert(!std::common_reference_with<int (S::*)() volatile,
+                                          int (S::*)() const volatile>);
+} // namespace BuiltinTypes
+
+namespace NoDefaultCommonReference {
+class T {};
+
+static_assert(!std::common_reference_with<T, int>);
+static_assert(!std::common_reference_with<int, T>);
+static_assert(!std::common_reference_with<T, int[10]>);
+static_assert(!std::common_reference_with<T[10], int>);
+static_assert(!std::common_reference_with<T*, int*>);
+static_assert(!std::common_reference_with<T*, const int*>);
+static_assert(!std::common_reference_with<T*, volatile int*>);
+static_assert(!std::common_reference_with<T*, const volatile int*>);
+static_assert(!std::common_reference_with<const T*, int*>);
+static_assert(!std::common_reference_with<volatile T*, int*>);
+static_assert(!std::common_reference_with<const volatile T*, int*>);
+static_assert(!std::common_reference_with<const T*, const int*>);
+static_assert(!std::common_reference_with<const T*, volatile int*>);
+static_assert(!std::common_reference_with<const T*, const volatile int*>);
+static_assert(!std::common_reference_with<const T*, const int*>);
+static_assert(!std::common_reference_with<volatile T*, const int*>);
+static_assert(!std::common_reference_with<const volatile T*, const int*>);
+static_assert(!std::common_reference_with<volatile T*, const int*>);
+static_assert(!std::common_reference_with<volatile T*, volatile int*>);
+static_assert(!std::common_reference_with<volatile T*, const volatile int*>);
+static_assert(!std::common_reference_with<const T*, volatile int*>);
+static_assert(!std::common_reference_with<volatile T*, volatile int*>);
+static_assert(!std::common_reference_with<const volatile T*, volatile int*>);
+static_assert(!std::common_reference_with<const volatile T*, const int*>);
+static_assert(!std::common_reference_with<const volatile T*, volatile int*>);
+static_assert(
+    !std::common_reference_with<const volatile T*, const volatile int*>);
+static_assert(!std::common_reference_with<const T*, const volatile int*>);
+static_assert(!std::common_reference_with<volatile T*, const volatile int*>);
+static_assert(
+    !std::common_reference_with<const volatile T*, const volatile int*>);
+static_assert(!std::common_reference_with<T&, int&>);
+static_assert(!std::common_reference_with<T&, const int&>);
+static_assert(!std::common_reference_with<T&, volatile int&>);
+static_assert(!std::common_reference_with<T&, const volatile int&>);
+static_assert(!std::common_reference_with<const T&, int&>);
+static_assert(!std::common_reference_with<volatile T&, int&>);
+static_assert(!std::common_reference_with<const volatile T&, int&>);
+static_assert(!std::common_reference_with<const T&, const int&>);
+static_assert(!std::common_reference_with<const T&, volatile int&>);
+static_assert(!std::common_reference_with<const T&, const volatile int&>);
+static_assert(!std::common_reference_with<const T&, const int&>);
+static_assert(!std::common_reference_with<volatile T&, const int&>);
+static_assert(!std::common_reference_with<const volatile T&, const int&>);
+static_assert(!std::common_reference_with<volatile T&, const int&>);
+static_assert(!std::common_reference_with<volatile T&, volatile int&>);
+static_assert(!std::common_reference_with<volatile T&, const volatile int&>);
+static_assert(!std::common_reference_with<const T&, volatile int&>);
+static_assert(!std::common_reference_with<volatile T&, volatile int&>);
+static_assert(!std::common_reference_with<const volatile T&, volatile int&>);
+static_assert(!std::common_reference_with<const volatile T&, const int&>);
+static_assert(!std::common_reference_with<const volatile T&, volatile int&>);
+static_assert(
+    !std::common_reference_with<const volatile T&, const volatile int&>);
+static_assert(!std::common_reference_with<const T&, const volatile int&>);
+static_assert(!std::common_reference_with<volatile T&, const volatile int&>);
+static_assert(
+    !std::common_reference_with<const volatile T&, const volatile int&>);
+static_assert(!std::common_reference_with<T&, int&&>);
+static_assert(!std::common_reference_with<T&, const int&&>);
+static_assert(!std::common_reference_with<T&, volatile int&&>);
+static_assert(!std::common_reference_with<T&, const volatile int&&>);
+static_assert(!std::common_reference_with<const T&, int&&>);
+static_assert(!std::common_reference_with<volatile T&, int&&>);
+static_assert(!std::common_reference_with<const volatile T&, int&&>);
+static_assert(!std::common_reference_with<const T&, const int&&>);
+static_assert(!std::common_reference_with<const T&, volatile int&&>);
+static_assert(!std::common_reference_with<const T&, const volatile int&&>);
+static_assert(!std::common_reference_with<const T&, const int&&>);
+static_assert(!std::common_reference_with<volatile T&, const int&&>);
+static_assert(!std::common_reference_with<const volatile T&, const int&&>);
+static_assert(!std::common_reference_with<volatile T&, const int&&>);
+static_assert(!std::common_reference_with<volatile T&, volatile int&&>);
+static_assert(!std::common_reference_with<volatile T&, const volatile int&&>);
+static_assert(!std::common_reference_with<const T&, volatile int&&>);
+static_assert(!std::common_reference_with<volatile T&, volatile int&&>);
+static_assert(!std::common_reference_with<const volatile T&, volatile int&&>);
+static_assert(!std::common_reference_with<const volatile T&, const int&&>);
+static_assert(!std::common_reference_with<const volatile T&, volatile int&&>);
+static_assert(
+    !std::common_reference_with<const volatile T&, const volatile int&&>);
+static_assert(!std::common_reference_with<const T&, const volatile int&&>);
+static_assert(!std::common_reference_with<volatile T&, const volatile int&&>);
+static_assert(
+    !std::common_reference_with<const volatile T&, const volatile int&&>);
+static_assert(!std::common_reference_with<T&&, int&>);
+static_assert(!std::common_reference_with<T&&, const int&>);
+static_assert(!std::common_reference_with<T&&, volatile int&>);
+static_assert(!std::common_reference_with<T&&, const volatile int&>);
+static_assert(!std::common_reference_with<const T&&, int&>);
+static_assert(!std::common_reference_with<volatile T&&, int&>);
+static_assert(!std::common_reference_with<const volatile T&&, int&>);
+static_assert(!std::common_reference_with<const T&&, const int&>);
+static_assert(!std::common_reference_with<const T&&, volatile int&>);
+static_assert(!std::common_reference_with<const T&&, const volatile int&>);
+static_assert(!std::common_reference_with<const T&&, const int&>);
+static_assert(!std::common_reference_with<volatile T&&, const int&>);
+static_assert(!std::common_reference_with<const volatile T&&, const int&>);
+static_assert(!std::common_reference_with<volatile T&&, const int&>);
+static_assert(!std::common_reference_with<volatile T&&, volatile int&>);
+static_assert(!std::common_reference_with<volatile T&&, const volatile int&>);
+static_assert(!std::common_reference_with<const T&&, volatile int&>);
+static_assert(!std::common_reference_with<volatile T&&, volatile int&>);
+static_assert(!std::common_reference_with<const volatile T&&, volatile int&>);
+static_assert(!std::common_reference_with<const volatile T&&, const int&>);
+static_assert(!std::common_reference_with<const volatile T&&, volatile int&>);
+static_assert(
+    !std::common_reference_with<const volatile T&&, const volatile int&>);
+static_assert(!std::common_reference_with<const T&&, const volatile int&>);
+static_assert(!std::common_reference_with<volatile T&&, const volatile int&>);
+static_assert(
+    !std::common_reference_with<const volatile T&&, const volatile int&>);
+static_assert(!std::common_reference_with<T&&, int&&>);
+static_assert(!std::common_reference_with<T&&, const int&&>);
+static_assert(!std::common_reference_with<T&&, volatile int&&>);
+static_assert(!std::common_reference_with<T&&, const volatile int&&>);
+static_assert(!std::common_reference_with<const T&&, int&&>);
+static_assert(!std::common_reference_with<volatile T&&, int&&>);
+static_assert(!std::common_reference_with<const volatile T&&, int&&>);
+static_assert(!std::common_reference_with<const T&&, const int&&>);
+static_assert(!std::common_reference_with<const T&&, volatile int&&>);
+static_assert(!std::common_reference_with<const T&&, const volatile int&&>);
+static_assert(!std::common_reference_with<const T&&, const int&&>);
+static_assert(!std::common_reference_with<volatile T&&, const int&&>);
+static_assert(!std::common_reference_with<const volatile T&&, const int&&>);
+static_assert(!std::common_reference_with<volatile T&&, const int&&>);
+static_assert(!std::common_reference_with<volatile T&&, volatile int&&>);
+static_assert(!std::common_reference_with<volatile T&&, const volatile int&&>);
+static_assert(!std::common_reference_with<const T&&, volatile int&&>);
+static_assert(!std::common_reference_with<volatile T&&, volatile int&&>);
+static_assert(!std::common_reference_with<const volatile T&&, volatile int&&>);
+static_assert(!std::common_reference_with<const volatile T&&, const int&&>);
+static_assert(!std::common_reference_with<const volatile T&&, volatile int&&>);
+static_assert(
+    !std::common_reference_with<const volatile T&&, const volatile int&&>);
+static_assert(!std::common_reference_with<const T&&, const volatile int&&>);
+static_assert(!std::common_reference_with<volatile T&&, const volatile int&&>);
+static_assert(
+    !std::common_reference_with<const volatile T&&, const volatile int&&>);
+} // namespace NoDefaultCommonReference
+
+struct BadBasicCommonReference {
+  // This test is ill-formed, NDR. If it ever blows up in our faces: that's a good thing.
+  // In the meantime, the test should be included. If compiler support is added, then an include guard
+  // should be placed so the test doesn't get deleted.
+  operator int() const;
+  operator int&();
+};
+static_assert(std::convertible_to<BadBasicCommonReference, int>);
+static_assert(std::convertible_to<BadBasicCommonReference, int&>);
+
+namespace std {
+template <template <class> class X, template <class> class Y>
+struct basic_common_reference<BadBasicCommonReference, int, X, Y> {
+  using type = BadBasicCommonReference&;
+};
+
+template <template <class> class X, template <class> class Y>
+struct basic_common_reference<int, BadBasicCommonReference, X, Y> {
+  using type = int&;
+};
+} // namespace std
+static_assert(!std::common_reference_with<BadBasicCommonReference, int>);
+
+struct StructNotConvertibleToCommonReference {
+  explicit(false) StructNotConvertibleToCommonReference(int);
+};
+static_assert(std::convertible_to<int, StructNotConvertibleToCommonReference>);
+
+namespace std {
+template <template <class> class X, template <class> class Y>
+struct basic_common_reference<StructNotConvertibleToCommonReference, int, X,
+                              Y> {
+  using type = int&;
+};
+
+template <template <class> class X, template <class> class Y>
+struct basic_common_reference<int, StructNotConvertibleToCommonReference, X,
+                              Y> {
+  using type = int&;
+};
+} // namespace std
+static_assert(
+    !std::common_reference_with<StructNotConvertibleToCommonReference, int>);
+
+struct IntNotConvertibleToCommonReference {
+  operator int&() const;
+};
+
+namespace std {
+template <template <class> class X, template <class> class Y>
+struct basic_common_reference<IntNotConvertibleToCommonReference, int, X, Y> {
+  using type = int&;
+};
+
+template <template <class> class X, template <class> class Y>
+struct basic_common_reference<int, IntNotConvertibleToCommonReference, X, Y> {
+  using type = int&;
+};
+} // namespace std
+static_assert(
+    !std::common_reference_with<StructNotConvertibleToCommonReference, int>);
+
+struct HasCommonReference {
+  explicit(false) HasCommonReference(int);
+  operator int&() const;
+};
+
+namespace std {
+template <template <class> class X, template <class> class Y>
+struct basic_common_reference<HasCommonReference, int, X, Y> {
+  using type = int&;
+};
+
+template <template <class> class X, template <class> class Y>
+struct basic_common_reference<int, HasCommonReference, X, Y> {
+  using type = int&;
+};
+} // namespace std
+static_assert(std::common_reference_with<HasCommonReference, int>);
+
+int main(int, char**) { return 0; }