COMMON-REF Tim's solution

[huixie90]

remove MSVC-STL code

[huixie90]

remove MSVC code

libcxx/include/__functional/reference_wrapper.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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___FUNCTIONAL_REFERENCE_WRAPPER_H
 #define _LIBCPP___FUNCTIONAL_REFERENCE_WRAPPER_H
 
+#include "__concepts/convertible_to.h"
 #include <__config>
 #include <__functional/invoke.h>
 #include <__functional/weak_result_type.h>
 #include <__memory/addressof.h>
+#include <__type_traits/common_reference.h>
 #include <__type_traits/enable_if.h>
+#include <__type_traits/integral_constant.h>
 #include <__type_traits/remove_cvref.h>
 #include <__utility/declval.h>
 #include <__utility/forward.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

 cref(reference_wrapper<_Tp> __t) _NOEXCEPT
 {
     return __t;
 }
 
 template <class _Tp> void ref(const _Tp&&) = delete;
 template <class _Tp> void cref(const _Tp&&) = delete;
 
+
+#if _LIBCPP_STD_VER >= 20
+
+template <class>
+inline constexpr bool __is_ref_wrapper = false;
+
+template <class _Tp>
+inline constexpr bool __is_ref_wrapper<reference_wrapper<_Tp>> = true;
+
+// clang-format off
+
+template<class _Rp, class _Tp, class _RQ, class _TQ>
+concept __specialization_constraint = // CRW macro
+    // [1.1] first type is a reference_wrapper.
+    __is_ref_wrapper<_Rp>
+    // [1.2] common_reference with the underlying type exists
+    && requires {
+        typename common_reference_t<typename _Rp::type&, _TQ>;
+    }
+    // [1.3] reference_wrapper as specified is convertible to the above
+    && convertible_to<_RQ, common_reference_t<typename _Rp::type&, _TQ>>
+    ;
+
+template <class _Rp, class _Tp, template <class> class _RQual,  template <class> class _TQual>
+    requires(  __specialization_constraint<_Rp, _Tp, _RQual<_Rp>, _TQual<_Tp>>
+           // [1.4] commuted constraint should not match:
+           && !__specialization_constraint<_Tp, _Rp, _TQual<_Tp>, _RQual<_Rp>>  )
+struct basic_common_reference<_Rp, _Tp, _RQual, _TQual> {
+    using type = common_reference_t<typename _Rp::type&, _TQual<_Tp>>;
+};
+
+
+template <class _Tp, class _Rp, template <class> class _TQual,  template <class> class _RQual>
+    requires(  __specialization_constraint<_Rp, _Tp, _RQual<_Rp>, _TQual<_Tp>>
+           // [1.4] commuted constraint should not match:
+           && !__specialization_constraint<_Tp, _Rp, _TQual<_Tp>, _RQual<_Rp>>  )
+struct basic_common_reference<_Tp, _Rp, _TQual, _RQual> {
+    using type = common_reference_t<typename _Rp::type&, _TQual<_Tp>>;
+};
+
+// clang-format on
+
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FUNCTIONAL_REFERENCE_WRAPPER_H

libcxx/include/__type_traits/common_reference.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___TYPE_TRAITS_COMMON_REFERENCE_H
 #define _LIBCPP___TYPE_TRAITS_COMMON_REFERENCE_H
 
 #include <__config>
+#include <__type_traits/add_pointer.h>
 #include <__type_traits/common_type.h>
 #include <__type_traits/copy_cv.h>
 #include <__type_traits/copy_cvref.h>
 #include <__type_traits/is_convertible.h>
 #include <__type_traits/is_reference.h>
 #include <__type_traits/remove_cv.h>
 #include <__type_traits/remove_cvref.h>
 #include <__type_traits/remove_reference.h>

 template<class _Xp, class _Yp>
 using __cv_cond_res = __cond_res<__copy_cv_t<_Xp, _Yp>&, __copy_cv_t<_Yp, _Xp>&>;
 
 
 //    If A and B are both lvalue reference types, COMMON-REF(A, B) is
 //    COND-RES(COPYCV(X, Y)&, COPYCV(Y, X)&) if that type exists and is a reference type.
 template<class _Ap, class _Bp, class _Xp, class _Yp>
 requires requires { typename __cv_cond_res<_Xp, _Yp>; } && is_reference_v<__cv_cond_res<_Xp, _Yp>>
