[libc++][ranges] implement ranges::elements_of

libcxx/include/CMakeLists.txt

@@ -645,6 +645,7 @@ set(files
   __ranges/data.h
   __ranges/drop_view.h
   __ranges/drop_while_view.h
+  __ranges/elements_of.h
   __ranges/elements_view.h
   __ranges/empty.h
   __ranges/empty_view.h

libcxx/include/__ranges/elements_of.h

@@ -0,0 +1,62 @@
+// -*- 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___RANGES_ELEMENTS_OF_H
+#define _LIBCPP___RANGES_ELEMENTS_OF_H
+
+#include <__config>
+#include <__memory/allocator.h>
+#include <__ranges/concepts.h>
+#include <__utility/forward.h>
+#include <cstddef>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+namespace ranges {
+
+template <range _Range, class _Allocator = allocator<byte>>
+struct elements_of {
+  _LIBCPP_NO_UNIQUE_ADDRESS _Range range;
+  _LIBCPP_NO_UNIQUE_ADDRESS _Allocator allocator = _Allocator();
+
+#  if defined(_LIBCPP_COMPILER_CLANG_BASED) && defined(_LIBCPP_APPLE_CLANG_VER) && _LIBCPP_APPLE_CLANG_VER < 1600
+  // This explicit constructor is required because AppleClang 15 hasn't
+  // implemented P0960R3.
+  template <std::ranges::range _Range2, class _Allocator2 = std::allocator<std::byte>>
+  _LIBCPP_HIDE_FROM_ABI explicit constexpr elements_of(_Range2&& Range, _Allocator2&& Alloc = _Allocator())
+      : range(std::forward<_Range2>(Range)), allocator(std::forward<_Allocator2>(Alloc)) {}
+#  endif
+};
+
+template <class _Range, class _Allocator = allocator<byte>>
+#  if defined(_LIBCPP_COMPILER_CLANG_BASED) && defined(_LIBCPP_APPLE_CLANG_VER) && _LIBCPP_APPLE_CLANG_VER < 1600
+// This explicit constraint is required because AppleClang 15 might not deduce
+// the correct type for `_Range` without it.
+  requires range<_Range&&>
+#  endif
+elements_of(_Range&&, _Allocator = _Allocator()) -> elements_of<_Range&&, _Allocator>;
+
+} // namespace ranges
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_ELEMENTS_OF_H

libcxx/include/module.modulemap

