[libc++] [ranges] Implement ranges::cdata

[var-const]

Can you also update docs/Status/RangesPaper.csv?

libcxx/include/__ranges/data.h

76

Is there any reason to close the ranges namespace above and then reopen it here?

78

I think we agreed to only indent inside __cpo namespaces, so this struct should not have any extra indentation.

84

Question: would decltype(auto) work here?

[philnik]

LGTM

libcxx/include/__ranges/data.h

83–85

The standard only says static_cast<const T&>(), but that doesn't make much sense, so I'm guessing that's a wording defect?

[• Quuxplusone]

libcxx/include/__ranges/data.h

76

https://reviews.llvm.org/D89057#inline-1117677
(Also consistency with all the other CPOs at this point, but then, I wrote them ;))

78

True, we did. But I guess I only took that as far as reverting the indentation in uninitialized_foo; I didn't actually go remove the existing indentation in begin/end/cbegin/etc. This was copied from cbegin. I'll go remove that existing indentation tomorrow, unless someone else objects before then (which will certainly give me enough of an excuse to avoid doing it, again ;))

83–85

Serendipitously, Casey Carter emphasized the answer just today in D116991. The standard uses T to refer to the "type" of the expression, which is never a reference type (although it may be cv-qualified). On paper, you can have an lvalue expression of type const int, but you can't have an lvalue expression of type const int&. So when in libc++ we take a parameter of declared type _Tp&&, that corresponds to a paper expression E of "type" remove_reference_t<_Tp>.
TLDR the standard is correct as written; the trick is that its notion of "type T" is not the same as our _Tp here.

84

No, because we need SFINAE.
This is the "you must write it three times" idiom; see Vittorio Romeo's 2017 lightning talk https://www.youtube.com/watch?v=I3T4lePH-yA

[var-const]

LGTM (modulo the one agreed-upon style nitpick).

libcxx/include/__ranges/data.h

76

Personally, I'd rather have everything in a single contiguous namespace. When I see this reopening, it makes me wonder whether this file contains other nested namespaces (whatever they might be) and leads me to expand the file and start searching around.

84

Thanks for the link!

[ldionne]

LGTM with passing CI and updated status paper.

Interesting learn about what the Standard means when it says "the type of an expression"!

[Mordante]

LGTM after the CI passes and the status page is updated.

[• Quuxplusone]

Update status page (include a few old PRs too). Rebase to poke CI.

[var-const]

libcxx/docs/Status/RangesPaper.csv

100 ↗