+    && is_convertible_v<_Xp*, add_pointer_t<__cv_cond_res<_Xp, _Yp>>>
+    && is_convertible_v<_Yp*, add_pointer_t<__cv_cond_res<_Xp, _Yp>>>
 struct __common_ref<_Ap&, _Bp&, _Xp, _Yp>
 {
     using __type = __cv_cond_res<_Xp, _Yp>;
 };
 
 //    Otherwise, let C be remove_reference_t<COMMON-REF(X&, Y&)>&&. ...
 template <class _Xp, class _Yp>
 using __common_ref_C = remove_reference_t<__common_ref_t<_Xp&, _Yp&>>&&;
 
 
 //    .... If A and B are both rvalue reference types, C is well-formed, and
 //    is_convertible_v<A, C> && is_convertible_v<B, C> is true, then COMMON-REF(A, B) is C.
 template<class _Ap, class _Bp, class _Xp, class _Yp>
 requires
   requires { typename __common_ref_C<_Xp, _Yp>; } &&
   is_convertible_v<_Ap&&, __common_ref_C<_Xp, _Yp>> &&
   is_convertible_v<_Bp&&, __common_ref_C<_Xp, _Yp>>
+    && is_convertible_v<_Xp*, add_pointer_t<__common_ref_C<_Xp, _Yp>>>
+    && is_convertible_v<_Yp*, add_pointer_t<__common_ref_C<_Xp, _Yp>>>
 struct __common_ref<_Ap&&, _Bp&&, _Xp, _Yp>
 {
     using __type = __common_ref_C<_Xp, _Yp>;
 };
 
 //    Otherwise, let D be COMMON-REF(const X&, Y&). ...
 template <class _Tp, class _Up>
 using __common_ref_D = __common_ref_t<const _Tp&, _Up&>;
 
 //    ... If A is an rvalue reference and B is an lvalue reference and D is well-formed and
 //    is_convertible_v<A, D> is true, then COMMON-REF(A, B) is D.
 template<class _Ap, class _Bp, class _Xp, class _Yp>
 requires requires { typename __common_ref_D<_Xp, _Yp>; } &&
          is_convertible_v<_Ap&&, __common_ref_D<_Xp, _Yp>>
+    && is_convertible_v<_Xp*, add_pointer_t<__common_ref_D<_Xp, _Yp>>>
+    && is_convertible_v<_Yp*, add_pointer_t<__common_ref_D<_Xp, _Yp>>>
 struct __common_ref<_Ap&&, _Bp&, _Xp, _Yp>
 {
     using __type = __common_ref_D<_Xp, _Yp>;
 };
 
 //    Otherwise, if A is an lvalue reference and B is an rvalue reference, then
 //    COMMON-REF(A, B) is COMMON-REF(B, A).
 template<class _Ap, class _Bp, class _Xp, class _Yp>

libcxx/test/std/utilities/function.objects/refwrap/refwrap.common_ref/happy.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
+
+#include "testutil.h"
+
+#include <functional>
+
+//   +-----------------------------------+
+//   |            TESTS                  |
+//   +-----------------------------------+
+
+// clang-format off
+static_assert(check<int &     , Ref<int      >, int &      >);
+static_assert(check<int const&, Ref<int      >, int const& >);
+static_assert(check<int const&, Ref<int const>, int &      >);
+static_assert(check<int const&, Ref<int const>, int const& >);
+static_assert(check<const volatile int&, Ref<const volatile int>, const volatile int&>);
+
+// derived-base and implicit convertibles
+struct B {};
+struct D : B {};
+struct C {
+    operator B&() const;
+};
+
+static_assert(check<B&      , Ref<B>,       D &     >);
+static_assert(check<B const&, Ref<B>,       D const&>);
+static_assert(check<B const&, Ref<B const>, D const&>);
+
+
+static_assert(check<B&      , Ref<D>,       B &     >);
+static_assert(check<B const&, Ref<D>,       B const&>);
+static_assert(check<B const&, Ref<D const>, B const&>);
+// Interesting note: This last set works on VC++ thanks to our specialization.
+// But on GCC, it works naturally since ternary operator is no longer ambiguous.
+// Here:
+#ifndef _MSC_VER
+static_assert(std::same_as<B&, CondRes<Ref<D>, B&>>);
+static_assert(std::same_as<B const&, CondRes<Ref<D>, B const &>>);
+static_assert(std::same_as<B const&, CondRes<Ref<D const>, B const&>>);
+#else
+// but for some reason ternary operator on VC++ yields a base prvalue!
+static_assert(std::same_as<B, CondRes<Ref<D>, B&>>);
+static_assert(std::same_as<B const, CondRes<Ref<D>, B const &>>);
+static_assert(std::same_as<B const, CondRes<Ref<D const>, B const&>>);
+// fortunately, since this is not a reference type, common_reference rules fallthru
+// basic_common_reference specialization, and we compute B& here.
+#endif
+
+
+// implicit conversions are two hops so shouldn't work:
+static_assert( check_none<Ref<C>, B& >);
+static_assert( !std::convertible_to<Ref<C>, B&>);
+
+
+static_assert( check<B&        , Ref<B>      , C&      >);
+static_assert( check<B&        , Ref<B>      , C       >);
+static_assert( check<B const&  , Ref<B const>, C       >);
+static_assert(!check<B &       , Ref<C>      , B&      >); // Ref<C> cannot be converted to B&
+
+// Hui: Tim's solution makes this one behaves more sensible (B& instead of const B&)
+static_assert( check< B &       , Ref<B>      , C const&>); //
+
+// clang-format on
+
+using Ri   = Ref<int>;
+using RRi  = Ref<Ref<int>>;
+using RRRi = Ref<Ref<Ref<int>>>;
+static_assert(check<Ri&, Ri&, RRi>);
+static_assert(check<RRi&, RRi&, RRRi>);
+static_assert(check<Ri, Ri, RRi>);
+static_assert(check<RRi, RRi, RRRi>);
+
+static_assert(check_none<int&, RRi>);
+static_assert(check_none<int, RRi>);
+static_assert(check_none<int&, RRRi>);
+static_assert(check_none<int, RRRi>);
+
+static_assert(check_none<Ri&, RRRi>);
+static_assert(check_none<Ri, RRRi>);

