[libcxx][ranges] Add `std::ranges::single_view`.

[cjdb]

Please add concept conformance tests!

libcxx/test/std/ranges/range.factories/range.single.view/assign.pass.cpp

15

I think these should be backticks, not angle brackets.

libcxx/test/std/ranges/range.factories/range.single.view/begin.pass.cpp

72

Commented out.

[zoecarver]

libcxx/test/std/ranges/range.factories/range.single.view/assign.pass.cpp

15

We decided to use angle brackets for the exposition only types.

libcxx/test/std/ranges/range.factories/range.single.view/begin.pass.cpp

72

Good catch, thanks.

[zoecarver]

Apply Chris' feedback.

[cjdb]

Nearly there!

libcxx/test/std/ranges/range.factories/range.single.view/view_conformance.compile.pass.cpp

1 ↗

(On Diff #362066)

Please rename file to match the other range concept conformance tests.

25 ↗

(On Diff #362066)

This is a test for single_view, no?

[ldionne]

libcxx/include/__ranges/copyable_box.h

170

_VSTD::addressof(__val_)

Also, would it be possible to add a test for it, like we do for operator*?

libcxx/include/__ranges/single_view.h

2

Could you add views::single at the same time? It's pretty small so it makes sense to implement both in the same go, I think.

Also, this makes me think that we don't have views::empty, right?

41

Here you could use __value_(std::in_place, __t) instead, and you would not have to modify __copyable_box. Same for the rvalue ref below.

libcxx/test/std/ranges/range.factories/range.single.view/size.pass.cpp

14

Since the spec documents this as being static, can you add a test that std::ranges::single_view<int>::size() works as well?

[cjdb]

libcxx/include/__ranges/single_view.h

2

If you're going to take @ldionne up on this (and I think you should), please DM me so we can discuss a cohesive design for the adaptor closures. I don't want us to have wildly different ideas about what goes in this namespace.

libcxx/test/std/ranges/range.factories/range.single.view/size.pass.cpp

14

Unless there are already tests in ranges::size for static members, is it worth adding a test here for ranges::size too?

[zoecarver]

libcxx/test/std/ranges/range.factories/range.single.view/view_conformance.compile.pass.cpp

25 ↗

(On Diff #362066)

🤦‍♂️

[zoecarver]

Address Chris' comments.

[zoecarver]

Address Louis' comments.

[ldionne]

LGTM with all comments applied and CI passing.

libcxx/include/__ranges/single_view.h

2

views::single is not a range adaptor object, so we still are not implementing the pipe operator. But regardless, let's chat on Discord since you seem to have a specific approach in mind for the pipe operator.

libcxx/test/std/ranges/range.factories/range.single.view/assign.pass.cpp

2

Stray comment?

11

I really like that you're testing this property of the type, thanks for being thorough.

libcxx/test/std/ranges/range.factories/range.single.view/size.pass.cpp

14

I'm not sure I understand your comment. Are you asking that we should add a test for ranges::size() on a type that provides a static size() method? If that's your suggestion, I would agree. It's actually a hole in our current testing coverage, since the spec for ranges::size() basically says "use x.size() if that is valid", which does not specify whether .size() is a static or non-static member function.

So as a fly-by fix in this patch, @zoecarver can you add a test in ranges::size() with a type that defines a static size() function?

[zoecarver]

So it appears that the assign test crashes on GCC trunk! Anyway, I filed a bug (id = 101663), and I'll mark this test as unsupported on GCC.

libcxx/test/std/ranges/range.factories/range.single.view/assign.pass.cpp

11

Thank you :)

[zoecarver]

Apply review feedback

[cjdb]

LGTM pending last bit of feedback (just test it locally, no need to wait for CI).

libcxx/test/std/ranges/range.factories/range.single.view/range_concept_conformance.compile.pass.cpp

26

This should be input_range.

[zoecarver]

Apply Chris' last comment. Fix GCC.

libcxx/docs/Status/RangesPaper.csv

 `[range.all] <http://wg21.link/range.all>`_,`view::all <https://llvm.org/D102028>`_,"[range.subrange], [range.view.ref]",Zoe Carver,✅
 `[range.view.ref] <http://wg21.link/range.view>`_,`ref-view <https://llvm.org/D102020>`_,[view.interface],Zoe Carver,✅
 `[range.filter] <http://wg21.link/range.filter>`_,filter_view,[range.all],Louis Dionne,Not started
 `[range.transform] <http://wg21.link/range.transform>`_,`transform_view <https://llvm.org/D103056>`_,[range.all],Zoe Carver,✅
 `[range.iota] <http://wg21.link/range.iota>`_,iota_view,[range.all],Louis Dionne,Not started
 `[range.take] <http://wg21.link/range.take>`_,take_view,[range.all],Zoe Carver,✅
 `[range.join] <http://wg21.link/range.join>`_,join_view,[range.all],Christopher Di Bella,Not started
 `[range.empty] <http://wg21.link/range.empty>`_,`empty_view <https://llvm.org/D103208>`_,[view.interface],Zoe Carver,✅
-`[range.single] <http://wg21.link/range.single>`_,single_view,[view.interface],Zoe Carver,In Progress
+`[range.single] <http://wg21.link/range.single>`_,single_view,[view.interface],Zoe Carver,✅
 `[range.split] <http://wg21.link/range.split>`_,split_view,[range.all],Unassigned,Not started
 `[range.counted] <http://wg21.link/range.counted>`_,view::counted,[range.subrange],Zoe Carver,Not started
 `[range.common] <http://wg21.link/range.common>`_,common_view,[range.all],Zoe Carver,✅
 `[range.reverse] <http://wg21.link/range.reverse>`_,reverse_view,[range.all],Unassigned,Not started

libcxx/include/CMakeLists.txt

set(files
   __ranges/data.h
   __ranges/drop_view.h
   __ranges/empty_view.h
   __ranges/empty.h
   __ranges/enable_borrowed_range.h
   __ranges/enable_view.h
   __ranges/non_propagating_cache.h
   __ranges/ref_view.h
-  __ranges/take_view.h
+  __ranges/single_view.h
   __ranges/size.h
   __ranges/subrange.h
+  __ranges/take_view.h
   __ranges/transform_view.h
   __ranges/view_interface.h
   __split_buffer
   __std_stream
   __string
   __support/android/locale_bionic.h
   __support/fuchsia/xlocale.h
   __support/ibm/gettod_zos.h

libcxx/include/__ranges/copyable_box.h

constexpr __copyable_box& operator=(__copyable_box&& __other)
         if (__other.__has_value()) __val_.emplace(_VSTD::move(*__other));
         else                       __val_.reset();
       }
       return *this;
     }
 
     _LIBCPP_HIDE_FROM_ABI constexpr _Tp const& operator*() const noexcept { return *__val_; }
     _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() noexcept { return *__val_; }
+
+    _LIBCPP_HIDE_FROM_ABI constexpr const _Tp *operator->() const noexcept { return __val_.operator->(); }
+    _LIBCPP_HIDE_FROM_ABI constexpr _Tp *operator->() noexcept { return __val_.operator->(); }
+
     _LIBCPP_HIDE_FROM_ABI constexpr bool __has_value() const noexcept { return __val_.has_value(); }
   };
 
   // This partial specialization implements an optimization for when we know we don't need to store
   // an empty state to represent failure to perform an assignment. For copy-assignment, this happens:
   //
   // 1. If the type is copyable (which includes copy-assignment), we can use the type's own assignment operator
   //    directly and avoid using std::optional.
