Implement LWG-4112 has-arrow should require operator->() to be const-qualified (#5152)

frederick-vs-ja · CaseyCarter · web-flow · commit a4ae6c355540 · 2024-12-04T22:53:26.000-08:00
Co-authored-by: Casey Carter &lt;cacarter@microsoft.com&gt;
diff --git a/stl/inc/ranges b/stl/inc/ranges
@@ -89,7 +89,7 @@ namespace ranges {
                         && same_as<sentinel_t<_Rng>, sentinel_t<const _Rng>>;
 
     template <class _It>
-    concept _Has_arrow = input_iterator<_It> && (is_pointer_v<_It> || _Has_member_arrow<_It&>);
+    concept _Has_arrow = input_iterator<_It> && (is_pointer_v<_It> || _Has_member_arrow<const _It&>);
 
     template <bool _IsWrapped, class _Ty>
     using _Maybe_wrapped = conditional_t<_IsWrapped, _Ty, _Unwrapped_t<_Ty>>;
diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
@@ -152,6 +152,9 @@ std/ranges/range.factories/range.iota.view/iterator/member_typedefs.compile.pass
 std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer.value/ctor.default.pass.cpp FAIL
 std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer.value/ctor.iter.pass.cpp FAIL
 
+# libc++ doesn't implement LWG-4112
+std/ranges/range.adaptors/range.join/range.join.iterator/arrow.pass.cpp FAIL
+
 # If any feature-test macro test is failing, this consolidated test will also fail.
 std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp FAIL
 
diff --git a/tests/std/tests/P0896R4_views_filter/test.cpp b/tests/std/tests/P0896R4_views_filter/test.cpp
@@ -3,6 +3,7 @@
 
 #include <algorithm>
 #include <cassert>
+#include <cstddef>
 #include <forward_list>
 #include <ranges>
 #include <span>
@@ -347,6 +348,33 @@ using move_only_view = test::range<Category, const int, test::Sized{is_random},
     IsCommon, test::CanCompare{derived_from<Category, forward_iterator_tag>},
     test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
 
+// LWG-4112 "has-arrow should require operator->() to be const-qualified"
+
+template <class T>
+concept CanArrow = requires(T&& t) { forward<T>(t).operator->(); };
+
+enum class arrow_status : bool { bad, good };
+
+template <arrow_status S>
+struct arrowed_iterator {
+    using difference_type = ptrdiff_t;
+    using value_type      = int;
+
+    int& operator*() const;
+    int* operator->()
+        requires (S == arrow_status::bad);
+    int* operator->() const
+        requires (S == arrow_status::good);
+    arrowed_iterator& operator++();
+    arrowed_iterator operator++(int);
+    friend bool operator==(arrowed_iterator, arrowed_iterator);
+};
+
+static_assert(CanArrow<ranges::iterator_t<decltype(ranges::subrange<arrowed_iterator<arrow_status::good>>{} //
+                                                   | views::filter(is_even))>>);
+static_assert(!CanArrow<ranges::iterator_t<decltype(ranges::subrange<arrowed_iterator<arrow_status::bad>>{} //
+                                                    | views::filter(is_even))>>);
+
 int main() {
     // Validate views
     { // ... copyable
diff --git a/tests/std/tests/P0896R4_views_join/test.cpp b/tests/std/tests/P0896R4_views_join/test.cpp
@@ -4,6 +4,7 @@
 #include <algorithm>
 #include <array>
 #include <cassert>
+#include <cstddef>
 #include <forward_list>
 #include <list>
 #include <ranges>
@@ -688,6 +689,40 @@ constexpr bool test_lwg3791() {
     return true;
 }
 
+// LWG-4112 "has-arrow should require operator->() to be const-qualified"
+
+template <class T>
+concept CanArrow = requires(T&& t) { forward<T>(t).operator->(); };
+
+enum class arrow_status : bool { bad, good };
+
+template <arrow_status S>
+struct arrowed_iterator {
+    using difference_type = ptrdiff_t;
+    using value_type      = int;
+
+    int& operator*() const;
+    int* operator->()
+        requires (S == arrow_status::bad);
+    int* operator->() const
+        requires (S == arrow_status::good);
+    arrowed_iterator& operator++();
+    arrowed_iterator operator++(int);
+    friend bool operator==(arrowed_iterator, arrowed_iterator);
+};
+
+void test_lwg_4112() { // COMPILE-ONLY
+    using good_inner_range  = ranges::subrange<arrowed_iterator<arrow_status::good>>;
+    using good_nested_range = span<const good_inner_range>;
+    using good_joined_range = decltype(good_nested_range{} | views::join);
+    static_assert(CanArrow<ranges::iterator_t<good_joined_range>>);
+
+    using bad_inner_range  = ranges::subrange<arrowed_iterator<arrow_status::bad>>;
+    using bad_nested_range = span<const bad_inner_range>;
+    using bad_joined_range = decltype(bad_nested_range{} | views::join);
+    static_assert(!CanArrow<ranges::iterator_t<bad_joined_range>>);
+}
+
 int main() {
     // Validate views
     constexpr string_view expected = "Hello World!"sv;