libcxx/test/std/utilities/function.objects/refwrap/refwrap.common_ref/sad.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
+
+#include "testutil.h"
+#include <functional>
+
+
+
+using namespace std;
+
+
+// FACT: const& ref_wrapper can still be converted to int&
+int i;
+const std::reference_wrapper<int> ri = i;
+int& j = ri; // OK
+static_assert(std::convertible_to<Ref<int> const &, int &>);
+
+// ========================================================
+// Hui: Happy now
+// ========================================================
+static_assert(check<int &, Ref<int> const &, int &  >);
+
+// This is because of the first rule of common_reference,
+// *before* it even instantiates the basic_common_reference:
+
+// Hui: Tim's solution will make CommonRef ill-formed, which makes it possible to use basic_common_reference
+// static_assert(std::same_as<int const &, CommonRef<Ref<int> const &, int &>> ); // CommonRef is from the standard, std::__common_ref in libc++
+static_assert(!hasCommonRef<Ref<int> const&, int&>);
+
+// The reason CommonRef is no longer ill-formed is because of
+// COPYCV https://eel.is/c++draft/meta.trans#other-2.3
+// which ends up copying the const from Ref<int> const & to int,
+// checking for  const int & instead of int &
+// This satisfies https://eel.is/c++draft/meta.trans#other-2.5
+static_assert(std::same_as<int const &, Ternary_t<Ref<int> const&, int const&>>);
+
+
+
+
+
+
+
+// --- gunk:
+
+static_assert(!HasType<Ternary<Ref<int> const&, int&>>); // ok, ternary is still ambiguous
+static_assert(
+    std::convertible_to<Ref<int> const&, int&>);         // Ref<int> const& CAN be converted to int&
+
+// ========================================================
+// Hui: Happy now
+// ========================================================
+static_assert(check<int &, Ref<int> const&, int&>); // BUT we compute common ref as const int &
+
+
+template <typename T>
+struct Test {
+    using R1 = common_reference_t<T&, T&>;
+    using R2 = common_reference_t<T&, T const&>;
+    using R3 = common_reference_t<T&, T&&>;
+    using R4 = common_reference_t<T&, T const&&>;
+    using R5 = common_reference_t<T&, T>;
+
+    using U = reference_wrapper<T>;
+
+    static_assert(same_as<R1, common_reference_t<U, T&>>);
+    static_assert(same_as<R2, common_reference_t<U, T const&>>);
+    static_assert(same_as<R3, common_reference_t<U, T&&>>);
+    static_assert(same_as<R4, common_reference_t<U, T const&&>>);
+    static_assert(same_as<R5, common_reference_t<U, T>>);
+
+    // commute:
+    static_assert(same_as<R1, common_reference_t<T&, U>>);
+    static_assert(same_as<R2, common_reference_t<T const&, U>>);
+    static_assert(same_as<R3, common_reference_t<T&&, U>>);
+    static_assert(same_as<R4, common_reference_t<T const&&, U>>);
+    static_assert(same_as<R5, common_reference_t<T, U>>);
+
+    // reference qualification of reference_wrapper is irrelevant (except KINKs
+    // we may need to resolve - see below)
+    static_assert(same_as<R1, common_reference_t<U&, T&>>);
+    static_assert(same_as<R1, common_reference_t<U, T&>>);
+    // !! KINKS !!
+
+// ========================================================
+// Hui: What are they testing? I changed All of them to R1 and they pass
+// ========================================================
+    static_assert(same_as<R1, common_reference_t<U const&, T&>>); // NOT R1 which is non-const &
+    static_assert(same_as<R1, common_reference_t<U&&, T&>>);
+    static_assert(same_as<R1, common_reference_t<U const&&, T&>>);
+};
+
+// Instantiate above checks:
+template struct Test<int>;
+template struct Test<reference_wrapper<int>>;
+
+// !! KINKS !!
+//  unfortunately,  ?: is not ambigous with const & and && reference_wrapper so
+//  the specialiation is never consulted:
+
+// per https://eel.is/c++draft/meta.trans.other#2.5
+// common_reference< X&, Y const &> has  const& for both sides of ternary-check:
+using Kink =
+    decltype(false ? std::declval<int const&>() : std::declval<reference_wrapper<int> const&>());
+// the ?: is no longer ambigous and resolves to:
+static_assert(same_as<Kink, int const&>);
+
+// ========================================================
+// Hui: Kink no longer used in common_reference
+// ========================================================
+static_assert(!same_as<Kink, common_reference_t<int&, reference_wrapper<int> const&>>);
+static_assert( same_as<int&, common_reference_t<int&, reference_wrapper<int> const&>>);
+
+// per https://eel.is/c++draft/meta.trans.other#2.7
+// common_reference<X&, Y&&> checks for <X&, Y const &> again, same as above:
+
+// ========================================================
+// Hui: Kink no longer used here
+// ========================================================
+static_assert(!same_as<Kink, common_reference_t<int&, reference_wrapper<int>&&>>);
+static_assert( same_as<int&, common_reference_t<int&, reference_wrapper<int>&&>>);
+
+
+/////////////////////////////////////////////////////
+/// Unrelated cases involving reference_wrapper:  ///
+/////////////////////////////////////////////////////
+
+// reference_wrapper as both args is unaffected. unrelated to the proposal,
+// subject to simple first rule of
+static_assert(same_as<common_reference_t<reference_wrapper<int>&, reference_wrapper<int>&>,
+                      reference_wrapper<int>&>);
+
+// double wrap is unaffected. unrelated to the proposal:
+template <class T>
+concept CommonRefWithNestedRefWrapExists =
+    requires(T) { typename common_reference_t<reference_wrapper<reference_wrapper<T>>, T&>; };
+static_assert(!CommonRefWithNestedRefWrapExists<int>);
+
+
+static_assert(
+    same_as<common_reference_t<reference_wrapper<int>&, reference_wrapper<reference_wrapper<int>>>,
+            reference_wrapper<int>&>);