constexpr __copyable_box& operator=(__copyable_box&& __other) noexcept {
         _VSTD::destroy_at(_VSTD::addressof(__val_));
         _VSTD::construct_at(_VSTD::addressof(__val_), _VSTD::move(__other.__val_));
       }
       return *this;
     }
 
     _LIBCPP_HIDE_FROM_ABI constexpr _Tp const& operator*() const noexcept { return __val_; }
     _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() noexcept { return __val_; }
+
+    _LIBCPP_HIDE_FROM_ABI constexpr const _Tp *operator->() const noexcept { return _VSTD::addressof(__val_); }
+    _LIBCPP_HIDE_FROM_ABI constexpr _Tp *operator->() noexcept { return _VSTD::addressof(__val_); }
+
     _LIBCPP_HIDE_FROM_ABI constexpr bool __has_value() const noexcept { return true; }
   };
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___RANGES_COPYABLE_BOX_H

libcxx/include/__ranges/single_view.h

+// -*- 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_SINGLE_VIEW_H
+#define _LIBCPP___RANGES_SINGLE_VIEW_H
+
+#include <__config>
+#include <__ranges/view_interface.h>
+#include <__ranges/copyable_box.h>
+#include <concepts>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+
+namespace ranges {
+  template<copy_constructible _Tp>
+    requires is_object_v<_Tp>
+  class single_view : public view_interface<single_view<_Tp>> {
+    __copyable_box<_Tp> __value_;
+
+  public:
+    _LIBCPP_HIDE_FROM_ABI
+    single_view() requires default_initializable<_Tp> = default;
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr explicit single_view(const _Tp& __t) : __value_(in_place, __t) {}
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr explicit single_view(_Tp&& __t) : __value_(in_place, _VSTD::move(__t)) {}
+
+    template<class... _Args>
+      requires constructible_from<_Tp, _Args...>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr explicit single_view(in_place_t, _Args&&... __args)
+      : __value_{in_place, _VSTD::forward<_Args>(__args)...} {}
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr _Tp* begin() noexcept { return data(); }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr const _Tp* begin() const noexcept { return data(); }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr _Tp* end() noexcept { return data() + 1; }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr const _Tp* end() const noexcept { return data() + 1; }
+
+    _LIBCPP_HIDE_FROM_ABI
+    static constexpr size_t size() noexcept { return 1; }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr _Tp* data() noexcept { return __value_.operator->(); }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr const _Tp* data() const noexcept { return __value_.operator->(); }
+  };
+
+  template<class _Tp>
+  single_view(_Tp) -> single_view<_Tp>;
+} // namespace ranges
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_SINGLE_VIEW_H

