Differential D96657
[libcxx] adds common_reference to <type_traits> Authored by cjdb on Feb 13 2021, 4:44 PM.
Details
Implements part of P0898R3 Standard Library Concepts Reworks D74351 to use requires-clauses over SFINAE and so that it more Co-authored by: Michael Schellenberger Costa <mschellenbergercosta@googlemail.com> (Michael did all the heavy lifting and I came in to polish it for
Diff Detail
Event TimelineComment Actions I'm not sure why Mac OS is failing (and I don't have a Mac to test on at home). It looks like C++20 mode isn't being enabled despite -std=c++2a being in the build config?
Comment Actions Apple clang doesn't concepts support yet.
Comment Actions fixes test so it works on compilers without concepts, applies various bits of feedback
Comment Actions Thanks a lot for working on this (both you and @miscco). I left some comments - some of them are about re-organization and could be seen as being subjective. If you disagree with some of my suggestions, let me know and we can talk. Just for the sake of curiosity, I did try to re-implement COMMON-REF from the spec because I was struggling to get an understanding of what that beast does (and hence give a meaningful review). Here's what I came up with. I am *not* suggesting that we go down that route, I'm just posting it so it doesn't get lost forever since I think it's an interesting take on the problem (using if constexpr). I think your solution is superior though. template <class _Tp>
struct __type { using type = _Tp; };
struct __illformed;
template <class _Tp>
constexpr bool __is_well_formed_v = !is_same_v<_Tp, __illformed>;
// __maybe_t applies an alias to the provided arguments, and returns
// `__illformed` if the alias isn't well-formed with those arguments.
template <template <class ...> class _Fp, class ..._Args>
struct __maybe {
using type = __illformed;
};
template <template <class ...> class _Fp, class ..._Args>
requires requires { typename _Fp<_Args...>; }
struct __maybe<_Fp, _Args...> {
using type = _Fp<_Args...>;
};
template <template <class ...> class _Fp, class ..._Args>
using __maybe_t = typename __maybe<_Fp, _Args...>::type;
template <class _Xp, class _Yp>
struct __cond_res_criterion {
using _Res = __maybe_t<__cond_res, __copy_cv<_Xp, _Yp>&, __copy_cv<_Yp, _Xp>&>;
static constexpr bool value = __is_well_formed_v<_Res> && is_reference_v<_Res>;
};
template <class _Ap, class _Bp, class _Xp, class _Yp>
struct _Cp_criterion;
template <class _Ap, class _Bp, class _Xp, class _Yp>
struct _Dp_criterion;
template <class _Ap, class _Bp>
auto __common_ref_impl() {
using _Xp = remove_reference_t<_Ap>;
using _Yp = remove_reference_t<_Bp>;
// 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.
if constexpr (_And<is_lvalue_reference<_Ap>,
is_lvalue_reference<_Bp>,
__cond_res_criterion<_Xp, _Yp>>::value) {
using _Res = typename __cond_res_criterion<_Xp, _Yp>::_Res;
return __type<_Res>{};
}
// Otherwise, let C be remove_reference_t<COMMON-REF(X&, Y&)>&&.
// 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.
else if constexpr (_And<is_rvalue_reference<_Ap>,
is_rvalue_reference<_Bp>,
_Cp_criterion<_Ap, _Bp, _Xp, _Yp>>::value) {
using _Cp = typename _Cp_criterion<_Ap, _Bp, _Xp, _Yp>::_Cp;
return __type<_Cp>{};
}
// Otherwise, let D be COMMON-REF(const X&, Y&).
// 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.
else if constexpr (_And<is_rvalue_reference<_Ap>,
is_lvalue_reference<_Bp>,
_Dp_criterion<_Ap, _Bp, _Xp, _Yp>>::value) {
using _Dp = typename _Dp_criterion<_Ap, _Bp, _Xp, _Yp>::_Dp;
return __type<_Dp>{};
}
// Otherwise, if A is an lvalue reference and B is an rvalue reference,
// then COMMON-REF(A, B) is COMMON-REF(B, A).
else if constexpr (is_lvalue_reference_v<_Ap> && is_rvalue_reference_v<_Bp>) {
return __common_ref_impl<_Bp, _Ap>();
}
// Otherwise, COMMON-REF(A, B) is ill-formed.
else {
return __type<__illformed>{};
}
}
template <class _Ap, class _Bp, class _Xp, class _Yp>
struct _Cp_criterion {
using _Cp = remove_reference_t<typename decltype(__common_ref_impl<_Xp&, _Yp&>())::type>&&;
static constexpr bool value = __is_well_formed_v<_Cp> &&
is_convertible_v<_Ap, _Cp> &&
is_convertible_v<_Bp, _Cp>;
};
template <class _Ap, class _Bp, class _Xp, class _Yp>
struct _Dp_criterion {
using _Dp = typename decltype(__common_ref_impl<const _Xp&, _Yp&>())::type;
static constexpr bool value = __is_well_formed_v<_Dp> && is_convertible_v<_Ap, _Dp>;
};
template <class _Ap, class _Bp, class _Res = typename decltype(__common_ref_impl<_Ap, _Bp>())::type>
using __common_ref = enable_if_t<__is_well_formed_v<_Res>, _Res>;
Comment Actions Thanks for your review here, it's really appreciated!
Comment Actions This basically LGTM, except for a few comments and the failing CI.
Comment Actions Here are the unexpected failures I get when running ninja check-cxx locally. Failed Tests (3): libc++ :: libcxx/gdb/gdb_pretty_printer_test.sh.cpp libc++ :: libcxx/modules/stds_include.sh.cpp libc++ :: std/iterators/iterator.primitives/iterator.traits/empty.fail.cpp Could these be impacting CI failure? I can't see how common_reference would interact with any of these to the point of failure.
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
_LIBCPP_HAS_NO_CONCEPTS?