(On Diff #399529)

I think you should also add your name here (so that if anyone is considering taking one of the remaining items in this section, they would know to talk to you).

libcxx/include/__ranges/data.h

namespace __data {
   };
 }
 
 inline namespace __cpo {
   inline constexpr auto data = __data::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
+// [range.prim.cdata]
+
+namespace ranges {
+namespace __cdata {
+  struct __fn {
+    template <class _Tp>
+      requires is_lvalue_reference_v<_Tp&&>
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+    constexpr auto operator()(_Tp&& __t) const
+      noexcept(noexcept(ranges::data(static_cast<const remove_reference_t<_Tp>&>(__t))))
+      -> decltype(      ranges::data(static_cast<const remove_reference_t<_Tp>&>(__t)))
+      { return          ranges::data(static_cast<const remove_reference_t<_Tp>&>(__t)); }
+
+    template <class _Tp>
+      requires is_rvalue_reference_v<_Tp&&>
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+    constexpr auto operator()(_Tp&& __t) const
+      noexcept(noexcept(ranges::data(static_cast<const _Tp&&>(__t))))
+      -> decltype(      ranges::data(static_cast<const _Tp&&>(__t)))
+      { return          ranges::data(static_cast<const _Tp&&>(__t)); }
+  };
+}
+
+inline namespace __cpo {
+  inline constexpr auto cdata = __cdata::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_DATA_H

libcxx/test/std/library/description/conventions/customization.point.object/cpo.compile.pass.cpp

 //static_assert(test(std::compare_partial_order_fallback, 1, 2));
 //static_assert(test(std::compare_strong_order_fallback, 1, 2));
 //static_assert(test(std::compare_weak_order_fallback, 1, 2));
 
 // [range.access]
 static_assert(test(std::ranges::begin, a));
 static_assert(test(std::ranges::end, a));
 static_assert(test(std::ranges::cbegin, a));
-//static_assert(test(std::ranges::cdata, a));
+static_assert(test(std::ranges::cdata, a));
 static_assert(test(std::ranges::cend, a));
 //static_assert(test(std::ranges::crbegin, a));
 //static_assert(test(std::ranges::crend, a));
 static_assert(test(std::ranges::data, a));
 static_assert(test(std::ranges::empty, a));
 //static_assert(test(std::ranges::rbegin, a));
 //static_assert(test(std::ranges::rend, a));
 static_assert(test(std::ranges::size, a));

libcxx/test/std/ranges/range.access/data.pass.cpp

 #include <ranges>
 
 #include <cassert>
 #include <type_traits>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 using RangeDataT = decltype(std::ranges::data);
+using RangeCDataT = decltype(std::ranges::cdata);
 
 static int globalBuff[2];
 
 struct Incomplete;
 
 static_assert(!std::is_invocable_v<RangeDataT, Incomplete[]>);
 static_assert(!std::is_invocable_v<RangeDataT, Incomplete(&&)[2]>);
 static_assert(!std::is_invocable_v<RangeDataT, Incomplete(&&)[2][2]>);
 static_assert(!std::is_invocable_v<RangeDataT, int [1]>);
 static_assert(!std::is_invocable_v<RangeDataT, int (&&)[1]>);
 static_assert( std::is_invocable_v<RangeDataT, int (&)[1]>);
 
+static_assert(!std::is_invocable_v<RangeCDataT, Incomplete[]>);
+static_assert(!std::is_invocable_v<RangeCDataT, Incomplete(&&)[2]>);
+static_assert(!std::is_invocable_v<RangeCDataT, Incomplete(&&)[2][2]>);
+static_assert(!std::is_invocable_v<RangeCDataT, int [1]>);
+static_assert(!std::is_invocable_v<RangeCDataT, int (&&)[1]>);
+static_assert( std::is_invocable_v<RangeCDataT, int (&)[1]>);
+
 struct DataMember {
   int x;
   constexpr const int *data() const { return &x; }
 };
 static_assert( std::is_invocable_v<RangeDataT, DataMember &>);
 static_assert(!std::is_invocable_v<RangeDataT, DataMember &&>);
 static_assert( std::is_invocable_v<RangeDataT, DataMember const&>);
 static_assert(!std::is_invocable_v<RangeDataT, DataMember const&&>);
+static_assert( std::is_invocable_v<RangeCDataT, DataMember &>);
+static_assert(!std::is_invocable_v<RangeCDataT, DataMember &&>);
+static_assert( std::is_invocable_v<RangeCDataT, DataMember const&>);
+static_assert(!std::is_invocable_v<RangeCDataT, DataMember const&&>);
 
 constexpr bool testReturnTypes() {
   {
     int *x[2];
     ASSERT_SAME_TYPE(decltype(std::ranges::data(x)), int**);
+    ASSERT_SAME_TYPE(decltype(std::ranges::cdata(x)), int* const*);
   }
   {
     int x[2][2];
     ASSERT_SAME_TYPE(decltype(std::ranges::data(x)), int(*)[2]);
+    ASSERT_SAME_TYPE(decltype(std::ranges::cdata(x)), const int(*)[2]);
   }
   {
     struct D {
       char*& data();
       short*& data() const;
     };
     ASSERT_SAME_TYPE(decltype(std::ranges::data(std::declval<D&>())), char*);
     static_assert(!std::is_invocable_v<RangeDataT, D&&>);
     ASSERT_SAME_TYPE(decltype(std::ranges::data(std::declval<const D&>())), short*);
     static_assert(!std::is_invocable_v<RangeDataT, const D&&>);
+    ASSERT_SAME_TYPE(decltype(std::ranges::cdata(std::declval<D&>())), short*);
+    static_assert(!std::is_invocable_v<RangeCDataT, D&&>);
+    ASSERT_SAME_TYPE(decltype(std::ranges::cdata(std::declval<const D&>())), short*);
+    static_assert(!std::is_invocable_v<RangeCDataT, const D&&>);
   }
   {
     struct NC {
       char *begin() const;
       char *end() const;
       int *data();
     };
     static_assert(!std::ranges::contiguous_range<NC>);
     static_assert( std::ranges::contiguous_range<const NC>);
     ASSERT_SAME_TYPE(decltype(std::ranges::data(std::declval<NC&>())), int*);
     static_assert(!std::is_invocable_v<RangeDataT, NC&&>);
     ASSERT_SAME_TYPE(decltype(std::ranges::data(std::declval<const NC&>())), char*);
     static_assert(!std::is_invocable_v<RangeDataT, const NC&&>);
+    ASSERT_SAME_TYPE(decltype(std::ranges::cdata(std::declval<NC&>())), char*);
+    static_assert(!std::is_invocable_v<RangeCDataT, NC&&>);
+    ASSERT_SAME_TYPE(decltype(std::ranges::cdata(std::declval<const NC&>())), char*);
+    static_assert(!std::is_invocable_v<RangeCDataT, const NC&&>);
   }
   return true;
 }
 
 struct VoidDataMember {
   void *data() const;
 };
 static_assert(!std::is_invocable_v<RangeDataT, VoidDataMember const&>);
+static_assert(!std::is_invocable_v<RangeCDataT, VoidDataMember const&>);
 
 struct Empty { };
 struct EmptyDataMember {
   Empty data() const;
 };
 static_assert(!std::is_invocable_v<RangeDataT, EmptyDataMember const&>);
+static_assert(!std::is_invocable_v<RangeCDataT, EmptyDataMember const&>);
 
 struct PtrConvertibleDataMember {
   struct Ptr {
     operator int*() const;
   };
   Ptr data() const;
 };
 static_assert(!std::is_invocable_v<RangeDataT, PtrConvertibleDataMember const&>);
+static_assert(!std::is_invocable_v<RangeCDataT, PtrConvertibleDataMember const&>);
 
 struct NonConstDataMember {
   int x;
   constexpr int *data() { return &x; }
 };
 
 struct EnabledBorrowingDataMember {
   constexpr int *data() { return &globalBuff[0]; }
 };
 template<>
 inline constexpr bool std::ranges::enable_borrowed_range<EnabledBorrowingDataMember> = true;
 
 struct DataMemberAndBegin {
   int x;
   constexpr const int *data() const { return &x; }
   const int *begin() const;
 };
 
 constexpr bool testDataMember() {
   DataMember a;
   assert(std::ranges::data(a) == &a.x);
+  assert(std::ranges::cdata(a) == &a.x);
 
   NonConstDataMember b;
   assert(std::ranges::data(b) == &b.x);
+  static_assert(!std::is_invocable_v<RangeCDataT, decltype((b))>);
 
   EnabledBorrowingDataMember c;
   assert(std::ranges::data(std::move(c)) == &globalBuff[0]);
+  static_assert(!std::is_invocable_v<RangeCDataT, decltype(std::move(c))>);
 
   DataMemberAndBegin d;
   assert(std::ranges::data(d) == &d.x);
+  assert(std::ranges::cdata(d) == &d.x);
 
   return true;
 }
 
 using ContiguousIter = contiguous_iterator<const int*>;
 
 struct BeginMemberContiguousIterator {
   int buff[8];
 
   constexpr ContiguousIter begin() const { return ContiguousIter(buff); }
 };
 static_assert( std::is_invocable_v<RangeDataT, BeginMemberContiguousIterator &>);
 static_assert(!std::is_invocable_v<RangeDataT, BeginMemberContiguousIterator &&>);
 static_assert( std::is_invocable_v<RangeDataT, BeginMemberContiguousIterator const&>);
 static_assert(!std::is_invocable_v<RangeDataT, BeginMemberContiguousIterator const&&>);
+static_assert( std::is_invocable_v<RangeCDataT, BeginMemberContiguousIterator &>);
+static_assert(!std::is_invocable_v<RangeCDataT, BeginMemberContiguousIterator &&>);
+static_assert( std::is_invocable_v<RangeCDataT, BeginMemberContiguousIterator const&>);
+static_assert(!std::is_invocable_v<RangeCDataT, BeginMemberContiguousIterator const&&>);
 
 struct BeginMemberRandomAccess {
   int buff[8];
 
   random_access_iterator<const int*> begin() const;
 };
 static_assert(!std::is_invocable_v<RangeDataT, BeginMemberRandomAccess&>);
 static_assert(!std::is_invocable_v<RangeDataT, BeginMemberRandomAccess&&>);
 static_assert(!std::is_invocable_v<RangeDataT, const BeginMemberRandomAccess&>);
 static_assert(!std::is_invocable_v<RangeDataT, const BeginMemberRandomAccess&&>);
+static_assert(!std::is_invocable_v<RangeCDataT, BeginMemberRandomAccess&>);
+static_assert(!std::is_invocable_v<RangeCDataT, BeginMemberRandomAccess&&>);
+static_assert(!std::is_invocable_v<RangeCDataT, const BeginMemberRandomAccess&>);
+static_assert(!std::is_invocable_v<RangeCDataT, const BeginMemberRandomAccess&&>);
 
 struct BeginFriendContiguousIterator {
   int buff[8];
 
   friend constexpr ContiguousIter begin(const BeginFriendContiguousIterator &iter) {
     return ContiguousIter(iter.buff);
   }
 };
 static_assert( std::is_invocable_v<RangeDataT, BeginMemberContiguousIterator &>);
 static_assert(!std::is_invocable_v<RangeDataT, BeginMemberContiguousIterator &&>);
 static_assert( std::is_invocable_v<RangeDataT, BeginMemberContiguousIterator const&>);
 static_assert(!std::is_invocable_v<RangeDataT, BeginMemberContiguousIterator const&&>);
+static_assert( std::is_invocable_v<RangeCDataT, BeginMemberContiguousIterator &>);
+static_assert(!std::is_invocable_v<RangeCDataT, BeginMemberContiguousIterator &&>);
+static_assert( std::is_invocable_v<RangeCDataT, BeginMemberContiguousIterator const&>);
+static_assert(!std::is_invocable_v<RangeCDataT, BeginMemberContiguousIterator const&&>);
 
 struct BeginFriendRandomAccess {
   friend random_access_iterator<const int*> begin(const BeginFriendRandomAccess iter);
 };
 static_assert(!std::is_invocable_v<RangeDataT, BeginFriendRandomAccess&>);
 static_assert(!std::is_invocable_v<RangeDataT, BeginFriendRandomAccess&&>);
 static_assert(!std::is_invocable_v<RangeDataT, const BeginFriendRandomAccess&>);
 static_assert(!std::is_invocable_v<RangeDataT, const BeginFriendRandomAccess&&>);
+static_assert(!std::is_invocable_v<RangeCDataT, BeginFriendRandomAccess&>);
+static_assert(!std::is_invocable_v<RangeCDataT, BeginFriendRandomAccess&&>);
+static_assert(!std::is_invocable_v<RangeCDataT, const BeginFriendRandomAccess&>);
+static_assert(!std::is_invocable_v<RangeCDataT, const BeginFriendRandomAccess&&>);
 
 struct BeginMemberRvalue {
   int buff[8];
 
   ContiguousIter begin() &&;
 };
 static_assert(!std::is_invocable_v<RangeDataT, BeginMemberRvalue&>);
 static_assert(!std::is_invocable_v<RangeDataT, BeginMemberRvalue&&>);
 static_assert(!std::is_invocable_v<RangeDataT, BeginMemberRvalue const&>);
 static_assert(!std::is_invocable_v<RangeDataT, BeginMemberRvalue const&&>);
+static_assert(!std::is_invocable_v<RangeCDataT, BeginMemberRvalue&>);
+static_assert(!std::is_invocable_v<RangeCDataT, BeginMemberRvalue&&>);
+static_assert(!std::is_invocable_v<RangeCDataT, BeginMemberRvalue const&>);
+static_assert(!std::is_invocable_v<RangeCDataT, BeginMemberRvalue const&&>);
 
 struct BeginMemberBorrowingEnabled {
   constexpr contiguous_iterator<int*> begin() { return contiguous_iterator<int*>{&globalBuff[1]}; }
 };
 template<>
 inline constexpr bool std::ranges::enable_borrowed_range<BeginMemberBorrowingEnabled> = true;
 static_assert( std::is_invocable_v<RangeDataT, BeginMemberBorrowingEnabled &>);
 static_assert( std::is_invocable_v<RangeDataT, BeginMemberBorrowingEnabled &&>);
 static_assert(!std::is_invocable_v<RangeDataT, BeginMemberBorrowingEnabled const&>);
 static_assert(!std::is_invocable_v<RangeDataT, BeginMemberBorrowingEnabled const&&>);
+static_assert(!std::is_invocable_v<RangeCDataT, BeginMemberBorrowingEnabled &>);
+static_assert(!std::is_invocable_v<RangeCDataT, BeginMemberBorrowingEnabled &&>);
+static_assert(!std::is_invocable_v<RangeCDataT, BeginMemberBorrowingEnabled const&>);
+static_assert(!std::is_invocable_v<RangeCDataT, BeginMemberBorrowingEnabled const&&>);
 
 constexpr bool testViaRangesBegin() {
   int arr[2];
   assert(std::ranges::data(arr) == arr + 0);
+  assert(std::ranges::cdata(arr) == arr + 0);
 
   BeginMemberContiguousIterator a;
   assert(std::ranges::data(a) == a.buff);
+  assert(std::ranges::cdata(a) == a.buff);
 
   const BeginFriendContiguousIterator b {};
   assert(std::ranges::data(b) == b.buff);
+  assert(std::ranges::cdata(b) == b.buff);
 
   BeginMemberBorrowingEnabled c;
   assert(std::ranges::data(std::move(c)) == &globalBuff[1]);
+  static_assert(!std::is_invocable_v<RangeCDataT, decltype(std::move(c))>);
 
   return true;
 }
 
 // Test ADL-proofing.
 struct Incomplete;
 template<class T> struct Holder { T t; };
 static_assert(!std::is_invocable_v<RangeDataT, Holder<Incomplete>*>);
 static_assert(!std::is_invocable_v<RangeDataT, Holder<Incomplete>*&>);
+static_assert(!std::is_invocable_v<RangeCDataT, Holder<Incomplete>*>);
+static_assert(!std::is_invocable_v<RangeCDataT, Holder<Incomplete>*&>);
 
 struct RandomButNotContiguous {
   random_access_iterator<int*> begin() const;
   random_access_iterator<int*> end() const;
 };
 static_assert(!std::is_invocable_v<RangeDataT, RandomButNotContiguous>);
 static_assert(!std::is_invocable_v<RangeDataT, RandomButNotContiguous&>);
+static_assert(!std::is_invocable_v<RangeCDataT, RandomButNotContiguous>);
+static_assert(!std::is_invocable_v<RangeCDataT, RandomButNotContiguous&>);
 
 int main(int, char**) {
   static_assert(testReturnTypes());
 
   testDataMember();
   static_assert(testDataMember());
 
   testViaRangesBegin();
   static_assert(testViaRangesBegin());
 
   return 0;
 }