libcxx/include/module.modulemap

module __ranges {
       module drop_view              { private header "__ranges/drop_view.h"             }
       module empty                  { private header "__ranges/empty.h"                 }
       module empty_view             { private header "__ranges/empty_view.h"            }
       module enable_borrowed_range  { private header "__ranges/enable_borrowed_range.h" }
       module enable_view            { private header "__ranges/enable_view.h"           }
       module non_propagating_cache  { private header "__ranges/non_propagating_cache.h" }
       module ref_view               { private header "__ranges/ref_view.h"              }
       module size                   { private header "__ranges/size.h"                  }
+      module single_view            { private header "__ranges/single_view.h"           }
       module subrange               { private header "__ranges/subrange.h"              }
       module take_view              { private header "__ranges/take_view.h"             }
       module transform_view         { private header "__ranges/transform_view.h"        }
       module view_interface         { private header "__ranges/view_interface.h"        }
     }
   }
   module ratio {
     header "ratio"

libcxx/include/ranges

namespace std::ranges {
   template<class T>
   inline constexpr bool enable_borrowed_range<common_view<T>> = enable_borrowed_range<T>;
 
    // [range.take], take view
   template<view> class take_view;
 
   template<class T>
   inline constexpr bool enable_borrowed_range<take_view<T>> = enable_borrowed_range<T>;
+
+  template<copy_constructible T>
+    requires is_object_v<T>
+  class single_view;
 }
 
 */
 
 #include <__config>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/common_view.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
 #include <__ranges/data.h>
 #include <__ranges/drop_view.h>
 #include <__ranges/empty.h>
 #include <__ranges/empty_view.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__ranges/ref_view.h>
-#include <__ranges/take_view.h>
+#include <__ranges/single_view.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
+#include <__ranges/take_view.h>
 #include <__ranges/transform_view.h>
 #include <__ranges/view_interface.h>
 #include <compare>          // Required by the standard.
 #include <initializer_list> // Required by the standard.
 #include <iterator>         // Required by the standard.
 #include <type_traits>
 #include <version>
 

libcxx/test/libcxx/diagnostics/detail.headers/ranges/single_view.module.verify.cpp

+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__ranges/single_view.h'}}
+#include <__ranges/single_view.h>

libcxx/test/libcxx/ranges/range.adaptors/range.copy.wrap/arrow.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// T* <copyable-box>::operator->()
+// const T* <copyable-box>::operator->() const
+
+#include <ranges>
+
+#include <cassert>
+#include <type_traits>
+#include <utility> // in_place_t
+
+#include "types.h"
+
+template<class T>
+constexpr void check() {
+  // non-const version
+  {
+    std::ranges::__copyable_box<T> x(std::in_place, 10);
+    T* result = x.operator->();
+    static_assert(noexcept(x.operator->()));
+    assert(result->value == 10);
+    assert(x->value == 10);
+  }
+
+  // const version
+  {
+    std::ranges::__copyable_box<T> const x(std::in_place, 10);
+    const T* result = x.operator->();
+    static_assert(noexcept(x.operator->()));
+    assert(result->value == 10);
+    assert(x->value == 10);
+  }
+}
+
+constexpr bool test() {
+  check<CopyConstructible>(); // primary template
+  check<Copyable>(); // optimization #1
+  check<NothrowCopyConstructible>(); // optimization #2
+  return true;
+}
+
+int main(int, char**) {
+  assert(test());
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/ranges/range.access/range.prim/size.pass.cpp

 static_assert( std::is_invocable_v<RangeSizeT, int (&)[1]>);
 
 static_assert(std::semiregular<std::remove_cv_t<RangeSizeT>>);
 
 struct SizeMember {
   constexpr size_t size() { return 42; }
 };
 
+struct StaticSizeMember {
+  constexpr static size_t size() { return 42; }
+};
+
 static_assert(!std::is_invocable_v<RangeSizeT, const SizeMember>);
 
 struct SizeFunction {
   friend constexpr size_t size(SizeFunction) { return 42; }
 };
 
 // Make sure the size member is preferred.
 struct SizeMemberAndFunction {
bool constexpr testHasSizeMember() {
   const SizeMemberConst sizeMemberConst;
   assert(std::ranges::size(sizeMemberConst) == 42);
 
   assert(std::ranges::size(SizeMemberAndFunction()) == 42);
 
   assert(std::ranges::size(SizeMemberSigned()) == 42);
   ASSERT_SAME_TYPE(decltype(std::ranges::size(SizeMemberSigned())), long);
 
+  assert(std::ranges::size(StaticSizeMember()) == 42);
+  ASSERT_SAME_TYPE(decltype(std::ranges::size(StaticSizeMember())), size_t);
+
   return true;
 }
 
 struct MoveOnlySizeFunction {
   MoveOnlySizeFunction() = default;
   MoveOnlySizeFunction(MoveOnlySizeFunction &&) = default;
   MoveOnlySizeFunction(MoveOnlySizeFunction const&) = delete;
 

libcxx/test/std/ranges/range.factories/range.single.view/assign.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10, gcc-11
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// Tests that <value_> is a <copyable-box>.
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct NotAssignable {
+  NotAssignable() = default;
+  NotAssignable(const NotAssignable&) = default;
+  NotAssignable(NotAssignable&&) = default;
+
+  NotAssignable& operator=(const NotAssignable&) = delete;
+  NotAssignable& operator=(NotAssignable&&) = delete;
+};
+
+constexpr bool test() {
+  const std::ranges::single_view<NotAssignable> a;
+  std::ranges::single_view<NotAssignable> b;
+  b = a;
+  b = std::move(a);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.single.view/begin.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr T* begin() noexcept;
+// constexpr const T* begin() const noexcept;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct Empty {};
+struct BigType { char buffer[64] = {10}; };
+
+constexpr bool test() {
+  {
+    auto sv = std::ranges::single_view<int>(42);
+    assert(*sv.begin() == 42);
+
+    ASSERT_SAME_TYPE(decltype(sv.begin()), int*);
+    static_assert(noexcept(sv.begin()));
+  }
+  {
+    const auto sv = std::ranges::single_view<int>(42);
+    assert(*sv.begin() == 42);
+
+    ASSERT_SAME_TYPE(decltype(sv.begin()), const int*);
+    static_assert(noexcept(sv.begin()));
+  }
+
+  {
+    auto sv = std::ranges::single_view<Empty>(Empty());
+    assert(sv.begin() != nullptr);
+
+    ASSERT_SAME_TYPE(decltype(sv.begin()), Empty*);
+  }
+  {
+    const auto sv = std::ranges::single_view<Empty>(Empty());
+    assert(sv.begin() != nullptr);
+
+    ASSERT_SAME_TYPE(decltype(sv.begin()), const Empty*);
+  }
+
+  {
+    auto sv = std::ranges::single_view<BigType>(BigType());
+    assert(sv.begin()->buffer[0] == 10);
+
+    ASSERT_SAME_TYPE(decltype(sv.begin()), BigType*);
+  }
+  {
+    const auto sv = std::ranges::single_view<BigType>(BigType());
+    assert(sv.begin()->buffer[0] == 10);
+
+    ASSERT_SAME_TYPE(decltype(sv.begin()), const BigType*);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.single.view/ctad.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template<class T>
+//   single_view(T) -> single_view<T>;
+
+#include <ranges>
+
+#include <cassert>
+#include <concepts>
+
+#include "test_iterators.h"
+
+struct Empty {};
+
+static_assert(std::same_as<
+  decltype(std::ranges::single_view(Empty())),
+  std::ranges::single_view<Empty>
+>);
+
+static_assert(std::same_as<
+  decltype(std::ranges::single_view(std::declval<Empty&>())),
+  std::ranges::single_view<Empty>
+>);
+
+static_assert(std::same_as<
+  decltype(std::ranges::single_view(std::declval<Empty&&>())),
+  std::ranges::single_view<Empty>
+>);

libcxx/test/std/ranges/range.factories/range.single.view/ctor.default.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// single_view() requires default_initializable<T> = default;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct BigType { char buffer[64] = {10}; };
+
+template<bool DefaultCtorEnabled>
+struct IsDefaultConstructible {
+  IsDefaultConstructible() requires DefaultCtorEnabled = default;
+};
+
+constexpr bool test() {
+  static_assert( std::default_initializable<std::ranges::single_view<IsDefaultConstructible<true>>>);
+  static_assert(!std::default_initializable<std::ranges::single_view<IsDefaultConstructible<false>>>);
+
+  {
+    std::ranges::single_view<BigType> sv;
+    assert(sv.data()->buffer[0] == 10);
+    assert(sv.size() == 1);
+  }
+  {
+    const std::ranges::single_view<BigType> sv;
+    assert(sv.data()->buffer[0] == 10);
+    assert(sv.size() == 1);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.single.view/ctor.in_place.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template<class... Args>
+//   requires constructible_from<T, Args...>
+// constexpr explicit single_view(in_place_t, Args&&... args);
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct TakesTwoInts {
+  int a_, b_;
+  constexpr TakesTwoInts(int a, int b) : a_(a), b_(b) {}
+};
+
+constexpr bool test() {
+  {
+    std::ranges::single_view<TakesTwoInts> sv(std::in_place, 1, 2);
+    assert(sv.data()->a_ == 1);
+    assert(sv.data()->b_ == 2);
+    assert(sv.size() == 1);
+  }
+  {
+    const std::ranges::single_view<TakesTwoInts> sv(std::in_place, 1, 2);
+    assert(sv.data()->a_ == 1);
+    assert(sv.data()->b_ == 2);
+    assert(sv.size() == 1);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.single.view/ctor.value.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr explicit single_view(const T& t);
+// constexpr explicit single_view(T&& t);
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct Empty {};
+struct BigType { char buffer[64] = {10}; };
+
+constexpr bool test() {
+  {
+    BigType bt;
+    std::ranges::single_view<BigType> sv(bt);
+    assert(sv.data()->buffer[0] == 10);
+    assert(sv.size() == 1);
+  }
+  {
+    const BigType bt;
+    const std::ranges::single_view<BigType> sv(bt);
+    assert(sv.data()->buffer[0] == 10);
+    assert(sv.size() == 1);
+  }
+
+  {
+    BigType bt;
+    std::ranges::single_view<BigType> sv(std::move(bt));
+    assert(sv.data()->buffer[0] == 10);
+    assert(sv.size() == 1);
+  }
+  {
+    const BigType bt;
+    const std::ranges::single_view<BigType> sv(std::move(bt));
+    assert(sv.data()->buffer[0] == 10);
+    assert(sv.size() == 1);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.single.view/data.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr T* data() noexcept;
+// constexpr const T* data() const noexcept;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct Empty {};
+struct BigType { char buffer[64] = {10}; };
+
+constexpr bool test() {
+  {
+    auto sv = std::ranges::single_view<int>(42);
+    assert(*sv.data() == 42);
+
+    ASSERT_SAME_TYPE(decltype(sv.data()), int*);
+    static_assert(noexcept(sv.data()));
+  }
+  {
+    const auto sv = std::ranges::single_view<int>(42);
+    assert(*sv.data() == 42);
+
+    ASSERT_SAME_TYPE(decltype(sv.data()), const int*);
+    static_assert(noexcept(sv.data()));
+  }
+
+  {
+    auto sv = std::ranges::single_view<Empty>(Empty());
+    assert(sv.data() != nullptr);
+
+    ASSERT_SAME_TYPE(decltype(sv.data()), Empty*);
+  }
+  {
+    const auto sv = std::ranges::single_view<Empty>(Empty());
+    assert(sv.data() != nullptr);
+
+    ASSERT_SAME_TYPE(decltype(sv.data()), const Empty*);
+  }
+
+  {
+    auto sv = std::ranges::single_view<BigType>(BigType());
+    assert(sv.data()->buffer[0] == 10);
+
+    ASSERT_SAME_TYPE(decltype(sv.data()), BigType*);
+  }
+  {
+    const auto sv = std::ranges::single_view<BigType>(BigType());
+    assert(sv.data()->buffer[0] == 10);
+
+    ASSERT_SAME_TYPE(decltype(sv.data()), const BigType*);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.single.view/end.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr T* end() noexcept;
+// constexpr const T* end() const noexcept;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct Empty {};
+struct BigType { char buffer[64] = {10}; };
+
+constexpr bool test() {
+  {
+    auto sv = std::ranges::single_view<int>(42);
+    assert(sv.end() == sv.begin() + 1);
+
+    ASSERT_SAME_TYPE(decltype(sv.end()), int*);
+    static_assert(noexcept(sv.end()));
+  }
+  {
+    const auto sv = std::ranges::single_view<int>(42);
+    assert(sv.end() == sv.begin() + 1);
+
+    ASSERT_SAME_TYPE(decltype(sv.end()), const int*);
+    static_assert(noexcept(sv.end()));
+  }
+
+  {
+    auto sv = std::ranges::single_view<Empty>(Empty());
+    assert(sv.end() == sv.begin() + 1);
+
+    ASSERT_SAME_TYPE(decltype(sv.end()), Empty*);
+  }
+  {
+    const auto sv = std::ranges::single_view<Empty>(Empty());
+    assert(sv.end() == sv.begin() + 1);
+
+    ASSERT_SAME_TYPE(decltype(sv.end()), const Empty*);
+  }
+
+  {
+    auto sv = std::ranges::single_view<BigType>(BigType());
+    assert(sv.end() == sv.begin() + 1);
+
+    ASSERT_SAME_TYPE(decltype(sv.end()), BigType*);
+  }
+  {
+    const auto sv = std::ranges::single_view<BigType>(BigType());
+    assert(sv.end() == sv.begin() + 1);
+
+    ASSERT_SAME_TYPE(decltype(sv.end()), const BigType*);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.single.view/range_concept_conformance.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// Test that single_view conforms to range and view concepts.
+
+#include <ranges>
+
+#include <cassert>
+#include <concepts>
+
+#include "test_iterators.h"
+
+struct Empty {};
+
+static_assert(std::ranges::contiguous_range<std::ranges::single_view<Empty>>);
+static_assert(std::ranges::contiguous_range<const std::ranges::single_view<Empty>>);
+static_assert(std::ranges::view<std::ranges::single_view<Empty>>);
+static_assert(std::ranges::view<std::ranges::single_view<const Empty>>);
+static_assert(std::ranges::contiguous_range<const std::ranges::single_view<const Empty>>);
+static_assert(std::ranges::view<std::ranges::single_view<int>>);
+static_assert(std::ranges::view<std::ranges::single_view<const int>>);
+static_assert(std::ranges::contiguous_range<const std::ranges::single_view<const int>>);

libcxx/test/std/ranges/range.factories/range.single.view/size.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// static constexpr size_t size() noexcept;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+
+constexpr bool test() {
+  {
+    auto sv = std::ranges::single_view<int>(42);
+    assert(sv.size() == 1);
+
+    ASSERT_SAME_TYPE(decltype(sv.size()), size_t);
+    static_assert(noexcept(sv.size()));
+  }
+  {
+    const auto sv = std::ranges::single_view<int>(42);
+    assert(sv.size() == 1);
+
+    ASSERT_SAME_TYPE(decltype(sv.size()), size_t);
+    static_assert(noexcept(sv.size()));
+  }
+  {
+    auto sv = std::ranges::single_view<int>(42);
+    assert(std::ranges::size(sv) == 1);
+
+    ASSERT_SAME_TYPE(decltype(std::ranges::size(sv)), size_t);
+    static_assert(noexcept(std::ranges::size(sv)));
+  }
+  {
+    const auto sv = std::ranges::single_view<int>(42);
+    assert(std::ranges::size(sv) == 1);
+
+    ASSERT_SAME_TYPE(decltype(std::ranges::size(sv)), size_t);
+    static_assert(noexcept(std::ranges::size(sv)));
+  }
+
+  // Test that it's static.
+  {
+    assert(std::ranges::single_view<int>::size() == 1);
+
+    ASSERT_SAME_TYPE(decltype(std::ranges::single_view<int>::size()), size_t);
+    static_assert(noexcept(std::ranges::single_view<int>::size()));
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}