Implement LWG-4074

llvm · huixie90 · Jun 21, 2025 · Feb 2, 2024 · Nov 21, 2024 · Nov 21, 2024
commit 67784267be6c04786ff9bed56026e2b63134b2f0
@@ -66,7 +66,7 @@
 "`LWG4060 <https://wg21.link/LWG4060>`__","``submdspan`` preconditions do not forbid creating invalid pointer","2024-06 (St. Louis)","","",""
 "`LWG4061 <https://wg21.link/LWG4061>`__","Should ``std::basic_format_context`` be default-constructible/copyable/movable?","2024-06 (St. Louis)","|Complete|","19",""
 "`LWG4071 <https://wg21.link/LWG4071>`__","``reference_wrapper`` comparisons are not SFINAE-friendly","2024-06 (St. Louis)","|Complete|","19",""
-"`LWG4074 <https://wg21.link/LWG4074>`__","``compatible-joinable-ranges`` is underconstrained","2024-06 (St. Louis)","","",""
+"`LWG4074 <https://wg21.link/LWG4074>`__","``compatible-joinable-ranges`` is underconstrained","2024-06 (St. Louis)","|Complete|","20",""
 "`LWG4076 <https://wg21.link/LWG4076>`__","``concat_view`` should be freestanding","2024-06 (St. Louis)","","",""
 "`LWG4079 <https://wg21.link/LWG4079>`__","Missing Preconditions in ``concat_view::iterator``\`s conversion constructor","2024-06 (St. Louis)","","",""
 "`LWG4082 <https://wg21.link/LWG4082>`__","``views::concat(r)`` is well-formed when ``r`` is an ``output_range``","2024-06 (St. Louis)","","",""

@@ -10,7 +10,9 @@
 #ifndef _LIBCPP___RANGES_CONCEPTS_H
 #define _LIBCPP___RANGES_CONCEPTS_H
 
+#include <__concepts/common_reference_with.h>
 #include <__concepts/constructible.h>
+#include <__concepts/convertible_to.h>
 #include <__concepts/movable.h>
 #include <__concepts/same_as.h>
 #include <__config>
@@ -25,6 +27,8 @@
 #include <__ranges/enable_view.h>
 #include <__ranges/size.h>
 #include <__type_traits/add_pointer.h>
+#include <__type_traits/common_reference.h>
+#include <__type_traits/common_type.h>
 #include <__type_traits/is_reference.h>
 #include <__type_traits/remove_cvref.h>
 #include <__type_traits/remove_reference.h>
@@ -133,6 +137,42 @@ concept viewable_range =
       (is_lvalue_reference_v<_Tp> ||
        (movable<remove_reference_t<_Tp>> && !__is_std_initializer_list<remove_cvref_t<_Tp>>))));
 
+#  if _LIBCPP_STD_VER >= 23
+
+template <class... _Rs>
+using __concat_reference_t = common_reference_t<range_reference_t<_Rs>...>;
+
+template <class... _Rs>
+using __concat_value_t = common_type_t<range_value_t<_Rs>...>;
+
+template <class... _Rs>
+using __concat_rvalue_reference_t = common_reference_t<range_rvalue_reference_t<_Rs>...>;
+
+template <class _Ref, class _RRef, class _It>
+concept __concat_indirectly_readable_impl = requires(const _It __it) {
+  { *__it } -> convertible_to<_Ref>;
+  { ranges::iter_move(__it) } -> convertible_to<_RRef>;
+};
+
+template <class... _Rs>
+concept __concat_indirectly_readable =
+    common_reference_with<__concat_reference_t<_Rs...>&&, __concat_value_t<_Rs...>&> &&
+    common_reference_with<__concat_reference_t<_Rs...>&&, __concat_rvalue_reference_t<_Rs...>&&> &&
+    common_reference_with<__concat_rvalue_reference_t<_Rs...>&&, const __concat_value_t<_Rs...>&> &&
+    (__concat_indirectly_readable_impl<__concat_reference_t<_Rs...>,
+                                       __concat_rvalue_reference_t<_Rs...>,
+                                       iterator_t<_Rs>> &&
+     ...);
+
+template <class... _Rs>
+concept __concatable = requires {
+  typename __concat_reference_t<_Rs...>;
+  typename __concat_value_t<_Rs...>;
+  typename __concat_rvalue_reference_t<_Rs...>;
+} && __concat_indirectly_readable<_Rs...>;
+
+#  endif // _LIBCPP_STD_VER >= 23
+
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER >= 20