libcxx/test/std/utilities/function.objects/refwrap/refwrap.common_ref/testutil.h

+#ifndef __LIBCPP_TEST_REFWRAPPER_UTIL_H
+#define __LIBCPP_TEST_REFWRAPPER_UTIL_H
+
+#include <concepts>
+#include <type_traits>
+
+template <class T>
+concept HasType = requires {
+    typename T::type;
+};
+
+template <class Result, class T1, class T2>
+concept check1 = std::same_as<Result, std::common_reference_t<T1, T2>>;
+
+template <class Result, class T1, class T2>
+concept check2 = std::same_as<Result, std::common_reference_t<T2, T1>>;
+
+template <class Result, class T1, class T2>
+concept check = check1<Result, T1, T2> && check2<Result, T1, T2>;
+
+template <class T1, class T2>
+concept check_none1 = !HasType<std::common_reference<T1, T2>>;
+template <class T1, class T2>
+concept check_none2 = !HasType<std::common_reference<T2, T1>>;
+
+template <class T1, class T2>
+concept check_none = check_none1<T1, T2> && check_none2<T1, T2>;
+
+template <class T>
+using Ref = std::reference_wrapper<T>;
+
+// https://eel.is/c++draft/meta.trans#other-2.4
+template <class X, class Y>
+using CondRes = decltype(false ? std::declval<X (&)()>()() : std::declval<Y (&)()>()());
+
+template <class X, class Y>
+struct Ternary {};
+
+template <class X, class Y>
+requires requires() { typename CondRes<X, Y>; }
+struct Ternary<X, Y> {
+    using type = CondRes<X, Y>;
+};
+template <class X, class Y>
+using Ternary_t = typename Ternary<X, Y>::type;
+
+// https://eel.is/c++draft/meta.trans#other-2.5
+template <class A, class B>
+using CopyCV = typename std::__copy_cv<A, B>::type;
+
+template <class A, class B>
+using CommonRef = typename std::__common_ref<A, B>::__type;
+
+template <class A, class B>
+concept hasCommonRef = requires{
+    typename CommonRef<A, B>;
+};
+
+#endif //__LIBCPP_TEST_REFWRAPPER_UTIL_H