@@ -1715,6 +1715,7 @@ module std_private_ranges_dangling                   [system] { header "__ranges
 module std_private_ranges_data                       [system] { header "__ranges/data.h" }
 module std_private_ranges_drop_view                  [system] { header "__ranges/drop_view.h" }
 module std_private_ranges_drop_while_view            [system] { header "__ranges/drop_while_view.h" }
+module std_private_ranges_elements_of                [system] { header "__ranges/elements_of.h" }
 module std_private_ranges_elements_view              [system] { header "__ranges/elements_view.h" }
 module std_private_ranges_empty                      [system] { header "__ranges/empty.h" }
 module std_private_ranges_empty_view                 [system] { header "__ranges/empty_view.h" }

libcxx/include/ranges

@@ -116,6 +116,10 @@ namespace std::ranges {
   // [range.dangling], dangling iterator handling
   struct dangling;
 
+  // [range.elementsof], class template elements_of
+  template<range R, class Allocator = allocator<byte>>
+    struct elements_of;
+
   template<range R>
     using borrowed_iterator_t = see below;
 
@@ -392,6 +396,7 @@ namespace std {
 #  include <__ranges/data.h>
 #  include <__ranges/drop_view.h>
 #  include <__ranges/drop_while_view.h>
+#  include <__ranges/elements_of.h>
 #  include <__ranges/elements_view.h>
 #  include <__ranges/empty.h>
 #  include <__ranges/empty_view.h>

libcxx/modules/std/ranges.inc

@@ -83,8 +83,10 @@ export namespace std {
     // [range.dangling], dangling iterator handling
     using std::ranges::dangling;
 
+#if _LIBCPP_STD_VER >= 23
     // [range.elementsof], class template elements_­of
-    // using std::ranges::elements_of;
+    using std::ranges::elements_of;
+#endif
 
     using std::ranges::borrowed_iterator_t;
 

libcxx/test/libcxx/transitive_includes/cxx23.csv

@@ -464,6 +464,7 @@ ranges cwchar
 ranges initializer_list
 ranges iterator
 ranges limits
+ranges new
 ranges optional
 ranges span
 ranges tuple

libcxx/test/libcxx/transitive_includes/cxx26.csv

@@ -464,6 +464,7 @@ ranges cwchar
 ranges initializer_list
 ranges iterator
 ranges limits
+ranges new
 ranges optional
 ranges span
 ranges tuple

libcxx/test/std/ranges/range.utility/range.elementsof/ctad.compile.pass.cpp

@@ -0,0 +1,49 @@
+//===----------------------------------------------------------------------===//
+//
+// 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, c++20
+
+// std::ranges::elements_of;
+
+#include <ranges>
+
+#include <memory>
+
+#include "min_allocator.h"
+#include "test_allocator.h"
+#include "test_iterators.h"
+
+template <class Iterator>
+struct Range {
+  Iterator begin() const;
+  sentinel_wrapper<Iterator> end() const;
+};
+
+constexpr bool test() {
+  types::for_each(
+      types::type_list<std::allocator<std::byte>, min_allocator<std::byte>, test_allocator<std::byte>>{},
+      []<class Allocator> {
+        types::for_each(types::cpp20_input_iterator_list<int*>{}, []<class Iterator> {
+          Range<Iterator> r;
+          static_assert(std::same_as<decltype(std::ranges::elements_of(r)),
+                                     std::ranges::elements_of<Range<Iterator>&, std::allocator<std::byte>>>);
+          static_assert(std::same_as<decltype(std::ranges::elements_of(Range<Iterator>())),
+                                     std::ranges::elements_of<Range<Iterator>&&, std::allocator<std::byte>>>);
+
+          Allocator a;
+          static_assert(std::same_as<decltype(std::ranges::elements_of(r, a)),
+                                     std::ranges::elements_of<Range<Iterator>&, Allocator>>);
+          static_assert(std::same_as<decltype(std::ranges::elements_of(Range<Iterator>(), Allocator())),
+                                     std::ranges::elements_of<Range<Iterator>&&, Allocator>>);
+        });
+      });
+
+  return true;
+}
+
+static_assert(test());

libcxx/test/std/ranges/range.utility/range.elementsof/elements_of.pass.cpp

@@ -0,0 +1,112 @@
+//===----------------------------------------------------------------------===//
+//
+// 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, c++20
+
+// std::ranges::elements_of;
+
+#include <ranges>
+
+#include <memory>
+#include <type_traits>
+#include <vector>
+
+#include "min_allocator.h"
+#include "test_allocator.h"
+#include "test_iterators.h"
+
+template <class Iterator>
+struct Range {
+  using Sentinel = sentinel_wrapper<Iterator>;
+
+  Iterator begin() { return Iterator(data_.data()); }
+
+  sentinel_wrapper<Iterator> end() { return Sentinel(Iterator(data_.data() + data_.size())); }
+
+private:
+  std::vector<int> data_ = {0, 1, 2, 3};
+};
+
+template <class Range, class Allocator>
+constexpr bool test_range() {
+  Range r;
+
+  using elements_of_t = std::ranges::elements_of<Range&, Allocator>;
+  {
+    // constructor
+    std::same_as<elements_of_t> decltype(auto) elements_of                 = std::ranges::elements_of(r, Allocator());
+    [[maybe_unused]] std::same_as<Range&> decltype(auto) elements_of_range = elements_of.range;
+    if (!std::is_constant_evaluated()) {
+      assert(std::ranges::distance(elements_of_range) == 4);
+    }
+    [[maybe_unused]] std::same_as<Allocator> decltype(auto) elements_of_allocator = elements_of.allocator;
+  }
+  {
+    // designated initializer
+
+    // AppleClang 15 hasn't implemented P0960R3, so `std::ranges::elements_of` requires a
+    // user-defined constructor, making it non-aggregate and therefore incompatible with designated
+    // initializers.
+    if constexpr (std::is_aggregate_v<elements_of_t>) {
+      std::same_as<elements_of_t> decltype(auto) elements_of = std::ranges::elements_of{
+          .range     = r,
+          .allocator = Allocator(),
+      };
+      [[maybe_unused]] std::same_as<Range&> decltype(auto) elements_of_range = elements_of.range;
+      if (!std::is_constant_evaluated()) {
+        assert(std::ranges::distance(elements_of_range) == 4);
+      }
+      [[maybe_unused]] std::same_as<Allocator> decltype(auto) elements_of_allocator = elements_of.allocator;
+    }
+  }
+  {
+    // copy constructor
+    std::same_as<elements_of_t> decltype(auto) elements_of_1                 = std::ranges::elements_of(r, Allocator());
+    std::same_as<elements_of_t> auto elements_of_2                           = elements_of_1;
+    [[maybe_unused]] std::same_as<Range&> decltype(auto) elements_of_1_range = elements_of_1.range;
+    [[maybe_unused]] std::same_as<Range&> decltype(auto) elements_of_2_range = elements_of_2.range;
+    if (!std::is_constant_evaluated()) {
+      assert(std::ranges::distance(elements_of_1_range) == 4);
+      assert(std::ranges::distance(elements_of_2_range) == 4);
+    }
+    [[maybe_unused]] std::same_as<Allocator> decltype(auto) elements_of_2_allocator = elements_of_2.allocator;
+  }
+
+  using elements_of_r_t = std::ranges::elements_of<Range&&, Allocator>;
+  {
+    // move constructor
+    std::same_as<elements_of_r_t> decltype(auto) elements_of_1 = std::ranges::elements_of(std::move(r), Allocator());
+    std::same_as<elements_of_r_t> auto elements_of_2           = std::move(elements_of_1);
+    [[maybe_unused]] std::same_as<Range&&> decltype(auto) elements_of_1_range = std::move(elements_of_1.range);
+    [[maybe_unused]] std::same_as<Range&&> decltype(auto) elements_of_2_range = std::move(elements_of_2.range);
+    if (!std::is_constant_evaluated()) {
+      assert(std::ranges::distance(elements_of_1_range) == 4);
+      assert(std::ranges::distance(elements_of_2_range) == 4);
+    }
+    [[maybe_unused]] std::same_as<Allocator> decltype(auto) elements_of_2_allocator = elements_of_2.allocator;
+  }
+  return true;
+}
+
+constexpr bool test() {
+  types::for_each(types::type_list<std::allocator<std::byte>, min_allocator<std::byte>, test_allocator<std::byte>>{},
+                  []<class Allocator> {
+                    types::for_each(types::cpp20_input_iterator_list<int*>{}, []<class Iterator> {
+                      test_range<Range<Iterator>, Allocator>();
+                    });
+                  });
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}