@@ -54,18 +54,12 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 23
 
 namespace ranges {
-template <class _Range, class _Pattern>
-concept __compatible_joinable_ranges =
-    common_with<range_value_t<_Range>, range_value_t<_Pattern>> &&
-    common_reference_with<range_reference_t<_Range>, range_reference_t<_Pattern>> &&
-    common_reference_with<range_rvalue_reference_t<_Range>, range_rvalue_reference_t<_Pattern>>;
-
 template <class _Range>
 concept __bidirectional_common = bidirectional_range<_Range> && common_range<_Range>;
 
 template <input_range _View, forward_range _Pattern>
   requires view<_View> && input_range<range_reference_t<_View>> && view<_Pattern> &&
-           __compatible_joinable_ranges<range_reference_t<_View>, _Pattern>
+           __concatable<range_reference_t<_View>, _Pattern>
 class join_with_view : public view_interface<join_with_view<_View, _Pattern>> {
   using _InnerRng = range_reference_t<_View>;
 
@@ -121,7 +115,8 @@ class join_with_view : public view_interface<join_with_view<_View, _Pattern>> {
 
   [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
     requires forward_range<const _View> && forward_range<const _Pattern> &&
-             is_reference_v<range_reference_t<const _View>> && input_range<range_reference_t<const _View>>
+             is_reference_v<range_reference_t<const _View>> && input_range<range_reference_t<const _View>> &&
+             __concatable<range_reference_t<const _View>, const _Pattern>
   {
     return __iterator<true>{*this, ranges::begin(__base_)};
   }
@@ -137,7 +132,8 @@ class join_with_view : public view_interface<join_with_view<_View, _Pattern>> {
 
   [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
     requires forward_range<const _View> && forward_range<const _Pattern> &&
-             is_reference_v<range_reference_t<const _View>> && input_range<range_reference_t<const _View>>
+             is_reference_v<range_reference_t<const _View>> && input_range<range_reference_t<const _View>> &&
+             __concatable<range_reference_t<const _View>, const _Pattern>
   {
     using _InnerConstRng = range_reference_t<const _View>;
     if constexpr (forward_range<_InnerConstRng> && common_range<const _View> && common_range<_InnerConstRng>)
@@ -187,7 +183,7 @@ struct __join_with_view_iterator_category<_Base, _PatternBase, _InnerBase> {
 
 template <input_range _View, forward_range _Pattern>
   requires view<_View> && input_range<range_reference_t<_View>> && view<_Pattern> &&
-           __compatible_joinable_ranges<range_reference_t<_View>, _Pattern>
+           __concatable<range_reference_t<_View>, _Pattern>
 template <bool _Const>
 struct join_with_view<_View, _Pattern>::__iterator
     : public __join_with_view_iterator_category<__maybe_const<_Const, _View>, __maybe_const<_Const, _Pattern>> {
@@ -395,7 +391,7 @@ struct join_with_view<_View, _Pattern>::__iterator
 
 template <input_range _View, forward_range _Pattern>
   requires view<_View> && input_range<range_reference_t<_View>> && view<_Pattern> &&
-           __compatible_joinable_ranges<range_reference_t<_View>, _Pattern>
+           __concatable<range_reference_t<_View>, _Pattern>
 template <bool _Const>
 struct join_with_view<_View, _Pattern>::__sentinel {
 private:

@@ -240,6 +240,11 @@ constexpr void test_const_begin() {
     using JWV = std::ranges::join_with_view<MaybeSimpleForwardView<true>, MaybeSimplePattern<true>>;
     static_assert(std::same_as<std::ranges::iterator_t<JWV&>, std::ranges::iterator_t<const JWV&>>);
   }
+
+  { // Check LWG-4074: compatible-joinable-ranges is underconstrained
+    static_assert(!JoinWithViewHasConstBegin<BasicVectorView<int, ViewProperties{}, forward_iterator>,
+                                             lwg4074::PatternWithProxyConstAccess>);
+  }
 }
 
 constexpr bool test() {

@@ -21,6 +21,7 @@
 #include <vector>
 
 #include "test_iterators.h"
+#include "../types.h"
 
 template <class View, class Pattern>
 concept CanFormJoinWithView = requires { typename std::ranges::join_with_view<View, Pattern>; };
@@ -133,7 +134,7 @@ static_assert(!CanFormJoinWithView<View, Pattern>);
 
 // join_with_view is not valid when `range_reference_t<View>` and pattern
 // does not model together compatible-joinable-ranges
-namespace test_when_used_ranges_are_not_compatible_joinable_ranges {
+namespace test_when_used_ranges_are_not_concatable {
 using std::ranges::range_reference_t;
 using std::ranges::range_rvalue_reference_t;
 using std::ranges::range_value_t;
@@ -144,15 +145,15 @@ struct View : std::ranges::view_base {
   InnerRange* end();
 };
 
-namespace no_common_range_value_type {
+namespace no_concat_reference_t {
+struct ValueType {};
+
 struct InnerRange {
   struct It {
-    using difference_type = ptrdiff_t;
-    struct value_type {};
-
+    using difference_type = std::ptrdiff_t;
+    using value_type      = ValueType;
     struct reference {
       operator value_type();
-      operator float();
     };
 
     It& operator++();
@@ -165,28 +166,42 @@ struct InnerRange {
 };
 
 struct Pattern : std::ranges::view_base {
-  const float* begin();
-  const float* end();
+  struct It {
+    using difference_type = std::ptrdiff_t;
+    using value_type      = ValueType;
+    struct reference {
+      operator value_type();
+    };
+
+    It& operator++();
+    It operator++(int);
+    reference operator*() const;
+    bool operator==(const It&) const;
+    friend value_type&& iter_move(const It&);
+  };
+
+  It begin();
+  It end();
 };
 
 static_assert(std::ranges::input_range<InnerRange>);
 static_assert(std::ranges::forward_range<Pattern>);
 static_assert(std::ranges::view<Pattern>);
-static_assert(!std::common_with<range_value_t<InnerRange>, range_value_t<Pattern>>);
-static_assert(std::common_reference_with<range_reference_t<InnerRange>, range_reference_t<Pattern>>);
+static_assert(!std::common_reference_with<range_reference_t<InnerRange>, range_reference_t<Pattern>>);
+static_assert(std::common_with<range_value_t<InnerRange>, range_value_t<Pattern>>);
 static_assert(std::common_reference_with<range_rvalue_reference_t<InnerRange>, range_rvalue_reference_t<Pattern>>);
 static_assert(!CanFormJoinWithView<View<InnerRange>, Pattern>);
-} // namespace no_common_range_value_type
-
-namespace no_common_range_reference_type {
-struct ValueType {};
+} // namespace no_concat_reference_t
 
+namespace no_concat_value_t {
 struct InnerRange {
   struct It {
-    using difference_type = ptrdiff_t;
-    using value_type      = ValueType;
+    using difference_type = std::ptrdiff_t;
+    struct value_type {};
+
     struct reference {
       operator value_type();
+      operator float();
     };
 
     It& operator++();
@@ -199,34 +214,20 @@ struct InnerRange {
 };
 
 struct Pattern : std::ranges::view_base {
-  struct It {
-    using difference_type = ptrdiff_t;
-    using value_type      = ValueType;
-    struct reference {
-      operator value_type();
-    };
-
-    It& operator++();
-    It operator++(int);
-    reference operator*() const;
-    bool operator==(const It&) const;
-    friend value_type&& iter_move(const It&);
-  };
-
-  It begin();
-  It end();
+  const float* begin();
+  const float* end();
 };
 
 static_assert(std::ranges::input_range<InnerRange>);
 static_assert(std::ranges::forward_range<Pattern>);
 static_assert(std::ranges::view<Pattern>);
-static_assert(std::common_with<range_value_t<InnerRange>, range_value_t<Pattern>>);
-static_assert(!std::common_reference_with<range_reference_t<InnerRange>, range_reference_t<Pattern>>);
+static_assert(std::common_reference_with<range_reference_t<InnerRange>, range_reference_t<Pattern>>);
+static_assert(!std::common_with<range_value_t<InnerRange>, range_value_t<Pattern>>);
 static_assert(std::common_reference_with<range_rvalue_reference_t<InnerRange>, range_rvalue_reference_t<Pattern>>);
 static_assert(!CanFormJoinWithView<View<InnerRange>, Pattern>);
-} // namespace no_common_range_reference_type
+} // namespace no_concat_value_t
 
-namespace no_common_range_rvalue_reference_type {
+namespace no_concat_rvalue_reference_t {
 struct InnerRange {
   using It = cpp20_input_iterator<int*>;
   It begin();
@@ -235,7 +236,7 @@ struct InnerRange {
 
 struct Pattern : std::ranges::view_base {
   struct It {
-    using difference_type = ptrdiff_t;
+    using difference_type = std::ptrdiff_t;
     struct value_type {
       operator int() const;
     };
@@ -258,9 +259,31 @@ struct Pattern : std::ranges::view_base {
 static_assert(std::ranges::input_range<InnerRange>);
 static_assert(std::ranges::forward_range<Pattern>);
 static_assert(std::ranges::view<Pattern>);
-static_assert(std::common_with<range_value_t<InnerRange>, range_value_t<Pattern>>);
 static_assert(std::common_reference_with<range_reference_t<InnerRange>, range_reference_t<Pattern>>);
+static_assert(std::common_with<range_value_t<InnerRange>, range_value_t<Pattern>>);
 static_assert(!std::common_reference_with<range_rvalue_reference_t<InnerRange>, range_rvalue_reference_t<Pattern>>);
 static_assert(!CanFormJoinWithView<View<InnerRange>, Pattern>);
-} // namespace no_common_range_rvalue_reference_type
-} // namespace test_when_used_ranges_are_not_compatible_joinable_ranges
+} // namespace no_concat_rvalue_reference_t
+
+namespace not_concat_indirectly_readable { // Required after LWG-4074 ("compatible-joinable-ranges is underconstrained")
+struct InnerRange {
+  using It = cpp20_input_iterator<int*>;
+  It begin();
+  sentinel_wrapper<It> end();
+};
+
+struct Pattern : std::ranges::view_base {
+  lwg4074::Iter begin();
+  lwg4074::Iter end();
+};
+
+static_assert(std::ranges::input_range<InnerRange>);
+static_assert(std::ranges::forward_range<Pattern>);
+static_assert(std::ranges::view<Pattern>);
+static_assert(std::common_reference_with<range_reference_t<InnerRange>, range_reference_t<Pattern>>);
+static_assert(std::common_with<range_value_t<InnerRange>, range_value_t<Pattern>>);
+static_assert(std::common_reference_with<range_rvalue_reference_t<InnerRange>, range_rvalue_reference_t<Pattern>>);
+LIBCPP_STATIC_ASSERT(!std::ranges::__concat_indirectly_readable<InnerRange, Pattern>);
+static_assert(!CanFormJoinWithView<View<InnerRange>, Pattern>);
+} // namespace not_concat_indirectly_readable
+} // namespace test_when_used_ranges_are_not_concatable
@@ -233,6 +233,10 @@ constexpr bool test() {
     static_assert(std::same_as<Sentinel, ConstSentinel>);
   }
 
+  // Check LWG-4074: compatible-joinable-ranges is underconstrained
+  static_assert(!JoinWithViewHasConstEnd<BasicVectorView<int, ViewProperties{}, forward_iterator>,
+                                         lwg4074::PatternWithProxyConstAccess>);
+
   return true;
 }